master..c612d04 · project-m36

.appveyor.yml+3−2

since splitsnapshots

unifiedsplit

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

17 global:

18 STACK_ROOT: "c:\\sr"

19 matrix:

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

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

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

21

22

22platform:

23platform:

23 - x64

24 - x64

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

36

37

37#artifacts:

38#artifacts:

38# - path: project-m36.7z

39# - path: project-m36.7z

39−# name: project-m36.7z

40+# name: project-m36.7z

.github/workflows/ci.yamldeleted−69

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

1−name: "CI"

2−on:

3− pull_request:

4− push:

5−jobs:

6− dockerimage:

7− runs-on: ubuntu-latest

8− steps:

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

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

11− with:

12− nix_path: nixpkgs=channel:nixos-unstable

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

14− with:

15− name: project-m36

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

17− - run: cachix use iohk

18− - name: docker load

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

20− - name: docker login

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

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

23− - name: docker tag with version

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

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

26− - name: docker tag latest

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

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

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

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

31−

32− stack-build:

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

34− strategy:

35− matrix:

36− os: [ubuntu-latest]

37− ghc:

38− - ghc8.10

39− - ghc8.8

40− - ghc8.6

41− include:

42− - os: macos-latest

43− ghc: ghc8.10

44− env:

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

46− steps:

47− - uses: actions/checkout@v2

48− - name: Cache

49− uses: actions/cache@v1

50− with:

51− path: ~/.stack

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

53− restore-keys: |

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

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

56− - name: Fix macOS cache bug

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

58− - name: Build

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

60− - name: Test

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

62− - name: HLint

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

64− - name: Haddock

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

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

67− with:

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

69− path: out/

.gitignore+1−3

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

18jupyter/itutd.egg-info

19jupyter/build

20juyter/dist

21−.ipynb_checkpoints

21+.ipynb_checkpoints

22−project-m36.nix

23−stack.yaml

.travis.ymlnew file+60

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

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

2+language: c

3+sudo: false

4+

5+git:

6+ submodules: false # whether to recursively clone submodules

7+

8+cache:

9+ directories:

10+ - $HOME/.ghc

11+ - $HOME/.cabal

12+ - $HOME/.stack

13+ - .stack-work

14+ timeout: 1000

15+

16+matrix:

17+ fast_finish: true

18+ include:

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

20+ compiler: ": #stack 8.2.2"

21+

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

23+ os: osx

24+ os_image: xcode7.3

25+ compiler: ": #stack 8.2.2"

26+

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

28+ compiler: ": #stack 8.4.3"

29+

30+before_script:

31+ - unset CC

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

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

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

35+

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

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

38+script:

39+ - |

40+ # Run tests

41+ set -e

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

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

44+ - |

45+ #Run HLint

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

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

48+ fi

49+ - |

50+ #Run Haddock

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

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

53+ fi

54+

55+after_success:

56+ - |

57+ # Build and ship binary

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

59+

60+# EOF

.travis/attach-binary.shnew file+25

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

1+#!/bin/sh

2+set -o errexit -o verbose

3+

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

5+then

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

7+elif test ! "$GITHUB_TOKEN"

8+then

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

10+ exit 1

11+else

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

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

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

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

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

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

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

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

20+ chmod +x "./$REPO"

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

22+ echo "SHA256:"

23+ shasum -a 256 "$BUNDLE_NAME"

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

25+fi

.travis/install-dependencies.shnew file+22

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

1+# Run tests

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

3+ timeout_cmd="gtimeout"

4+else

5+ timeout_cmd="timeout"

6+fi

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

8+ret=$?

9+case "$ret" in

10+ 0)

11+ # continue

12+ ;;

13+ 124)

14+ echo "Timed out while installing dependencies."

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

16+ exit 1

17+ ;;

18+ *)

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

20+ exit "$ret"

21+ ;;

22+esac

.travis/install-ghc.shnew file+16

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

1+#!/bin/sh

2+set -eux

3+#assume stack is installed

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

5+

6+fetch_ghc_osx() {

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

8+ $STACK setup $GHC_VERSION

9+}

10+

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

12+ fetch_ghc_osx

13+else

14+ #installed by apt

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

16+fi

.travis/install-ghr.shnew file+21

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

1+#!/bin/sh

2+set -o errexit -o verbose

3+

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

5+then

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

7+else

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

9+ then

10+ ARCH="linux"

11+ else

12+ ARCH="darwin"

13+ fi

14+ echo "Installing ghr"

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

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

17+ mkdir -p "$HOME/bin"

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

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

20+ rm ghr.zip

21+fi

.travis/install-stack.shnew file+27

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

1+#!/bin/sh

2+

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

4+

5+set -eux

6+

7+travis_retry() {

8+ cmd=$*

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

10+}

11+

12+fetch_stack_osx() {

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

14+}

15+

16+fetch_stack_linux() {

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

18+}

19+

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

21+# builds.

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

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

24+ travis_retry fetch_stack_osx

25+else

26+ travis_retry fetch_stack_linux

27+fi

Changelog.markdown−33

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

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

2−

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

4−

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

6−

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

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

9−

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

11−

12−* support multiple extend expressions in TutorialD

13−* fix parsing of Bool atoms in TutorialD

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

15−* show constraints as TutorialD when using tutd console

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

17−

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

19−

20−* support GHC 8.10

21−

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

23−

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

25−

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

27−

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

29−* fix multibyte escaping in data frames

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

31−* fix `TypeConstructor` validation of argument count

32−* add help option to executables

33−

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

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

35

2

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

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

README.markdown+3−12

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

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

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

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

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

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

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

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

9

10

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

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

14

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

16

17−## Quick Install

18−

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

20−

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

22−

23## Description

17## Description

24

18

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

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

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

44

38

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

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

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

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

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

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

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

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

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

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

50

44

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

54

48

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

71

63

72### Advanced Features

64### Advanced Features

73

65

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

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

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

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

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

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

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

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

88

79

89### Integrations

80### Integrations

90

81

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

94

85

95## Development

86## Development

96

87

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

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

98

89

99## Related Projects

90## Related Projects

100

91

cabal.project+2−9

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

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

1packages: project-m36.cabal

2packages: project-m36.cabal

2−

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

3−package *

4− split-sections: True

5−

6−--high-performance streaming library

7−source-repository-package

8− type: git

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

10− tag: ac3af8749194f1788704dda8667d0b3807075cc2

default.nixdeleted−1

@@ -1 +0,0 @@

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

docker.nixdeleted−18

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

1−{ compiler ? "ghc8104"

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

3−, pkgs ? import sources.nixpkgs { }

4−}:

5−let

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

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

8−in

9−pkgs.dockerTools.buildImage {

10− name = "project-m36";

11− tag = "latest";

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

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

14− config = {

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

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

17− };

18−}

docs/15_minute_tutorial.markdown+68−65

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

4

5## Prerequisites

6

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

7+* any Linux

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

9+* cabal (package downloader) installed

8

10

9## Download and Install

11## Download and Install

10

12

11−Run a pre-built docker image:

12−

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

14−

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

16−

17```bash

13```bash

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

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

15+cabal sandbox init

16+cabal install --dependencies-only

19−cabal new-run tutd

17+cabal run tutd

20```

18```

21

19

22## Some Basic TutorialD

20## Some Basic TutorialD

23

21

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

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

25

23

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

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

27

25

28### Load the Canonical Chris Date Example

26### Load the Canonical Chris Date Example

29

27

30```

28```

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

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

30+```

31+

32+or

33+

34+```

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

32```

36```

33

37

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

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

39+

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

35

41

36### Execute Relational Expressions

42### Execute Relational Expressions

37

43

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

158#### Create a Relation Variable

164#### Create a Relation Variable

159

165

160```

166```

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

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

162TutorialD (master/main): :showexpr x

168TutorialD (master/main): :showexpr x

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

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

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

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

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

173#### Insert Additional Tuples

179#### Insert Additional Tuples

174

180

175```

181```

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

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

177TutorialD (master/main): :showexpr x

183TutorialD (master/main): :showexpr x

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

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

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

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

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

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

187+│40 │"Steve" │

181−│31 │"Mike" │

188+│31 │"Mike" │

182−│40 │"Steve" │

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

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

184−

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

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

186TutorialD (master/main): :showexpr x

191TutorialD (master/main): :showexpr x

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

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

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

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

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

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

190−│31 │"Mike" │

191−│40 │"Steve" │

195+│40 │"Steve" │

192−│24 │"Bob" │

196+│24 │"Bob" │

197+│31 │"Mike" │

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

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

194−

195```

199```

196

200

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

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

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

200

204

201```

205```

202TutorialD (master/main): :showexpr s

206TutorialD (master/main): :showexpr s

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

213TutorialD (master/main): :showexpr s

217TutorialD (master/main): :showexpr s

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

223−

224```

227```

225#### Deleting Tuples from a Relation Variable

228#### Deleting Tuples from a Relation Variable

226

229

227```

230```

228TutorialD (master/main): :showexpr s

231TutorialD (master/main): :showexpr s

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

239TutorialD (master/main): :showexpr s

242TutorialD (master/main): :showexpr s

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

248```

251```

249

252

250### Execute Transaction Graph Expressions

253### Execute Transaction Graph Expressions

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

267

270

268```

271```

269TutorialD (master/main): :branch experimental

272TutorialD (master/main): :branch experimental

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

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

271TutorialD (experimental): :commit

274TutorialD (experimental): :commit

272```

275```

273

276

docs/commits_in_constant_time.markdowndeleted−134

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

1−# Transactional Database Commits in O(1)

2−

3−A.M.

4−

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

6−

7−## Synopsis

8−

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

10−

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

12−

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

14−

15−## Rationale

16−

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

18−

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

20−

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

22−

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

24−

25−## Example and Comparison to PostgreSQL

26−

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

28−

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

30−

31−

32−### The Update Expression

33−

34−Consider the following database update:

35−

36−```

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

38−```

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

40−

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

42−

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

44−

45−### The Commit

46−

47−```

48−COMMIT;

49−```

50−

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

52−

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

54−

55−### The Subsequent Query

56−

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

58−

59−```

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

61−```

62−

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

64−

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

66−

67−```

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

69−```

70−

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

72−

73−### Summary

74−

75−| | PostgreSQL | Project:M36 |

76−|-|------------|-------------|

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

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

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

80−

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

82−

83−## Constraint Oracles

84−

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

86−

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

88−

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

90−

91−## Worst Case Behavior

92−

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

94−

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

96−

97−## Caveats

98−

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

100−

101−```

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

103−```

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

105−

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

107−

108−## Applying Laziness to SQL RDBMSes

109−

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

111−

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

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

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

115−

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

117−

118−## Benchmarks

119−

120−Forthcoming.

121−

122−## Conclusion

123−

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

125−

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

127−

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

129−

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

131−

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

133−

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

docs/data_independence.markdowndeleted−109

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

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

2−

3−## Introduction

4−

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

6−

7−## What is Data Independence?

8−

9−C.J. Date writes:

10−

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

12−

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

14−

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

16−

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

18−

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

20−

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

22−

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

24−

25−

26−## Transactional Isolation

27−

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

29−

30−## The Transaction Graph

31−

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

33−

34−```

35−┌──────────┬────────┬───────────┬───────────┐

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

37−├──────────┼────────┼───────────┼───────────┤

38−│"Paris" │"S2" │"Jones" │10 │

39−└──────────┴────────┴───────────┴───────────┘

40−```

41−

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

43−

44−```

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

46−```

47−

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

49−

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

51−

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

53−

54−## Storage Representations

55−

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

57−

58−## Benefits

59−

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

61−

62−### Multiple On-Disk Representations

63−

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

65−

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

67−

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

69−

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

71−

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

73−

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

75−

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

77−

78−### Less Disk Usage

79−

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

81−

82−### Audit Logging

83−

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

85−

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

87−* shuttling audit logs to a secondary database

88−

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

90−

91−### Selective Caching

92−

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

94−

95−### Never-Materialized Tuples Replace Partitions

96−

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

98−

99−### Elimination of DBA role

100−

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

102−

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

104−

105−## Conclusion

106−

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

108−

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

docs/filesystem-persistence.markdown+1−1

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

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

1+# Project-M36 Filesystem Persistence

2

3## Introduction

4

docs/import_export_csv.markdown+2−2

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

9### Example Export

10

11```

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

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

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

14```

15```

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

37S6,Samson,100,New York

38```

39```

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

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

41TutorialD (master/main): :showexpr s

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

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

docs/introduction_to_projectm36.markdown+9−28

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

15

16## Binary Releases

17

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

18+### Windows

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

19

20

20−### Install Docker:

21+### MacOS X

21

22

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

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

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

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

25

24

26−### Run TutorialD from Docker Image

25+### Linux

27

26

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

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

29−

30−```bash

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

32−```

33−

34−### Run Project:M36 Server

35−

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

37−

38−```bash

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

40−```

41−

42−### Connect to Project:M36 Server

43−

44−```bash

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

46−```

47

28

48## Source Installation

29## Source Installation

49

30

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

51

32

52To build with stack:

33To build with stack:

53

34

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

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

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

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

56* Linux, macOS, or Microsoft Windows

37* Linux, macOS, or Microsoft Windows

57

38

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

59

40

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

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

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

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

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

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

63

44

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

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

65

46

66−Alternative building with GHC 8.6.5 or greater:

47+Alternative building with GHC 8.0.2 or greater:

67

48

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

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

69

50

docs/introduction_to_the_relational_algebra.markdown+2−2

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

202

203(Course Relation)

204

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

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

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

207|English 1|Steve|Room 104|

208|French 2|Bob|Room 103|

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

378

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

380

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

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

382

383Example:

384

docs/merkle_transaction_graph.markdowndeleted−33

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

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

2−

3−## Introduction

4−

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

6−

7−## Usage

8−

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

10−

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

12−

13−### Audit Logging

14−

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

16−

17−### Reproducibility

18−

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

20−

21−### High-Availability

22−

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

24−

25−## Merkle Hashes in Other DBMSes

26−

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

28−

29−## Conclusion

30−

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

32−

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

docs/reaching_out_of_the_tarpit.markdown+1−1

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

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

58

59```

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

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

61TutorialD (master/main): :showexpr p

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

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

docs/server_mode.markdown+1−1

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

8

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

10

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

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

12

13## Connecting an Interactive Client

14

docs/transaction_graph_operators.markdown+4−6

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

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

44

45```

46+TutorialD (master/main): :showgraph

46−┌─────────────┬────────────────────────────────────────────┬──────────┬──────────────────────────────────────┬────────────────────────────────────────┬─────────────────────────────────┐

47+┌─────────────┬──────────┬──────────────────────────────────────┬────────────────────────────┬──────────────────────────────┐

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

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

48−├─────────────┼────────────────────────────────────────────┼──────────┼──────────────────────────────────────┼────────────────────────────────────────┼─────────────────────────────────┤

49+├─────────────┼──────────┼──────────────────────────────────────┼────────────────────────────┼──────────────────────────────┤

49−

50

51<big result elided>

52```

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

54

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

56−

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

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

58

56

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

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

docs/tupleable.markdown−19

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

23

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

25

26−### Changing Options

27−

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

29−

30−```haskell

31−import ProjectM36.Tupleable.Deriving

32−

33−data Person = Person {

34− personName :: Text,

35− personEmployeeNumber :: Int,

36− personLikesHorses :: Bool

37− }

38− deriving stock Generic

39− deriving Tupleable

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

41−```

42−

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

44−

45## Usage

26## Usage

46

27

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

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

docs/tutd_cheatsheet.markdowndeleted−99

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

1−# Tutorial D Cheatsheet

2−

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

4−

5−## Relational Expressions

6−

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

8−

9−|Relational Expression |Description |

10−|------------------------------------------------------|---------------------------------------|

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

29−

30−## Built-In Types

31−

32−|Example Value Expression |Type |Explanation|

33−|------------------------------------------------------|---------------------------------------|-----------|

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

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

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

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

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

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

40−|`t`|Bool|`t` or `f`|

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

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

43−

44−## Database Context Expressions

45−

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

47−

48−|Database Context Expression |Description |

49−|------------------------------------------------------|---------------------------------------|

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

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

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

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

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

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

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

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

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

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

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

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

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

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

65−

66−

67−## Transaction Graph Expressions

68−

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

70−

71−|Transaction Graph Expression |Description |

72−|------------------------------------------------------|---------------------------------------|

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

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

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

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

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

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

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

80−

81−## Data Frame Expressions

82−

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

84−

85−|Data Frame Expression |Description |

86−|------------------------------------------------------|---------------------------------------|

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

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

89−

90−## Trans-Graph Relational Expressions

91−

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

93−

94−|Trans-Graph Relational Expressions |Description |

95−|------------------------------------------------------|---------------------------------------|

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

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

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

99−

docs/tutd_tutorial.markdown+2−56

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

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

20

21```

22−:importexample cjdate

22+:importexample date

23```

24

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

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

30|p|parts|

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

32

33−### Importing TutorialD from Other Sources

34−

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

36−

37−To import TutorialD from a file:

38−

39−```

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

41−```

42−

43−or from a web server:

44−

45−```

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

47−```

48−

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

50−

51### Types

33### Types

52

34

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

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

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

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

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

216```

198```

217

199

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

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

219

201

220```

202```

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

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

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

231

213

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

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

233

215

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

235−

236−```

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

238−┌──────────┬────────────┬────────┬───────────┬───────────────┐

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

240−├──────────┼────────────┼────────┼───────────┼───────────────┤

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

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

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

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

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

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

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

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

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

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

251−└──────────┴────────────┴────────┴───────────┴───────────────┘

252−```

253−

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

255−

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

257−

258−```

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

260−┌──────────┐

261−│city::Text│

262−├──────────┤

263−│"London" │

264−│"Paris" │

265−└──────────┘

266−```

267−

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

269−

270#### Restriction

216#### Restriction

271

217

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

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

docs/websocket_server.markdown+2−2

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

16

17## Client Connection

18

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

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

20

21## Sample Application

22

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

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

examples/DerivingCustomTupleable.hsdeleted−54

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

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

2−

3−import ProjectM36.Tupleable.Deriving

4−import ProjectM36.Atomable (Atomable)

5−import Control.DeepSeq (NFData)

6−import Data.Text (Text)

7−import GHC.Generics (Generic)

8−import Codec.Winery

9−

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

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

12− deriving newtype (Num)

13− deriving Serialise via WineryRecord BlogId

14−

15−instance NFData BlogId

16−instance Atomable BlogId

17−

18−data Blog = Blog

19− { blogId :: BlogId

20− , blogTitle :: Text

21− , blogAuthorName :: Text

22− }

23− deriving stock (Show, Generic)

24− deriving (Tupleable)

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

26− deriving Serialise via WineryRecord Blog

27−

28−data Comment = Comment

29− { commentAuthorName :: Text

30− , commentComment :: Text

31− , commentFor :: BlogId

32− }

33− deriving stock (Show, Generic)

34− deriving (Tupleable)

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

36− deriving Serialise via WineryRecord Comment

37−

38−main :: IO ()

39−main = do

40− let exampleBlog = Blog

41− { blogId = 0

42− , blogTitle = "Cat Pics"

43− , blogAuthorName = "Alice"

44− }

45− exampleComment = Comment

46− { commentAuthorName = "Bob"

47− , commentComment = "great"

48− , commentFor = 0

49− }

50− print exampleBlog

51− print (toTuple exampleBlog)

52− putStrLn ""

53− print exampleComment

54− print (toTuple exampleComment)

examples/Plantfarm.hsdeleted−446

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

1−{-# LANGUAGE DeriveGeneric #-}

2−

3−{-# LANGUAGE OverloadedStrings #-}

4−

5−{-# LANGUAGE DeriveAnyClass #-}

6−

7−{-# LANGUAGE DerivingVia #-}

8−

9−

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

11−import Control.DeepSeq (NFData)

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

13−import Data.Data (Proxy(Proxy))

14−import Data.Either (lefts, rights)

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

16−import Data.Text as T (Text)

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

18−import GHC.Generics (Generic)

19−import qualified ProjectM36.Base as Base

20−import ProjectM36.Client

21− ( AtomExprBase(NakedAtomExpr)

22− , Atomable(toAddTypeExpr, toAtom)

23− , AttributeName

24− , Connection

25− , ConnectionInfo(InProcessConnectionInfo)

26− , DatabaseContextExpr

27− , DatabaseContextExprBase(Delete)

28− , PersistenceStrategy(NoPersistence)

29− , RelationalError

30− , RelationalExprBase(RelationVariable, Restrict)

31− , RestrictionPredicateExprBase(AttributeEqualityPredicate)

32− , SessionId

33− , close

34− , commit

35− , connectProjectM36

36− , createSessionAtHead

37− , databaseContextExprForUniqueKey

38− , defaultHeadName

39− , emptyNotificationCallback

40− , executeDatabaseContextExpr

41− , executeRelationalExpr

42− , withTransaction

43− )

44−import qualified ProjectM36.Relation as Relation

45−import ProjectM36.Tupleable

46− ( Tupleable(fromTuple)

47− , toDefineExpr

48− , toDeleteExpr

49− , toInsertExpr

50− , toUpdateExpr

51− )

52−import qualified System.Random as R

53−

54−

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

56−import qualified Web.Scotty as S

57−

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

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

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

61−-- plants grow in nature. \\

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

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

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

65−--

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

67−

68−

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

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

71− deriving Serialise via WineryVariant Stage

72−

73−

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

75− -- if the ascii values are not wanted

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

77−

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

79−

80−instance FromJSON Stage

81−

82−instance S.Parsable Stage where

83− parseParam t

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

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

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

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

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

89− | otherwise = Left t

90−

91−

92−-- Just for ToJSON for ilustration of stage

93−type ASCIIStage = String

94−

95−seedStr :: ASCIIStage

96−seedStr = "<>\n\

97− \'''\n"

98−sproutStr :: ASCIIStage

99−sproutStr = " ..\n\

100− \<|>\n\

101− \''''\n"

102−seedlingStr :: ASCIIStage

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

104− \ v|/\n\

105− \'´;'''\n"

106−adultStr :: ASCIIStage

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

108− \ \\,Y,e\n\

109− \ \\|/\n\

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

111−deadStr :: ASCIIStage

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

113− \'/'''''\n"

114−

115−-- Just used for ToJSON illustration of stages

116−stagetoAscii :: Stage -> ASCIIStage

117−stagetoAscii Seed = seedStr

118−stagetoAscii Sprout = sproutStr

119−stagetoAscii Seedling = seedlingStr

120−stagetoAscii Adult = adultStr

121−stagetoAscii Dead = deadStr

122−

123−-- used for update stage

124−next :: Stage -> Stage

125−next Seed = Sprout

126−next Sprout = Seedling

127−next Seedling = Adult

128−next s = s

129−

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

131−instance Tupleable Plant

132−instance ToJSON Plant

133−instance FromJSON Plant

134−

135−

136−main :: IO ()

137−main = do

138− putStrLn "Connecting to plant farm"

139− c <- dbConnection

140− _ <- createSchema c

141− putStrLn "Planting some plants"

142− _ <- insertSampleData c

143− let port = 8001

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

145− S.scotty port $ do

146−

147− -- retrieve a plant by name

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

149− n <- S.param "name"

150− e <- liftIO $ getPlant c n

151− p <- handleWebError e

152− S.json p

153−

154−

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

156− S.post "/plant" $ do

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

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

159− p <- handleWebError e

160− S.json p

161−

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

163− S.put "/plant" $ do

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

165− e <- liftIO $ updatePlantFst c pl

166− p <- handleWebError e

167− S.json p

168−

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

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

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

172− n <- S.param "name"

173− e <- liftIO $ waterPlant c n

174− p <- handleWebError e

175− S.json p

176−

177− -- retriving all the plants as json data

178− S.get "/plants" $ do

179− e <- liftIO $ getAllPlants c

180− ps <- handleWebErrors e

181− S.json ps

182−

183− -- saving many plants at the same time

184− S.post "/plants" $ do

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

186− e <- liftIO $ savePlant c pl

187− p <- handleWebError e

188− S.json p

189−

190− -- deleting all plants at a specific stage

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

192− s <- S.param "stage"

193− e <- liftIO $ deletePlantsByStage c s

194− p <- handleWebError e

195− S.json p

196−

197− -- deleting all plants at a specific stage

198− S.delete "/plants" $ do

199− s <- S.param "name"

200− e <- liftIO $ deletePlantByName c s

201− p <- handleWebError e

202− S.json p

203−

204− -- deleting all dead plants

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

206− e <- liftIO $ clearDeadPlants c

207− ps <- handleWebErrors e

208− S.json ps

209−

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

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

212−handleWebError (Right v) = pure v

213−

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

215−handleWebErrors e = do

216− case lefts e of

217− [] -> pure (rights e)

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

219−

220−

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

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

223−waterPlant db n = do

224− p <- getPlant db n

225− case p of

226− Left e -> pure $ Left e

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

228−

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

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

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

232− tmp <- updatePlantFst db p

233− case tmp of

234− Left e -> pure $ Left e

235− Right _ -> pure $ Right p

236−updateStage db p = do

237− res <- calculateStage p

238− tmp <- updatePlantFst db res

239− case tmp of

240− Left e -> pure $ Left e

241− Right _ -> pure $ Right res

242− where calculateStage p' = do

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

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

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

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

247−

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

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

250−clearDeadPlants db = do

251− _ <- deletePlantsByStage db Dead

252− getAllPlants db

253−

254−

255−-- ****************************

256−-- | *Database functions* :

257−-- ****************************

258−

259−

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

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

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

263−

264−instance ToJSON Err

265−

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

267−-- and the Connection

268−data DBConnection = DB SessionId Connection

269−

270−

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

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

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

274−-- Alternatively we could return a list.

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

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

277− get db

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

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

280− (RelationVariable "plants" ())

281− )

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

283− )

284−

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

286−defaultHead d [] = d

287−defaultHead _ (x:_) = x

288−

289−-- | Getting all the plants

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

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

292−

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

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

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

296−

297−

298−-- | Saving a plant

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

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

301−

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

303−-- not being cached yet \

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

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

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

307−updatePlantFst db pln = do

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

309− savePlant db [pln]

310−

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

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

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

314−-- be cached.\

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

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

317−updatePlant db sps = update

318− db -- db connection

319− sps -- plant value

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

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

322−

323−

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

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

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

327−

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

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

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

331−

332−

333−-- | Inserting the schema into the DB

334−createSchema :: DBConnection -> IO ()

335−createSchema (DB sessionId conn) = do

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

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

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

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

340− -- Foreign Key restrictions are available too

341− ]

342− pure ()

343−

344−

345−-- | inserting some sample data

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

347−insertSampleData (DB sid conn) = do

348− insert (DB sid conn) [

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

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

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

352− ] "plants"

353−

354−dbConnection :: IO DBConnection

355−dbConnection = do

356− -- connect to the database

357− let connInfo = InProcessConnectionInfo NoPersistence emptyNotificationCallback []

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

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

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

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

362− conn <- handleIOErrorAndQuit $ connectProjectM36 connInfo

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

364− sessionId <- handleIOErrorAndQuit $ createSessionAtHead conn defaultHeadName

365− pure (DB sessionId conn)

366−

367−

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

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

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

371−

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

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

374−--

375−-- - SessionId

376−-- - Connection

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

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

379−-- - RelVarName -- the name of the relation

380−--

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

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

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

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

385−

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

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

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

389−

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

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

392−-- Therefor ultimately return Either _ ()

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

394−executeWithTransaction (DB sid conn) expr = do

395− iEx <- handleError expr

396− case iEx of

397− Left e -> pure $ Left e

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

399−

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

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

402−get (DB sessionId conn) q = do

403− eRel <- executeRelationalExpr sessionId conn q

404− e <- handleError eRel

405− case e of

406− Left err -> pure [Left err]

407− Right pRel -> do

408− ws <- Relation.toList pRel

409− mapM (handleError . fromTuple) ws

410−

411−-- | for closing the DB connection.

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

413−closeConn :: DBConnection -> IO ()

414−closeConn (DB _ conn) = close conn

415−

416−

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

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

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

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

421−handleIOErrorAndQuit m = do

422− v <- m

423− handleErrorAndQuit v

424−

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

426−handleError eErr = case eErr of

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

428− Right v -> pure $ Right v

429−

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

431−handleIOError m = do

432− v <- m

433− handleError v

434−

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

436−handleErrorAndQuit eErr = case eErr of

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

438− Right v -> pure v

439−

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

441−handleIOErrorsAndQuit m = do

442− eErrs <- m

443− case lefts eErrs of

444− [] -> pure (rights eErrs)

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

446−

examples/SimpleClient.hs+1−1

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

6main :: IO ()

7main = do

8 -- 1. create a ConnectionInfo

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

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

10 -- 2. conncted to the remote database

11 eConn <- connectProjectM36 connInfo

12 case eConn of

examples/blog.hs+4−5

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

1-- a simple example of a blog schema

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

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

3

4import ProjectM36.Client

5import ProjectM36.Base

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

10

11import Data.Either

12import GHC.Generics

13+import Data.Binary

13import qualified Data.Text as T

14import qualified Data.Text as T

14import qualified Data.Text.Lazy as TL

15import qualified Data.Text.Lazy as TL

15import Data.Time.Clock

16import Data.Time.Clock

16import Data.Time.Calendar

17import Data.Time.Calendar

17import Control.DeepSeq

18import Control.DeepSeq

18import Data.Proxy

19import Data.Proxy

19−#if __GLASGOW_HASKELL__ < 804

20+#if __GLASGOW_HASKELL__ <= 802

20import Data.Monoid

21import Data.Monoid

21#endif

22#endif

22import Data.List

23import Data.List

23import Control.Monad (when, forM_)

24import Control.Monad (when, forM_)

24−import Codec.Winery

25

26import Web.Scotty as S

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

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

52instance Tupleable Comment

53

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, Generic) -- derive Atomable so that values of this type can be stored as a database value

55+ deriving (Atomable, Eq, Show, NFData, Binary, 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

56

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

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

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

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

examples/hair.hs+6−9

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

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

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

2import ProjectM36.Client

3import ProjectM36.Relation.Show.Term

4import GHC.Generics

5import Data.Text

6+import Data.Binary

6import Control.DeepSeq

7import Control.DeepSeq

7import qualified Data.Map as M

8import qualified Data.Map as M

8import qualified Data.Text.IO as TIO

9import qualified Data.Text.IO as TIO

9import Data.Proxy

10import Data.Proxy

10−import Codec.Winery

11

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

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

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

14− deriving Serialise via WineryVariant Hair

15

14

16main :: IO ()

15main :: IO ()

17main = do

16main = do

@@ -32,13 +31,11 @@ main = do

32

31

33 --create a relation with the new Hair AtomType

32 --create a relation with the new Hair AtomType

34 let blond = NakedAtomExpr (toAtom Blond)

33 let blond = NakedAtomExpr (toAtom Blond)

35− eCheck $ executeDatabaseContextExpr sessionId conn

34+ eCheck $ executeDatabaseContextExpr sessionId conn (Assign "people" (MakeRelationFromExprs Nothing [

36− (Assign "people"

37− (MakeRelationFromExprs Nothing $ TupleExprs () [

38− TupleExpr (M.fromList [("hair", blond), ("name", NakedAtomExpr (TextAtom "Colin"))])]))

35+ TupleExpr (M.fromList [("hair", blond), ("name", NakedAtomExpr (TextAtom "Colin"))])]))

39

36

40 let restrictionPredicate = AttributeEqualityPredicate "hair" blond

37 let restrictionPredicate = AttributeEqualityPredicate "hair" blond

41 peopleRel <- eCheck $ executeRelationalExpr sessionId conn (Restrict restrictionPredicate (RelationVariable "people" ()))

38 peopleRel <- eCheck $ executeRelationalExpr sessionId conn (Restrict restrictionPredicate (RelationVariable "people" ()))

42

39

43 TIO.putStrLn (showRelation peopleRel)

40 TIO.putStrLn (showRelation peopleRel)

44−

41+

examples/out_of_the_tarpit.hs+7−11

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

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

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

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

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

10import Control.DeepSeq

11import Control.DeepSeq

11import qualified Data.Text as T

12import qualified Data.Text as T

12import Data.Time.Calendar

13import Data.Time.Calendar

13import Data.Proxy

14import Data.Proxy

14−import Codec.Winery

15

16--create various database value (atom) types

17type Price = Double

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

21type Address = T.Text

22

23data RoomType = Kitchen | Bathroom | LivingRoom

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

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

25− deriving Serialise via WineryVariant RoomType

26

25

27data PriceBand = Low | Medium | High | Premium

26data PriceBand = Low | Medium | High | Premium

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

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

29− deriving Serialise via WineryVariant PriceBand

30

28

31data AreaCode = City | Suburban | Rural

29data AreaCode = City | Suburban | Rural

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

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

33− deriving Serialise via WineryVariant AreaCode

34

31

35data SpeedBand = VeryFastBand | FastBand | MediumBand | SlowBand

32data SpeedBand = VeryFastBand | FastBand | MediumBand | SlowBand

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

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

37− deriving Serialise via WineryVariant SpeedBand

38

34

39main :: IO ()

35main :: IO ()

40main = do

36main = do

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

261 [] -> pure (rights eErrs)

257 [] -> pure (rights eErrs)

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

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

263

259

264−

260+

examples/out_of_the_tarpit.tutd+4−4

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

3data Address = Address Text

4data Agent = Agent Text

5data Name = Name Text

6−data Price = Price Integer --dollars

6+data Price = Price Double

7data RoomType = Kitchen | Bathroom | LivingRoom

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

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

9data AreaCode = City | Suburban | Rural

10data SpeedBand = VeryFast | Fast | Medium | Slow

11

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

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

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

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

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

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

61

62−constraint noBidderCanMakeMoreThan10BidsOnAProperty (((offer group ({all but bidderAddress} as bidder)) : {bidCount:=gt(count(@bidder),10)}) where ^gt(@bidCount,10)) {} equals false

62+constraint noBidderCanMakeMoreThan10BidsOnAProperty (((offer group ({all but bidderAddress} as bidder)) : {bidCount:=gt(count(@bidder),10)}) where ^gt(bidCount,10)) {} equals false

63

64-- sample data

65

jupyter/TutorialD Notebook Walkthrough.ipynb+1−1

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

38 }

39 ],

40 "source": [

41− ":importexample cjdate"

41+ ":importexample date"

42 ]

43 },

44 {

nix/sources.jsondeleted−50

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

1−{

2− "curryer": {

3− "branch": "master",

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

5− "homepage": null,

6− "owner": "agentm",

7− "repo": "curryer",

8− "rev": "74ecaac619ad1165a4517d5c0f4e530493bda130",

9− "sha256": "1izdvzj00k0y76ixm7dfgvq2fzphb8h4nzqgwkl3p0bg0806rsn1",

10− "type": "tarball",

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

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

13− },

14− "niv": {

15− "branch": "master",

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

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

18− "owner": "nmattia",

19− "repo": "niv",

20− "rev": "1819632b5823e0527da28ad82fecd6be5136c1e9",

21− "sha256": "08jz17756qchq0zrqmapcm33nr4ms9f630mycc06i6zkfwl5yh5i",

22− "type": "tarball",

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

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

25− },

26− "nixpkgs": {

27− "branch": "master",

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

29− "homepage": "",

30− "owner": "NixOS",

31− "repo": "nixpkgs",

32− "rev": "429c23aad0fce9ef38b0e60d55d7459c19d53ddc",

33− "sha256": "1nj8sh1fnxp07jdlvjkijwfd1pnsi2zj0ivy7a0dhx02g63byhg3",

34− "type": "tarball",

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

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

37− },

38− "streamly": {

39− "branch": "ac3af8749194f1788704dda8667d0b3807075cc2",

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

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

42− "owner": "composewell",

43− "repo": "streamly",

44− "rev": "ac3af8749194f1788704dda8667d0b3807075cc2",

45− "sha256": "04d8fk654vawdfs0dfidmq2awwgwi8x44iv8r7vqz70zkcsd5fij",

46− "type": "tarball",

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

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

49− }

50−}

nix/sources.nixdeleted−171

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

1−# This file has been generated by Niv.

2−

3−let

4−

5− #

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

7− #

8−

9− fetch_file = pkgs: name: spec:

10− let

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

12− in

13− if spec.builtin or true then

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

15− else

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

17−

18− fetch_tarball = pkgs: name: spec:

19− let

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

21− in

22− if spec.builtin or true then

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

24− else

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

26−

27− fetch_git = name: spec:

28− let

29− ref =

30− if spec ? ref then spec.ref else

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

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

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

34− in

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

36−

37− fetch_local = spec: spec.path;

38−

39− fetch_builtin-tarball = name: throw

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

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

42−

43− fetch_builtin-url = name: throw

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

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

46−

47− #

48− # Various helpers

49− #

50−

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

52− sanitizeName = name:

53− (

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

55− (

56− builtins.split "[^[:alnum:]+._?=-]+"

57− ((x: builtins.elemAt (builtins.match "\\.*(.*)" x) 0) name)

58− )

59− );

60−

61− # The set of packages used when specs are fetched using non-builtins.

62− mkPkgs = sources: system:

63− let

64− sourcesNixpkgs =

65− import (builtins_fetchTarball { inherit (sources.nixpkgs) url sha256; }) { inherit system; };

66− hasNixpkgsPath = builtins.any (x: x.prefix == "nixpkgs") builtins.nixPath;

67− hasThisAsNixpkgsPath = <nixpkgs> == ./.;

68− in

69− if builtins.hasAttr "nixpkgs" sources

70− then sourcesNixpkgs

71− else if hasNixpkgsPath && ! hasThisAsNixpkgsPath then

72− import <nixpkgs> {}

73− else

74− abort

75− ''

76− Please specify either <nixpkgs> (through -I or NIX_PATH=nixpkgs=...) or

77− add a package called "nixpkgs" to your sources.json.

78− '';

79−

80− # The actual fetching function.

81− fetch = pkgs: name: spec:

82−

83− if ! builtins.hasAttr "type" spec then

84− abort "ERROR: niv spec ${name} does not have a 'type' attribute"

85− else if spec.type == "file" then fetch_file pkgs name spec

86− else if spec.type == "tarball" then fetch_tarball pkgs name spec

87− else if spec.type == "git" then fetch_git name spec

88− else if spec.type == "local" then fetch_local spec

89− else if spec.type == "builtin-tarball" then fetch_builtin-tarball name

90− else if spec.type == "builtin-url" then fetch_builtin-url name

91− else

92− abort "ERROR: niv spec ${name} has unknown type ${builtins.toJSON spec.type}";

93−

94− # If the environment variable NIV_OVERRIDE_${name} is set, then use

95− # the path directly as opposed to the fetched source.

96− replace = name: drv:

97− let

98− saneName = stringAsChars (c: if isNull (builtins.match "[a-zA-Z0-9]" c) then "_" else c) name;

99− ersatz = builtins.getEnv "NIV_OVERRIDE_${saneName}";

100− in

101− if ersatz == "" then drv else ersatz;

102−

103− # Ports of functions for older nix versions

104−

105− # a Nix version of mapAttrs if the built-in doesn't exist

106− mapAttrs = builtins.mapAttrs or (

107− f: set: with builtins;

108− listToAttrs (map (attr: { name = attr; value = f attr set.${attr}; }) (attrNames set))

109− );

110−

111− # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/lists.nix#L295

112− range = first: last: if first > last then [] else builtins.genList (n: first + n) (last - first + 1);

113−

114− # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L257

115− stringToCharacters = s: map (p: builtins.substring p 1 s) (range 0 (builtins.stringLength s - 1));

116−

117− # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L269

118− stringAsChars = f: s: concatStrings (map f (stringToCharacters s));

119− concatMapStrings = f: list: concatStrings (map f list);

120− concatStrings = builtins.concatStringsSep "";

121−

122− # https://github.com/NixOS/nixpkgs/blob/8a9f58a375c401b96da862d969f66429def1d118/lib/attrsets.nix#L331

123− optionalAttrs = cond: as: if cond then as else {};

124−

125− # fetchTarball version that is compatible between all the versions of Nix

126− builtins_fetchTarball = { url, name ? null, sha256 }@attrs:

127− let

128− inherit (builtins) lessThan nixVersion fetchTarball;

129− in

130− if lessThan nixVersion "1.12" then

131− fetchTarball ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))

132− else

133− fetchTarball attrs;

134−

135− # fetchurl version that is compatible between all the versions of Nix

136− builtins_fetchurl = { url, name ? null, sha256 }@attrs:

137− let

138− inherit (builtins) lessThan nixVersion fetchurl;

139− in

140− if lessThan nixVersion "1.12" then

141− fetchurl ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))

142− else

143− fetchurl attrs;

144−

145− # Create the final "sources" from the config

146− mkSources = config:

147− mapAttrs (

148− name: spec:

149− if builtins.hasAttr "outPath" spec

150− then abort

151− "The values in sources.json should not have an 'outPath' attribute"

152− else

153− spec // { outPath = replace name (fetch config.pkgs name spec); }

154− ) config.sources;

155−

156− # The "config" used by the fetchers

157− mkConfig =

158− { sourcesFile ? if builtins.pathExists ./sources.json then ./sources.json else null

159− , sources ? if isNull sourcesFile then {} else builtins.fromJSON (builtins.readFile sourcesFile)

160− , system ? builtins.currentSystem

161− , pkgs ? mkPkgs sources system

162− }: rec {

163− # The sources, i.e. the attribute set of spec name to spec

164− inherit sources;

165−

166− # The "pkgs" (evaluated nixpkgs) to use for e.g. non-builtin fetchers

167− inherit pkgs;

168− };

169−

170−in

171−mkSources (mkConfig {}) // { __functor = _: settings: mkSources (mkConfig settings); }

project-m36.cabal+160−168

@@ -1,8 +1,6 @@

1−Cabal-Version: 2.2

2Name: project-m36

1Name: project-m36

3−Version: 0.9.3

2+Version: 0.6

4−License: MIT

3+License: PublicDomain

5−--note that this license specification is erroneous and only labeled MIT to appease hackage which does not recognize public domain packages in cabal >2.2- Project:M36 is dedicated to the public domain

6Build-Type: Simple

4Build-Type: Simple

7Homepage: https://github.com/agentm/project-m36

5Homepage: https://github.com/agentm/project-m36

8Bug-Reports: https://github.com/agentm/project-m36/issues

6Bug-Reports: https://github.com/agentm/project-m36/issues

@@ -10,6 +8,7 @@ Author: AgentM

10Stability: experimental

8Stability: experimental

11Category: Relational Algebra

9Category: Relational Algebra

12Maintainer: agentm@themactionfaction.com

10Maintainer: agentm@themactionfaction.com

11+Cabal-Version: >= 1.10

13Synopsis: Relational Algebra Engine

12Synopsis: Relational Algebra Engine

14Description: A relational algebra engine which can be used to persist and query Haskell data types.

13Description: A relational algebra engine which can be used to persist and query Haskell data types.

15Extra-Source-Files: Changelog.markdown README.markdown

14Extra-Source-Files: Changelog.markdown README.markdown

@@ -29,21 +28,8 @@ Flag stack

29 Manual: True

28 Manual: True

30 Default: False

29 Default: False

31

30

32−Flag haskell-scripting

33− Description: enables Haskell scripting which links against GHC as a library

34− Manual: True

35− Default: True

36−

37Library

31Library

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

32+ Build-Depends: base>=4.8 && < 4.12, ghc >= 7.8 && < 8.5, ghc-paths, mtl, containers, unordered-containers, hashable, haskeline, directory, MonadRandom, random-shuffle, uuid >= 1.3.12, cassava >= 0.4.5.1 && < 0.6, text, bytestring, deepseq, deepseq-generics, vector, parallel, monad-parallel, exceptions, transformers, gnuplot, binary, filepath, zlib, directory, vector-binary-instances, temporary, stm, time, hashable-time, old-locale, rset, attoparsec, either, base64-bytestring, data-interval, extended-reals, network-transport, aeson >= 1.1, path-pieces, conduit, resourcet, http-api-data, semigroups, QuickCheck, quickcheck-instances, distributed-process-client-server >= 0.2.3, distributed-process >= 0.7.4, distributed-process-extras >= 0.3.2, distributed-process-async >= 0.2.4.1, network-transport-tcp >= 0.6.0, network-transport, list-t, stm-containers >= 0.2.15, foldl, optparse-applicative, Glob, cryptohash-sha256

39− if flag(haskell-scripting)

40− Build-Depends: ghc >= 8.2 && < 8.11

41− CPP-Options: -DPM36_HASKELL_SCRIPTING

42− if impl(ghc>= 8) && flag(haskell-scripting)

43− build-depends:

44− ghc-boot, ghci

45− if impl(ghc>= 8.6)

46− Build-Depends: deferred-folds

47 Exposed-Modules: ProjectM36.Error,

33 Exposed-Modules: ProjectM36.Error,

48 ProjectM36.Transaction,

34 ProjectM36.Transaction,

49 ProjectM36.TransactionGraph,

35 ProjectM36.TransactionGraph,

@@ -52,8 +38,6 @@ Library

52 ProjectM36.TransactionGraph.Merge,

38 ProjectM36.TransactionGraph.Merge,

53 ProjectM36.TransGraphRelationalExpression,

39 ProjectM36.TransGraphRelationalExpression,

54 ProjectM36.Base,

40 ProjectM36.Base,

55− ProjectM36.Serialise.Base,

56− ProjectM36.Serialise.Error,

57 ProjectM36.DataFrame,

41 ProjectM36.DataFrame,

58 ProjectM36.Attribute,

42 ProjectM36.Attribute,

59 ProjectM36.AttributeNames,

43 ProjectM36.AttributeNames,

@@ -63,7 +47,6 @@ Library

63 ProjectM36.AtomFunction,

47 ProjectM36.AtomFunction,

64 ProjectM36.AtomFunctionError,

48 ProjectM36.AtomFunctionError,

65 ProjectM36.ScriptSession,

49 ProjectM36.ScriptSession,

66− ProjectM36.Shortcuts,

67 ProjectM36.DatabaseContextFunction,

50 ProjectM36.DatabaseContextFunction,

68 ProjectM36.DatabaseContextFunctionError,

51 ProjectM36.DatabaseContextFunctionError,

69 ProjectM36.DatabaseContextFunctionUtils,

52 ProjectM36.DatabaseContextFunctionUtils,

@@ -83,7 +66,6 @@ Library

83 ProjectM36.Relation.Parse.CSV,

66 ProjectM36.Relation.Parse.CSV,

84 ProjectM36.IsomorphicSchema,

67 ProjectM36.IsomorphicSchema,

85 ProjectM36.InclusionDependency,

68 ProjectM36.InclusionDependency,

86− ProjectM36.MerkleHash,

87 ProjectM36.Client,

69 ProjectM36.Client,

88 ProjectM36.Client.Simple,

70 ProjectM36.Client.Simple,

89 ProjectM36.Persist,

71 ProjectM36.Persist,

@@ -93,7 +75,6 @@ Library

93 ProjectM36.AtomFunctions.Primitive,

75 ProjectM36.AtomFunctions.Primitive,

94 ProjectM36.Atomable,

76 ProjectM36.Atomable,

95 ProjectM36.Tupleable,

77 ProjectM36.Tupleable,

96− ProjectM36.Tupleable.Deriving,

97 ProjectM36.DataConstructorDef,

78 ProjectM36.DataConstructorDef,

98 ProjectM36.DataTypes.Basic,

79 ProjectM36.DataTypes.Basic,

99 ProjectM36.DataTypes.Sorting,

80 ProjectM36.DataTypes.Sorting,

@@ -114,10 +95,6 @@ Library

114 ProjectM36.Server.EntryPoints,

95 ProjectM36.Server.EntryPoints,

115 ProjectM36.Server.ParseArgs,

96 ProjectM36.Server.ParseArgs,

116 ProjectM36.Server.RemoteCallTypes,

97 ProjectM36.Server.RemoteCallTypes,

117− ProjectM36.Serialise.AtomFunctionError,

118− ProjectM36.Serialise.DataFrame,

119− ProjectM36.Serialise.DatabaseContextFunctionError,

120− ProjectM36.Serialise.IsomorphicSchema,

121 ProjectM36.Session,

98 ProjectM36.Session,

122 ProjectM36.Sessions,

99 ProjectM36.Sessions,

123 ProjectM36.Transaction.Persist,

100 ProjectM36.Transaction.Persist,

@@ -136,20 +113,22 @@ Library

136 Other-Modules: ProjectM36.Win32Handle

113 Other-Modules: ProjectM36.Win32Handle

137 else

114 else

138 --219- too many exported symbols under Windows and GHC 8.4

115 --219- too many exported symbols under Windows and GHC 8.4

139− GHC-Options: -rdynamic -fexternal-interpreter

116+ GHC-Options: -rdynamic

140 C-sources: cbits/DirectoryFsync.c, cbits/darwin_statfs.c

117 C-sources: cbits/DirectoryFsync.c, cbits/darwin_statfs.c

141 Build-Depends: unix

118 Build-Depends: unix

142− CC-Options: -fPIC

119+ CC-Options: -fPIC

143 Hs-Source-Dirs: ./src/lib

120 Hs-Source-Dirs: ./src/lib

144 Default-Language: Haskell2010

121 Default-Language: Haskell2010

145 Default-Extensions: OverloadedStrings, CPP

122 Default-Extensions: OverloadedStrings, CPP

123+ if impl(ghc>= 8)

124+ build-depends:

125+ ghc-boot, ghci

146− if !flag(stack)

126+ if !flag(stack)

147 Build-Depends: deferred-folds

127 Build-Depends: deferred-folds

148

128

149Executable tutd

129Executable tutd

150− if flag(haskell-scripting)

151− Build-Depends: ghc >= 8.2 && < 8.11

152 Build-Depends: base >=4.8 && <5.0,

130 Build-Depends: base >=4.8 && <5.0,

131+ ghc >= 7.8 && < 8.5,

153 ghc-paths,

132 ghc-paths,

154 project-m36,

133 project-m36,

155 containers,

134 containers,

@@ -163,11 +142,13 @@ Executable tutd

163 MonadRandom, MonadRandom,

142 MonadRandom, MonadRandom,

164 vector,

143 vector,

165 text,

144 text,

145+ vector-binary-instances,

166 time,

146 time,

167 hashable-time,

147 hashable-time,

168 bytestring,

148 bytestring,

169 stm,

149 stm,

170 deepseq,

150 deepseq,

151+ binary,

171 data-interval,

152 data-interval,

172 parallel,

153 parallel,

173 cassava,

154 cassava,

@@ -175,23 +156,14 @@ Executable tutd

175 directory,

156 directory,

176 filepath,

157 filepath,

177 temporary,

158 temporary,

178− megaparsec >= 5.2.0 && < 10,

159+ megaparsec >= 5.2.0 && < 7,

179 haskeline,

160 haskeline,

180 random, MonadRandom,

161 random, MonadRandom,

181 base64-bytestring,

162 base64-bytestring,

182 optparse-applicative,

163 optparse-applicative,

183 attoparsec,

164 attoparsec,

184 stm-containers >= 1.0.0,

165 stm-containers >= 1.0.0,

185− list-t,

166+ list-t

186− parser-combinators,

187− curryer-rpc,

188− prettyprinter,

189− cryptohash-sha256,

190− --due to decode signature change

191− base16-bytestring >= 1.0.0.0,

192− http-conduit,

193− modern-uri,

194− http-types

195 Other-Modules: TutorialD.Interpreter,

167 Other-Modules: TutorialD.Interpreter,

196 TutorialD.Interpreter.Base,

168 TutorialD.Interpreter.Base,

197 TutorialD.Interpreter.DatabaseContextExpr,

169 TutorialD.Interpreter.DatabaseContextExpr,

@@ -210,7 +182,6 @@ Executable tutd

210 TutorialD.Interpreter.SchemaOperator,

182 TutorialD.Interpreter.SchemaOperator,

211 TutorialD.Interpreter.TransGraphRelationalOperator,

183 TutorialD.Interpreter.TransGraphRelationalOperator,

212 TutorialD.Interpreter.SchemaOperator

184 TutorialD.Interpreter.SchemaOperator

213− TutorialD.Printer

214 main-is: TutorialD/tutd.hs

185 main-is: TutorialD/tutd.hs

215 CC-Options: -fPIC

186 CC-Options: -fPIC

216 GHC-Options: -Wall -threaded

187 GHC-Options: -Wall -threaded

@@ -219,12 +190,12 @@ Executable tutd

219 Default-Extensions: OverloadedStrings

190 Default-Extensions: OverloadedStrings

220

191

221Executable project-m36-server

192Executable project-m36-server

222− if flag(haskell-scripting)

223− Build-Depends: ghc >= 8.2 && < 8.11

224 Build-Depends: base,

193 Build-Depends: base,

194+ ghc >= 7.8 && < 8.5,

225 ghc-paths,

195 ghc-paths,

226− transformers,

227 project-m36,

196 project-m36,

197+ binary,

198+ transformers,

228 temporary,

199 temporary,

229 data-interval,

200 data-interval,

230 deepseq,

201 deepseq,

@@ -237,6 +208,7 @@ Executable project-m36-server

237 optparse-applicative,

208 optparse-applicative,

238 hashable-time,

209 hashable-time,

239 time,

210 time,

211+ vector-binary-instances,

240 text,

212 text,

241 deepseq-generics,

213 deepseq-generics,

242 mtl,

214 mtl,

@@ -249,32 +221,11 @@ Executable project-m36-server

249 list-t,

221 list-t,

250 base64-bytestring

222 base64-bytestring

251 Main-Is: ./src/bin/ProjectM36/Server/project-m36-server.hs

223 Main-Is: ./src/bin/ProjectM36/Server/project-m36-server.hs

252− GHC-Options: -Wall -threaded -rtsopts

224+ GHC-Options: -Wall -threaded -rtsopts

253− if flag(profiler)

254− GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

255− Default-Language: Haskell2010

256− Default-Extensions: OverloadedStrings

257−

258−Executable bigrel

259− Default-Language: Haskell2010

260− Default-Extensions: OverloadedStrings

261− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups, parser-combinators

262− Other-Modules: TutorialD.Interpreter.Base,

263− TutorialD.Interpreter.DatabaseContextExpr,

264− TutorialD.Interpreter.RelationalExpr,

265− TutorialD.Interpreter.Types

266− main-is: benchmark/bigrel.hs

267− GHC-Options: -Wall -threaded -rtsopts

268− HS-Source-Dirs: ./src/bin

269 if flag(profiler)

225 if flag(profiler)

270 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

226 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

271−

272−Common commontest

273 Default-Language: Haskell2010

227 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

228 Default-Extensions: OverloadedStrings

276− GHC-Options: -Wall -threaded

277− Hs-Source-Dirs: test, src/bin

278

229

279Benchmark basic-benchmark

230Benchmark basic-benchmark

280 Default-Language: Haskell2010

231 Default-Language: Haskell2010

@@ -287,202 +238,240 @@ Benchmark basic-benchmark

287 if flag(profiler)

238 if flag(profiler)

288 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

239 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

289

240

290−--benchmark inserts, updates, deletes for a basic use-case to shake out any space leaks

291−Benchmark update-exprs

292− Default-Language: Haskell2010

293− Default-Extensions: OverloadedStrings

294− Build-Depends: base, criterion, project-m36, text, winery

295− Main-Is: benchmark/Server.hs

296− Type: exitcode-stdio-1.0

297− GHC-Options: -Wall -threaded -rtsopts

298− HS-Source-Dirs: ./src/bin

299− if flag(profiler)

300− GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall -fexternal-interpreter

301−

302Test-Suite test-tutoriald

241Test-Suite test-tutoriald

303− import: commontest

242+ Default-Language: Haskell2010

243+ Default-Extensions: OverloadedStrings

304 type: exitcode-stdio-1.0

244 type: exitcode-stdio-1.0

305− main-is: TutorialD/InterpreterTest.hs

245+ main-is: test/TutorialD/Interpreter.hs

306− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer

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

246+ 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

247+ 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

248+ GHC-Options: -Wall -threaded

249+ Hs-Source-Dirs: ./src/bin, ., test

308

250

309Test-Suite test-tutoriald-atomfunctionscript

251Test-Suite test-tutoriald-atomfunctionscript

310− import: commontest

252+ Default-Language: Haskell2010

253+ Default-Extensions: OverloadedStrings

311 type: exitcode-stdio-1.0

254 type: exitcode-stdio-1.0

312− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer

255+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator

313− main-is: TutorialD/Interpreter/AtomFunctionScript.hs

256+ main-is: test/TutorialD/Interpreter/AtomFunctionScript.hs

257+ Build-Depends: base, HUnit, project-m36, uuid, containers, megaparsec, text, vector, directory, bytestring, mtl, haskeline, random, MonadRandom, semigroups, time

258+ GHC-Options: -Wall -threaded

259+ Hs-Source-Dirs: ./src/bin, ./test, .

314

260

315Test-Suite test-tutoriald-databasecontextfunctionscript

261Test-Suite test-tutoriald-databasecontextfunctionscript

316− import: commontest

262+ Default-Language: Haskell2010

263+ Default-Extensions: OverloadedStrings

317 type: exitcode-stdio-1.0

264 type: exitcode-stdio-1.0

318− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer

265+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator

319− main-is: TutorialD/Interpreter/DatabaseContextFunctionScript.hs

266+ main-is: test/TutorialD/Interpreter/DatabaseContextFunctionScript.hs

267+ Build-Depends: base, HUnit, project-m36, uuid, containers, megaparsec, text, vector, directory, bytestring, mtl, haskeline, random, MonadRandom, semigroups, time

268+ GHC-Options: -Wall -threaded

269+ Hs-Source-Dirs: ./src/bin, ./test, .

320

270

321Test-Suite test-relation

271Test-Suite test-relation

322− import: commontest

272+ Default-Language: Haskell2010

273+ Default-Extensions: OverloadedStrings

323 type: exitcode-stdio-1.0

274 type: exitcode-stdio-1.0

324− main-is: Relation/Basic.hs

275+ main-is: test/Relation/Basic.hs

276+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, transformers

277+ GHC-Options: -Wall -threaded

325

278

326Test-Suite test-static-optimizer

279Test-Suite test-static-optimizer

327− import: commontest

280+ Default-Language: Haskell2010

281+ Default-Extensions: OverloadedStrings

328 type: exitcode-stdio-1.0

282 type: exitcode-stdio-1.0

329− main-is: Relation/StaticOptimizer.hs

283+ main-is: test/Relation/StaticOptimizer.hs

284+ 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

285+ GHC-Options: -Wall -threaded

330

286

331Test-Suite test-transactiongraph-persist

287Test-Suite test-transactiongraph-persist

332− import: commontest

288+ Default-Language: Haskell2010

289+ Default-Extensions: OverloadedStrings

333 type: exitcode-stdio-1.0

290 type: exitcode-stdio-1.0

334− main-is: TransactionGraph/Persist.hs

291+ main-is: test/TransactionGraph/Persist.hs

292+ 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

335− Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Printer

293+ Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples

294+ Hs-Source-Dirs: ., ./src/bin

295+ GHC-Options: -Wall -threaded

336

296

337Test-Suite test-relation-import-csv

297Test-Suite test-relation-import-csv

338− import: commontest

298+ Default-Language: Haskell2010

299+ Default-Extensions: OverloadedStrings

339 type: exitcode-stdio-1.0

300 type: exitcode-stdio-1.0

340− main-is: Relation/Import/CSV.hs

301+ main-is: test/Relation/Import/CSV.hs

302+ 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

303+ GHC-Options: -Wall -threaded

341

304

342Test-Suite test-tutoriald-import-tutoriald

305Test-Suite test-tutoriald-import-tutoriald

343− import: commontest

306+ Default-Language: Haskell2010

307+ Default-Extensions: OverloadedStrings

344 type: exitcode-stdio-1.0

308 type: exitcode-stdio-1.0

345− main-is: TutorialD/Interpreter/Import/ImportTest.hs

309+ main-is: test/TutorialD/Interpreter/Import/TutorialD.hs

310+ 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

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

311+ 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

312+ GHC-Options: -Wall -threaded

313+ Hs-Source-Dirs: ., ./src/bin

347

314

348Test-Suite test-relation-export-csv

315Test-Suite test-relation-export-csv

349− import: commontest

316+ Default-Language: Haskell2010

317+ Default-Extensions: OverloadedStrings

350 type: exitcode-stdio-1.0

318 type: exitcode-stdio-1.0

351− main-is: Relation/Export/CSV.hs

319+ main-is: test/Relation/Export/CSV.hs

320+ 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

321+ GHC-Options: -Wall -threaded

352

322

353Test-Suite test-transactiongraph-merge

323Test-Suite test-transactiongraph-merge

354− import: commontest

324+ Default-Language: Haskell2010

355− type: exitcode-stdio-1.0

325+ Default-Extensions: OverloadedStrings

356− main-is: TransactionGraph/Merge.hs

357−

358−

359−Test-Suite test-prettyprinter

360− import: commontest

361 type: exitcode-stdio-1.0

326 type: exitcode-stdio-1.0

362− main-is: TutorialD/PrinterTest.hs

327+ main-is: test/TransactionGraph/Merge.hs

363− Other-Modules: TutorialD.Printer, TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types

328+ 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

329+ GHC-Options: -Wall -threaded

364

330

365benchmark bench

331benchmark bench

366− import: commontest

332+ Default-Language: Haskell2010

333+ Default-Extensions: OverloadedStrings

367 type: exitcode-stdio-1.0

334 type: exitcode-stdio-1.0

368 main-is: benchmark/Relation.hs

335 main-is: benchmark/Relation.hs

336+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, criterion, stm-containers, project-m36

337+ GHC-Options: -Wall -rtsopts -threaded

338+ Hs-Source-Dirs: ./src/bin

369

339

370Test-Suite test-server

340Test-Suite test-server

371− import: commontest

341+ Default-Language: Haskell2010

342+ Default-Extensions: OverloadedStrings

372 type: exitcode-stdio-1.0

343 type: exitcode-stdio-1.0

373− main-is: Server/Main.hs

344+ main-is: test/Server/Main.hs

374−

345+ 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

346+ HS-Source-Dirs: ., ./src/bin

347+ GHC-Options: -Wall -threaded

375

348

376Executable Example-SimpleClient

349Executable Example-SimpleClient

377 Default-Language: Haskell2010

350 Default-Language: Haskell2010

378 Default-Extensions: OverloadedStrings

351 Default-Extensions: OverloadedStrings

379− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, ghc, ghc-paths, project-m36, random, MonadRandom

352+ 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

380 Main-Is: examples/SimpleClient.hs

353 Main-Is: examples/SimpleClient.hs

381 GHC-Options: -Wall -threaded

354 GHC-Options: -Wall -threaded

382

355

383Executable Example-OutOfTheTarpit

356Executable Example-OutOfTheTarpit

384 Default-Language: Haskell2010

357 Default-Language: Haskell2010

385 Default-Extensions: OverloadedStrings

358 Default-Extensions: OverloadedStrings

386− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery

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, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36

387 Main-Is: examples/out_of_the_tarpit.hs

360 Main-Is: examples/out_of_the_tarpit.hs

388 GHC-Options: -Wall -threaded

361 GHC-Options: -Wall -threaded

389

362

390Executable Example-Blog

363Executable Example-Blog

391 Default-Language: Haskell2010

364 Default-Language: Haskell2010

392 Default-Extensions: OverloadedStrings

365 Default-Extensions: OverloadedStrings

393− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, scotty, blaze-html, http-types, winery

366+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, scotty, blaze-html, http-types

394 Main-Is: examples/blog.hs

367 Main-Is: examples/blog.hs

395 GHC-Options: -Wall -threaded

368 GHC-Options: -Wall -threaded

396

369

370+

397Executable Example-Hair

371Executable Example-Hair

398 Default-Language: Haskell2010

372 Default-Language: Haskell2010

399 Default-Extensions: OverloadedStrings

373 Default-Extensions: OverloadedStrings

400− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery

374+ 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

401 Main-Is: examples/hair.hs

375 Main-Is: examples/hair.hs

402 GHC-Options: -Wall -threaded

376 GHC-Options: -Wall -threaded

403

377

404−Executable Example-Plantfarm

405− Default-Language: Haskell2010

406− Default-Extensions: OverloadedStrings

407− Build-Depends: aeson, barbies, base, binary, containers, deepseq, hashable, project-m36, random, scotty, text, winery

408− Main-Is: examples/Plantfarm.hs

409− GHC-Options: -Wall -threaded

410−

411Executable Example-CustomTupleable

378Executable Example-CustomTupleable

412 Default-Language: Haskell2010

379 Default-Language: Haskell2010

413 Default-Extensions: OverloadedStrings

380 Default-Extensions: OverloadedStrings

414− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery

381+ 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

415 Main-Is: examples/CustomTupleable.hs

382 Main-Is: examples/CustomTupleable.hs

416 GHC-Options: -Wall -threaded

383 GHC-Options: -Wall -threaded

417

384

418−Executable Example-DerivingCustomTupleable

419− if impl(ghc>=8.6)

420− Buildable: True

421− else

422− Buildable: False

423− Default-Language: Haskell2010

424− Build-Depends: base, text, deepseq, project-m36, winery

425− Main-Is: examples/DerivingCustomTupleable.hs

426− GHC-Options: -Wall -threaded

427−

428Test-Suite test-scripts

385Test-Suite test-scripts

429− import: commontest

386+ Default-Language: Haskell2010

387+ Default-Extensions: OverloadedStrings

430 type: exitcode-stdio-1.0

388 type: exitcode-stdio-1.0

431− main-is: scripts.hs

389+ main-is: test/scripts.hs

390+ 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

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

391+ 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

392+ GHC-Options: -Wall -threaded

393+ Hs-Source-Dirs: ., ./src/bin

433

394

434Executable project-m36-websocket-server

395Executable project-m36-websocket-server

435 Default-Language: Haskell2010

396 Default-Language: Haskell2010

436− Build-Depends: base, aeson, path-pieces, either, conduit, http-api-data, template-haskell, websockets, aeson, optparse-applicative, project-m36, containers, bytestring, text, vector, uuid, megaparsec, haskeline, mtl, directory, base64-bytestring, random, MonadRandom, time, semigroups, attoparsec, parser-combinators, prettyprinter, network, modern-uri, http-conduit, base16-bytestring, http-types, cryptohash-sha256, wai, wai-websockets, warp, warp-tls

397+ 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

437 Main-Is: ProjectM36/Server/WebSocket/websocket-server.hs

398 Main-Is: ProjectM36/Server/WebSocket/websocket-server.hs

438− Other-Modules: ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer

399+ Other-Modules: ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator

439 GHC-Options: -Wall -threaded

400 GHC-Options: -Wall -threaded

440 Hs-Source-Dirs: ./src/bin

401 Hs-Source-Dirs: ./src/bin

441 Default-Extensions: OverloadedStrings

402 Default-Extensions: OverloadedStrings

442

403

443Test-Suite test-websocket-server

404Test-Suite test-websocket-server

444− import: commontest

405+ Default-Language: Haskell2010

445 type: exitcode-stdio-1.0

406 type: exitcode-stdio-1.0

446− main-is: Server/WebSocket.hs

407+ main-is: test/Server/WebSocket.hs

408+ 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

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

409+ 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

410+ Default-Extensions: OverloadedStrings

411+ GHC-Options: -Wall -threaded

412+ Hs-Source-Dirs: ./src/bin, .

448

413

449Test-Suite test-isomorphic-schemas

414Test-Suite test-isomorphic-schemas

450− import: commontest

415+ Default-Language: Haskell2010

451 type: exitcode-stdio-1.0

416 type: exitcode-stdio-1.0

452− main-is: IsomorphicSchema.hs

417+ main-is: test/IsomorphicSchema.hs

418+ 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

419+ Default-Extensions: OverloadedStrings

420+ GHC-Options: -Wall -threaded

421+ Hs-Source-Dirs: ./src/bin, .

453

422

454Test-Suite test-atomable

423Test-Suite test-atomable

455− import: commontest

424+ Default-Language: Haskell2010

456 type: exitcode-stdio-1.0

425 type: exitcode-stdio-1.0

457− main-is: Relation/Atomable.hs

426+ main-is: test/Relation/Atomable.hs

427+ 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

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

428+ 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

429+ Default-Extensions: OverloadedStrings

430+ GHC-Options: -Wall -threaded

431+ Hs-Source-Dirs: ./src/bin, ., test/

459

432

460Test-Suite test-multiprocess-access

433Test-Suite test-multiprocess-access

461− import: commontest

434+ Default-Language: Haskell2010

462 type: exitcode-stdio-1.0

435 type: exitcode-stdio-1.0

463− main-is: MultiProcessDatabaseAccess.hs

436+ main-is: test/MultiProcessDatabaseAccess.hs

437+ 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

438+ Default-Extensions: OverloadedStrings

439+ GHC-Options: -Wall -threaded

440+ Hs-Source-Dirs: ./src/bin, ., test/

464

441

465Test-Suite test-transactiongraph-automerge

442Test-Suite test-transactiongraph-automerge

466− import: commontest

443+ Default-Language: Haskell2010

467 type: exitcode-stdio-1.0

444 type: exitcode-stdio-1.0

468− main-is: TransactionGraph/Automerge.hs

445+ main-is: test/TransactionGraph/Automerge.hs

446+ 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

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

447+ 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

448+ Default-Extensions: OverloadedStrings

449+ GHC-Options: -Wall -threaded

450+ Hs-Source-Dirs: ./src/bin, ., test/

470

451

471Test-Suite test-tupleable

452Test-Suite test-tupleable

472− import: commontest

453+ Default-Language: Haskell2010

473 type: exitcode-stdio-1.0

454 type: exitcode-stdio-1.0

474− main-is: Relation/Tupleable.hs

455+ main-is: test/Relation/Tupleable.hs

456+ 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

457+ Default-Extensions: OverloadedStrings

458+ GHC-Options: -Wall -threaded

459+ Hs-Source-Dirs: ./src/bin, ., test/

475

460

476Test-Suite test-client-simple

461Test-Suite test-client-simple

477− import: commontest

462+ Default-Language: Haskell2010

478− Main-Is: Client/Simple.hs

463+ Main-Is: test/Client/Simple.hs

479 type: exitcode-stdio-1.0

464 type: exitcode-stdio-1.0

465+ 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

466+ Default-Extensions: OverloadedStrings

467+ GHC-Options: -Wall -threaded

468+ Hs-Source-Dirs: ./src/bin, ., test/

480

469

481-- test for file handle leaks

470-- test for file handle leaks

482Executable handles

471Executable handles

483 Default-Language: Haskell2010

472 Default-Language: Haskell2010

484 Default-Extensions: OverloadedStrings

473 Default-Extensions: OverloadedStrings

485− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups, parser-combinators, prettyprinter, modern-uri, http-types, http-conduit, base16-bytestring, cryptohash-sha256

474+ 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

486 main-is: benchmark/Handles.hs

475 main-is: benchmark/Handles.hs

487 Other-Modules: TutorialD.Interpreter,

476 Other-Modules: TutorialD.Interpreter,

488 TutorialD.Interpreter.Base,

477 TutorialD.Interpreter.Base,

@@ -501,14 +490,17 @@ Executable handles

501 TutorialD.Interpreter.TransGraphRelationalOperator,

490 TutorialD.Interpreter.TransGraphRelationalOperator,

502 TutorialD.Interpreter.TransactionGraphOperator,

491 TutorialD.Interpreter.TransactionGraphOperator,

503 TutorialD.Interpreter.Types

492 TutorialD.Interpreter.Types

504− TutorialD.Printer

505 GHC-Options: -Wall -threaded -rtsopts

493 GHC-Options: -Wall -threaded -rtsopts

506 HS-Source-Dirs: ./src/bin

494 HS-Source-Dirs: ./src/bin

507 if flag(profiler)

495 if flag(profiler)

508 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

496 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

509−

497+

510Test-Suite test-dataframe

498Test-Suite test-dataframe

511− import: commontest

499+ Default-Language: Haskell2010

500+ Main-Is: test/DataFrame.hs

512 type: exitcode-stdio-1.0

501 type: exitcode-stdio-1.0

513− Main-Is: DataFrame.hs

514− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Printer

502+ 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

503+ 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

504+ Default-Extensions: OverloadedStrings

505+ GHC-Options: -Wall -threaded

506+ Hs-Source-Dirs: ./src/bin, ., test/

release.nixdeleted−36

@@ -1,36 +0,0 @@

1−{ compiler ? "ghc8104"

2−, sources ? import ./nix/sources.nix

3−, pkgs ? import sources.nixpkgs { }

4−}:

5−let

6− doJailbreak = pkgs.haskell.lib.doJailbreak;

7− needsCocoa = drv:

8− if pkgs.stdenv.isDarwin

9− then drv.overrideDerivation (old:

10− { buildInputs = [ pkgs.darwin.apple_sdk.frameworks.Cocoa ] ++ old.buildInputs; }

11− )

12− else drv;

13−

14− haskellPackages = pkgs.haskell.packages.${compiler}.override {

15− overrides = self: super: {

16− curryer-rpc = self.callCabal2nix "curryer-rpc" sources.curryer { };

17− streamly = doJailbreak (needsCocoa (self.callCabal2nix "streamly" sources.streamly { }));

18− project-m36 = ((self.callCabal2nixWithOptions "project-m36" ./. "-f-haskell-scripting" { }));

19− };

20− };

21−in

22−{

23− project = haskellPackages.project-m36;

24−

25− shell = haskellPackages.shellFor {

26− packages = p: [

27− p.project-m36

28− ];

29− buildInputs = [

30− haskellPackages.ghcid

31− haskellPackages.hlint

32− pkgs.docker

33− ];

34− withHoogle = true;

35− };

36−}

scripts/DateExamples.tutd+2−2

@@ -20,7 +20,7 @@ sp := relation{tuple{s# "S1",p# "P1",qty 300},

20 tuple{s# "S3",p# "P2",qty 200},

21 tuple{s# "S4",p# "P4",qty 300},

22 tuple{s# "S4",p# "P5",qty 400}};

23−key s_pkey {s#} s;

23+key s_pkey {s#} s

24−key p_key {p#} p;

24+key p_key {p#} p

25foreign key s_sp_fk sp{s#} in s{s#};

26foreign key p_sp_fk sp{p#} in p{p#};

scripts/multiline.tutddeleted−2

@@ -1,2 +0,0 @@

1−x:=relation{

2−tuple{ x 2}} -- nice

shell.nixdeleted−1

@@ -1 +0,0 @@

1−(import ./release.nix { }).shell

src/bin/ProjectM36/Client/Json.hs+1−4

@@ -3,7 +3,6 @@ module ProjectM36.Client.Json where

3import Data.Aeson

4import ProjectM36.Server.RemoteCallTypes.Json ()

5import ProjectM36.Client

6−import ProjectM36.TransactionGraph

7import Control.Exception (IOException)

6import Control.Exception (IOException)

8

7

9instance ToJSON EvaluatedNotification

8instance ToJSON EvaluatedNotification

@@ -12,6 +11,4 @@ instance FromJSON EvaluatedNotification

12instance ToJSON ConnectionError

11instance ToJSON ConnectionError

13

12

14instance ToJSON IOException where

13instance ToJSON IOException where

15− toJSON err = object ["IOException" .= show err]

14+ toJSON err = object ["IOException" .= show err]

16−

17−instance ToJSON MerkleValidationError

src/bin/ProjectM36/Server/RemoteCallTypes/Json.hs+2−33

@@ -10,8 +10,6 @@ import ProjectM36.DataTypes.Primitive

10import ProjectM36.Error

11import ProjectM36.IsomorphicSchema

12import ProjectM36.Server.RemoteCallTypes

13−import ProjectM36.MerkleHash

14−import ProjectM36.Attribute as A

15

13

16import Data.Aeson

14import Data.Aeson

17import Data.ByteString.Base64 as B64

15import Data.ByteString.Base64 as B64

@@ -24,9 +22,6 @@ instance FromJSON RelationalExpr

24instance ToJSON TupleExpr

22instance ToJSON TupleExpr

25instance FromJSON TupleExpr

23instance FromJSON TupleExpr

26

24

27−instance ToJSON TupleExprs

28−instance FromJSON TupleExprs

29−

30instance ToJSON RestrictionPredicateExpr

25instance ToJSON RestrictionPredicateExpr

31instance FromJSON RestrictionPredicateExpr

26instance FromJSON RestrictionPredicateExpr

32

27

@@ -45,11 +40,8 @@ instance FromJSON ExecuteRelationalExpr

45instance ToJSON Relation

40instance ToJSON Relation

46instance FromJSON Relation

41instance FromJSON Relation

47

42

48−instance ToJSON Attribute where

43+instance ToJSON Attribute

49− toJSON (Attribute attrName aType) = object [ "name" .= attrName

50− , "type" .= toJSON aType ]

51−instance FromJSON Attribute where

44+instance FromJSON Attribute

52− parseJSON = withObject "Attribute" $ \v -> Attribute <$> v .: "name" <*> v .: "type"

53

45

54instance ToJSON ExtendTupleExpr

46instance ToJSON ExtendTupleExpr

55instance FromJSON ExtendTupleExpr

47instance FromJSON ExtendTupleExpr

@@ -103,8 +95,6 @@ instance ToJSON Atom where

103 "val" .= i ]

95 "val" .= i ]

104 toJSON atom@(RelationAtom i) = object [ "type" .= atomTypeForAtom atom,

96 toJSON atom@(RelationAtom i) = object [ "type" .= atomTypeForAtom atom,

105 "val" .= i ]

97 "val" .= i ]

106− toJSON atom@(RelationalExprAtom i) = object [ "type" .= atomTypeForAtom atom,

107− "val" .= i ]

108 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [

98 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [

109 "dataconstructorname" .= dConsName,

99 "dataconstructorname" .= dConsName,

110 "type" .= toJSON atomtype,

100 "type" .= toJSON atomtype,

@@ -132,7 +122,6 @@ instance FromJSON Atom where

132 Left err -> fail ("Failed to parse base64-encoded ByteString: " ++ err)

122 Left err -> fail ("Failed to parse base64-encoded ByteString: " ++ err)

133 Right bs -> pure (ByteStringAtom bs)

123 Right bs -> pure (ByteStringAtom bs)

134 BoolAtomType -> BoolAtom <$> o .: "val"

124 BoolAtomType -> BoolAtom <$> o .: "val"

135− RelationalExprAtomType -> RelationalExprAtom <$> o .: "val"

136

125

137instance ToJSON Notification

126instance ToJSON Notification

138instance FromJSON Notification

127instance FromJSON Notification

@@ -140,21 +129,6 @@ instance FromJSON Notification

140instance ToJSON ScriptCompilationError

129instance ToJSON ScriptCompilationError

141instance FromJSON ScriptCompilationError

130instance FromJSON ScriptCompilationError

142

131

143−instance ToJSON MerkleHash where

144− toJSON h = object [ "merklehash" .= decodeUtf8 (B64.encode (_unMerkleHash h))]

145−instance FromJSON MerkleHash where

146− parseJSON = withObject "merklehash" $ \o -> do

147− b64bs <- encodeUtf8 <$> o .: "merklehash"

148− case B64.decode b64bs of

149− Left err -> fail ("Failed to parse merkle hash: " ++ err)

150− Right bs -> pure (MerkleHash bs)

151−

152−instance ToJSON Attributes where

153− toJSON attrs = object ["attributes" .= map toJSON (A.toList attrs)]

154−instance FromJSON Attributes where

155− parseJSON = withObject "Attributes" $ \o ->

156− A.attributesFromList <$> o .: "attributes"

157−

158instance ToJSON RelationalError

132instance ToJSON RelationalError

159instance FromJSON RelationalError

133instance FromJSON RelationalError

160

134

@@ -164,9 +138,6 @@ instance FromJSON SchemaError

164instance ToJSON MergeError

138instance ToJSON MergeError

165instance FromJSON MergeError

139instance FromJSON MergeError

166

140

167−instance ToJSON ImportError'

168−instance FromJSON ImportError'

169−

170instance ToJSON DatabaseContextFunctionError

141instance ToJSON DatabaseContextFunctionError

171instance FromJSON DatabaseContextFunctionError

142instance FromJSON DatabaseContextFunctionError

172

143

@@ -181,5 +152,3 @@ instance FromJSON AtomFunctionError

181

152

182instance ToJSON WithNameExpr

153instance ToJSON WithNameExpr

183instance FromJSON WithNameExpr

154instance FromJSON WithNameExpr

184−

185−

src/bin/ProjectM36/Server/WebSocket.hs+21−33

@@ -1,4 +1,4 @@

1−{-# LANGUAGE LambdaCase, CPP #-}

1+{-# LANGUAGE LambdaCase #-}

2module ProjectM36.Server.WebSocket where

3-- while the tutd client performs TutorialD parsing on the client, the websocket server will pass tutd to be parsed and executed on the server- otherwise I have to pull in ghcjs as a dependency to allow client-side parsing- that's not appealing because then the frontend is not language-agnostic, but this could change in the future, perhaps by sending different messages over the websocket

4-- ideally, the wire protocol should not be exposed to a straight string-based API ala SQL, so we could make perhaps a javascript DSL which compiles to the necessary JSON- anaylyze tradeoffs

@@ -22,14 +22,9 @@ import Data.Attoparsec.Text

22import Control.Applicative

23import Text.Megaparsec.Error

24import Data.Functor

25−import Data.Either (fromRight)

26−

27−#if MIN_VERSION_megaparsec(7,0,0)

28−import Data.List.NonEmpty as NE

29−#endif

30

25

31websocketProxyServer :: Port -> Hostname -> WS.ServerApp

26websocketProxyServer :: Port -> Hostname -> WS.ServerApp

32−websocketProxyServer port host pending = do

27+websocketProxyServer port host pending = do

33 conn <- WS.acceptRequest pending

28 conn <- WS.acceptRequest pending

34 let unexpectedMsg = WS.sendTextData conn ("messagenotexpected" :: T.Text)

29 let unexpectedMsg = WS.sendTextData conn ("messagenotexpected" :: T.Text)

35 --phase 1- accept database name for connection

30 --phase 1- accept database name for connection

@@ -38,10 +33,10 @@ websocketProxyServer port host pending = do

38 if not (connectdbmsg `T.isPrefixOf` dbmsg) then unexpectedMsg >> WS.sendClose conn ("" :: T.Text)

33 if not (connectdbmsg `T.isPrefixOf` dbmsg) then unexpectedMsg >> WS.sendClose conn ("" :: T.Text)

39 else do

34 else do

40 let dbname = T.unpack $ T.drop (T.length connectdbmsg) dbmsg

35 let dbname = T.unpack $ T.drop (T.length connectdbmsg) dbmsg

41− bracket (createConnection conn dbname port host)

36+ bracket (createConnection conn dbname port host)

42 (\case

37 (\case

43 Right dbconn -> close dbconn

38 Right dbconn -> close dbconn

44− Left _ -> pure ()) $ \case

39+ Left _ -> pure ()) $ \case

45 Left err -> sendError conn err

40 Left err -> sendError conn err

46 Right dbconn -> do

41 Right dbconn -> do

47 eSessionId <- createSessionAtHead dbconn "master"

42 eSessionId <- createSessionAtHead dbconn "master"

@@ -52,41 +47,34 @@ websocketProxyServer port host pending = do

52 _ <- forever $ do

47 _ <- forever $ do

53 pInfo <- promptInfo sessionId dbconn

48 pInfo <- promptInfo sessionId dbconn

54 --figure out why sending three times during startup is necessary

49 --figure out why sending three times during startup is necessary

55− sendPromptInfo pInfo conn

50+ sendPromptInfo pInfo conn

56 sendPromptInfo pInfo conn

51 sendPromptInfo pInfo conn

57 msg <- WS.receiveData conn :: IO T.Text

52 msg <- WS.receiveData conn :: IO T.Text

58 case parseOnly parseExecuteMessage msg of

53 case parseOnly parseExecuteMessage msg of

59 Left _ -> unexpectedMsg

54 Left _ -> unexpectedMsg

60 Right (presentation, tutdString) ->

55 Right (presentation, tutdString) ->

61 case parseTutorialD tutdString of

56 case parseTutorialD tutdString of

62− Left err -> handleOpResult conn dbconn presentation

63−#if MIN_VERSION_megaparsec(7,0,0)

64− (DisplayErrorResult

65− ("parse error: " `T.append` T.pack

66− (parseErrorPretty . NE.head . bundleErrors $ err)))

67−#else

68− (DisplayErrorResult ("parse error: " `T.append` T.pack (parseErrorPretty err)))

57+ Left err -> handleOpResult conn dbconn presentation (DisplayErrorResult ("parse error: " `T.append` T.pack (parseErrorPretty err)))

69−#endif

70 Right parsed -> do

58 Right parsed -> do

71− let timeoutFilter exc = if exc == RequestTimeoutException

59+ let timeoutFilter exc = if exc == RequestTimeoutException

72− then Just exc

60+ then Just exc

73 else Nothing

61 else Nothing

74 responseHandler = do

62 responseHandler = do

75 result <- evalTutorialD sessionId dbconn SafeEvaluation parsed

63 result <- evalTutorialD sessionId dbconn SafeEvaluation parsed

76 pInfo' <- promptInfo sessionId dbconn

64 pInfo' <- promptInfo sessionId dbconn

77− sendPromptInfo pInfo' conn

65+ sendPromptInfo pInfo' conn

78 handleOpResult conn dbconn presentation result

66 handleOpResult conn dbconn presentation result

79 catchJust timeoutFilter responseHandler (\_ -> handleOpResult conn dbconn presentation (DisplayErrorResult "Request Timed Out."))

67 catchJust timeoutFilter responseHandler (\_ -> handleOpResult conn dbconn presentation (DisplayErrorResult "Request Timed Out."))

80 pure ()

68 pure ()

81−

69+

82−notificationCallback :: WS.Connection -> NotificationCallback

70+notificationCallback :: WS.Connection -> NotificationCallback

83notificationCallback conn notifName evaldNotif = WS.sendTextData conn (encode (object ["notificationname" .= notifName,

71notificationCallback conn notifName evaldNotif = WS.sendTextData conn (encode (object ["notificationname" .= notifName,

84 "evaldnotification" .= evaldNotif

72 "evaldnotification" .= evaldNotif

85 ]))

73 ]))

86−

74+

87--this creates a new database for each connection- perhaps not what we want (?)

75--this creates a new database for each connection- perhaps not what we want (?)

88createConnection :: WS.Connection -> DatabaseName -> Port -> Hostname -> IO (Either ConnectionError Connection)

76createConnection :: WS.Connection -> DatabaseName -> Port -> Hostname -> IO (Either ConnectionError Connection)

89−createConnection wsconn dbname port host = connectProjectM36 (RemoteConnectionInfo dbname host (show port) (notificationCallback wsconn))

77+createConnection wsconn dbname port host = connectProjectM36 (RemoteProcessConnectionInfo dbname (createNodeId host port) (notificationCallback wsconn))

90

78

91sendError :: (ToJSON a) => WS.Connection -> a -> IO ()

79sendError :: (ToJSON a) => WS.Connection -> a -> IO ()

92sendError conn err = WS.sendTextData conn (encode (object ["displayerror" .= err]))

80sendError conn err = WS.sendTextData conn (encode (object ["displayerror" .= err]))

@@ -112,32 +100,32 @@ handleOpResult conn _ presentation (DisplayDataFrameResult df) = do

112 texto = ["text" .= showDataFrame df | textPresentation presentation]

100 texto = ["text" .= showDataFrame df | textPresentation presentation]

113 htmlo = ["html" .= dataFrameAsHTML df | htmlPresentation presentation]

101 htmlo = ["html" .= dataFrameAsHTML df | htmlPresentation presentation]

114 WS.sendTextData conn (encode (object ["displaydataframe" .= object (jsono ++ texto ++ htmlo)]))

102 WS.sendTextData conn (encode (object ["displaydataframe" .= object (jsono ++ texto ++ htmlo)]))

115−

103+

116-- get current schema and head name for client

104-- get current schema and head name for client

117promptInfo :: SessionId -> Connection -> IO (HeadName, SchemaName)

105promptInfo :: SessionId -> Connection -> IO (HeadName, SchemaName)

118promptInfo sessionId conn = do

106promptInfo sessionId conn = do

119− eHeadName <- headName sessionId conn

107+ eHeadName <- headName sessionId conn

120 eSchemaName <- currentSchemaName sessionId conn

108 eSchemaName <- currentSchemaName sessionId conn

121− pure (fromRight "<unknown>" eHeadName, fromRight "<no schema>" eSchemaName)

109+ pure (either (const "<unknown>") id eHeadName, either (const "<no schema>") id eSchemaName)

122−

110+

123sendPromptInfo :: (HeadName, SchemaName) -> WS.Connection -> IO ()

111sendPromptInfo :: (HeadName, SchemaName) -> WS.Connection -> IO ()

124sendPromptInfo (hName, sName) conn = WS.sendTextData conn (encode (object ["promptInfo" .= object ["headname" .= hName, "schemaname" .= sName]]))

112sendPromptInfo (hName, sName) conn = WS.sendTextData conn (encode (object ["promptInfo" .= object ["headname" .= hName, "schemaname" .= sName]]))

125

113

126--a returning relation can be returned as JSON, Text (for consoles), or HTML

114--a returning relation can be returned as JSON, Text (for consoles), or HTML

127data Presentation = Presentation {

115data Presentation = Presentation {

128− jsonPresentation :: Bool,

116+ jsonPresentation :: Bool,

129 textPresentation :: Bool,

117 textPresentation :: Bool,

130 htmlPresentation :: Bool }

118 htmlPresentation :: Bool }

131−

119+

132data PresentationFlag = JSONFlag | TextFlag | HTMLFlag

120data PresentationFlag = JSONFlag | TextFlag | HTMLFlag

133−

121+

134parseExecuteMessage :: Parser (Presentation, T.Text)

122parseExecuteMessage :: Parser (Presentation, T.Text)

135parseExecuteMessage = do

123parseExecuteMessage = do

136 _ <- string "executetutd/"

124 _ <- string "executetutd/"

137 flags <- sepBy ((string "json" $> JSONFlag) <|>

125 flags <- sepBy ((string "json" $> JSONFlag) <|>

138 (string "text" $> TextFlag) <|>

126 (string "text" $> TextFlag) <|>

139 (string "html" $> HTMLFlag)) "+"

127 (string "html" $> HTMLFlag)) "+"

140− let presentation = foldr (\flag acc -> case flag of

128+ let presentation = foldr (\flag acc -> case flag of

141 JSONFlag -> acc {jsonPresentation = True}

129 JSONFlag -> acc {jsonPresentation = True}

142 TextFlag -> acc {textPresentation = True}

130 TextFlag -> acc {textPresentation = True}

143 HTMLFlag -> acc {htmlPresentation = True}) (Presentation False False False) flags

131 HTMLFlag -> acc {htmlPresentation = True}) (Presentation False False False) flags

src/bin/ProjectM36/Server/WebSocket/websocket-client.html+1−1

@@ -126,7 +126,7 @@ margin-bottom: 5pt;

126 <li>:showrelvars</li>

127 <li>:showexpr true</li>

128 <li>:showexpr false</li>

129− <li>:importexample cjdate</li>

129+ <li>:importexample date</li>

130 <li>:showexpr s join sp</li>

131 <li>update s where city="Paris" (status:=10)</li>

132 <li>:showexpr s</li>

src/bin/ProjectM36/Server/WebSocket/websocket-server.hs+18−48

@@ -1,63 +1,33 @@

1{-# LANGUAGE CPP #-}

2−

3−import Control.Concurrent

4−import Control.Exception

5−import Control.Monad (when)

6−import Data.Maybe (isJust)

7−import Data.String (fromString)

8−import Network.HTTP.Types (status400)

9−import Network.Socket

10−import Network.Wai (Application, responseLBS)

11−import Network.Wai.Handler.Warp

12−import Network.Wai.Handler.WarpTLS (runTLS, tlsSettings)

13−import qualified Network.Wai.Handler.WebSockets as WS

14−import Network.WebSockets (defaultConnectionOptions)

15−import ProjectM36.Server

2+import ProjectM36.Server.WebSocket

16import ProjectM36.Server.Config

3import ProjectM36.Server.Config

17import ProjectM36.Server.ParseArgs

4import ProjectM36.Server.ParseArgs

18−import ProjectM36.Server.WebSocket

5+import ProjectM36.Server

6+import Control.Concurrent

7+import qualified Network.WebSockets as WS

8+

9+#if MIN_VERSION_network_transport_tcp(0,6,0)

10+import Network.Transport.TCP.Internal (decodeEndPointAddress)

11+#else

12+import Network.Transport.TCP (decodeEndPointAddress)

13+#endif

14+

15+import Control.Exception

19

16

20main :: IO ()

17main :: IO ()

21main = do

18main = do

22 -- launch normal project-m36-server

19 -- launch normal project-m36-server

23 addressMVar <- newEmptyMVar

20 addressMVar <- newEmptyMVar

24− wsConfig <- parseWSConfigWithDefaults (defaultServerConfig {bindPort = 8000, bindHost = "127.0.0.1"})

21+ serverConfig <- parseConfigWithDefaults (defaultServerConfig { bindPort = 8000, bindHost = "127.0.0.1" })

25−

26 --usurp the serverConfig for our websocket server and make the proxied server run locally

22 --usurp the serverConfig for our websocket server and make the proxied server run locally

27− let serverConfig = wsServerConfig wsConfig

28− wsHost = bindHost serverConfig

23+ let wsHost = bindHost serverConfig

29 wsPort = bindPort serverConfig

24 wsPort = bindPort serverConfig

30 serverHost = "127.0.0.1"

25 serverHost = "127.0.0.1"

31 serverConfig' = serverConfig {bindPort = 0, bindHost = serverHost}

26 serverConfig' = serverConfig {bindPort = 0, bindHost = serverHost}

32− configCertificateFile = tlsCertificatePath wsConfig

33− configKeyFile = tlsKeyPath wsConfig

34−

35− when (isJust configCertificateFile /= isJust configKeyFile) $

36− throwIO $ ErrorCall "TLS_CERTIFICATE_PATH and TLS_KEY_PATH must be set in tandem"

37−

38 _ <- forkFinally (launchServer serverConfig' (Just addressMVar) >> pure ()) (either throwIO pure)

27 _ <- forkFinally (launchServer serverConfig' (Just addressMVar) >> pure ()) (either throwIO pure)

39 --wait for server to be listening

28 --wait for server to be listening

40− addr <- takeMVar addressMVar

29+ address <- takeMVar addressMVar

41− let port =

30+ let Just (_, serverPort, _) = decodeEndPointAddress address

42− case addr of

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

43− SockAddrInet port' _ -> fromIntegral port'

32+ WS.runServer wsHost (fromIntegral wsPort) (websocketProxyServer (read serverPort) serverHost)

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"

55

33

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+28−30

@@ -28,13 +28,12 @@ import System.Console.Haskeline

28import System.Directory (getHomeDirectory)

29import qualified Data.Text as T

30import System.IO (hPutStrLn, stderr)

31−#if __GLASGOW_HASKELL__ < 804

31+#if __GLASGOW_HASKELL__ <= 802

32import Data.Monoid

33#endif

34import Data.List (isPrefixOf)

35import Control.Exception

36import System.Exit

37−import Data.Either (fromRight)

38

37

39{-

38{-

40context ops are read-only operations which only operate on the database context (relvars and constraints)

39context ops are read-only operations which only operate on the database context (relvars and constraints)

@@ -62,7 +61,7 @@ interpreterParserP = safeInterpreterParserP <|>

62 fmap ImportDBContextOp (tutdImportP <* eof) <|>

61 fmap ImportDBContextOp (tutdImportP <* eof) <|>

63 fmap RelVarExportOp (exportCSVP <* eof) <|>

62 fmap RelVarExportOp (exportCSVP <* eof) <|>

64 fmap DatabaseContextIOExprOp (dbContextIOExprP <* eof)

63 fmap DatabaseContextIOExprOp (dbContextIOExprP <* eof)

65−

64+

66-- the safe interpreter never reads or writes the file system

65-- the safe interpreter never reads or writes the file system

67safeInterpreterParserP :: Parser ParsedOperation

66safeInterpreterParserP :: Parser ParsedOperation

68safeInterpreterParserP = fmap RODatabaseContextOp (roDatabaseContextOperatorP <* eof) <|>

67safeInterpreterParserP = fmap RODatabaseContextOp (roDatabaseContextOperatorP <* eof) <|>

@@ -78,8 +77,8 @@ safeInterpreterParserP = fmap RODatabaseContextOp (roDatabaseContextOperatorP <*

78promptText :: Either RelationalError HeadName -> Either RelationalError SchemaName -> StringType

77promptText :: Either RelationalError HeadName -> Either RelationalError SchemaName -> StringType

79promptText eHeadName eSchemaName = "TutorialD (" <> transInfo <> "): "

78promptText eHeadName eSchemaName = "TutorialD (" <> transInfo <> "): "

80 where

79 where

81− transInfo = fromRight "<unknown>" eHeadName <> "/" <> fromRight "<no schema>" eSchemaName

80+ transInfo = either (const "<unknown>") id eHeadName <> "/" <> either (const "<no schema>") id eSchemaName

82−

81+

83parseTutorialD :: T.Text -> Either ParserError ParsedOperation

82parseTutorialD :: T.Text -> Either ParserError ParsedOperation

84parseTutorialD = parse interpreterParserP ""

83parseTutorialD = parse interpreterParserP ""

85

84

@@ -107,20 +106,20 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of

107 else

106 else

108 pure res

107 pure res

109 _ -> pure res

108 _ -> pure res

110−

109+

111− (DatabaseContextExprOp execOp) ->

110+ (DatabaseContextExprOp execOp) ->

112− eHandler $ C.executeDatabaseContextExpr sessionId conn execOp

111+ eHandler $ C.executeDatabaseContextExpr sessionId conn execOp

113−

112+

114− (DatabaseContextIOExprOp execOp) ->

113+ (DatabaseContextIOExprOp execOp) ->

115 if needsSafe then

114 if needsSafe then

116 unsafeError

115 unsafeError

117 else

116 else

118 eHandler $ C.executeDatabaseContextIOExpr sessionId conn execOp

117 eHandler $ C.executeDatabaseContextIOExpr sessionId conn execOp

119−

118+

120 (GraphOp execOp) -> do

119 (GraphOp execOp) -> do

121 -- warn if the graph op could cause uncommited changes to be discarded

120 -- warn if the graph op could cause uncommited changes to be discarded

122 eIsDirty <- C.disconnectedTransactionIsDirty sessionId conn

121 eIsDirty <- C.disconnectedTransactionIsDirty sessionId conn

123− let runGraphOp = eHandler $ C.executeGraphExpr sessionId conn execOp

122+ let runGraphOp = eHandler $ C.executeGraphExpr sessionId conn execOp

124 settings = Settings {complete = noCompletion,

123 settings = Settings {complete = noCompletion,

125 historyFile = Nothing,

124 historyFile = Nothing,

126 autoAddHistory = False}

125 autoAddHistory = False}

@@ -144,20 +143,20 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of

144 pure (DisplayErrorResult "Graph operation cancelled.")

143 pure (DisplayErrorResult "Graph operation cancelled.")

145 else

144 else

146 runGraphOp

145 runGraphOp

147−

146+

148 (ConvenienceGraphOp execOp) ->

147 (ConvenienceGraphOp execOp) ->

149 eHandler $ evalConvenienceGraphOp sessionId conn execOp

148 eHandler $ evalConvenienceGraphOp sessionId conn execOp

150

149

151 (ROGraphOp execOp) -> do

150 (ROGraphOp execOp) -> do

152 opResult <- evalROGraphOp sessionId conn execOp

151 opResult <- evalROGraphOp sessionId conn execOp

153− case opResult of

152+ case opResult of

154 Left err -> barf err

153 Left err -> barf err

155 Right rel -> pure (DisplayRelationResult rel)

154 Right rel -> pure (DisplayRelationResult rel)

156−

155+

157 (SchemaOp execOp) ->

156 (SchemaOp execOp) ->

158 eHandler $ evalSchemaOperator sessionId conn execOp

157 eHandler $ evalSchemaOperator sessionId conn execOp

159−

158+

160− (ImportRelVarOp execOp@(RelVarDataImportOperator relVarName _ _)) ->

159+ (ImportRelVarOp execOp@(RelVarDataImportOperator relVarName _ _)) ->

161 if needsSafe then

160 if needsSafe then

162 unsafeError

161 unsafeError

163 else do

162 else do

@@ -175,8 +174,8 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of

175 case exprErr of

174 case exprErr of

176 Left err -> barf err

175 Left err -> barf err

177 Right dbexpr -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexpr)

176 Right dbexpr -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexpr)

178−

177+

179− (ImportDBContextOp execOp) ->

178+ (ImportDBContextOp execOp) ->

180 if needsSafe then

179 if needsSafe then

181 unsafeError

180 unsafeError

182 else do

181 else do

@@ -184,15 +183,15 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of

184 case eErr of

183 case eErr of

185 Left err -> barf err

184 Left err -> barf err

186 Right dbexprs -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexprs)

185 Right dbexprs -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexprs)

187−

186+

188− (InfoOp execOp) ->

187+ (InfoOp execOp) ->

189 if needsSafe then

188 if needsSafe then

190 unsafeError

189 unsafeError

191 else

190 else

192 case evalInformationOperator execOp of

191 case evalInformationOperator execOp of

193 Left err -> pure (DisplayErrorResult err)

192 Left err -> pure (DisplayErrorResult err)

194 Right info -> pure (DisplayResult info)

193 Right info -> pure (DisplayResult info)

195−

194+

196 (RelVarExportOp execOp@(RelVarDataExportOperator relExpr _ _)) ->

195 (RelVarExportOp execOp@(RelVarDataExportOperator relExpr _ _)) ->

197 --eval relexpr to relation and pass to export function

196 --eval relexpr to relation and pass to export function

198 if needsSafe then

197 if needsSafe then

@@ -216,20 +215,19 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of

216 unsafeError = pure $ DisplayErrorResult "File I/O operation prohibited."

215 unsafeError = pure $ DisplayErrorResult "File I/O operation prohibited."

217 barf :: RelationalError -> IO TutorialDOperatorResult

216 barf :: RelationalError -> IO TutorialDOperatorResult

218 barf (ScriptError (OtherScriptCompilationError errStr)) = pure (DisplayErrorResult (T.pack errStr))

217 barf (ScriptError (OtherScriptCompilationError errStr)) = pure (DisplayErrorResult (T.pack errStr))

219− barf (ParseError err) = pure (DisplayErrorResult err)

220 barf err = return $ DisplayErrorResult (T.pack (show err))

218 barf err = return $ DisplayErrorResult (T.pack (show err))

221 eHandler io = do

219 eHandler io = do

222 eErr <- io

220 eErr <- io

223 case eErr of

221 case eErr of

224 Left err -> barf err

222 Left err -> barf err

225 Right () -> return QuietSuccessResult

223 Right () -> return QuietSuccessResult

226−

224+

227−type GhcPkgPath = String

225+type GhcPkgPath = String

228type TutorialDExec = String

226type TutorialDExec = String

229type CheckFS = Bool

227type CheckFS = Bool

230−

228+

231data InterpreterConfig = LocalInterpreterConfig PersistenceStrategy HeadName (Maybe TutorialDExec) [GhcPkgPath] CheckFS |

229data InterpreterConfig = LocalInterpreterConfig PersistenceStrategy HeadName (Maybe TutorialDExec) [GhcPkgPath] CheckFS |

232− RemoteInterpreterConfig C.Hostname C.Port C.DatabaseName HeadName (Maybe TutorialDExec) CheckFS

230+ RemoteInterpreterConfig C.NodeId C.DatabaseName HeadName (Maybe TutorialDExec) CheckFS

233

231

234outputNotificationCallback :: C.NotificationCallback

232outputNotificationCallback :: C.NotificationCallback

235outputNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received " ++ show notName ++ ":\n" ++ "\n" ++ prettyEvaluatedNotification evaldNot

233outputNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received " ++ show notName ++ ":\n" ++ "\n" ++ prettyEvaluatedNotification evaldNot

@@ -258,12 +256,12 @@ reprLoop config sessionId conn = do

258 Just line -> do

256 Just line -> do

259 runTutorialD sessionId conn (Just (T.length prompt)) (T.pack line)

257 runTutorialD sessionId conn (Just (T.length prompt)) (T.pack line)

260 reprLoop config sessionId conn

258 reprLoop config sessionId conn

261−

259+

262

260

263runTutorialD :: C.SessionId -> C.Connection -> Maybe PromptLength -> T.Text -> IO ()

261runTutorialD :: C.SessionId -> C.Connection -> Maybe PromptLength -> T.Text -> IO ()

264−runTutorialD sessionId conn mPromptLength tutd =

262+runTutorialD sessionId conn mPromptLength tutd =

265 case parseTutorialD tutd of

263 case parseTutorialD tutd of

266− Left err ->

264+ Left err ->

267 displayOpResult $ DisplayParseErrorResult mPromptLength err

265 displayOpResult $ DisplayParseErrorResult mPromptLength err

268 Right parsed ->

266 Right parsed ->

269 catchJust (\exc -> if exc == C.RequestTimeoutException then Just exc else Nothing) (do

267 catchJust (\exc -> if exc == C.RequestTimeoutException then Just exc else Nothing) (do

src/bin/TutorialD/Interpreter/Base.hs+38−66

@@ -1,8 +1,8 @@

1{-# LANGUAGE DeriveGeneric, CPP #-}

2module TutorialD.Interpreter.Base (

3− module TutorialD.Interpreter.Base,

3+ module TutorialD.Interpreter.Base,

4 module Text.Megaparsec,

5−#if MIN_VERSION_megaparsec(6,0,0)

5+#if MIN_VERSION_megaparsec(6,0,0)

6 module Text.Megaparsec.Char,

7 module Control.Applicative

8#else

@@ -12,12 +12,11 @@ module TutorialD.Interpreter.Base (

12 where

13import ProjectM36.Base

14import ProjectM36.AtomType

15−import ProjectM36.Attribute as A

16import ProjectM36.Relation

15import ProjectM36.Relation

17import ProjectM36.DataFrame

16import ProjectM36.DataFrame

18

17

19#if MIN_VERSION_megaparsec(6,0,0)

18#if MIN_VERSION_megaparsec(6,0,0)

20−import Text.Megaparsec.Char

19+import Text.Megaparsec.Char

21import qualified Text.Megaparsec.Char.Lexer as Lex

20import qualified Text.Megaparsec.Char.Lexer as Lex

22import Text.Megaparsec

21import Text.Megaparsec

23import Data.Void

22import Data.Void

@@ -31,11 +30,12 @@ import Data.Text hiding (count)

31import System.Random

30import System.Random

32import qualified Data.Text as T

31import qualified Data.Text as T

33import qualified Data.List as L

32import qualified Data.List as L

33+import qualified Data.Vector as V

34import qualified Data.Text.IO as TIO

35import System.IO

36import ProjectM36.Relation.Show.Term

37import GHC.Generics

38−#if __GLASGOW_HASKELL__ < 804

38+#if __GLASGOW_HASKELL__ <= 802

39import Data.Monoid

40#endif

41import qualified Data.UUID as U

@@ -44,18 +44,12 @@ import Data.List.NonEmpty as NE

44import Data.Time.Clock

45import Data.Time.Format

46import Control.Monad (void)

47−import Data.Char

48−

49−#if !MIN_VERSION_megaparsec(7,0,0)

50−anySingle :: Parsec Void Text (Token Text)

51−anySingle = anyChar

52−#endif

53

47

54displayOpResult :: TutorialDOperatorResult -> IO ()

48displayOpResult :: TutorialDOperatorResult -> IO ()

55displayOpResult QuitResult = return ()

49displayOpResult QuitResult = return ()

56displayOpResult (DisplayResult out) = TIO.putStrLn out

50displayOpResult (DisplayResult out) = TIO.putStrLn out

57displayOpResult (DisplayIOResult ioout) = ioout

51displayOpResult (DisplayIOResult ioout) = ioout

58−displayOpResult (DisplayErrorResult err) = let outputf = if T.length err > 0 && T.last err /= '\n' then TIO.hPutStrLn else TIO.hPutStr in

52+displayOpResult (DisplayErrorResult err) = let outputf = if T.length err > 0 && T.last err /= '\n' then TIO.hPutStrLn else TIO.hPutStr in

59 outputf stderr ("ERR: " <> err)

53 outputf stderr ("ERR: " <> err)

60displayOpResult QuietSuccessResult = return ()

54displayOpResult QuietSuccessResult = return ()

61displayOpResult (DisplayRelationResult rel) = do

55displayOpResult (DisplayRelationResult rel) = do

@@ -63,13 +57,8 @@ displayOpResult (DisplayRelationResult rel) = do

63 let randomlySortedRel = evalRand (randomizeTupleOrder rel) gen

57 let randomlySortedRel = evalRand (randomizeTupleOrder rel) gen

64 TIO.putStrLn (showRelation randomlySortedRel)

58 TIO.putStrLn (showRelation randomlySortedRel)

65displayOpResult (DisplayParseErrorResult mPromptLength err) = do

59displayOpResult (DisplayParseErrorResult mPromptLength err) = do

66−#if MIN_VERSION_megaparsec(7,0,0)

67− let errorIndent = errorOffset . NE.head . bundleErrors $ err

68− errString = T.pack (parseErrorPretty . NE.head . bundleErrors $ err)

60+ let errString = T.pack (parseErrorPretty err)

69−#else

70− let errorIndent = unPos (sourceColumn (NE.head (errorPos err)))

61+ errorIndent = unPos (sourceColumn (NE.head (errorPos err)))

71− errString = T.pack (parseErrorPretty err)

72−#endif

73 pointyString len = T.justifyRight (len + fromIntegral errorIndent) '_' "^"

62 pointyString len = T.justifyRight (len + fromIntegral errorIndent) '_' "^"

74 maybe (pure ()) (TIO.putStrLn . pointyString) mPromptLength

63 maybe (pure ()) (TIO.putStrLn . pointyString) mPromptLength

75 TIO.putStr ("ERR:" <> errString)

64 TIO.putStr ("ERR:" <> errString)

@@ -82,10 +71,9 @@ type ParseStr = Text

82type ParseStr = String

71type ParseStr = String

83#endif

72#endif

84

73

85−-- consumes only horizontal spaces

86spaceConsumer :: Parser ()

74spaceConsumer :: Parser ()

87−spaceConsumer = Lex.space space1 (Lex.skipLineComment "--") (Lex.skipBlockComment "{-" "-}")

75+spaceConsumer = Lex.space (void spaceChar) (Lex.skipLineComment "--") (Lex.skipBlockComment "{-" "-}")

88−

76+

89opChar :: Parser Char

77opChar :: Parser Char

90opChar = oneOf (":!#$%&*+./<=>?\\^|-~" :: String)-- remove "@" so it can be used as attribute marker without spaces

78opChar = oneOf (":!#$%&*+./<=>?\\^|-~" :: String)-- remove "@" so it can be used as attribute marker without spaces

91

79

@@ -104,13 +92,9 @@ braces = between (symbol "{") (symbol "}")

104identifier :: Parser Text

92identifier :: Parser Text

105identifier = do

93identifier = do

106 istart <- letterChar <|> char '_'

94 istart <- letterChar <|> char '_'

107− identifierRemainder istart

108−

109−identifierRemainder :: Char -> Parser Text

110−identifierRemainder c = do

111− rest <- many (alphaNumChar <|> char '_' <|> char '#')

95+ irest <- many (alphaNumChar <|> char '_' <|> char '#')

112 spaceConsumer

96 spaceConsumer

113− pure (pack (c:rest))

97+ pure (pack (istart:irest))

114

98

115symbol :: ParseStr -> Parser Text

99symbol :: ParseStr -> Parser Text

116#if MIN_VERSION_megaparsec(6,0,0)

100#if MIN_VERSION_megaparsec(6,0,0)

@@ -137,14 +121,11 @@ arrow = symbol "->"

137semi :: Parser Text

121semi :: Parser Text

138semi = symbol ";"

122semi = symbol ";"

139

123

140−nline :: Parser Text

141−nline = (T.singleton <$> newline) <|> crlf

142−

143integer :: Parser Integer

124integer :: Parser Integer

144#if MIN_VERSION_megaparsec(6,0,0)

125#if MIN_VERSION_megaparsec(6,0,0)

145−integer = Lex.signed (pure ()) Lex.decimal <* spaceConsumer

126+integer = Lex.signed spaceConsumer Lex.decimal

146#else

127#else

147−integer = Lex.signed (pure ()) Lex.integer <* spaceConsumer

128+integer = Lex.signed spaceConsumer Lex.integer

148#endif

129#endif

149

130

150natural :: Parser Integer

131natural :: Parser Integer

@@ -155,30 +136,36 @@ natural = Lex.integer <* spaceConsumer

155#endif

136#endif

156

137

157float :: Parser Double

138float :: Parser Double

158−float = Lex.float <* spaceConsumer

139+float = Lex.float

159

140

160capitalizedIdentifier :: Parser Text

141capitalizedIdentifier :: Parser Text

161−capitalizedIdentifier =

142+capitalizedIdentifier = do

162− upperChar >>= identifierRemainder

143+ fletter <- upperChar

163−

144+ restOfIdentifier_ fletter

145+

146+restOfIdentifier_ :: Char -> Parser Text

147+restOfIdentifier_ fletter = do

148+ rest <- option "" identifier

149+ spaceConsumer

150+ pure (T.cons fletter rest)

151+

164uncapitalizedIdentifier :: Parser Text

152uncapitalizedIdentifier :: Parser Text

165−uncapitalizedIdentifier =

153+uncapitalizedIdentifier = do

166− lowerChar >>= identifierRemainder

154+ fletter <- lowerChar

155+ restOfIdentifier_ fletter

167

156

168showRelationAttributes :: Attributes -> Text

157showRelationAttributes :: Attributes -> Text

169showRelationAttributes attrs = "{" <> T.concat (L.intersperse ", " $ L.map showAttribute attrsL) <> "}"

158showRelationAttributes attrs = "{" <> T.concat (L.intersperse ", " $ L.map showAttribute attrsL) <> "}"

170 where

159 where

171− showAttribute (Attribute name atomType') = name <> " " <> prettyAtomType atomType'

160+ showAttribute (Attribute name atomType) = name <> " " <> prettyAtomType atomType

172− attrsL = A.toList attrs

161+ attrsL = V.toList attrs

173

162

174−type PromptLength = Int

163+type PromptLength = Int

175

164

176−#if MIN_VERSION_megaparsec(7,0,0)

165+#if MIN_VERSION_megaparsec(6,0,0)

177−type ParserError = ParseErrorBundle T.Text Void

178−#elif MIN_VERSION_megaparsec(6,0,0)

179type ParserError = ParseError Char Void

166type ParserError = ParseError Char Void

180−#else

167+#else

181−type ParserError = ParseError Char Dec

168+type ParserError = ParseError Char Dec

182#endif

169#endif

183

170

184data TutorialDOperatorResult = QuitResult |

171data TutorialDOperatorResult = QuitResult |

@@ -190,27 +177,24 @@ data TutorialDOperatorResult = QuitResult |

190 DisplayParseErrorResult (Maybe PromptLength) ParserError | -- PromptLength refers to length of prompt text

177 DisplayParseErrorResult (Maybe PromptLength) ParserError | -- PromptLength refers to length of prompt text

191 QuietSuccessResult

178 QuietSuccessResult

192 deriving (Generic)

179 deriving (Generic)

193−

180+

194type TransactionGraphWasUpdated = Bool

181type TransactionGraphWasUpdated = Bool

195

182

196--allow for python-style triple quoting because guessing the correct amount of escapes in different contexts is annoying

183--allow for python-style triple quoting because guessing the correct amount of escapes in different contexts is annoying

197tripleQuotedString :: Parser Text

184tripleQuotedString :: Parser Text

198tripleQuotedString = do

185tripleQuotedString = do

199 _ <- tripleQuote

186 _ <- tripleQuote

200− pack <$> manyTill anySingle (try (tripleQuote >> notFollowedBy quote))

187+ pack <$> manyTill anyChar (try (tripleQuote >> notFollowedBy quote))

201−

188+

202normalQuotedString :: Parser Text

189normalQuotedString :: Parser Text

203normalQuotedString = quote *> (T.pack <$> manyTill Lex.charLiteral quote)

190normalQuotedString = quote *> (T.pack <$> manyTill Lex.charLiteral quote)

204

191

205quotedString :: Parser Text

192quotedString :: Parser Text

206quotedString = try tripleQuotedString <|> normalQuotedString

193quotedString = try tripleQuotedString <|> normalQuotedString

207

194

208−quoted :: Parser a -> Parser a

209−quoted = between quote quote

210−

211uuidP :: Parser U.UUID

195uuidP :: Parser U.UUID

212uuidP = do

196uuidP = do

213− uuidStart <- count 8 hexDigitChar

197+ uuidStart <- count 8 hexDigitChar

214 _ <- char '-' -- min 28 with no dashes, maximum 4 dashes

198 _ <- char '-' -- min 28 with no dashes, maximum 4 dashes

215 uuidMid1 <- count 4 hexDigitChar

199 uuidMid1 <- count 4 hexDigitChar

216 _ <- char '-'

200 _ <- char '-'

@@ -230,16 +214,4 @@ utcTimeP = do

230 case parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" (T.unpack timeStr) of

214 case parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" (T.unpack timeStr) of

231 Nothing -> fail "invalid datetime input, use \"YYYY-MM-DD HH:MM:SS\""

215 Nothing -> fail "invalid datetime input, use \"YYYY-MM-DD HH:MM:SS\""

232 Just stamp' -> pure stamp'

216 Just stamp' -> pure stamp'

233−

234−

235−colonOp :: Text -> Parser ()

236−colonOp opStr = do

237− _ <- string opStr <* (void spaceChar <|> eof) <* spaceConsumer

238− pure ()

239−

240−hex :: Parser Text

241−hex = takeWhileP (Just "hexadecimal")

242− (\c ->

243− isDigit c

244− || (c >= 'a' && c <= 'f'))

245

217

src/bin/TutorialD/Interpreter/DatabaseContextExpr.hs+13−16

@@ -12,7 +12,7 @@ import ProjectM36.Error

12import qualified ProjectM36.RelationalExpression as RE

13import ProjectM36.Key

14import ProjectM36.FunctionalDependency

15−#if __GLASGOW_HASKELL__ < 804

15+#if __GLASGOW_HASKELL__ <= 802

16import Data.Monoid

17#endif

18import Data.Functor

@@ -44,7 +44,7 @@ nothingP = spaceConsumer >> pure NoOperation

44assignP :: Parser DatabaseContextExpr

45assignP = do

46 relVarName <- try $ do

47− relVarName <- relVarNameP

47+ relVarName <- identifier

48 reservedOp ":="

49 return relVarName

50 Assign relVarName <$> relExprP

@@ -53,20 +53,19 @@ multilineSep :: Parser T.Text

53multilineSep = newline >> pure "\n"

54

55multipleDatabaseContextExprP :: Parser DatabaseContextExpr

56−multipleDatabaseContextExprP = do

56+multipleDatabaseContextExprP =

57− exprs <- filter (/= NoOperation) <$> sepBy1 databaseContextExprP semi

57+ MultipleExpr <$> sepBy1 databaseContextExprP semi

58− pure (MultipleExpr exprs)

59

58

60insertP :: Parser DatabaseContextExpr

59insertP :: Parser DatabaseContextExpr

61insertP = do

60insertP = do

62 reservedOp "insert"

61 reservedOp "insert"

63− relvar <- relVarNameP

62+ relvar <- identifier

64 Insert relvar <$> relExprP

63 Insert relvar <$> relExprP

65

64

66defineP :: Parser DatabaseContextExpr

65defineP :: Parser DatabaseContextExpr

67defineP = do

66defineP = do

68 relVarName <- try $ do

67 relVarName <- try $ do

69− relVarName <- relVarNameP

68+ relVarName <- identifier

70 reservedOp "::"

69 reservedOp "::"

71 return relVarName

70 return relVarName

72 Define relVarName <$> makeAttributeExprsP

71 Define relVarName <$> makeAttributeExprsP

@@ -74,17 +73,17 @@ defineP = do

74undefineP :: Parser DatabaseContextExpr

73undefineP :: Parser DatabaseContextExpr

75undefineP = do

74undefineP = do

76 reservedOp "undefine"

75 reservedOp "undefine"

77− Undefine <$> relVarNameP

76+ Undefine <$> identifier

78

77

79deleteP :: Parser DatabaseContextExpr

78deleteP :: Parser DatabaseContextExpr

80deleteP = do

79deleteP = do

81 reservedOp "delete"

80 reservedOp "delete"

82− Delete <$> relVarNameP <*> option TruePredicate (reservedOp "where" *> restrictionPredicateP)

81+ Delete <$> identifier <*> option TruePredicate (reservedOp "where" *> restrictionPredicateP)

83

82

84updateP :: Parser DatabaseContextExpr

83updateP :: Parser DatabaseContextExpr

85updateP = do

84updateP = do

86 reservedOp "update"

85 reservedOp "update"

87− relVarName <- relVarNameP

86+ relVarName <- identifier

88 predicate <- option TruePredicate (reservedOp "where" *> restrictionPredicateP <* spaceConsumer)

87 predicate <- option TruePredicate (reservedOp "where" *> restrictionPredicateP <* spaceConsumer)

89 attributeAssignments <- M.fromList <$> parens (sepBy attributeAssignmentP comma)

88 attributeAssignments <- M.fromList <$> parens (sepBy attributeAssignmentP comma)

90 return $ Update relVarName attributeAssignments predicate

89 return $ Update relVarName attributeAssignments predicate

@@ -167,7 +166,7 @@ addTypeConstructorP = do

167removeTypeConstructorP :: Parser DatabaseContextExpr

166removeTypeConstructorP :: Parser DatabaseContextExpr

168removeTypeConstructorP = do

167removeTypeConstructorP = do

169 reserved "undata"

168 reserved "undata"

170− RemoveTypeConstructor <$> typeConstructorNameP

169+ RemoveTypeConstructor <$> identifier

171

170

172removeAtomFunctionP :: Parser DatabaseContextExpr

171removeAtomFunctionP :: Parser DatabaseContextExpr

173removeAtomFunctionP = do

172removeAtomFunctionP = do

@@ -179,13 +178,10 @@ removeDatabaseContextFunctionP = do

179 reserved "removedatabasecontextfunction"

178 reserved "removedatabasecontextfunction"

180 RemoveDatabaseContextFunction <$> quotedString

179 RemoveDatabaseContextFunction <$> quotedString

181

180

182−functionNameP :: Parser AtomFunctionName

183−functionNameP = uncapitalizedIdentifier

184−

185executeDatabaseContextFunctionP :: Parser DatabaseContextExpr

181executeDatabaseContextFunctionP :: Parser DatabaseContextExpr

186executeDatabaseContextFunctionP = do

182executeDatabaseContextFunctionP = do

187 reserved "execute"

183 reserved "execute"

188− funcName <- functionNameP

184+ funcName <- identifier

189 args <- parens (sepBy atomExprP comma)

185 args <- parens (sepBy atomExprP comma)

190 pure (ExecuteDatabaseContextFunction funcName args)

186 pure (ExecuteDatabaseContextFunction funcName args)

191

187

@@ -207,7 +203,8 @@ interpretDatabaseContextExpr context transId graph tutdstring =

207 Left err -> Left $ PM36E.ParseError (T.pack (show err))

203 Left err -> Left $ PM36E.ParseError (T.pack (show err))

208 Right parsed -> do

204 Right parsed -> do

209 let env = RE.mkDatabaseContextEvalEnv transId graph

205 let env = RE.mkDatabaseContextEvalEnv transId graph

210− RE.dbc_context <$> RE.runDatabaseContextEvalMonad context env (optimizeAndEvalDatabaseContextExpr True parsed)

206+ x <- RE.dbc_context <$> RE.runDatabaseContextEvalMonad context env (optimizeAndEvalDatabaseContextExpr True parsed)

207+ pure x

211

208

212{-

209{-

213--no optimization

210--no optimization

src/bin/TutorialD/Interpreter/Export/Base.hs+1−1

@@ -2,7 +2,7 @@

2module TutorialD.Interpreter.Export.Base where

3import ProjectM36.Base

4import ProjectM36.Error

5−#if __GLASGOW_HASKELL__ < 804

5+#if __GLASGOW_HASKELL__ <= 802

6import Data.Monoid

7#endif

8

src/bin/TutorialD/Interpreter/Import/Base.hs+4−9

@@ -2,9 +2,7 @@

2module TutorialD.Interpreter.Import.Base where

3import ProjectM36.Base

4import ProjectM36.Error

5−import Text.URI (URI)

6−import Data.Text (Text)

7−#if __GLASGOW_HASKELL__ < 804

5+#if __GLASGOW_HASKELL__ <= 802

8import Data.Monoid

6import Data.Monoid

9#endif

7#endif

10

8

@@ -14,14 +12,11 @@ data RelVarDataImportOperator = RelVarDataImportOperator RelVarName FilePath (Re

14instance Show RelVarDataImportOperator where

12instance Show RelVarDataImportOperator where

15 show (RelVarDataImportOperator rv path _) = "RelVarDataImportOperator " <> show rv <> " " <> path

13 show (RelVarDataImportOperator rv path _) = "RelVarDataImportOperator " <> show rv <> " " <> path

16

14

17−type HashVerification = Maybe Text

18−

19-- | import data into a database context

15-- | import data into a database context

20−data DatabaseContextDataImportOperator = DatabaseContextDataImportOperator URI HashVerification (URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr))

16+data DatabaseContextDataImportOperator = DatabaseContextDataImportOperator FilePath (FilePath -> IO (Either RelationalError DatabaseContextExpr))

21

17

22instance Show DatabaseContextDataImportOperator where

18instance Show DatabaseContextDataImportOperator where

23− show (DatabaseContextDataImportOperator uri hash _) =

19+ show (DatabaseContextDataImportOperator path _) = "DatabaseContextDataImportOperator " <> path

24− "DatabaseContextDataImportOperator " <> show uri <> " " <> show hash

25

20

26-- perhaps create a structure to import a whole transaction graph section in the future

21-- perhaps create a structure to import a whole transaction graph section in the future

27

22

@@ -29,4 +24,4 @@ evalRelVarDataImportOperator :: RelVarDataImportOperator -> TypeConstructorMappi

29evalRelVarDataImportOperator (RelVarDataImportOperator relVarName path importFunc) tConsMap attrs = importFunc relVarName tConsMap attrs path

24evalRelVarDataImportOperator (RelVarDataImportOperator relVarName path importFunc) tConsMap attrs = importFunc relVarName tConsMap attrs path

30

25

31evalDatabaseContextDataImportOperator :: DatabaseContextDataImportOperator -> IO (Either RelationalError DatabaseContextExpr)

26evalDatabaseContextDataImportOperator :: DatabaseContextDataImportOperator -> IO (Either RelationalError DatabaseContextExpr)

32−evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator uri hash importFunc) = importFunc uri hash

27+evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator path importFunc) = importFunc path

src/bin/TutorialD/Interpreter/Import/BasicExamples.hs+2−2

@@ -20,8 +20,8 @@ importBasicExampleOperatorP :: Parser ImportBasicExampleOperator

20importBasicExampleOperatorP = do

21 reservedOp ":importexample"

22 example <- identifier

23− if example == "cjdate" then

23+ if example == "date" then

24 pure ImportBasicDateExampleOperator

25 else

26 fail "Unknown example name"

27−

27+

src/bin/TutorialD/Interpreter/Import/CSV.hs+3−3

@@ -14,10 +14,10 @@ importCSVRelation relVarName tConsMap attrs pathIn = do

14 --TODO: handle filesystem errors

15 csvData <- try (BS.readFile pathIn) :: IO (Either IOError BS.ByteString)

16 case csvData of

17− Left err -> pure $ Left (ImportError (ImportFileError (T.pack (show err))))

17+ Left err -> return $ Left (ImportError $ T.pack (show err))

18 Right csvData' -> case csvAsRelation attrs tConsMap csvData' of

19− Left err -> pure $ Left (ParseError $ T.pack (show err))

19+ Left err -> return $ Left (ParseError $ T.pack (show err))

20− Right csvRel -> pure $ Right (Insert relVarName (ExistingRelation csvRel))

20+ Right csvRel -> return $ Right (Insert relVarName (ExistingRelation csvRel))

21

22importCSVP :: Parser RelVarDataImportOperator

23importCSVP = do

src/bin/TutorialD/Interpreter/Import/TutorialD.hs+17−70

@@ -9,78 +9,25 @@ import qualified Data.Text as T

9import Control.Exception

10import qualified Data.ByteString as BS

11import qualified Data.Text.Encoding as TE

12−import qualified Text.URI as URI

13−import Text.URI (URI)

14−import Crypto.Hash.SHA256

15−import Data.ByteString.Base16 as B16

16−import Network.HTTP.Simple

17−import Network.HTTP.Types

18−--import a file containing TutorialD database context expressions via local files or HTTP/HTTPS

12+--import a file containing TutorialD database context expressions

19

13

20−importTutorialDFromFile :: URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr)

14+importTutorialD :: FilePath -> IO (Either RelationalError DatabaseContextExpr)

21−importTutorialDFromFile fileURI mHash = do

15+importTutorialD pathIn = do

22− case URI.uriPath fileURI of

23− Just (False, _) -> do

24− eTutdBytes <- try (BS.readFile filePath) :: IO (Either IOError BS.ByteString)

16+ eTutdBytes <- try (BS.readFile pathIn) :: IO (Either IOError BS.ByteString)

25− case eTutdBytes of

17+ case eTutdBytes of

26− Left err -> pure $ Left (ImportError (ImportFileError (T.pack (show err))))

18+ Left err -> return $ Left (ImportError $ T.pack (show err))

27− Right tutdBytes ->

19+ Right tutdBytes ->

28− case validateBytes tutdBytes mHash of

29− Left err -> pure (Left err)

30− Right tutdBytes' -> importTutorialDBytes tutdBytes'

31− _ -> pure (Left (ImportError (InvalidFileURIError (URI.render fileURI))))

32− where

33− filePath = drop (length ("file://" :: String)) (URI.renderStr fileURI)

34−

35−

36−importTutorialDBytes :: BS.ByteString -> IO (Either RelationalError DatabaseContextExpr)

37−importTutorialDBytes tutdBytes =

38− case TE.decodeUtf8' tutdBytes of

20+ case TE.decodeUtf8' tutdBytes of

39− Left err -> pure (Left (ImportError (ImportFileDecodeError (T.pack (show err)))))

21+ Left err -> pure (Left (ImportError $ T.pack (show err)))

40− Right tutdUtf8 ->

22+ Right tutdUtf8 ->

41− case parse (multipleDatabaseContextExprP <* eof) "import" tutdUtf8 of

23+ case parse multipleDatabaseContextExprP "import" tutdUtf8 of

42− --parseErrorPretty is new in megaparsec 5

24+ --parseErrorPretty is new in megaparsec 5

43− Left err -> pure (Left (PM36E.ParseError (T.pack (errorBundlePretty err))))

25+ Left err -> pure (Left (PM36E.ParseError (T.pack (show err))))

44− Right expr -> pure (Right expr)

26+ Right expr -> pure (Right expr)

45−

27+

46−importTutorialDViaHTTP :: URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr)

47−importTutorialDViaHTTP uri mHash = do

48− reqURI <- parseRequest (URI.renderStr uri)

49− response <- httpBS reqURI

50− let scode = getResponseStatus response

51− if scode == ok200 then

52− let byteBody = getResponseBody response in

53− case validateBytes byteBody mHash of

54− Right byteBody' -> do

55− importTutorialDBytes byteBody'

56− Left err -> pure (Left err)

57− else

58− pure (Left (ImportError (ImportDownloadError (T.pack ("download failed: " <> show scode)))))

59−

60−validateBytes :: BS.ByteString -> HashVerification -> Either RelationalError BS.ByteString

61−validateBytes tutdBytes mHash =

62− case mHash of

63− Nothing -> pure tutdBytes

64− Just expectedHashText ->

65− case B16.decode (TE.encodeUtf8 expectedHashText) of

66− Left _ -> Left (ImportError (InvalidSHA256Error expectedHashText))

67− Right expectedHash | hashBytes == expectedHash -> pure tutdBytes

68− | otherwise ->

69− let p = TE.decodeUtf8 . B16.encode in

70− Left (ImportError (SHA256MismatchError (p expectedHash) (p hashBytes)))

71− where

72− hashBytes = hash tutdBytes

73−

74−

75tutdImportP :: Parser DatabaseContextDataImportOperator

28tutdImportP :: Parser DatabaseContextDataImportOperator

76tutdImportP = do

29tutdImportP = do

77 reserved ":importtutd"

30 reserved ":importtutd"

78− uri <- quoted URI.parser

31+ path <- quotedString

79 spaceConsumer

32 spaceConsumer

80− mhash <- optional (quoted hex)

81− handler <- case URI.unRText <$> URI.uriScheme uri of

82− Nothing -> fail "URI scheme missing"

83− Just "file" -> pure importTutorialDFromFile

84− Just scheme | scheme `elem` ["http", "https"] -> pure importTutorialDViaHTTP

85− | otherwise -> fail ( "unsupported URI scheme: " <> show scheme)

86− pure $ DatabaseContextDataImportOperator uri mhash handler

33+ return $ DatabaseContextDataImportOperator (T.unpack path) importTutorialD

src/bin/TutorialD/Interpreter/RODatabaseContextOperator.hs+16−33

@@ -1,16 +1,13 @@

1{-# LANGUAGE GADTs #-}

2module TutorialD.Interpreter.RODatabaseContextOperator where

3import ProjectM36.Base

4−import ProjectM36.Relation

5import qualified ProjectM36.DataFrame as DF

4import qualified ProjectM36.DataFrame as DF

6import ProjectM36.Error

5import ProjectM36.Error

7−import ProjectM36.Tuple

8import ProjectM36.InclusionDependency

6import ProjectM36.InclusionDependency

9import qualified ProjectM36.Client as C

7import qualified ProjectM36.Client as C

10import TutorialD.Interpreter.Base

8import TutorialD.Interpreter.Base

11import TutorialD.Interpreter.RelationalExpr

9import TutorialD.Interpreter.RelationalExpr

12import TutorialD.Interpreter.DatabaseContextExpr

10import TutorialD.Interpreter.DatabaseContextExpr

13−import TutorialD.Printer

14import Control.Monad.State

11import Control.Monad.State

15import qualified Data.Text as T

12import qualified Data.Text as T

16import ProjectM36.Relation.Show.Gnuplot

13import ProjectM36.Relation.Show.Gnuplot

@@ -22,7 +19,7 @@ data RODatabaseContextOperator where

22 ShowRelation :: RelationalExpr -> RODatabaseContextOperator

19 ShowRelation :: RelationalExpr -> RODatabaseContextOperator

23 PlotRelation :: RelationalExpr -> RODatabaseContextOperator

20 PlotRelation :: RelationalExpr -> RODatabaseContextOperator

24 ShowRelationType :: RelationalExpr -> RODatabaseContextOperator

21 ShowRelationType :: RelationalExpr -> RODatabaseContextOperator

25− ShowConstraints :: StringType -> RODatabaseContextOperator

22+ ShowConstraint :: StringType -> RODatabaseContextOperator

26 ShowPlan :: DatabaseContextExpr -> RODatabaseContextOperator

23 ShowPlan :: DatabaseContextExpr -> RODatabaseContextOperator

27 ShowTypes :: RODatabaseContextOperator

24 ShowTypes :: RODatabaseContextOperator

28 ShowRelationVariables :: RODatabaseContextOperator

25 ShowRelationVariables :: RODatabaseContextOperator

@@ -34,44 +31,44 @@ data RODatabaseContextOperator where

34

31

35typeP :: Parser RODatabaseContextOperator

32typeP :: Parser RODatabaseContextOperator

36typeP = do

33typeP = do

37− colonOp ":type"

34+ reservedOp ":type"

38 ShowRelationType <$> relExprP

35 ShowRelationType <$> relExprP

39

36

40showRelP :: Parser RODatabaseContextOperator

37showRelP :: Parser RODatabaseContextOperator

41showRelP = do

38showRelP = do

42− colonOp ":showexpr"

39+ reservedOp ":showexpr"

43 ShowRelation <$> relExprP

40 ShowRelation <$> relExprP

44

41

45showPlanP :: Parser RODatabaseContextOperator

42showPlanP :: Parser RODatabaseContextOperator

46showPlanP = do

43showPlanP = do

47− colonOp ":showplan"

44+ reservedOp ":showplan"

48 ShowPlan <$> databaseContextExprP

45 ShowPlan <$> databaseContextExprP

49

46

50showTypesP :: Parser RODatabaseContextOperator

47showTypesP :: Parser RODatabaseContextOperator

51−showTypesP = colonOp ":showtypes" >> pure ShowTypes

48+showTypesP = reserved ":showtypes" >> pure ShowTypes

52

49

53showRelationVariables :: Parser RODatabaseContextOperator

50showRelationVariables :: Parser RODatabaseContextOperator

54−showRelationVariables = colonOp ":showrelvars" >> pure ShowRelationVariables

51+showRelationVariables = reserved ":showrelvars" >> pure ShowRelationVariables

55

52

56showAtomFunctionsP :: Parser RODatabaseContextOperator

53showAtomFunctionsP :: Parser RODatabaseContextOperator

57−showAtomFunctionsP = colonOp ":showatomfunctions" >> pure ShowAtomFunctions

54+showAtomFunctionsP = reserved ":showatomfunctions" >> pure ShowAtomFunctions

58

55

59showDatabaseContextFunctionsP :: Parser RODatabaseContextOperator

56showDatabaseContextFunctionsP :: Parser RODatabaseContextOperator

60−showDatabaseContextFunctionsP = colonOp ":showdatabasecontextfunctions" >> pure ShowDatabaseContextFunctions

57+showDatabaseContextFunctionsP = reserved ":showdatabasecontextfunctions" >> pure ShowDatabaseContextFunctions

61

58

62quitP :: Parser RODatabaseContextOperator

59quitP :: Parser RODatabaseContextOperator

63quitP = do

60quitP = do

64− colonOp ":quit"

61+ reservedOp ":quit"

65 return Quit

62 return Quit

66

63

67showConstraintsP :: Parser RODatabaseContextOperator

64showConstraintsP :: Parser RODatabaseContextOperator

68showConstraintsP = do

65showConstraintsP = do

69− colonOp ":constraints"

66+ reservedOp ":constraints"

70− ShowConstraints <$> option "" identifier

67+ ShowConstraint <$> option "" identifier

71

68

72plotRelExprP :: Parser RODatabaseContextOperator

69plotRelExprP :: Parser RODatabaseContextOperator

73plotRelExprP = do

70plotRelExprP = do

74− colonOp ":plotexpr"

71+ reserved ":plotexpr"

75 PlotRelation <$> relExprP

72 PlotRelation <$> relExprP

76

73

77roDatabaseContextOperatorP :: Parser RODatabaseContextOperator

74roDatabaseContextOperatorP :: Parser RODatabaseContextOperator

@@ -109,16 +106,15 @@ evalRODatabaseContextOp sessionId conn (PlotRelation expr) = do

109 err <- plotRelation rel

106 err <- plotRelation rel

110 when (isJust err) $ print err

107 when (isJust err) $ print err

111

108

112−evalRODatabaseContextOp sessionId conn (ShowConstraints name) = do

109+evalRODatabaseContextOp sessionId conn (ShowConstraint name) = do

113 eIncDeps <- C.inclusionDependencies sessionId conn

110 eIncDeps <- C.inclusionDependencies sessionId conn

114 let val = case eIncDeps of

111 let val = case eIncDeps of

115 Left err -> Left err

112 Left err -> Left err

116 Right incDeps -> case name of

113 Right incDeps -> case name of

117− "" -> inclusionDependenciesAsRelation incDeps >>= renderRelExprsInIncDeps

114+ "" -> inclusionDependenciesAsRelation incDeps

118 depName -> case M.lookup depName incDeps of

115 depName -> case M.lookup depName incDeps of

119 Nothing -> Left (InclusionDependencyNameNotInUseError depName)

116 Nothing -> Left (InclusionDependencyNameNotInUseError depName)

120− Just dep ->

121− inclusionDependenciesAsRelation (M.singleton depName dep) >>= renderRelExprsInIncDeps

117+ Just dep -> inclusionDependenciesAsRelation (M.singleton depName dep)

122 pure $ case val of

118 pure $ case val of

123 Left err -> DisplayErrorResult (T.pack (show err))

119 Left err -> DisplayErrorResult (T.pack (show err))

124 Right rel -> DisplayRelationResult rel

120 Right rel -> DisplayRelationResult rel

@@ -168,7 +164,7 @@ interpretRODatabaseContextOp sessionId conn tutdstring = case parse roDatabaseCo

168

164

169showDataFrameP :: Parser RODatabaseContextOperator

165showDataFrameP :: Parser RODatabaseContextOperator

170showDataFrameP = do

166showDataFrameP = do

171− colonOp ":showdataframe"

167+ reservedOp ":showdataframe"

172 relExpr <- relExprP

168 relExpr <- relExprP

173 reservedOp "orderby"

169 reservedOp "orderby"

174 attrOrdersExpr <- attrOrdersExprP

170 attrOrdersExpr <- attrOrdersExprP

@@ -195,16 +191,3 @@ attrOrderExprP = DF.AttributeOrderExpr <$> identifier <*> orderP

195

191

196orderP :: Parser DF.Order

192orderP :: Parser DF.Order

197orderP = try (reservedOp "ascending" >> pure DF.AscendingOrder) <|> try (reservedOp "descending" >> pure DF.DescendingOrder) <|> pure DF.AscendingOrder

193orderP = try (reservedOp "ascending" >> pure DF.AscendingOrder) <|> try (reservedOp "descending" >> pure DF.DescendingOrder) <|> pure DF.AscendingOrder

198−

199−-- render RelationalExprAtoms as TutorialD

200−renderRelExprsInIncDeps :: Relation -> Either RelationalError Relation

201−renderRelExprsInIncDeps = relMogrify tupMapper attrs

202− where

203− tupMapper tup = pure $ mkRelationTupleFromMap (M.map mapper (tupleToMap tup))

204− mapper (RelationalExprAtom expr) = TextAtom (T.pack (show (prettyRelationalExpr expr)))

205− mapper atom = atom

206− attrs = C.attributesFromList [Attribute "name" TextAtomType,

207− Attribute "sub" TextAtomType,

208− Attribute "super" TextAtomType

209− ]

210−

src/bin/TutorialD/Interpreter/RelationalExpr.hs+44−77

@@ -1,11 +1,6 @@

1−{-# LANGUAGE CPP #-}

2module TutorialD.Interpreter.RelationalExpr where

1module TutorialD.Interpreter.RelationalExpr where

3import Text.Megaparsec

2import Text.Megaparsec

4−#if MIN_VERSION_megaparsec(7,0,0)

5−import Control.Monad.Combinators.Expr

6−#else

7import Text.Megaparsec.Expr

3import Text.Megaparsec.Expr

8−#endif

9import ProjectM36.Base

4import ProjectM36.Base

10import TutorialD.Interpreter.Base

5import TutorialD.Interpreter.Base

11import TutorialD.Interpreter.Types

6import TutorialD.Interpreter.Types

@@ -17,36 +12,26 @@ import ProjectM36.MiscUtils

17

12

18--used in projection

13--used in projection

19attributeListP :: RelationalMarkerExpr a => Parser (AttributeNamesBase a)

14attributeListP :: RelationalMarkerExpr a => Parser (AttributeNamesBase a)

20−attributeListP =

15+attributeListP =

21 (reservedOp "all but" >>

16 (reservedOp "all but" >>

22− InvertedAttributeNames . S.fromList <$> sepBy attributeNameP comma) <|>

17+ InvertedAttributeNames . S.fromList <$> sepBy identifier comma) <|>

23−

24 (reservedOp "all from" >>

18 (reservedOp "all from" >>

25 RelationalExprAttributeNames <$> relExprP) <|>

19 RelationalExprAttributeNames <$> relExprP) <|>

26−

27− (reservedOp "union of" >>

28− UnionAttributeNames <$> braces attributeListP <*> braces attributeListP) <|>

29−

30− (reservedOp "intersection of" >>

31− IntersectAttributeNames <$> braces attributeListP <*> braces attributeListP) <|>

32−

33− (AttributeNames . S.fromList <$> sepBy attributeNameP comma)

20+ (AttributeNames . S.fromList <$> sepBy identifier comma)

34−

35

21

36makeRelationP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

22makeRelationP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

37makeRelationP = do

23makeRelationP = do

38 reserved "relation"

24 reserved "relation"

39 attrExprs <- try (fmap Just makeAttributeExprsP) <|> pure Nothing

25 attrExprs <- try (fmap Just makeAttributeExprsP) <|> pure Nothing

40 tupleExprs <- braces (sepBy tupleExprP comma) <|> pure []

26 tupleExprs <- braces (sepBy tupleExprP comma) <|> pure []

41− marker <- parseMarkerP

42− pure $ MakeRelationFromExprs attrExprs (TupleExprs marker tupleExprs)

27+ pure $ MakeRelationFromExprs attrExprs tupleExprs

43−

44

28

29+

45--abstract data type parser- in this context, the type constructor must not include any type arguments

30--abstract data type parser- in this context, the type constructor must not include any type arguments

46--Either Text Int

31--Either Text Int

47adTypeConstructorP :: Parser TypeConstructor

32adTypeConstructorP :: Parser TypeConstructor

48adTypeConstructorP = do

33adTypeConstructorP = do

49− tConsName <- typeConstructorNameP

34+ tConsName <- capitalizedIdentifier

50 tConsArgs <- many typeConstructorP

35 tConsArgs <- many typeConstructorP

51 pure $ ADTypeConstructor tConsName tConsArgs

36 pure $ ADTypeConstructor tConsName tConsArgs

52

37

@@ -56,25 +41,25 @@ tupleExprP = do

56 attrAssocs <- braces (sepBy tupleAtomExprP comma)

41 attrAssocs <- braces (sepBy tupleAtomExprP comma)

57 --detect duplicate attribute names

42 --detect duplicate attribute names

58 let dupAttrNames = dupes (sort (map fst attrAssocs))

43 let dupAttrNames = dupes (sort (map fst attrAssocs))

59− if not (null dupAttrNames) then

44+ if not (null dupAttrNames) then

60 fail ("Attribute names duplicated: " ++ show dupAttrNames)

45 fail ("Attribute names duplicated: " ++ show dupAttrNames)

61 else

46 else

62 pure (TupleExpr (M.fromList attrAssocs))

47 pure (TupleExpr (M.fromList attrAssocs))

63

48

64tupleAtomExprP :: RelationalMarkerExpr a => Parser (AttributeName, AtomExprBase a)

49tupleAtomExprP :: RelationalMarkerExpr a => Parser (AttributeName, AtomExprBase a)

65tupleAtomExprP = do

50tupleAtomExprP = do

66− attributeName <- attributeNameP

51+ attributeName <- identifier

67 atomExpr <- atomExprP

52 atomExpr <- atomExprP

68 pure (attributeName, atomExpr)

53 pure (attributeName, atomExpr)

69−

54+

70projectP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

55projectP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

71projectP = Project <$> braces attributeListP

56projectP = Project <$> braces attributeListP

72

57

73renameClauseP :: Parser (T.Text, T.Text)

58renameClauseP :: Parser (T.Text, T.Text)

74renameClauseP = do

59renameClauseP = do

75− oldAttr <- attributeNameP

60+ oldAttr <- identifier

76 reservedOp "as"

61 reservedOp "as"

77− newAttr <- attributeNameP

62+ newAttr <- identifier

78 pure (oldAttr, newAttr)

63 pure (oldAttr, newAttr)

79

64

80renameP :: Parser (RelationalExprBase a -> RelationalExprBase a)

65renameP :: Parser (RelationalExprBase a -> RelationalExprBase a)

@@ -83,7 +68,7 @@ renameP = do

83 renameList <- braces (sepBy renameClauseP comma)

68 renameList <- braces (sepBy renameClauseP comma)

84 case renameList of

69 case renameList of

85 [] -> pure (Restrict TruePredicate) --no-op when rename list is empty

70 [] -> pure (Restrict TruePredicate) --no-op when rename list is empty

86− renames ->

71+ renames ->

87 pure $ \expr -> foldl (\acc (oldAttr, newAttr) -> Rename oldAttr newAttr acc) expr renames

72 pure $ \expr -> foldl (\acc (oldAttr, newAttr) -> Rename oldAttr newAttr acc) expr renames

88

73

89whereClauseP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

74whereClauseP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

@@ -93,7 +78,7 @@ groupClauseP :: RelationalMarkerExpr a => Parser (AttributeNamesBase a, T.Text)

93groupClauseP = do

78groupClauseP = do

94 attrs <- braces attributeListP

79 attrs <- braces attributeListP

95 reservedOp "as"

80 reservedOp "as"

96− newAttrName <- attributeNameP

81+ newAttrName <- identifier

97 pure (attrs, newAttrName)

82 pure (attrs, newAttrName)

98

83

99groupP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

84groupP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

@@ -106,30 +91,26 @@ groupP = do

106ungroupP :: Parser (RelationalExprBase a -> RelationalExprBase a)

91ungroupP :: Parser (RelationalExprBase a -> RelationalExprBase a)

107ungroupP = do

92ungroupP = do

108 reservedOp "ungroup"

93 reservedOp "ungroup"

109− Ungroup <$> attributeNameP

94+ Ungroup <$> identifier

110

95

111extendP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

96extendP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

112extendP = do

97extendP = do

113 reservedOp ":"

98 reservedOp ":"

114− extends <- braces (sepBy extendTupleExpressionP comma)

99+ Extend <$> braces extendTupleExpressionP

115− case extends of

100+

116− [] -> pure (Restrict TruePredicate)

117− extends' ->

118− pure $ \expr -> foldl (flip Extend) expr extends'

119−

120semijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)

101semijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)

121semijoinP = do

102semijoinP = do

122 reservedOp "semijoin" <|> reservedOp "matching"

103 reservedOp "semijoin" <|> reservedOp "matching"

123− pure (\exprA exprB ->

104+ pure (\exprA exprB ->

124 Project (RelationalExprAttributeNames exprA) (Join exprA exprB))

105 Project (RelationalExprAttributeNames exprA) (Join exprA exprB))

125−

106+

126−antijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)

107+antijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)

127antijoinP = do

108antijoinP = do

128 reservedOp "not matching" <|> reservedOp "antijoin"

109 reservedOp "not matching" <|> reservedOp "antijoin"

129 pure (\exprA exprB ->

110 pure (\exprA exprB ->

130 Difference exprA (

111 Difference exprA (

131 Project (RelationalExprAttributeNames exprA) (Join exprA exprB)))

112 Project (RelationalExprAttributeNames exprA) (Join exprA exprB)))

132−

113+

133relOperators :: RelationalMarkerExpr a => [[Operator Parser (RelationalExprBase a)]]

114relOperators :: RelationalMarkerExpr a => [[Operator Parser (RelationalExprBase a)]]

134relOperators = [

115relOperators = [

135 [Postfix projectP],

116 [Postfix projectP],

@@ -142,23 +123,15 @@ relOperators = [

142 [InfixL antijoinP],

123 [InfixL antijoinP],

143 [InfixL (reservedOp "union" >> return Union)],

124 [InfixL (reservedOp "union" >> return Union)],

144 [InfixL (reservedOp "minus" >> return Difference)],

125 [InfixL (reservedOp "minus" >> return Difference)],

145− [InfixN (reservedOp "=" >> return Equals),

126+ [InfixN (reservedOp "=" >> return Equals)],

146− InfixN (reservedOp "/=" >> return NotEquals)],

147 [Postfix extendP]

127 [Postfix extendP]

148 ]

128 ]

149

129

150relExprP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

130relExprP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

151relExprP = try withMacroExprP <|> makeExprParser relTerm relOperators

131relExprP = try withMacroExprP <|> makeExprParser relTerm relOperators

152

132

153−--allow for additional characters

154−attributeNameP :: Parser AttributeName

155−attributeNameP = uncapitalizedIdentifier

156−

157−relVarNameP :: Parser RelVarName

158−relVarNameP = uncapitalizedIdentifier

159−

160relVarP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

133relVarP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

161−relVarP = RelationVariable <$> relVarNameP <*> parseMarkerP

134+relVarP = RelationVariable <$> identifier <*> parseMarkerP

162

135

163relTerm :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

136relTerm :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

164relTerm = parens relExprP

137relTerm = parens relExprP

@@ -179,13 +152,13 @@ restrictionPredicateP = makeExprParser predicateTerm predicateOperators

179 <|> relationalBooleanExprP

152 <|> relationalBooleanExprP

180

153

181relationalBooleanExprP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)

154relationalBooleanExprP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)

182−relationalBooleanExprP =

155+relationalBooleanExprP =

183 --we can't actually detect if the type is relational boolean, so we just pass it to the next phase

156 --we can't actually detect if the type is relational boolean, so we just pass it to the next phase

184 RelationalExprPredicate <$> (parens relExprP <|> relTerm)

157 RelationalExprPredicate <$> (parens relExprP <|> relTerm)

185−

158+

186restrictionAttributeEqualityP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)

159restrictionAttributeEqualityP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)

187restrictionAttributeEqualityP = do

160restrictionAttributeEqualityP = do

188− attributeName <- attributeNameP

161+ attributeName <- identifier

189 reservedOp "="

162 reservedOp "="

190 AttributeEqualityPredicate attributeName <$> atomExprP

163 AttributeEqualityPredicate attributeName <$> atomExprP

191

164

@@ -202,7 +175,7 @@ extendTupleExpressionP = attributeExtendTupleExpressionP

202

175

203attributeExtendTupleExpressionP :: RelationalMarkerExpr a => Parser (ExtendTupleExprBase a)

176attributeExtendTupleExpressionP :: RelationalMarkerExpr a => Parser (ExtendTupleExprBase a)

204attributeExtendTupleExpressionP = do

177attributeExtendTupleExpressionP = do

205− newAttr <- attributeNameP

178+ newAttr <- identifier

206 reservedOp ":="

179 reservedOp ":="

207 AttributeExtendTupleExpr newAttr <$> atomExprP

180 AttributeExtendTupleExpr newAttr <$> atomExprP

208

181

@@ -214,34 +187,33 @@ consumeAtomExprP consume = try functionAtomExprP <|>

214 try (parens (constructedAtomExprP True)) <|>

187 try (parens (constructedAtomExprP True)) <|>

215 constructedAtomExprP consume <|>

188 constructedAtomExprP consume <|>

216 attributeAtomExprP <|>

189 attributeAtomExprP <|>

217− try nakedAtomExprP <|>

190+ nakedAtomExprP <|>

218 relationalAtomExprP

191 relationalAtomExprP

219−

220

192

221attributeAtomExprP :: Parser (AtomExprBase a)

193attributeAtomExprP :: Parser (AtomExprBase a)

222attributeAtomExprP = do

194attributeAtomExprP = do

223 _ <- string "@"

195 _ <- string "@"

224− AttributeAtomExpr <$> attributeNameP

196+ AttributeAtomExpr <$> identifier

225

197

226nakedAtomExprP :: Parser (AtomExprBase a)

198nakedAtomExprP :: Parser (AtomExprBase a)

227nakedAtomExprP = NakedAtomExpr <$> atomP

199nakedAtomExprP = NakedAtomExpr <$> atomP

228

200

229constructedAtomExprP :: RelationalMarkerExpr a => Bool -> Parser (AtomExprBase a)

201constructedAtomExprP :: RelationalMarkerExpr a => Bool -> Parser (AtomExprBase a)

230constructedAtomExprP consume = do

202constructedAtomExprP consume = do

231− dConsName <- dataConstructorNameP

203+ dConsName <- capitalizedIdentifier

232 dConsArgs <- if consume then sepBy (consumeAtomExprP False) spaceConsumer else pure []

204 dConsArgs <- if consume then sepBy (consumeAtomExprP False) spaceConsumer else pure []

233 ConstructedAtomExpr dConsName dConsArgs <$> parseMarkerP

205 ConstructedAtomExpr dConsName dConsArgs <$> parseMarkerP

234−

206+

235-- used only for primitive type parsing ?

207-- used only for primitive type parsing ?

236atomP :: Parser Atom

208atomP :: Parser Atom

237−atomP = stringAtomP <|>

209+atomP = stringAtomP <|>

238− try doubleAtomP <|>

210+ doubleAtomP <|>

239− integerAtomP <|>

211+ integerAtomP <|>

240 boolAtomP

212 boolAtomP

241−

213+

242functionAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

214functionAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

243−functionAtomExprP =

215+functionAtomExprP =

244− FunctionAtomExpr <$> uncapitalizedIdentifier <*> parens (sepBy atomExprP comma) <*> parseMarkerP

216+ FunctionAtomExpr <$> identifier <*> parens (sepBy atomExprP comma) <*> parseMarkerP

245

217

246relationalAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

218relationalAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

247relationalAtomExprP = RelationAtomExpr <$> relExprP

219relationalAtomExprP = RelationAtomExpr <$> relExprP

@@ -249,29 +221,25 @@ relationalAtomExprP = RelationAtomExpr <$> relExprP

249stringAtomP :: Parser Atom

221stringAtomP :: Parser Atom

250stringAtomP = TextAtom <$> quotedString

222stringAtomP = TextAtom <$> quotedString

251

223

252−doubleAtomP :: Parser Atom

224+doubleAtomP :: Parser Atom

253−doubleAtomP = DoubleAtom <$> float

225+doubleAtomP = DoubleAtom <$> try float

254

226

255integerAtomP :: Parser Atom

227integerAtomP :: Parser Atom

256integerAtomP = IntegerAtom <$> integer

228integerAtomP = IntegerAtom <$> integer

257

229

258boolAtomP :: Parser Atom

230boolAtomP :: Parser Atom

259boolAtomP = do

231boolAtomP = do

260− v <- identifier

232+ val <- char 't' <|> char 'f'

261− if v == "t" || v == "f" then

262− pure $ BoolAtom (v == "t")

233+ return $ BoolAtom (val == 't')

263− else

234+

264− fail "invalid boolAtom"

265−

266−

267relationAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

235relationAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

268relationAtomExprP = RelationAtomExpr <$> makeRelationP

236relationAtomExprP = RelationAtomExpr <$> makeRelationP

269

237

270withMacroExprP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

238withMacroExprP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

271withMacroExprP = do

239withMacroExprP = do

272 reservedOp "with"

240 reservedOp "with"

273− views <- parens (sepBy1 createMacroP comma)

241+ macros <- parens (sepBy1 createMacroP comma)

274− With views <$> relExprP

242+ With macros <$> relExprP

275

243

276createMacroP :: RelationalMarkerExpr a => Parser (WithNameExprBase a, RelationalExprBase a)

244createMacroP :: RelationalMarkerExpr a => Parser (WithNameExprBase a, RelationalExprBase a)

277createMacroP = do

245createMacroP = do

@@ -280,5 +248,4 @@ createMacroP = do

280 expr <- relExprP

248 expr <- relExprP

281 marker <- parseMarkerP

249 marker <- parseMarkerP

282 pure (WithNameExpr name marker, expr)

250 pure (WithNameExpr name marker, expr)

283−

251+

284−

src/bin/TutorialD/Interpreter/SchemaOperator.hs+3−3

@@ -42,7 +42,7 @@ isoRestrictP = do

42 reserved "isorestrict"

43 relVarIn <- qrelVarP

44 relvarsOut <- isoRestrictOutRelVarsP

45− IsoRestrict relVarIn <$> restrictionPredicateP <*> pure relvarsOut

45+ IsoRestrict <$> pure relVarIn <*> restrictionPredicateP <*> pure relvarsOut

46

47isoRestrictOutRelVarsP :: Parser (RelVarName, RelVarName)

48isoRestrictOutRelVarsP = (,) <$> qrelVarP <*> qrelVarP

@@ -55,7 +55,7 @@ isoUnionP = do

55 reserved "isounion"

56 relVarsIn <- isoUnionInRelVarsP

57 relVarsOut <- qrelVarP

58− IsoUnion relVarsIn <$> restrictionPredicateP <*> pure relVarsOut

58+ IsoUnion <$> pure relVarsIn <*> restrictionPredicateP <*> pure relVarsOut

59

60isoRenameP :: Parser SchemaIsomorph

61isoRenameP = do

@@ -74,4 +74,4 @@ isoUnionInRelVarsP = (,) <$> qrelVarP <*> qrelVarP

74evalSchemaOperator :: SessionId -> Connection -> SchemaOperator -> IO (Either RelationalError ())

75evalSchemaOperator sessionId conn (ModifySchemaExpr expr) = executeSchemaExpr sessionId conn expr

76evalSchemaOperator sessionId conn (SetCurrentSchema sname) = setCurrentSchemaName sessionId conn sname

77−

77+

src/bin/TutorialD/Interpreter/TransactionGraphOperator.hs+3−12

@@ -2,9 +2,8 @@

2module TutorialD.Interpreter.TransactionGraphOperator where

3import TutorialD.Interpreter.Base

4import ProjectM36.TransactionGraph hiding (autoMergeToHead)

5−import ProjectM36.Client as C

5+import ProjectM36.Client

6import ProjectM36.Base

7−import ProjectM36.Relation (relationTrue)

8import Data.Functor

7import Data.Functor

9

8

10data ConvenienceTransactionGraphOperator = AutoMergeToHead MergeStrategy HeadName

9data ConvenienceTransactionGraphOperator = AutoMergeToHead MergeStrategy HeadName

@@ -72,9 +71,6 @@ mergeTransactionsP = do

72 reservedOp ":mergetrans"

71 reservedOp ":mergetrans"

73 MergeTransactions <$> mergeTransactionStrategyP <*> identifier <*> identifier

72 MergeTransactions <$> mergeTransactionStrategyP <*> identifier <*> identifier

74

73

75−validateMerkleHashesP :: Parser ROTransactionGraphOperator

76−validateMerkleHashesP = reservedOp ":validatemerklehashes" $> ValidateMerkleHashes

77−

78transactionGraphOpP :: Parser TransactionGraphOperator

74transactionGraphOpP :: Parser TransactionGraphOperator

79transactionGraphOpP =

75transactionGraphOpP =

80 jumpToHeadP

76 jumpToHeadP

@@ -87,7 +83,7 @@ transactionGraphOpP =

87 <|> mergeTransactionsP

83 <|> mergeTransactionsP

88

84

89roTransactionGraphOpP :: Parser ROTransactionGraphOperator

85roTransactionGraphOpP :: Parser ROTransactionGraphOperator

90−roTransactionGraphOpP = showGraphP <|> validateMerkleHashesP

86+roTransactionGraphOpP = showGraphP

91

87

92

88

93

89

@@ -105,11 +101,6 @@ interpretOps newUUID trans@(DisconnectedTransaction _ context) transGraph instri

105

101

106evalROGraphOp :: SessionId -> Connection -> ROTransactionGraphOperator -> IO (Either RelationalError Relation)

102evalROGraphOp :: SessionId -> Connection -> ROTransactionGraphOperator -> IO (Either RelationalError Relation)

107evalROGraphOp sessionId conn ShowGraph = transactionGraphAsRelation sessionId conn

103evalROGraphOp sessionId conn ShowGraph = transactionGraphAsRelation sessionId conn

108−evalROGraphOp sessionId conn ValidateMerkleHashes = do

109− eVal <- C.validateMerkleHashes sessionId conn

110− case eVal of

111− Left err -> pure (Left err)

112− Right _ -> pure (Right relationTrue)

113

104

114evalConvenienceGraphOp :: SessionId -> Connection -> ConvenienceTransactionGraphOperator -> IO (Either RelationalError ())

105evalConvenienceGraphOp :: SessionId -> Connection -> ConvenienceTransactionGraphOperator -> IO (Either RelationalError ())

115−evalConvenienceGraphOp sessionId conn (AutoMergeToHead strat head') = autoMergeToHead sessionId conn strat head'

106+evalConvenienceGraphOp sessionId conn (AutoMergeToHead strat head') = autoMergeToHead sessionId conn strat head'

src/bin/TutorialD/Interpreter/Types.hs+4−10

@@ -9,24 +9,18 @@ class RelationalMarkerExpr a where

9

10instance RelationalMarkerExpr () where

11 parseMarkerP = pure ()

12−

12+

13−typeConstructorNameP :: Parser TypeConstructorName

14−typeConstructorNameP = capitalizedIdentifier

15−

16−dataConstructorNameP :: Parser DataConstructorName

17−dataConstructorNameP = capitalizedIdentifier

18−

19-- | Upper case names are type names while lower case names are polymorphic typeconstructor arguments.

13-- | Upper case names are type names while lower case names are polymorphic typeconstructor arguments.

20-- data *Either a b* = Left a | Right b

14-- data *Either a b* = Left a | Right b

21typeConstructorDefP :: Parser TypeConstructorDef

15typeConstructorDefP :: Parser TypeConstructorDef

22−typeConstructorDefP = ADTypeConstructorDef <$> typeConstructorNameP <*> typeVarNamesP

16+typeConstructorDefP = ADTypeConstructorDef <$> capitalizedIdentifier <*> typeVarNamesP

23

17

24typeVarNamesP :: Parser [TypeVarName]

18typeVarNamesP :: Parser [TypeVarName]

25typeVarNamesP = many uncapitalizedIdentifier

19typeVarNamesP = many uncapitalizedIdentifier

26

20

27-- data Either a b = *Left a* | *Right b*

21-- data Either a b = *Left a* | *Right b*

28dataConstructorDefP :: Parser DataConstructorDef

22dataConstructorDefP :: Parser DataConstructorDef

29−dataConstructorDefP = DataConstructorDef <$> typeConstructorNameP <*> many dataConstructorDefArgP

23+dataConstructorDefP = DataConstructorDef <$> capitalizedIdentifier <*> many dataConstructorDefArgP

30

24

31-- data *Either a b* = Left *a* | Right *b*

25-- data *Either a b* = Left *a* | Right *b*

32dataConstructorDefArgP :: Parser DataConstructorDefArg

26dataConstructorDefArgP :: Parser DataConstructorDefArg

@@ -53,7 +47,7 @@ typeConstructorP = relationTypeConstructorP <|>

53 monoTypeConstructorP

47 monoTypeConstructorP

54

48

55monoTypeConstructorP :: Parser TypeConstructor

49monoTypeConstructorP :: Parser TypeConstructor

56−monoTypeConstructorP = ADTypeConstructor <$> typeConstructorNameP <*> pure [] <|>

50+monoTypeConstructorP = ADTypeConstructor <$> capitalizedIdentifier <*> pure [] <|>

57 TypeVariable <$> uncapitalizedIdentifier

51 TypeVariable <$> uncapitalizedIdentifier

58

52

59

53

src/bin/TutorialD/Printer.hsdeleted−165

@@ -1,165 +0,0 @@

1−{-# OPTIONS_GHC -fno-warn-orphans #-}

2−{-# LANGUAGE FlexibleInstances #-}

3−{-# LANGUAGE OverloadedStrings #-}

4−{-# LANGUAGE ScopedTypeVariables #-}

5−{-# LANGUAGE TypeApplications #-}

6−module TutorialD.Printer where

7−import ProjectM36.Base

8−import ProjectM36.Attribute as A hiding (null)

9−import Data.Text.Prettyprint.Doc

10−import qualified Data.Set as S hiding (fromList)

11−import qualified Data.Vector as V

12−import qualified Data.Map.Strict as M

13−import Data.Time.Calendar

14−import Data.Time.Clock.POSIX

15−import qualified Data.ByteString.Base64 as B64

16−import qualified Data.Text.Encoding as TE

17−

18−instance Pretty Atom where

19− pretty (IntegerAtom x) = pretty x

20− pretty (IntAtom x) = "int" <> parensList [pretty x]

21− pretty (DoubleAtom x) = pretty x

22− pretty (TextAtom x) = dquotes (pretty x)

23− pretty (DayAtom x) = "fromGregorian" <> parensList [pretty a, pretty b, pretty c]

24− where

25− (a,b,c) = toGregorian x

26− pretty (DateTimeAtom time) = "dateTimeFromEpochSeconds" <> parensList [pretty @Integer (round (utcTimeToPOSIXSeconds time))]

27− pretty (ByteStringAtom bs) = "bytestring" <> parensList [dquotes (pretty (TE.decodeUtf8 (B64.encode bs)))]

28− pretty (BoolAtom x) = if x then "t" else "f"

29− pretty (RelationAtom x) = pretty x

30− pretty (RelationalExprAtom re) = pretty re

31− pretty (ConstructedAtom n _ as) = pretty n <+> prettyList as

32−

33−instance Pretty AtomExpr where

34− pretty (AttributeAtomExpr attrName) = pretty attrName

35− pretty (NakedAtomExpr atom) = pretty atom

36− pretty (FunctionAtomExpr atomFuncName' atomExprs _) = pretty atomFuncName' <> prettyAtomExprsAsArguments atomExprs

37− pretty (RelationAtomExpr relExpr) = pretty relExpr

38− pretty (ConstructedAtomExpr dName [] _) = pretty dName

39− pretty (ConstructedAtomExpr dName atomExprs _) = pretty dName <+> hsep (map prettyAtomExpr atomExprs)

40−

41−prettyAtomExpr :: AtomExpr -> Doc ann

42−prettyAtomExpr atomExpr =

43− case atomExpr of

44− AttributeAtomExpr attrName -> "@" <> pretty attrName

45− ConstructedAtomExpr dConsName [] () -> pretty dConsName

46− ConstructedAtomExpr dConsName atomExprs () -> parens (pretty dConsName <+> hsep (map prettyAtomExpr atomExprs))

47− _ -> pretty atomExpr

48−

49−prettyAtomExprsAsArguments :: [AtomExpr] -> Doc ann

50−prettyAtomExprsAsArguments = align . parensList . map addAt

51− where addAt (atomExpr :: AtomExpr) =

52− case atomExpr of

53− AttributeAtomExpr attrName -> "@" <> pretty attrName

54− _ -> pretty atomExpr

55−

56−instance Pretty TupleExpr where

57− pretty (TupleExpr map') = "tuple" <> bracesList (Prelude.map (\(attrName,atom)-> pretty attrName <+> pretty atom) (M.toList map'))

58−

59−instance Pretty RelationTuple where

60− pretty (RelationTuple attrs atoms) = "tuple" <> bracesList (zipWith (\x y-> pretty x <+> pretty y) (V.toList (attributeNames attrs)) (V.toList atoms))

61−

62−instance Pretty Relation where

63− pretty (Relation attrs tupSet) | attrs == mempty && null (asList tupSet) = "false"

64− pretty (Relation attrs tupSet) | attrs == mempty && asList tupSet == [RelationTuple mempty mempty] = "true"

65− pretty (Relation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)

66−

67−instance Pretty Attribute where

68− pretty (Attribute n aTy) = pretty n <+> pretty (show aTy) -- workaround

69−

70−instance Pretty RelationalExpr where

71− pretty (RelationVariable n _) = pretty n

72− pretty (ExistingRelation r) = pretty r

73− pretty (NotEquals a b) = pretty' a <+> "!=" <+> pretty' b

74− pretty (Equals a b) = pretty' a <+> "==" <+> pretty' b

75− pretty (Project ns r) = pretty' (ignoreProjects r) <> pretty ns

76− pretty (Extend ext r) = collectExtends r <> pretty ext <> "}"

77− pretty (MakeRelationFromExprs Nothing (TupleExprs () tupExprs)) = "relation" <> prettyBracesList tupExprs

78− pretty (MakeRelationFromExprs (Just attrExprs) (TupleExprs () tupExprs)) = "relation" <> prettyBracesList attrExprs <> prettyBracesList tupExprs

79− pretty (MakeStaticRelation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)

80− pretty (Union a b) = parens $ pretty' a <+> "union" <+> pretty' b

81− pretty (Join a b) = parens $ pretty' a <+> "join" <+> pretty' b

82− pretty (Rename n1 n2 relExpr) = parens $ pretty relExpr <+> "rename" <+> braces (pretty n1 <+> "as" <+> pretty n2)

83− pretty (Difference a b) = parens $ pretty' a <+> "minus" <+> pretty' b

84− pretty (Group attrNames attrName relExpr) = parens $ pretty relExpr <+> "group" <+> parens (pretty attrNames <+> "as" <+> pretty attrName)

85− pretty (Ungroup attrName relExpr) = parens $ pretty' relExpr <+> "ungroup" <+> pretty attrName

86− pretty (Restrict resPreExpr relExpr) = parens $ pretty' relExpr <+> "where" <+> pretty resPreExpr

87− pretty (With pairs a) = "with" <+> parensList (map (\(name,expr)-> pretty name <+> "as" <+> pretty expr) pairs) <+> pretty' a

88−

89−-- relvar:{a:=?}:{b:=?}:... in ADTs => relvar:{a:=?, b:=?, ...} in Doc ann

90−collectExtends :: RelationalExpr -> Doc ann

91−collectExtends (Extend ext r) = collectExtends r <> pretty ext <> ", "

92−collectExtends r = pretty r <> ":{"

93−

94−--relvar{a,b,c,...}{a,b,...}..{a} => relvar{a}

95−ignoreProjects :: RelationalExpr -> RelationalExpr

96−ignoreProjects (Project _ r) = ignoreProjects r

97−ignoreProjects r = r

98−

99−prettyRelationalExpr :: RelationalExpr -> Doc n

100−prettyRelationalExpr (RelationVariable n _) = pretty n

101−prettyRelationalExpr r = parens (pretty r)

102−

103−pretty' :: RelationalExpr -> Doc n

104−pretty' = prettyRelationalExpr

105−

106−instance Pretty AttributeNames where

107− pretty (AttributeNames attrNames) = prettyBracesList (S.toList attrNames)

108− pretty (InvertedAttributeNames attrNames) = braces $ "all but" <+> concatWith (surround ", ") (map pretty (S.toList attrNames))

109− pretty (RelationalExprAttributeNames relExpr) = braces $ "all from" <+> pretty relExpr

110− pretty (UnionAttributeNames aAttrNames bAttrNames) = braces ("union of" <+> pretty aAttrNames <+> pretty bAttrNames)

111− pretty (IntersectAttributeNames aAttrNames bAttrNames) = braces ("intersection of" <+> pretty aAttrNames <+> pretty bAttrNames)

112−

113−instance Pretty AttributeExpr where

114− pretty (NakedAttributeExpr attr) = pretty attr

115− pretty (AttributeAndTypeNameExpr name typeCons _) = pretty name <+> pretty typeCons

116−

117−instance Pretty TypeConstructor where

118− pretty (ADTypeConstructor tcName []) = pretty tcName

119− pretty (ADTypeConstructor tcName tConsArgs) = pretty tcName <+> hsep (map pretty tConsArgs)

120− pretty (PrimitiveTypeConstructor tcName atomType') = pretty tcName <+> pretty atomType'

121− pretty (RelationAtomTypeConstructor attrExprs) = "relation" <> prettyBracesList attrExprs

122− pretty (TypeVariable x) = pretty x

123−

124−instance Pretty AtomType where

125− pretty IntAtomType = "Int"

126− pretty IntegerAtomType = "Integer"

127− pretty DoubleAtomType = "Double"

128− pretty TextAtomType = "Text"

129− pretty DayAtomType = "Day"

130− pretty DateTimeAtomType = "DateTime"

131− pretty ByteStringAtomType = "ByteString"

132− pretty BoolAtomType = "Bool"

133− pretty (RelationAtomType attrs) = "relation " <+> prettyBracesList (A.toList attrs)

134− pretty (ConstructedAtomType tcName tvMap) = pretty tcName <+> hsep (map pretty (M.toList tvMap)) --order matters

135− pretty RelationalExprAtomType = "RelationalExpr"

136− pretty (TypeVariableType x) = pretty x

137−

138−instance Pretty ExtendTupleExpr where

139− pretty (AttributeExtendTupleExpr attrName atomExpr) = pretty attrName <> ":=" <> pretty atomExpr

140−

141−

142−instance Pretty RestrictionPredicateExpr where

143− pretty TruePredicate = "true"

144− pretty (AndPredicate a b) = pretty a <+> "and" <+> pretty b

145− pretty (OrPredicate a b) = pretty a <+> "or" <+> pretty b

146− pretty (NotPredicate a) = "not" <+> pretty a

147− pretty (RelationalExprPredicate relExpr) = pretty relExpr

148− pretty (AtomExprPredicate atomExpr) = pretty atomExpr

149− pretty (AttributeEqualityPredicate attrName atomExpr) = pretty attrName <> "=" <> pretty atomExpr

150−

151−instance Pretty WithNameExpr where

152− pretty (WithNameExpr name _) = pretty name

153−

154−bracesList :: [Doc ann] -> Doc ann

155−bracesList = group . encloseSep (flatAlt "{ " "{") (flatAlt " }" "}") ", "

156−

157−prettyBracesList :: Pretty a => [a] -> Doc ann

158−prettyBracesList = align . bracesList . map pretty

159−

160−parensList :: [Doc ann] -> Doc ann

161−parensList = group . encloseSep (flatAlt "( " "(") (flatAlt " )" ")") ", "

162−

163−prettyParensList :: Pretty a => [a] -> Doc ann

164−prettyParensList = align . parensList . map pretty

165−

src/bin/TutorialD/tutd.hs+19−15

@@ -5,11 +5,9 @@ import ProjectM36.Client

5import ProjectM36.Server.ParseArgs

6import ProjectM36.Server

7import System.IO

8−import GHC.IO.Encoding

9import Options.Applicative

8import Options.Applicative

10import System.Exit

9import System.Exit

11−import Control.Monad

12−#if __GLASGOW_HASKELL__ < 804

10+#if __GLASGOW_HASKELL__ <= 802

13import Data.Monoid

11import Data.Monoid

14#endif

12#endif

15import Data.Maybe

13import Data.Maybe

@@ -22,7 +20,7 @@ import qualified Data.Text as T

22

20

23parseArgs :: Parser InterpreterConfig

21parseArgs :: Parser InterpreterConfig

24parseArgs = LocalInterpreterConfig <$> parsePersistenceStrategy <*> parseHeadName <*> parseTutDExec <*> many parseGhcPkgPath <*> parseCheckFS <|>

22parseArgs = LocalInterpreterConfig <$> parsePersistenceStrategy <*> parseHeadName <*> parseTutDExec <*> many parseGhcPkgPath <*> parseCheckFS <|>

25− RemoteInterpreterConfig <$> parseHostname "127.0.0.1" <*> parsePort defaultServerPort <*> parseDatabaseName <*> parseHeadName <*> parseTutDExec <*> parseCheckFS

23+ RemoteInterpreterConfig <$> parseNodeId <*> parseDatabaseName <*> parseHeadName <*> parseTutDExec <*> parseCheckFS

26

24

27parseHeadName :: Parser HeadName

25parseHeadName :: Parser HeadName

28parseHeadName = option auto (long "head" <>

26parseHeadName = option auto (long "head" <>

@@ -31,6 +29,19 @@ parseHeadName = option auto (long "head" <>

31 value "master"

29 value "master"

32 )

30 )

33

31

32+parseNodeId :: Parser NodeId

33+parseNodeId = createNodeId <$>

34+ strOption (long "host" <>

35+ short 'h' <>

36+ help "Remote host name" <>

37+ metavar "HOSTNAME" <>

38+ value "127.0.0.1") <*>

39+ option auto (long "port" <>

40+ metavar "PORT NUMBER" <>

41+ short 'p' <>

42+ help "Remote port" <>

43+ value defaultServerPort)

44+

34--just execute some tutd and exit

45--just execute some tutd and exit

35parseTutDExec :: Parser (Maybe TutorialDExec)

46parseTutDExec :: Parser (Maybe TutorialDExec)

36parseTutDExec = optional $ strOption (long "exec-tutd" <>

47parseTutDExec = optional $ strOption (long "exec-tutd" <>

@@ -44,19 +55,19 @@ opts = info (parseArgs <**> helpOption) idm

44

55

45connectionInfoForConfig :: InterpreterConfig -> ConnectionInfo

56connectionInfoForConfig :: InterpreterConfig -> ConnectionInfo

46connectionInfoForConfig (LocalInterpreterConfig pStrategy _ _ ghcPkgPaths _) = InProcessConnectionInfo pStrategy outputNotificationCallback ghcPkgPaths

57connectionInfoForConfig (LocalInterpreterConfig pStrategy _ _ ghcPkgPaths _) = InProcessConnectionInfo pStrategy outputNotificationCallback ghcPkgPaths

47−connectionInfoForConfig (RemoteInterpreterConfig remoteHost remotePort remoteDBName _ _ _) = RemoteConnectionInfo remoteDBName remoteHost (show remotePort) outputNotificationCallback

58+connectionInfoForConfig (RemoteInterpreterConfig remoteNodeId remoteDBName _ _ _) = RemoteProcessConnectionInfo remoteDBName remoteNodeId outputNotificationCallback

48

59

49headNameForConfig :: InterpreterConfig -> HeadName

60headNameForConfig :: InterpreterConfig -> HeadName

50headNameForConfig (LocalInterpreterConfig _ headn _ _ _) = headn

61headNameForConfig (LocalInterpreterConfig _ headn _ _ _) = headn

51−headNameForConfig (RemoteInterpreterConfig _ _ _ headn _ _) = headn

62+headNameForConfig (RemoteInterpreterConfig _ _ headn _ _) = headn

52

63

53execTutDForConfig :: InterpreterConfig -> Maybe String

64execTutDForConfig :: InterpreterConfig -> Maybe String

54execTutDForConfig (LocalInterpreterConfig _ _ t _ _) = t

65execTutDForConfig (LocalInterpreterConfig _ _ t _ _) = t

55−execTutDForConfig (RemoteInterpreterConfig _ _ _ _ t _) = t

66+execTutDForConfig (RemoteInterpreterConfig _ _ _ t _) = t

56

67

57checkFSForConfig :: InterpreterConfig -> Bool

68checkFSForConfig :: InterpreterConfig -> Bool

58checkFSForConfig (LocalInterpreterConfig _ _ _ _ c) = c

69checkFSForConfig (LocalInterpreterConfig _ _ _ _ c) = c

59−checkFSForConfig (RemoteInterpreterConfig _ _ _ _ _ c) = c

70+checkFSForConfig (RemoteInterpreterConfig _ _ _ _ c) = c

60

71

61persistenceStrategyForConfig :: InterpreterConfig -> Maybe PersistenceStrategy

72persistenceStrategyForConfig :: InterpreterConfig -> Maybe PersistenceStrategy

62persistenceStrategyForConfig (LocalInterpreterConfig strat _ _ _ _) = Just strat

73persistenceStrategyForConfig (LocalInterpreterConfig strat _ _ _ _) = Just strat

@@ -75,15 +86,8 @@ printWelcome = do

75 putStrLn "A full tutorial is available at:"

86 putStrLn "A full tutorial is available at:"

76 putStrLn "https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown"

87 putStrLn "https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown"

77

88

78−-- | If the locale is set to ASCII, upgrade it to UTF-8 because tutd outputs UTF-8-encoded attributes. This is especially important in light docker images where the locale data may be missing.

79−setLocaleIfNecessary :: IO ()

80−setLocaleIfNecessary = do

81− l <- getLocaleEncoding

82− when (textEncodingName l == "ASCII") (setLocaleEncoding utf8)

83−

84main :: IO ()

89main :: IO ()

85main = do

90main = do

86− setLocaleIfNecessary

87 interpreterConfig <- execParser opts

91 interpreterConfig <- execParser opts

88 let connInfo = connectionInfoForConfig interpreterConfig

92 let connInfo = connectionInfoForConfig interpreterConfig

89 fscheck <- checkFSType (checkFSForConfig interpreterConfig) (fromMaybe NoPersistence (persistenceStrategyForConfig interpreterConfig))

93 fscheck <- checkFSType (checkFSForConfig interpreterConfig) (fromMaybe NoPersistence (persistenceStrategyForConfig interpreterConfig))

src/bin/benchmark/Handles.hs+14−25

@@ -6,15 +6,13 @@ import Options.Applicative

6import TutorialD.Interpreter

7import TutorialD.Interpreter.Base hiding (Parser, option)

8import qualified Data.Text as T

9−#if __GLASGOW_HASKELL__ < 804

10import Data.Monoid

9import Data.Monoid

11−#endif

12import Control.Monad

10import Control.Monad

13

11

14data HandlesArgs = HandlesArgs {

12data HandlesArgs = HandlesArgs {

15 openCloseCount :: Int,

13 openCloseCount :: Int,

16 transactionCount :: Int,

14 transactionCount :: Int,

17− dbdir :: FilePath,

15+ dbdir :: FilePath,

18 tutdSetup :: String,

16 tutdSetup :: String,

19 tutdIterate :: String

17 tutdIterate :: String

20 }

18 }

@@ -40,13 +38,13 @@ parseTutdIterate = strOption (short 'i' <> long "iterate-tutd" <> value "update

40main :: IO ()

38main :: IO ()

41main = do

39main = do

42 args <- execParser $ info (helper <*> parseArgs) fullDesc

40 args <- execParser $ info (helper <*> parseArgs) fullDesc

43− replicateM_ (openCloseCount args) (runOpenClose

41+ replicateM_ (openCloseCount args) (runOpenClose

44 (T.pack (tutdSetup args))

42 (T.pack (tutdSetup args))

45 (T.pack (tutdIterate args))

43 (T.pack (tutdIterate args))

46− (transactionCount args)

44+ (transactionCount args)

47 (dbdir args))

45 (dbdir args))

48−

46+

49−runOpenClose :: T.Text -> T.Text -> Int -> FilePath -> IO ()

47+runOpenClose :: T.Text -> T.Text -> Int -> FilePath -> IO ()

50runOpenClose tutdSetup' tutdIterate' tCount dbdir' = do

48runOpenClose tutdSetup' tutdIterate' tCount dbdir' = do

51 let connInfo = InProcessConnectionInfo (MinimalPersistence dbdir') emptyNotificationCallback []

49 let connInfo = InProcessConnectionInfo (MinimalPersistence dbdir') emptyNotificationCallback []

52 eConn <- connectProjectM36 connInfo

50 eConn <- connectProjectM36 connInfo

@@ -56,7 +54,7 @@ runOpenClose tutdSetup' tutdIterate' tCount dbdir' = do

56 eSess <- createSessionAtHead conn "master"

54 eSess <- createSessionAtHead conn "master"

57 case eSess of

55 case eSess of

58 Left err -> error (show err)

56 Left err -> error (show err)

59− Right session ->

57+ Right session ->

60 --database setup

58 --database setup

61 case parseTutorialD tutdSetup' of

59 case parseTutorialD tutdSetup' of

62 Left err -> error (show err)

60 Left err -> error (show err)

@@ -64,19 +62,14 @@ runOpenClose tutdSetup' tutdIterate' tCount dbdir' = do

64 res <- evalTutorialD session conn UnsafeEvaluation parsed

62 res <- evalTutorialD session conn UnsafeEvaluation parsed

65 case res of

63 case res of

66 DisplayErrorResult err -> error (T.unpack err)

64 DisplayErrorResult err -> error (T.unpack err)

67− DisplayParseErrorResult _ err ->

65+ DisplayParseErrorResult _ err -> error (parseErrorPretty err)

68−#if MIN_VERSION_megaparsec(7,0,0)

69− error (errorBundlePretty err)

70−#else

71− error (parseErrorPretty err)

72−#endif

73− _ -> do

66+ _ -> do

74 replicateM_ tCount (runTransaction tutdIterate' session conn)

67 replicateM_ tCount (runTransaction tutdIterate' session conn)

75 close conn

68 close conn

76 printFdCount

69 printFdCount

77−

70+

78runTransaction :: T.Text -> SessionId -> Connection -> IO ()

71runTransaction :: T.Text -> SessionId -> Connection -> IO ()

79−runTransaction tutdIterate' sess conn =

72+runTransaction tutdIterate' sess conn =

80 --run tutd on every iteration

73 --run tutd on every iteration

81 case parseTutorialD tutdIterate' of

74 case parseTutorialD tutdIterate' of

82 Left err -> error (show err)

75 Left err -> error (show err)

@@ -84,14 +77,10 @@ runTransaction tutdIterate' sess conn =

84 res <- evalTutorialD sess conn UnsafeEvaluation parsed

77 res <- evalTutorialD sess conn UnsafeEvaluation parsed

85 case res of

78 case res of

86 DisplayErrorResult err -> error (T.unpack err)

79 DisplayErrorResult err -> error (T.unpack err)

87− DisplayParseErrorResult _ err ->

80+ DisplayParseErrorResult _ err -> error (parseErrorPretty err)

88−#if MIN_VERSION_megaparsec(7,0,0)

89− error (errorBundlePretty err)

90−#else

91− error (parseErrorPretty err)

92−#endif

93− _ -> do

81+ _ -> do

94− eErr <- commit sess conn

82+ eErr <- commit sess conn

95 case eErr of

83 case eErr of

96 Left err -> error (show err)

84 Left err -> error (show err)

97 Right _ -> printFdCount

85 Right _ -> printFdCount

86+

src/bin/benchmark/bigrel.hs+7−8

@@ -1,4 +1,4 @@

1−{-# LANGUAGE FlexibleInstances, CPP #-}

1+{-# LANGUAGE FlexibleInstances #-}

2{-# OPTIONS_GHC -fno-warn-orphans #-}

3import ProjectM36.Base

4import ProjectM36.Relation

@@ -9,6 +9,7 @@ import qualified ProjectM36.Attribute as A

9import qualified Data.Text as T

10--import ProjectM36.Relation.Show.CSV

11import ProjectM36.Relation.Show.HTML

12+import TutorialD.Interpreter.DatabaseContextExpr (interpretDatabaseContextExpr)

12import ProjectM36.RelationalExpression

13import ProjectM36.RelationalExpression

13import ProjectM36.TransactionGraph

14import ProjectM36.TransactionGraph

14--import qualified Data.HashSet as HS

15--import qualified Data.HashSet as HS

@@ -17,16 +18,16 @@ import ProjectM36.TransactionGraph

17--import qualified Data.Hashable as Hash

18--import qualified Data.Hashable as Hash

18import qualified Data.Vector as V

19import qualified Data.Vector as V

19import Options.Applicative

20import Options.Applicative

21+import qualified Data.Map as M

20import qualified Data.Text.IO as TIO

22import qualified Data.Text.IO as TIO

21import System.IO

23import System.IO

24+import Control.Monad.State

22import Control.DeepSeq

25import Control.DeepSeq

23import Data.Text hiding (map)

26import Data.Text hiding (map)

27+import Data.Monoid

24import Data.Time.Clock

28import Data.Time.Clock

29+import Data.UUID

25import Data.UUID.V4

30import Data.UUID.V4

26−#if __GLASGOW_HASKELL__ < 804

27−import Data.Monoid

28−#endif

29−

30

31

31{-

32{-

32dumpcsv :: Relation -> IO ()

33dumpcsv :: Relation -> IO ()

@@ -75,9 +76,7 @@ matrixRun (BigrelArgs attributeCount tupleCount tutd) =

75 case eNewState of

76 case eNewState of

76 Right newState -> do

77 Right newState -> do

77 let ctx = dbc_context newState

78 let ctx = dbc_context newState

78− Right x = optimizeAndEvalRelationalExpr env' (RelationVariable "x" ())

79− env' = RelationalExprEnv ctx graph Nothing

80− TIO.putStrLn $ relationAsHTML x

79+ TIO.putStrLn $ relationAsHTML (relationVariables ctx M.! "x")

81 Left err -> hPrint stderr err

80 Left err -> hPrint stderr err

82

81

83{-

82{-

src/lib/ProjectM36/Arbitrary.hs+1−6

@@ -9,7 +9,6 @@ import ProjectM36.AtomType

9import ProjectM36.Attribute (atomType)

10import ProjectM36.DataConstructorDef as DCD

11import ProjectM36.DataTypes.Interval

12−import ProjectM36.Relation

13import qualified Data.Vector as V

12import qualified Data.Vector as V

14import Data.Text (Text)

13import Data.Text (Text)

15import Test.QuickCheck

14import Test.QuickCheck

@@ -49,10 +48,6 @@ arbitrary' ByteStringAtomType =

49

48

50arbitrary' BoolAtomType =

49arbitrary' BoolAtomType =

51 Right . BoolAtom <$> lift (arbitrary :: Gen Bool)

50 Right . BoolAtom <$> lift (arbitrary :: Gen Bool)

52−

53−arbitrary' RelationalExprAtomType =

54− pure (Right (RelationalExprAtom (ExistingRelation relationTrue))) -- don't bother with arbitrary relational expressions

55−

56arbitrary' constructedAtomType@(ConstructedAtomType tcName tvMap)

51arbitrary' constructedAtomType@(ConstructedAtomType tcName tvMap)

57 --special-casing for Interval type

52 --special-casing for Interval type

58 | isIntervalAtomType constructedAtomType = createArbitraryInterval (intervalSubType constructedAtomType)

53 | isIntervalAtomType constructedAtomType = createArbitraryInterval (intervalSubType constructedAtomType)

@@ -84,7 +79,7 @@ maybeToRight y Nothing = Left y

84arbitraryRelationTuple :: Attributes -> WithTCMap Gen (Either RelationalError RelationTuple)

79arbitraryRelationTuple :: Attributes -> WithTCMap Gen (Either RelationalError RelationTuple)

85arbitraryRelationTuple attris = do

80arbitraryRelationTuple attris = do

86 tcMap <- ask

81 tcMap <- ask

87− listOfMaybeAType <- lift $ mapM ((\aTy -> runReaderT (arbitrary' aTy) tcMap) . atomType) (V.toList (attributesVec attris))

82+ listOfMaybeAType <- lift $ mapM ((\aTy -> runReaderT (arbitrary' aTy) tcMap) . atomType) (V.toList attris)

88 case sequence listOfMaybeAType of

83 case sequence listOfMaybeAType of

89 Left err -> pure $ Left err

84 Left err -> pure $ Left err

90 Right listOfAttr -> do

85 Right listOfAttr -> do

src/lib/ProjectM36/Atom.hs+1−2

@@ -3,7 +3,7 @@ import ProjectM36.Base

3import ProjectM36.Error

4import ProjectM36.DataTypes.Interval

5import qualified Data.Text as T

6−#if __GLASGOW_HASKELL__ < 804

6+#if __GLASGOW_HASKELL__ <= 802

7import Data.Monoid

8#endif

9

@@ -20,7 +20,6 @@ atomToText (DayAtom i) = (T.pack . show) i

20atomToText (DateTimeAtom i) = (T.pack . show) i

21atomToText (ByteStringAtom i) = (T.pack . show) i

22atomToText (BoolAtom i) = (T.pack . show) i

23−atomToText (RelationalExprAtom re) = (T.pack . show) re

24

23

25atomToText (RelationAtom i) = (T.pack . show) i

24atomToText (RelationAtom i) = (T.pack . show) i

26atomToText (ConstructedAtom dConsName typ atoms)

25atomToText (ConstructedAtom dConsName typ atoms)

src/lib/ProjectM36/AtomFunction.hs+2−19

@@ -1,7 +1,5 @@

1−{-# LANGUAGE CPP #-}

2module ProjectM36.AtomFunction where

1module ProjectM36.AtomFunction where

3import ProjectM36.Base

2import ProjectM36.Base

4−import ProjectM36.Serialise.Base ()

5import ProjectM36.Error

3import ProjectM36.Error

6import ProjectM36.Relation

4import ProjectM36.Relation

7import ProjectM36.AtomType

5import ProjectM36.AtomType

@@ -10,8 +8,7 @@ import ProjectM36.ScriptSession

10import qualified ProjectM36.Attribute as A

8import qualified ProjectM36.Attribute as A

11import qualified Data.HashSet as HS

9import qualified Data.HashSet as HS

12import qualified Data.Text as T

10import qualified Data.Text as T

13−import qualified Data.ByteString.Lazy as BL

11+

14−import Codec.Winery

15

12

16foldAtomFuncType :: AtomType -> AtomType -> [AtomType]

13foldAtomFuncType :: AtomType -> AtomType -> [AtomType]

17--the underscore in the attribute name means that any attributes are acceptable

14--the underscore in the attribute name means that any attributes are acceptable

@@ -75,11 +72,7 @@ createScriptedAtomFunction funcName argsType retType = AddAtomFunction funcName

75 retType]])

72 retType]])

76

73

77loadAtomFunctions :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError [AtomFunction])

74loadAtomFunctions :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError [AtomFunction])

78−#ifdef PM36_HASKELL_SCRIPTING

79loadAtomFunctions = loadFunction

75loadAtomFunctions = loadFunction

80−#else

81−loadAtomFunctions _ _ _ = pure (Left LoadSymbolError)

82−#endif

83

76

84atomFunctionsAsRelation :: AtomFunctions -> Either RelationalError Relation

77atomFunctionsAsRelation :: AtomFunctions -> Either RelationalError Relation

85atomFunctionsAsRelation funcs = mkRelationFromList attrs tups

78atomFunctionsAsRelation funcs = mkRelationFromList attrs tups

@@ -88,14 +81,4 @@ atomFunctionsAsRelation funcs = mkRelationFromList attrs tups

88 Attribute "arguments" TextAtomType]

81 Attribute "arguments" TextAtomType]

89 atomFuncToTuple aFunc = [TextAtom (atomFuncName aFunc),

82 atomFuncToTuple aFunc = [TextAtom (atomFuncName aFunc),

90 TextAtom (atomFuncTypeToText aFunc)]

83 TextAtom (atomFuncTypeToText aFunc)]

91− atomFuncTypeToText aFunc = T.intercalate " -> " (map prettyAtomType (atomFuncType aFunc))

84+ atomFuncTypeToText aFunc = T.intercalate " -> " (map prettyAtomType (atomFuncType aFunc))

92−

93−--for calculating the merkle hash

94−hashBytes :: AtomFunction -> BL.ByteString

95−hashBytes func = BL.fromChunks [serialise (atomFuncName func),

96− serialise (atomFuncType func),

97− bodyBin

98− ]

99− where

100− bodyBin = case atomFuncBody func of

101− AtomFunctionBody mScript _ -> serialise mScript

src/lib/ProjectM36/AtomFunctionError.hs+2−1

@@ -1,5 +1,6 @@

1{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

2module ProjectM36.AtomFunctionError where

3+import Data.Binary

3import GHC.Generics

4import GHC.Generics

4import Control.DeepSeq

5import Control.DeepSeq

5import Data.Text

6import Data.Text

@@ -13,5 +14,5 @@ data AtomFunctionError = AtomFunctionUserError String |

13 AtomTypeDoesNotSupportOrderingError Text |

14 AtomTypeDoesNotSupportOrderingError Text |

14 AtomTypeDoesNotSupportIntervalError Text |

15 AtomTypeDoesNotSupportIntervalError Text |

15 AtomFunctionBytesDecodingError String

16 AtomFunctionBytesDecodingError String

16− deriving(Generic, Eq, Show, NFData)

17+ deriving(Generic, Eq, Show, Binary, NFData)

17

18

src/lib/ProjectM36/AtomType.hs+14−86

@@ -139,37 +139,14 @@ resolveAttributeExprTypeVars (AttributeAndTypeNameExpr _ tCons _) aType tConsMap

139

140-- check that type vars on the right also appear on the left

141-- check that the data constructor names are unique

142−validateTypeConstructorDef :: TypeConstructorDef -> [DataConstructorDef] -> TypeConstructorMapping -> Either RelationalError ()

142+validateTypeConstructorDef :: TypeConstructorDef -> [DataConstructorDef] -> [RelationalError]

143−validateTypeConstructorDef tConsDef dConsList tConsMap = do

143+validateTypeConstructorDef tConsDef dConsList = execWriter $ do

144 let duplicateDConsNames = dupes (L.sort (map DCD.name dConsList))

145− unless (null duplicateDConsNames) (Left (someErrors (map DataConstructorNameInUseError duplicateDConsNames)))

145+ mapM_ tell [map DataConstructorNameInUseError duplicateDConsNames]

146 let leftSideVars = S.fromList (TCD.typeVars tConsDef)

147 rightSideVars = S.unions (map DCD.typeVars dConsList)

148 varsDiff = S.difference leftSideVars rightSideVars

149− when (S.size varsDiff > 0) (Left (someErrors (map DataConstructorUsesUndeclaredTypeVariable (S.toList varsDiff))))

149+ mapM_ tell [map DataConstructorUsesUndeclaredTypeVariable (S.toList varsDiff)]

150− mapM_ (\dConsDef -> validateDataConstructorDef dConsDef tConsDef tConsMap) dConsList

151−

152−--check that the data constructor names are not in use (recursively)

153−validateDataConstructorDef :: DataConstructorDef -> TypeConstructorDef -> TypeConstructorMapping -> Either RelationalError ()

154−validateDataConstructorDef (DataConstructorDef dConsName dConsDefArgs) tConsDef tConsMap =

155− case findDataConstructor dConsName tConsMap of

156− Just _ -> Left (DataConstructorNameInUseError dConsName)

157− Nothing ->

158− mapM_ (\arg -> validateDataConstructorDefArg arg tConsDef tConsMap) dConsDefArgs

159−

160−

161−validateDataConstructorDefArg :: DataConstructorDefArg -> TypeConstructorDef -> TypeConstructorMapping -> Either RelationalError ()

162−validateDataConstructorDefArg (DataConstructorDefTypeConstructorArg (PrimitiveTypeConstructor _ _)) _ _ = Right ()

163−validateDataConstructorDefArg (DataConstructorDefTypeConstructorArg (TypeVariable _)) _ _ = Right ()

164−validateDataConstructorDefArg (DataConstructorDefTypeConstructorArg tCons) tConsDef tConsMap = case findTypeConstructor (TC.name tCons) tConsMap of

165− Nothing ->

166− when (TC.name tCons /= TCD.name tConsDef) (Left (NoSuchTypeConstructorName (TC.name tCons))) --allows for recursively-defined types

167− Just (ADTypeConstructorDef _ tConsArgs, _) -> do --validate that the argument count matches- type matching can occur later

168− let existingCount = length tConsArgs

169− newCount = length (TC.arguments tCons)

170− when (newCount /= existingCount) (Left (ConstructedAtomArgumentCountMismatchError existingCount newCount))

171− Just (PrimitiveTypeConstructorDef _ _, _) -> pure ()

172−validateDataConstructorDefArg (DataConstructorDefTypeVarNameArg _) _ _ = Right ()

173

150

174atomTypeForTypeConstructor :: TypeConstructor -> TypeConstructorMapping -> TypeVarMap -> Either RelationalError AtomType

151atomTypeForTypeConstructor :: TypeConstructor -> TypeConstructorMapping -> TypeVarMap -> Either RelationalError AtomType

175atomTypeForTypeConstructor = atomTypeForTypeConstructorValidate False

152atomTypeForTypeConstructor = atomTypeForTypeConstructorValidate False

@@ -211,7 +188,7 @@ isValidAtomTypeForTypeConstructor (ConstructedAtomType tConsName _) (ADTypeConst

211

188

212isValidAtomTypeForTypeConstructor (RelationAtomType attrs) (RelationAtomTypeConstructor attrExprs) tConsMap = do

189isValidAtomTypeForTypeConstructor (RelationAtomType attrs) (RelationAtomTypeConstructor attrExprs) tConsMap = do

213 evaldAtomTypes <- mapM (\expr -> atomTypeForAttributeExpr expr tConsMap M.empty) attrExprs

190 evaldAtomTypes <- mapM (\expr -> atomTypeForAttributeExpr expr tConsMap M.empty) attrExprs

214− mapM_ (uncurry resolveAtomType) (zip (A.atomTypesList attrs) evaldAtomTypes)

191+ mapM_ (uncurry resolveAtomType) (zip (map A.atomType (V.toList attrs)) evaldAtomTypes)

215isValidAtomTypeForTypeConstructor aType tCons _ = Left (AtomTypeTypeConstructorReconciliationError aType (TC.name tCons))

192isValidAtomTypeForTypeConstructor aType tCons _ = Left (AtomTypeTypeConstructorReconciliationError aType (TC.name tCons))

216

193

217findTypeConstructor :: TypeConstructorName -> TypeConstructorMapping -> Maybe (TypeConstructorDef, [DataConstructorDef])

194findTypeConstructor :: TypeConstructorName -> TypeConstructorMapping -> Maybe (TypeConstructorDef, [DataConstructorDef])

@@ -221,18 +198,10 @@ findTypeConstructor name = foldr tConsFolder Nothing

221 Just (tCons, dConsList)

198 Just (tCons, dConsList)

222 else

199 else

223 accum

200 accum

224−

201+

225−resolveAttributes :: Attribute -> Attribute -> Either RelationalError Attribute

226−resolveAttributes attrA attrB =

227− if A.attributeName attrA /= A.attributeName attrB then

228− Left $ AttributeNamesMismatchError (S.fromList (map A.attributeName [attrA, attrB]))

229− else

230− Attribute (A.attributeName attrA) <$> resolveAtomType (A.atomType attrA) (A.atomType attrB)

231−

232−--given two atom types, try to resolve type variables

233resolveAtomType :: AtomType -> AtomType -> Either RelationalError AtomType

202resolveAtomType :: AtomType -> AtomType -> Either RelationalError AtomType

234resolveAtomType (ConstructedAtomType tConsName resolvedTypeVarMap) (ConstructedAtomType _ unresolvedTypeVarMap) =

203resolveAtomType (ConstructedAtomType tConsName resolvedTypeVarMap) (ConstructedAtomType _ unresolvedTypeVarMap) =

235− ConstructedAtomType tConsName <$> resolveAtomTypesInTypeVarMap resolvedTypeVarMap unresolvedTypeVarMap

204+ ConstructedAtomType tConsName <$> resolveAtomTypesInTypeVarMap resolvedTypeVarMap unresolvedTypeVarMap

236resolveAtomType typeFromRelation unresolvedType = if typeFromRelation == unresolvedType then

205resolveAtomType typeFromRelation unresolvedType = if typeFromRelation == unresolvedType then

237 Right typeFromRelation

206 Right typeFromRelation

238 else

207 else

@@ -260,16 +229,12 @@ resolveAtomTypesInTypeVarMap resolvedTypeMap unresolvedTypeMap = do

260 let resolveTypePair resKey resType =

229 let resolveTypePair resKey resType =

261 -- if the key is missing in the unresolved type map, then fill it in with the value from the resolved map

230 -- if the key is missing in the unresolved type map, then fill it in with the value from the resolved map

262 case M.lookup resKey unresolvedTypeMap of

231 case M.lookup resKey unresolvedTypeMap of

263− Just unresType -> case unresType of

232+ Just unresType -> case unresType of

264 --do we need to recurse for RelationAtomType?

233 --do we need to recurse for RelationAtomType?

265 subType@(ConstructedAtomType _ _) -> do

234 subType@(ConstructedAtomType _ _) -> do

266 resSubType <- resolveAtomType resType subType

235 resSubType <- resolveAtomType resType subType

267 pure (resKey, resSubType)

236 pure (resKey, resSubType)

268− TypeVariableType _ -> pure (resKey, resType)

237+ _ -> pure (resKey, resType)

269− typ -> if typ == resType then

270− pure (resKey, resType)

271− else

272− Left $ AtomTypeMismatchError typ resType

273 Nothing ->

238 Nothing ->

274 pure (resKey, resType) --swipe the missing type var from the expected map

239 pure (resKey, resType) --swipe the missing type var from the expected map

275 tVarList <- mapM (uncurry resolveTypePair) (M.toList resolvedTypeMap)

240 tVarList <- mapM (uncurry resolveTypePair) (M.toList resolvedTypeMap)

@@ -295,7 +260,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.

260-- Example: "Nothing" does not specify the the argument in "Maybe a", so allow delayed resolution in the tuple before it is added to the relation. Note that this resolution could cause a type error. Hardly a Hindley-Milner system.

296resolveTypesInTuple :: Attributes -> TypeConstructorMapping -> RelationTuple -> Either RelationalError RelationTuple

261resolveTypesInTuple :: Attributes -> TypeConstructorMapping -> RelationTuple -> Either RelationalError RelationTuple

297resolveTypesInTuple resolvedAttrs tConss (RelationTuple _ tupAtoms) = do

262resolveTypesInTuple resolvedAttrs tConss (RelationTuple _ tupAtoms) = do

298− newAtoms <- mapM (\(atom, resolvedType) -> resolveTypeInAtom resolvedType atom tConss) (zip (V.toList tupAtoms) $ A.atomTypesList resolvedAttrs)

263+ newAtoms <- mapM (\(atom, resolvedType) -> resolveTypeInAtom resolvedType atom tConss) (zip (V.toList tupAtoms) $ map A.atomType (V.toList resolvedAttrs))

299 Right (RelationTuple resolvedAttrs (V.fromList newAtoms))

264 Right (RelationTuple resolvedAttrs (V.fromList newAtoms))

300

265

301-- | Validate that the type is provided with complete type variables for type constructors.

266-- | Validate that the type is provided with complete type variables for type constructors.

@@ -314,19 +279,10 @@ validateAtomType typ@(ConstructedAtomType tConsName tVarMap) tConss =

314 _ -> Right ()

279 _ -> Right ()

315validateAtomType (RelationAtomType attrs) tConss =

280validateAtomType (RelationAtomType attrs) tConss =

316 mapM_ (\attr ->

281 mapM_ (\attr ->

317− validateAtomType (A.atomType attr) tConss) (attributesVec attrs)

282+ validateAtomType (A.atomType attr) tConss) (V.toList attrs)

318validateAtomType (TypeVariableType x) _ = Left (TypeConstructorTypeVarMissing x)

283validateAtomType (TypeVariableType x) _ = Left (TypeConstructorTypeVarMissing x)

319validateAtomType _ _ = pure ()

284validateAtomType _ _ = pure ()

320

285

321−validateAttributes :: TypeConstructorMapping -> Attributes -> Either RelationalError ()

322−validateAttributes tConss attrs =

323− if not (null errs) then

324− Left (someErrors errs)

325− else

326− pure ()

327− where

328− errs = lefts $ map (`validateAtomType` tConss) (A.atomTypesList attrs)

329−

330--ensure that all type vars are fully resolved

286--ensure that all type vars are fully resolved

331validateTypeVarMap :: TypeVarMap -> TypeConstructorMapping -> Either RelationalError ()

287validateTypeVarMap :: TypeVarMap -> TypeConstructorMapping -> Either RelationalError ()

332validateTypeVarMap tvMap tConss = mapM_ (`validateAtomType` tConss) $ M.elems tvMap

288validateTypeVarMap tvMap tConss = mapM_ (`validateAtomType` tConss) $ M.elems tvMap

@@ -358,7 +314,7 @@ atomTypeVerify x@(RelationAtomType attrs1) y@(RelationAtomType attrs2) = do

358 if notElem "_" [name1, name2] && name1 /= name2 then

314 if notElem "_" [name1, name2] && name1 /= name2 then

359 Left $ AtomTypeMismatchError x y

315 Left $ AtomTypeMismatchError x y

360 else

316 else

361− atomTypeVerify (A.atomType attr1) (A.atomType attr2)) $ V.toList (V.zip (attributesVec attrs1) (attributesVec attrs2))

317+ atomTypeVerify (A.atomType attr1) (A.atomType attr2)) $ V.toList (V.zip attrs1 attrs2)

362 return x

318 return x

363atomTypeVerify x y = if x == y then

319atomTypeVerify x y = if x == y then

364 Right x

320 Right x

@@ -367,15 +323,10 @@ atomTypeVerify x y = if x == y then

367

323

368-- | Determine if two typeVars are logically compatible.

324-- | Determine if two typeVars are logically compatible.

369typeVarMapsVerify :: TypeVarMap -> TypeVarMap -> Bool

325typeVarMapsVerify :: TypeVarMap -> TypeVarMap -> Bool

370−typeVarMapsVerify a b = M.keysSet a == M.keysSet b && (length . rights) zipped == M.size a

326+typeVarMapsVerify a b = M.keysSet a == M.keysSet b && (length . rights) (map (\((_,v1),(_,v2)) -> atomTypeVerify v1 v2) (zip (M.toAscList a) (M.toAscList b))) == M.size a

371− where

372− zipped = zipWith

373− (curry (\ ((_, v1), (_, v2)) -> atomTypeVerify v1 v2))

374− (M.toAscList a)

375− (M.toAscList b)

376

327

377prettyAtomType :: AtomType -> T.Text

328prettyAtomType :: AtomType -> T.Text

378−prettyAtomType (RelationAtomType attrs) = "relation {" `T.append` T.intercalate "," (map prettyAttribute (V.toList (attributesVec attrs))) `T.append` "}"

329+prettyAtomType (RelationAtomType attrs) = "relation {" `T.append` T.intercalate "," (map prettyAttribute (V.toList attrs)) `T.append` "}"

379prettyAtomType (ConstructedAtomType tConsName typeVarMap) = tConsName `T.append` T.concat (map showTypeVars (M.toList typeVarMap))

330prettyAtomType (ConstructedAtomType tConsName typeVarMap) = tConsName `T.append` T.concat (map showTypeVars (M.toList typeVarMap))

380 where

331 where

381 showTypeVars (_, TypeVariableType x) = " " <> x

332 showTypeVars (_, TypeVariableType x) = " " <> x

@@ -431,26 +382,3 @@ resolvedAtomTypeForDataConstructorDefArg _ tvMap (DataConstructorDefTypeVarNameA

431 Nothing -> Left (DataConstructorUsesUndeclaredTypeVariable tvName)

382 Nothing -> Left (DataConstructorUsesUndeclaredTypeVariable tvName)

432 Just typ -> Right typ

383 Just typ -> Right typ

433

384

434−isResolvedType :: AtomType -> Bool

435−isResolvedType typ =

436− case typ of

437− IntAtomType -> True

438− IntegerAtomType -> True

439− DoubleAtomType -> True

440− TextAtomType -> True

441− DayAtomType -> True

442− DateTimeAtomType -> True

443− ByteStringAtomType -> True

444− BoolAtomType -> True

445− RelationalExprAtomType -> True

446− RelationAtomType attrs -> isResolvedAttributes attrs

447− ConstructedAtomType _ tvMap -> all isResolvedType (M.elems tvMap)

448− TypeVariableType _ -> False

449−

450−isResolvedAttributes :: Attributes -> Bool

451−isResolvedAttributes attrs = all isResolvedAttribute (V.toList (attributesVec attrs))

452−

453−isResolvedAttribute :: Attribute -> Bool

454−isResolvedAttribute = isResolvedType . A.atomType

455−

456−--given two AtomTypes x,y

src/lib/ProjectM36/Atomable.hs+49−33

@@ -13,16 +13,29 @@ 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

16import Control.Applicative

17import Control.Applicative

17import Data.Time.Calendar

18import Data.Time.Calendar

18import Data.ByteString (ByteString)

19import Data.ByteString (ByteString)

19import Data.Time.Clock

20import Data.Time.Clock

20import Data.Proxy

21import Data.Proxy

21import qualified Data.List.NonEmpty as NE

22import qualified Data.List.NonEmpty as NE

22−import Codec.Winery

23

24+--also add haskell scripting atomable support

25+--rename this module to Atomable along with test

26+

27+{-

28+data Test1T = Test1C Int

29+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)

30+

31+data Test2T = Test2C Int Int

32+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)

33+

34+data Test3T = Test3Ca | Test3Cb

35+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)

36+-}

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.

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.

25−class (Eq a, NFData a, Serialise a, Show a) => Atomable a where

38+class (Eq a, NFData a, Binary a, Show a) => Atomable a where

26 toAtom :: a -> Atom

39 toAtom :: a -> Atom

27 default toAtom :: (Generic a, AtomableG (Rep a)) => a -> Atom

40 default toAtom :: (Generic a, AtomableG (Rep a)) => a -> Atom

28 toAtom v = toAtomG (from v) (toAtomTypeG (from v))

41 toAtom v = toAtomG (from v) (toAtomTypeG (from v))

@@ -43,7 +56,7 @@ class (Eq a, NFData a, Serialise a, Show a) => Atomable a where

43 -- | Creates DatabaseContextExpr necessary to load the type constructor and data constructor into the database.

56 -- | Creates DatabaseContextExpr necessary to load the type constructor and data constructor into the database.

44 toAddTypeExpr :: proxy a -> DatabaseContextExpr

57 toAddTypeExpr :: proxy a -> DatabaseContextExpr

45 default toAddTypeExpr :: (Generic a, AtomableG (Rep a)) => proxy a -> DatabaseContextExpr

58 default toAddTypeExpr :: (Generic a, AtomableG (Rep a)) => proxy a -> DatabaseContextExpr

46− toAddTypeExpr _ = toAddTypeExprG (from (error "insufficient laziness" :: a)) (toAtomType (Proxy :: Proxy a))

59+ toAddTypeExpr _ = toAddTypeExprG (from (undefined :: a)) (toAtomType (Proxy :: Proxy a))

47

60

48instance Atomable Integer where

61instance Atomable Integer where

49 toAtom = IntegerAtom

62 toAtom = IntegerAtom

@@ -135,10 +148,10 @@ instance (Atomable a, Atomable b) => Atomable (Either a b) where

135--convert to ADT list

148--convert to ADT list

136instance Atomable a => Atomable [a] where

149instance Atomable a => Atomable [a] where

137 toAtom [] = ConstructedAtom "Empty" (listAtomType (toAtomType (Proxy :: Proxy a))) []

150 toAtom [] = ConstructedAtom "Empty" (listAtomType (toAtomType (Proxy :: Proxy a))) []

138− toAtom (x:xs) = ConstructedAtom "Cons" (listAtomType (toAtomType (Proxy :: Proxy a))) (toAtom x: [toAtom xs])

151+ toAtom (x:xs) = ConstructedAtom "Cons" (listAtomType (toAtomType (Proxy :: Proxy a))) (map toAtom (x:xs))

139

152

140 fromAtom (ConstructedAtom "Empty" _ _) = []

153 fromAtom (ConstructedAtom "Empty" _ _) = []

141− fromAtom (ConstructedAtom "Cons" _ [x,y]) = fromAtom x:fromAtom y

154+ fromAtom (ConstructedAtom "Cons" _ (x:xs)) = fromAtom x:map fromAtom xs

142 fromAtom _ = error "improper fromAtom [a]"

155 fromAtom _ = error "improper fromAtom [a]"

143

156

144 toAtomType _ = ConstructedAtomType "List" (M.singleton "a" (toAtomType (Proxy :: Proxy a)))

157 toAtomType _ = ConstructedAtomType "List" (M.singleton "a" (toAtomType (Proxy :: Proxy a)))

@@ -152,6 +165,10 @@ instance Atomable a => Atomable (NE.NonEmpty a) where

152 toAtomType _ = ConstructedAtomType "NonEmptyList" (M.singleton "a" (toAtomType (Proxy :: Proxy a)))

165 toAtomType _ = ConstructedAtomType "NonEmptyList" (M.singleton "a" (toAtomType (Proxy :: Proxy a)))

153 toAddTypeExpr _ = NoOperation

166 toAddTypeExpr _ = NoOperation

154

167

168+#if !MIN_VERSION_binary(0,8,4)

169+instance Binary a => Binary (NE.NonEmpty a)

170+#endif

171+

155-- Generics

172-- Generics

156class AtomableG g where

173class AtomableG g where

157 --type AtomTG g

174 --type AtomTG g

@@ -167,17 +184,17 @@ class AtomableG g where

167instance (Datatype c, AtomableG a) => AtomableG (M1 D c a) where

184instance (Datatype c, AtomableG a) => AtomableG (M1 D c a) where

168 toAtomG (M1 v) = toAtomG v

185 toAtomG (M1 v) = toAtomG v

169 fromAtomG atom args = M1 <$> fromAtomG atom args

186 fromAtomG atom args = M1 <$> fromAtomG atom args

170− toAtomsG = error "invalid toAtomsG in M1 D"

187+ toAtomsG = undefined

171 toAtomTypeG _ = ConstructedAtomType (T.pack typeName) M.empty -- generics don't allow us to get the type constructor variables- alternatives?

188 toAtomTypeG _ = ConstructedAtomType (T.pack typeName) M.empty -- generics don't allow us to get the type constructor variables- alternatives?

172 where

189 where

173 typeName = datatypeName (undefined :: M1 D c a x)

190 typeName = datatypeName (undefined :: M1 D c a x)

174− toAddTypeExprG ~(M1 v) (ConstructedAtomType tcName _) = AddTypeConstructor tcDef dataConstructors

191+ toAddTypeExprG (M1 v) (ConstructedAtomType tcName _) = AddTypeConstructor tcDef dataConstructors

175 where

192 where

176 tcDef = ADTypeConstructorDef tcName []

193 tcDef = ADTypeConstructorDef tcName []

177 dataConstructors = getConstructorsG v

194 dataConstructors = getConstructorsG v

178 toAddTypeExprG _ _ = NoOperation

195 toAddTypeExprG _ _ = NoOperation

179− getConstructorsG ~(M1 v) = getConstructorsG v

196+ getConstructorsG (M1 v) = getConstructorsG v

180− getConstructorArgsG = error "invalid getConstructorArgsG in M1 D"

197+ getConstructorArgsG = undefined

181

198

182--constructor metadata

199--constructor metadata

183instance (Constructor c, AtomableG a) => AtomableG (M1 C c a) where

200instance (Constructor c, AtomableG a) => AtomableG (M1 C c a) where

@@ -192,11 +209,11 @@ instance (Constructor c, AtomableG a) => AtomableG (M1 C c a) where

192 Nothing

209 Nothing

193 where

210 where

194 dName = T.pack (conName (undefined :: M1 C c a x))

211 dName = T.pack (conName (undefined :: M1 C c a x))

195− fromAtomG _ _ = error "invalid fromAtomG in M1 C"

212+ fromAtomG _ _ = error "unsupported generic traversal"

196− toAtomsG = error "invalid toAtomsG in M1 C"

213+ toAtomsG = undefined

197− toAtomTypeG = error "invalid toAtomTypeG in M1 C"

214+ toAtomTypeG = undefined

198− toAddTypeExprG = error "invalid toAddTypeExprG in M1 C"

215+ toAddTypeExprG = undefined

199− getConstructorsG ~(M1 v) = [DataConstructorDef (T.pack dName) dArgs]

216+ getConstructorsG (M1 v) = [DataConstructorDef (T.pack dName) dArgs]

200 where

217 where

201 dName = conName (undefined :: M1 C c a x)

218 dName = conName (undefined :: M1 C c a x)

202 dArgs = getConstructorArgsG v

219 dArgs = getConstructorArgsG v

@@ -208,9 +225,9 @@ instance (Selector c, AtomableG a) => AtomableG (M1 S c a) where

208 fromAtomG atom args = M1 <$> fromAtomG atom args

225 fromAtomG atom args = M1 <$> fromAtomG atom args

209 toAtomsG (M1 v) = toAtomsG v

226 toAtomsG (M1 v) = toAtomsG v

210 toAtomTypeG (M1 v) = toAtomTypeG v

227 toAtomTypeG (M1 v) = toAtomTypeG v

211− toAddTypeExprG = error "invalid toAddTypeExprG in M1 S"

228+ toAddTypeExprG _ _ = undefined

212− getConstructorsG = error "invalid getConstructorsG in M1 S"

229+ getConstructorsG = undefined

213− getConstructorArgsG ~(M1 v) = getConstructorArgsG v

230+ getConstructorArgsG (M1 v) = getConstructorArgsG v

214

231

215-- field data metadata

232-- field data metadata

216instance (Atomable a) => AtomableG (K1 c a) where

233instance (Atomable a) => AtomableG (K1 c a) where

@@ -220,9 +237,9 @@ instance (Atomable a) => AtomableG (K1 c a) where

220 headatom [] = error "no more atoms for constructor!"

237 headatom [] = error "no more atoms for constructor!"

221 toAtomsG (K1 v) = [toAtom v]

238 toAtomsG (K1 v) = [toAtom v]

222 toAtomTypeG _ = toAtomType (Proxy :: Proxy a)

239 toAtomTypeG _ = toAtomType (Proxy :: Proxy a)

223− toAddTypeExprG = error "invalid toAddTypeExprG in K1"

240+ toAddTypeExprG _ _ = undefined

224− getConstructorsG = error "invalid getConstructorsG in K1"

241+ getConstructorsG = undefined

225− getConstructorArgsG ~(K1 _) = [DataConstructorDefTypeConstructorArg tCons]

242+ getConstructorArgsG (K1 _) = [DataConstructorDefTypeConstructorArg tCons]

226 where

243 where

227 tCons = typeToTypeConstructor $ toAtomType (Proxy :: Proxy a)

244 tCons = typeToTypeConstructor $ toAtomType (Proxy :: Proxy a)

228

245

@@ -235,9 +252,8 @@ typeToTypeConstructor x@DayAtomType = PrimitiveTypeConstructor "Day" x

235typeToTypeConstructor x@DateTimeAtomType = PrimitiveTypeConstructor "DateTime" x

252typeToTypeConstructor x@DateTimeAtomType = PrimitiveTypeConstructor "DateTime" x

236typeToTypeConstructor x@ByteStringAtomType = PrimitiveTypeConstructor "ByteString" x

253typeToTypeConstructor x@ByteStringAtomType = PrimitiveTypeConstructor "ByteString" x

237typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x

254typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x

238−typeToTypeConstructor x@RelationalExprAtomType = PrimitiveTypeConstructor "RelationalExpr" x

239typeToTypeConstructor (RelationAtomType attrs)

255typeToTypeConstructor (RelationAtomType attrs)

240− = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList (attributesVec attrs)

256+ = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList attrs

241 where

257 where

242 attrToAttrExpr (Attribute n t) = AttributeAndTypeNameExpr n (typeToTypeConstructor t) ()

258 attrToAttrExpr (Attribute n t) = AttributeAndTypeNameExpr n (typeToTypeConstructor t) ()

243typeToTypeConstructor (ConstructedAtomType tcName tvMap)

259typeToTypeConstructor (ConstructedAtomType tcName tvMap)

@@ -245,12 +261,12 @@ typeToTypeConstructor (ConstructedAtomType tcName tvMap)

245typeToTypeConstructor (TypeVariableType tvName) = TypeVariable tvName

261typeToTypeConstructor (TypeVariableType tvName) = TypeVariable tvName

246

262

247instance AtomableG U1 where

263instance AtomableG U1 where

248− toAtomG = error "invalid toAtomG in U1"

264+ toAtomG = undefined

249 fromAtomG _ _ = pure U1

265 fromAtomG _ _ = pure U1

250 toAtomsG _ = []

266 toAtomsG _ = []

251− toAtomTypeG = error "invalid toAtomTypeG in U1"

267+ toAtomTypeG = undefined

252− toAddTypeExprG = error "invalid toAddTypeExprG in U1"

268+ toAddTypeExprG = undefined

253− getConstructorsG = error "invalid getConstructorsG in U1"

269+ getConstructorsG = undefined

254 getConstructorArgsG _ = []

270 getConstructorArgsG _ = []

255

271

256-- product types

272-- product types

@@ -260,23 +276,23 @@ instance (AtomableG a, AtomableG b) => AtomableG (a :*: b) where

260 where splitargs1 = take splitpoint args

276 where splitargs1 = take splitpoint args

261 splitargs2 = drop splitpoint args

277 splitargs2 = drop splitpoint args

262 splitpoint = length args `div` 2

278 splitpoint = length args `div` 2

263− toAtomTypeG = error "invalid toAtomTypeG in :*:"

279+ toAtomTypeG = undefined

264 toAtomsG (x :*: y) = toAtomsG x ++ toAtomsG y

280 toAtomsG (x :*: y) = toAtomsG x ++ toAtomsG y

265− toAddTypeExprG = error "invalid toAddTypeExprG in :*:"

281+ toAddTypeExprG _ _ = undefined

266− getConstructorsG = error "invalid getConstructorsG in :*:"

282+ getConstructorsG = undefined

267− getConstructorArgsG ~(x :*: y) = getConstructorArgsG x ++ getConstructorArgsG y

283+ getConstructorArgsG (x :*: y) = getConstructorArgsG x ++ getConstructorArgsG y

268

284

269-- sum types

285-- sum types

270instance (AtomableG a, AtomableG b) => AtomableG (a :+: b) where

286instance (AtomableG a, AtomableG b) => AtomableG (a :+: b) where

271 toAtomG (L1 x) = toAtomG x

287 toAtomG (L1 x) = toAtomG x

272 toAtomG (R1 x) = toAtomG x

288 toAtomG (R1 x) = toAtomG x

273 fromAtomG atom args = (L1 <$> fromAtomG atom args) <|> (R1 <$> fromAtomG atom args)

289 fromAtomG atom args = (L1 <$> fromAtomG atom args) <|> (R1 <$> fromAtomG atom args)

274− toAtomTypeG = error "invalid toAtomTypeG in :+:"

290+ toAtomTypeG = undefined

275 toAtomsG (L1 x) = toAtomsG x

291 toAtomsG (L1 x) = toAtomsG x

276 toAtomsG (R1 x) = toAtomsG x

292 toAtomsG (R1 x) = toAtomsG x

277− toAddTypeExprG = error "invalid toAddTypeExprG in :+:"

293+ toAddTypeExprG _ _ = undefined

278 getConstructorsG _ = getConstructorsG (undefined :: a x) ++ getConstructorsG (undefined :: b x)

294 getConstructorsG _ = getConstructorsG (undefined :: a x) ++ getConstructorsG (undefined :: b x)

279− getConstructorArgsG = error "invalid getConstructorArgsG in :+:"

295+ getConstructorArgsG = undefined

280

296

281--this represents the unimplemented generics traversals which should never be called

297--this represents the unimplemented generics traversals which should never be called

282{-

298{-

src/lib/ProjectM36/Attribute.hs+29−148

@@ -1,4 +1,3 @@

1−{-# OPTIONS_GHC -fno-warn-orphans #-}

2module ProjectM36.Attribute where

1module ProjectM36.Attribute where

3import ProjectM36.Base

2import ProjectM36.Base

4import ProjectM36.Error

3import ProjectM36.Error

@@ -11,54 +10,16 @@ import qualified Data.Map as M

11import Data.Either

10import Data.Either

12

11

13arity :: Attributes -> Int

12arity :: Attributes -> Int

14−arity a = V.length (attributesVec a)

13+arity = V.length

15−

16−instance Semigroup Attributes where

17− attrsA <> attrsB =

18− case joinAttributes attrsA attrsB of

19− Left err -> error (show err)

20− Right attrs' -> attrs'

21−

22−instance Monoid Attributes where

23− mempty = Attributes {

24− attributesVec = mempty

25− --,attributeSet = mempty

26− }

27

14

28emptyAttributes :: Attributes

15emptyAttributes :: Attributes

29−emptyAttributes = mempty

16+emptyAttributes = V.empty

30

17

31null :: Attributes -> Bool

18null :: Attributes -> Bool

32−null a = V.null (attributesVec a)

19+null = V.null

33−

34−singleton :: Attribute -> Attributes

35−singleton attr = Attributes {

36− attributesVec = V.singleton attr

37− --,attributesSet = HS.singleton attr

38− }

39−

40−toList :: Attributes -> [Attribute]

41−toList attrs = V.toList (attributesVec attrs)

42

20

43attributesFromList :: [Attribute] -> Attributes

21attributesFromList :: [Attribute] -> Attributes

44−attributesFromList attrsL = Attributes {

22+attributesFromList = V.fromList -- . L.nub --too expensive

45− attributesVec = vec

46− --,attributesSet = hset

47− }

48− where

49− vec = if length attrsL == HS.size hset then

50− --fast path- no duplicates

51− V.fromList attrsL

52− else

53− --duplicate detected, uniqueify while maintaining original ordering

54− V.fromList uniquedL

55− hset = HS.fromList attrsL

56− uniquedL = fst $ foldr (\attr acc@(l,s) ->

57− if HS.member attr s then

58− acc

59− else

60− (l ++ [attr], HS.insert attr s))

61− ([],mempty) attrsL

62

23

63attributeName :: Attribute -> AttributeName

24attributeName :: Attribute -> AttributeName

64attributeName (Attribute name _) = name

25attributeName (Attribute name _) = name

@@ -67,16 +28,17 @@ atomType :: Attribute -> AtomType

67atomType (Attribute _ atype) = atype

28atomType (Attribute _ atype) = atype

68

29

69atomTypes :: Attributes -> V.Vector AtomType

30atomTypes :: Attributes -> V.Vector AtomType

70−atomTypes attrs = V.map atomType (attributesVec attrs)

31+atomTypes = V.map atomType

71

32

72atomTypesList :: Attributes -> [AtomType]

33atomTypesList :: Attributes -> [AtomType]

73atomTypesList = V.toList . atomTypes

34atomTypesList = V.toList . atomTypes

74

35

36+--hm- no error-checking here

75addAttribute :: Attribute -> Attributes -> Attributes

37addAttribute :: Attribute -> Attributes -> Attributes

76−addAttribute attr attrs = attrs <> singleton attr

38+addAttribute attr attrs = attrs `V.snoc` attr

77

39

78--if some attribute names overlap but the types do not, then spit back an error

40--if some attribute names overlap but the types do not, then spit back an error

79−{-joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes

41+joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes

80joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length overlappingAttributes = Left (TupleAttributeTypeMismatchError overlappingAttributes)

42joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length overlappingAttributes = Left (TupleAttributeTypeMismatchError overlappingAttributes)

81 | V.length overlappingAttrsDifferentTypes > 0 = Left (TupleAttributeTypeMismatchError overlappingAttrsDifferentTypes)

43 | V.length overlappingAttrsDifferentTypes > 0 = Left (TupleAttributeTypeMismatchError overlappingAttrsDifferentTypes)

82 | otherwise = Right $ vectorUniqueify (attrs1 V.++ attrs2)

44 | otherwise = Right $ vectorUniqueify (attrs1 V.++ attrs2)

@@ -85,52 +47,20 @@ joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length

85 attrNames2 = V.map attributeName attrs2

47 attrNames2 = V.map attributeName attrs2

86 uniqueOverlappingAttributes = vectorUniqueify overlappingAttributes

48 uniqueOverlappingAttributes = vectorUniqueify overlappingAttributes

87 overlappingAttributes = V.filter (`V.elem` attrs2) attrs1

49 overlappingAttributes = V.filter (`V.elem` attrs2) attrs1

88−-}

89−joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes

90−joinAttributes attrs1 attrs2

91− | S.size overlappingNames == 0 = -- fast path, no overlapping names

92− pure (concated id)

93− | attributesForNames overlappingNames attrs1 == attributesForNames overlappingNames attrs2 = -- that atomtypes match

94− pure (concated vectorUniqueify)

95− | otherwise =

96− --special handling to validate that overlapping names have the same atom types

97− Left (TupleAttributeTypeMismatchError (attributesForNames overlappingNames attrs1))

98− where

99− nameSet1 = attributeNameSet attrs1

100− nameSet2 = attributeNameSet attrs2

101− overlappingNames = S.intersection nameSet1 nameSet2

102− concated f = Attributes {

103− attributesVec = f (attributesVec attrs1 <> attributesVec attrs2)

104− --,attributesSet = attributesSet attrs1 <> attributesSet attrs2

105− }

106

50

107addAttributes :: Attributes -> Attributes -> Attributes

51addAttributes :: Attributes -> Attributes -> Attributes

108−addAttributes = (<>)

52+addAttributes = (V.++)

109−

110−member :: Attribute -> Attributes -> Bool

111−member attr attrs = HS.member attr (attributesSet attrs)

112

53

113deleteAttributeName :: AttributeName -> Attributes -> Attributes

54deleteAttributeName :: AttributeName -> Attributes -> Attributes

114−deleteAttributeName attrName = deleteAttributeNames (S.singleton attrName)

55+deleteAttributeName attrName = V.filter (\attr -> attributeName attr /= attrName)

115−

116−deleteAttributeNames :: S.Set AttributeName -> Attributes -> Attributes

117−deleteAttributeNames attrNames attrs = Attributes {

118− attributesVec = vec

119− }

120− where

121− vec = V.filter attrFilter (attributesVec attrs)

122− attrFilter attr = S.notMember (attributeName attr) attrNames

123

56

124renameAttribute :: AttributeName -> Attribute -> Attribute

57renameAttribute :: AttributeName -> Attribute -> Attribute

125renameAttribute newAttrName (Attribute _ typeo) = Attribute newAttrName typeo

58renameAttribute newAttrName (Attribute _ typeo) = Attribute newAttrName typeo

126

59

127renameAttributes :: AttributeName -> AttributeName -> Attributes -> Attributes

60renameAttributes :: AttributeName -> AttributeName -> Attributes -> Attributes

128−renameAttributes oldAttrName newAttrName attrs = Attributes {

61+renameAttributes oldAttrName newAttrName = V.map renamer

129− attributesVec = vec

130− }

131 where

62 where

132− vec = V.map renamer (attributesVec attrs)

133− renamer attr = if attributeName attr == oldAttrName then

63+ renamer attr = if attributeName attr == oldAttrName then

134 renameAttribute newAttrName attr

64 renameAttribute newAttrName attr

135 else

65 else

136 attr

66 attr

@@ -141,7 +71,7 @@ atomTypeForAttributeName attrName attrs = do

141 return atype

71 return atype

142

72

143attributeForName :: AttributeName -> Attributes -> Either RelationalError Attribute

73attributeForName :: AttributeName -> Attributes -> Either RelationalError Attribute

144−attributeForName attrName attrs = case V.find (\attr -> attributeName attr == attrName) (attributesVec attrs) of

74+attributeForName attrName attrs = case V.find (\attr -> attributeName attr == attrName) attrs of

145 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

75 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

146 Just attr -> Right attr

76 Just attr -> Right attr

147

77

@@ -159,18 +89,15 @@ projectionAttributesForNames names attrsIn =

159 missingNames = attributeNamesNotContained names (S.fromList (V.toList (attributeNames attrsIn)))

89 missingNames = attributeNamesNotContained names (S.fromList (V.toList (attributeNames attrsIn)))

160

90

161attributesForNames :: S.Set AttributeName -> Attributes -> Attributes

91attributesForNames :: S.Set AttributeName -> Attributes -> Attributes

162−attributesForNames attrNameSet attrs = Attributes {

92+attributesForNames attrNameSet = V.filter filt

163− attributesVec = vec

164− }

165 where

93 where

166− vec = V.filter filt (attributesVec attrs)

167 filt attr = S.member (attributeName attr) attrNameSet

94 filt attr = S.member (attributeName attr) attrNameSet

168

95

169attributeNameSet :: Attributes -> S.Set AttributeName

96attributeNameSet :: Attributes -> S.Set AttributeName

170−attributeNameSet attrs = S.fromList $ V.toList $ V.map (\(Attribute name _) -> name) (attributesVec attrs)

97+attributeNameSet attrVec = S.fromList $ V.toList $ V.map (\(Attribute name _) -> name) attrVec

171

98

172attributeNames :: Attributes -> V.Vector AttributeName

99attributeNames :: Attributes -> V.Vector AttributeName

173−attributeNames attrs = V.map attributeName (attributesVec attrs)

100+attributeNames = V.map attributeName

174

101

175--checks if set s1 is wholly contained in the set s2

102--checks if set s1 is wholly contained in the set s2

176attributesContained :: Attributes -> Attributes -> Bool

103attributesContained :: Attributes -> Attributes -> Bool

@@ -191,88 +118,42 @@ attributeNamesNotContained subset superset = S.filter (`S.notMember` superset) s

191

118

192-- useful for display

119-- useful for display

193orderedAttributes :: Attributes -> [Attribute]

120orderedAttributes :: Attributes -> [Attribute]

194−orderedAttributes attrs = L.sortBy (\a b -> attributeName a `compare` attributeName b) (V.toList (attributesVec attrs))

121+orderedAttributes attrs = L.sortBy (\a b -> attributeName a `compare` attributeName b) (V.toList attrs)

195

122

196orderedAttributeNames :: Attributes -> [AttributeName]

123orderedAttributeNames :: Attributes -> [AttributeName]

197orderedAttributeNames attrs = map attributeName (orderedAttributes attrs)

124orderedAttributeNames attrs = map attributeName (orderedAttributes attrs)

198

125

199-- take two attribute sets and return an attribute set with the attributes which do not match

126-- take two attribute sets and return an attribute set with the attributes which do not match

200−--this is the function which benefits the most from the HashSet representation- this turned up in the insert performance test

201attributesDifference :: Attributes -> Attributes -> Attributes

127attributesDifference :: Attributes -> Attributes -> Attributes

202−{-attributesDifference attrsA attrsB = V.fromList $ diff (V.toList attrsA) (V.toList attrsB)

128+attributesDifference attrsA attrsB = V.fromList $ diff (V.toList attrsA) (V.toList attrsB)

203 where

129 where

204 diff a b = (a L.\\ b) ++ (b L.\\ a)

130 diff a b = (a L.\\ b) ++ (b L.\\ a)

205−-}

206−attributesDifference attrsA attrsB =

207− if attributesSet attrsA == attributesSet attrsB then

208− mempty

209− else

210− Attributes {

211− attributesVec = vec

212− --,attributesSet = hset

213− }

214− where

215− hset = HS.difference setA setB <> HS.difference setB setA

216− setA = attributesSet attrsA

217− setB = attributesSet attrsB

218− vec = V.filter (`HS.member` hset) (attributesVec attrsA <> attributesVec attrsB)

219

131

220vectorUniqueify :: (Hash.Hashable a, Eq a) => V.Vector a -> V.Vector a

132vectorUniqueify :: (Hash.Hashable a, Eq a) => V.Vector a -> V.Vector a

221vectorUniqueify vecIn = V.fromList $ HS.toList $ HS.fromList $ V.toList vecIn

133vectorUniqueify vecIn = V.fromList $ HS.toList $ HS.fromList $ V.toList vecIn

222

134

223--check that each attribute only appears once

135--check that each attribute only appears once

224verifyAttributes :: Attributes -> Either RelationalError Attributes

136verifyAttributes :: Attributes -> Either RelationalError Attributes

225−verifyAttributes attrs =

137+verifyAttributes attrs = if collapsedAttrs /= attrs then

226− if vecSet == attributesSet attrs then

227− pure attrs

228− else

229− Left (TupleAttributeTypeMismatchError diffAttrs)

138+ Left (TupleAttributeTypeMismatchError (attributesDifference collapsedAttrs attrs))

139+ else

140+ Right attrs

230 where

141 where

231− vecSet = V.foldr' HS.insert HS.empty (attributesVec attrs)

142+ collapsedAttrs = vectorUniqueify attrs

232− diffSet = HS.difference vecSet (attributesSet attrs) <> HS.difference (attributesSet attrs) vecSet

233− diffAttrs = Attributes {

234− attributesVec = V.fromList (HS.toList diffSet)

235− --,attributesSet = diffSet

236− }

237−

238−--used in Generics derivation for ADTs without named attributes- not to be used elsewhere

239−--drop first n attributes from vector representation

240−drop :: Int -> Attributes -> Attributes

241−drop c attrs = Attributes { attributesVec = vec

242− }

243− where

244− vec = V.drop c (attributesVec attrs)

245−

246−

247−-- use this in preference to attributesEqual when the attribute ordering matters such as during tuple unions

248−attributesAndOrderEqual :: Attributes -> Attributes -> Bool

249−attributesAndOrderEqual a b = attributesVec a == attributesVec b

250

143

251−-- use to determine if the same attributes are contained (but ordering is irrelevant)

252attributesEqual :: Attributes -> Attributes -> Bool

144attributesEqual :: Attributes -> Attributes -> Bool

253−attributesEqual attrsA attrsB =

145+attributesEqual attrs1 attrs2 = V.null (attributesDifference attrs1 attrs2)

254− attributesVec attrsA == attributesVec attrsB ||

255− attributesSet attrsA == attributesSet attrsB

256

146

257attributesAsMap :: Attributes -> M.Map AttributeName Attribute

147attributesAsMap :: Attributes -> M.Map AttributeName Attribute

258−attributesAsMap attrs = V.foldr' (\attr acc -> M.insert (attributeName attr) attr acc) mempty (attributesVec attrs)

148+attributesAsMap attrs = (M.fromList . V.toList) (V.map (\attr -> (attributeName attr, attr)) attrs)

259−

260

149

261-- | Left-biased union of attributes.

150-- | Left-biased union of attributes.

262union :: Attributes -> Attributes -> Attributes

151union :: Attributes -> Attributes -> Attributes

263−union attrsA attrsB = Attributes {

152+union attrsA attrsB = V.fromList (M.elems unioned)

264− attributesVec = vec

265− --,attributesSet = hset

266− }

267 where

153 where

268− hset = HS.union (attributesSet attrsA) (attributesSet attrsB)

154+ unioned = M.union (attributesAsMap attrsA) (attributesAsMap attrsB)

269− vec = HS.foldr (flip V.snoc) mempty hset

270

155

271intersection :: Attributes -> Attributes -> Attributes

156intersection :: Attributes -> Attributes -> Attributes

272−intersection attrsA attrsB = Attributes {

157+intersection attrsA attrsB = V.fromList (M.elems intersected)

273− attributesVec = vec

274− --,attributesSet = hset

275− }

276 where

158 where

277− hset = HS.intersection (attributesSet attrsA) (attributesSet attrsB)

159+ intersected = M.intersection (attributesAsMap attrsA) (attributesAsMap attrsB)

278− vec = HS.foldr (flip V.snoc) mempty hset

src/lib/ProjectM36/Base.hs+107−113

@@ -1,12 +1,10 @@

1−{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveTraversable, DerivingVia, TemplateHaskell, TypeFamilies #-}

1+{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveFoldable, DeriveFunctor, DeriveTraversable #-}

2{-# OPTIONS_GHC -fno-warn-orphans #-}

3

4module ProjectM36.Base where

5import ProjectM36.DatabaseContextFunctionError

6import ProjectM36.AtomFunctionError

7−import ProjectM36.MerkleHash

8

7

9−import Data.Functor.Foldable.TH

10import qualified Data.Map as M

8import qualified Data.Map as M

11import qualified Data.HashSet as HS

9import qualified Data.HashSet as HS

12import Data.Hashable (Hashable, hashWithSalt)

10import Data.Hashable (Hashable, hashWithSalt)

@@ -19,17 +17,16 @@ import GHC.Stack

19import qualified Data.Vector as V

17import qualified Data.Vector as V

20import qualified Data.List as L

18import qualified Data.List as L

21import Data.Text (Text,unpack)

19import Data.Text (Text,unpack)

20+import Data.Binary

21+import Data.Vector.Binary()

22import Data.Time.Clock

23+import Data.Time.Clock.POSIX

24+import Data.Time.Calendar (Day,toGregorian,fromGregorian)

23import Data.Hashable.Time ()

25import Data.Hashable.Time ()

24−import Data.Time.Calendar (Day)

25import Data.Typeable

26import Data.Typeable

26import Data.ByteString (ByteString)

27import Data.ByteString (ByteString)

27import qualified Data.List.NonEmpty as NE

28import qualified Data.List.NonEmpty as NE

28−import Data.Vector.Instances ()

29−

30type StringType = Text

29type StringType = Text

31−

32−type DatabaseName = String

33

30

34-- | Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.

31-- | Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.

35data Atom = IntegerAtom Integer |

32data Atom = IntegerAtom Integer |

@@ -41,9 +38,8 @@ data Atom = IntegerAtom Integer |

41 ByteStringAtom ByteString |

38 ByteStringAtom ByteString |

42 BoolAtom Bool |

39 BoolAtom Bool |

43 RelationAtom Relation |

40 RelationAtom Relation |

44− RelationalExprAtom RelationalExpr | --used for returning inc deps

45 ConstructedAtom DataConstructorName AtomType [Atom]

41 ConstructedAtom DataConstructorName AtomType [Atom]

46− deriving (Eq, Show, Typeable, NFData, Generic, Read)

42+ deriving (Eq, Show, Binary, Typeable, NFData, Generic)

47

43

48instance Hashable Atom where

44instance Hashable Atom where

49 hashWithSalt salt (ConstructedAtom dConsName _ atoms) = salt `hashWithSalt` atoms

45 hashWithSalt salt (ConstructedAtom dConsName _ atoms) = salt `hashWithSalt` atoms

@@ -57,7 +53,16 @@ instance Hashable Atom where

57 hashWithSalt salt (ByteStringAtom bs) = salt `hashWithSalt` bs

53 hashWithSalt salt (ByteStringAtom bs) = salt `hashWithSalt` bs

58 hashWithSalt salt (BoolAtom b) = salt `hashWithSalt` b

54 hashWithSalt salt (BoolAtom b) = salt `hashWithSalt` b

59 hashWithSalt salt (RelationAtom r) = salt `hashWithSalt` r

55 hashWithSalt salt (RelationAtom r) = salt `hashWithSalt` r

60− hashWithSalt salt (RelationalExprAtom re) = salt `hashWithSalt` re

56+

57+instance Binary UTCTime where

58+ put utc = put $ toRational (utcTimeToPOSIXSeconds utc)

59+ get = posixSecondsToUTCTime . fromRational <$> (get :: Get Rational)

60+

61+instance Binary Day where

62+ put day = put $ toGregorian day

63+ get = do

64+ (y,m,d) <- get :: Get (Integer, Int, Int)

65+ return (fromGregorian y m d)

61

66

62-- I suspect the definition of ConstructedAtomType with its name alone is insufficient to disambiguate the cases; for example, one could create a type named X, remove a type named X, and re-add it using different constructors. However, as long as requests are served from only one DatabaseContext at-a-time, the type name is unambiguous. This will become a problem for time-travel, however.

67-- I suspect the definition of ConstructedAtomType with its name alone is insufficient to disambiguate the cases; for example, one could create a type named X, remove a type named X, and re-add it using different constructors. However, as long as requests are served from only one DatabaseContext at-a-time, the type name is unambiguous. This will become a problem for time-travel, however.

63-- | The AtomType uniquely identifies the type of a atom.

68-- | The AtomType uniquely identifies the type of a atom.

@@ -71,15 +76,12 @@ data AtomType = IntAtomType |

71 BoolAtomType |

76 BoolAtomType |

72 RelationAtomType Attributes |

77 RelationAtomType Attributes |

73 ConstructedAtomType TypeConstructorName TypeVarMap |

78 ConstructedAtomType TypeConstructorName TypeVarMap |

74− RelationalExprAtomType |

75 TypeVariableType TypeVarName

79 TypeVariableType TypeVarName

76 --wildcard used in Atom Functions and tuples for data constructors which don't provide all arguments to the type constructor

80 --wildcard used in Atom Functions and tuples for data constructors which don't provide all arguments to the type constructor

77− deriving (Eq, NFData, Generic, Show, Read, Hashable)

81+ deriving (Eq, NFData, Generic, Binary, Show)

78

82

79instance Ord AtomType where

83instance Ord AtomType where

80− compare = undefined

84+ compare = undefined

81−

82−-- this should probably be an ordered dictionary in order to be able to round-trip these arguments

83type TypeVarMap = M.Map TypeVarName AtomType

85type TypeVarMap = M.Map TypeVarName AtomType

84

86

85instance Hashable TypeVarMap where

87instance Hashable TypeVarMap where

@@ -94,37 +96,25 @@ isRelationAtomType _ = False

94type AttributeName = StringType

96type AttributeName = StringType

95

97

96-- | A relation's type is composed of attribute names and types.

98-- | A relation's type is composed of attribute names and types.

97−data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Read, Generic, NFData)

99+data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Generic, NFData, Binary)

98

100

99instance Hashable Attribute where

101instance Hashable Attribute where

100 hashWithSalt salt (Attribute attrName _) = hashWithSalt salt attrName

102 hashWithSalt salt (Attribute attrName _) = hashWithSalt salt attrName

101

103

102−type AttributesHash = Int

103−

104-- | 'Attributes' represent the head of a relation.

105−newtype Attributes = Attributes {

106− attributesVec :: V.Vector Attribute

105+type Attributes = V.Vector Attribute

107− --,attributesSet :: HS.HashSet Attribute --compare with this generated in heap profile and benchmarks

108− }

109− deriving (NFData, Read, Hashable, Generic)

110−

111−attributesSet :: Attributes -> HS.HashSet Attribute

112−attributesSet = HS.fromList . V.toList . attributesVec

113−

114−instance Show Attributes where

115− show attrs = "attributesFromList [" <> L.intercalate ", " (map (\attr -> "(" <> show attr <> ")") (V.toList (attributesVec attrs))) <> "]"

116−

117−--when attribute ordering is irrelevant

118−instance Eq Attributes where

119− attrsA == attrsB =

120− attributesVec attrsA == attributesVec attrsB ||

121− attributesSet attrsA == attributesSet attrsB

122

106

107+-- | Equality function for a set of attributes.

108+attributesEqual :: Attributes -> Attributes -> Bool

109+attributesEqual attrs1 attrs2 = attrsAsSet attrs1 == attrsAsSet attrs2

110+ where

111+ attrsAsSet = HS.fromList . V.toList

112+

123sortedAttributesIndices :: Attributes -> [(Int, Attribute)]

113sortedAttributesIndices :: Attributes -> [(Int, Attribute)]

124−sortedAttributesIndices attrs = L.sortBy (\(_, Attribute name1 _) (_,Attribute name2 _) -> compare name1 name2) $ V.toList (V.indexed (attributesVec attrs))

114+sortedAttributesIndices attrs = L.sortBy (\(_, Attribute name1 _) (_,Attribute name2 _) -> compare name1 name2) $ V.toList (V.indexed attrs)

125

115

126-- | The relation's tuple set is the body of the relation.

116-- | The relation's tuple set is the body of the relation.

127−newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic, Read)

117+newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic, Binary)

128

118

129instance Read Relation where

119instance Read Relation where

130 readsPrec = error "relation read not supported"

120 readsPrec = error "relation read not supported"

@@ -140,8 +130,8 @@ instance NFData RelationTupleSet where rnf = genericRnf

140instance Hashable RelationTuple where

130instance Hashable RelationTuple where

141 --sanity check the tuple for attribute and tuple counts

131 --sanity check the tuple for attribute and tuple counts

142 --this bit me when tuples were being hashed before being verified

132 --this bit me when tuples were being hashed before being verified

143− hashWithSalt salt (RelationTuple attrs tupVec) = if V.length (attributesVec attrs) /= V.length tupVec then

133+ hashWithSalt salt (RelationTuple attrs tupVec) = if V.length attrs /= V.length tupVec then

144− error ("invalid tuple: attributes and tuple count mismatch " <> show (attributesVec attrs, tupVec))

134+ error "invalid tuple: attributes and tuple count mismatch"

145 else

135 else

146 salt `hashWithSalt`

136 salt `hashWithSalt`

147 sortedAttrs `hashWithSalt`

137 sortedAttrs `hashWithSalt`

@@ -152,23 +142,25 @@ instance Hashable RelationTuple where

152 sortedTupVec = V.map (\(index, _) -> tupVec V.! index) $ V.fromList sortedAttrsIndices

142 sortedTupVec = V.map (\(index, _) -> tupVec V.! index) $ V.fromList sortedAttrsIndices

153

143

154-- | A tuple is a set of attributes mapped to their 'Atom' values.

144-- | A tuple is a set of attributes mapped to their 'Atom' values.

155−data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Read, Generic)

145+data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Generic)

146+

147+instance Binary RelationTuple

156

148

157instance Eq RelationTuple where

149instance Eq RelationTuple where

158− tuple1@(RelationTuple attrs1 _) == tuple2@(RelationTuple attrs2 _) =

150+ (==) tuple1@(RelationTuple attrs1 _) tuple2@(RelationTuple attrs2 _) = attributesEqual attrs1 attrs2 && atomsEqual

159− attrs1 == attrs2 && atomsEqual

160 where

151 where

161− atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) (attributesVec attrs) of

152+ atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) attrs of

162 Nothing -> Nothing

153 Nothing -> Nothing

163 Just index -> tupVec V.!? index

154 Just index -> tupVec V.!? index

164− atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) (attributesVec attrs1)

155+ atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) attrs1

165

156

166instance NFData RelationTuple where rnf = genericRnf

157instance NFData RelationTuple where rnf = genericRnf

167

158

159+

168data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)

160data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)

169

161

170instance Eq Relation where

162instance Eq Relation where

171− Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attrs1 == attrs2 && tupSet1 == tupSet2

163+ Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attributesEqual attrs1 attrs2 && tupSet1 == tupSet2

172

164

173instance NFData Relation where rnf = genericRnf

165instance NFData Relation where rnf = genericRnf

174

166

@@ -179,6 +171,8 @@ instance Hashable Relation where

179 where

171 where

180 sortedAttrs = map snd (sortedAttributesIndices attrs)

172 sortedAttrs = map snd (sortedAttributesIndices attrs)

181

173

174+instance Binary Relation

175+

182-- | Used to represent the number of tuples in a relation.

176-- | Used to represent the number of tuples in a relation.

183data RelationCardinality = Countable | Finite Int deriving (Eq, Show, Generic, Ord)

177data RelationCardinality = Countable | Finite Int deriving (Eq, Show, Generic, Ord)

184

178

@@ -190,7 +184,7 @@ type RelationalExpr = RelationalExprBase ()

190-- | A relational expression represents query (read) operations on a database.

184-- | A relational expression represents query (read) operations on a database.

191data RelationalExprBase a =

185data RelationalExprBase a =

192 --- | Create a relation from tuple expressions.

186 --- | Create a relation from tuple expressions.

193− MakeRelationFromExprs (Maybe [AttributeExprBase a]) (TupleExprsBase a) |

187+ MakeRelationFromExprs (Maybe [AttributeExprBase a]) [TupleExprBase a] |

194 --- | Create and reference a relation from attributes and a tuple set.

188 --- | Create and reference a relation from attributes and a tuple set.

195 MakeStaticRelation Attributes RelationTupleSet |

189 MakeStaticRelation Attributes RelationTupleSet |

196 --- | Reference an existing relation in Haskell-space.

190 --- | Reference an existing relation in Haskell-space.

@@ -223,15 +217,17 @@ data RelationalExprBase a =

223 --Summarize :: AtomExpr -> AttributeName -> RelationalExpr -> RelationalExpr -> RelationalExpr -- a special case of Extend

217 --Summarize :: AtomExpr -> AttributeName -> RelationalExpr -> RelationalExpr -> RelationalExpr -- a special case of Extend

224 --Evaluate relationalExpr with scoped views

218 --Evaluate relationalExpr with scoped views

225 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)

219 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)

226− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

220+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

221+

222+instance Binary RelationalExpr

227

223

228−instance Hashable RelationalExpr

229−

230data WithNameExprBase a = WithNameExpr RelVarName a

224data WithNameExprBase a = WithNameExpr RelVarName a

231− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable, Hashable)

225+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

232

226

233type WithNameExpr = WithNameExprBase ()

227type WithNameExpr = WithNameExprBase ()

234

228

229+instance Binary WithNameExpr

230+

235type GraphRefWithNameExpr = WithNameExprBase GraphRefTransactionMarker

231type GraphRefWithNameExpr = WithNameExprBase GraphRefTransactionMarker

236

232

237type NotificationName = StringType

233type NotificationName = StringType

@@ -243,22 +239,22 @@ data Notification = Notification {

243 reportOldExpr :: RelationalExpr, --run the expression in the pre-change context

239 reportOldExpr :: RelationalExpr, --run the expression in the pre-change context

244 reportNewExpr :: RelationalExpr --run the expression in the post-change context

240 reportNewExpr :: RelationalExpr --run the expression in the post-change context

245 }

241 }

246− deriving (Show, Eq, Generic, NFData)

242+ deriving (Show, Eq, Binary, Generic, NFData)

247

243

248type TypeVarName = StringType

244type TypeVarName = StringType

249

245

250-- | Metadata definition for type constructors such as @data Either a b@.

246-- | Metadata definition for type constructors such as @data Either a b@.

251data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |

247data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |

252 PrimitiveTypeConstructorDef TypeConstructorName AtomType

248 PrimitiveTypeConstructorDef TypeConstructorName AtomType

253− deriving (Show, Generic, Eq, NFData, Hashable, Read)

249+ deriving (Show, Generic, Binary, Eq, NFData)

254

250

255-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int

251-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int

256type TypeConstructor = TypeConstructorBase ()

252type TypeConstructor = TypeConstructorBase ()

257data TypeConstructorBase a = ADTypeConstructor TypeConstructorName [TypeConstructor] |

253data TypeConstructorBase a = ADTypeConstructor TypeConstructorName [TypeConstructor] |

258− PrimitiveTypeConstructor TypeConstructorName AtomType |

254+ PrimitiveTypeConstructor TypeConstructorName AtomType |

259− RelationAtomTypeConstructor [AttributeExprBase a] |

255+ RelationAtomTypeConstructor [AttributeExprBase a] |

260− TypeVariable TypeVarName

256+ TypeVariable TypeVarName

261− deriving (Show, Generic, Eq, NFData, Hashable, Read)

257+ deriving (Show, Generic, Binary, Eq, NFData)

262

258

263type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]

259type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]

264

260

@@ -268,20 +264,20 @@ type DataConstructorName = StringType

268type AtomTypeName = StringType

264type AtomTypeName = StringType

269

265

270-- | Used to define a data constructor in a type constructor context such as @Left a | Right b@

266-- | Used to define a data constructor in a type constructor context such as @Left a | Right b@

271−data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Generic, NFData, Hashable, Read)

267+data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Binary, Generic, NFData)

272

268

273type DataConstructorDefs = [DataConstructorDef]

269type DataConstructorDefs = [DataConstructorDef]

274

270

275data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |

271data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |

276 DataConstructorDefTypeVarNameArg TypeVarName

272 DataConstructorDefTypeVarNameArg TypeVarName

277− deriving (Show, Generic, Eq, NFData, Hashable, Read)

273+ deriving (Show, Generic, Binary, Eq, NFData)

278

274

279type InclusionDependencies = M.Map IncDepName InclusionDependency

275type InclusionDependencies = M.Map IncDepName InclusionDependency

280type RelationVariables = M.Map RelVarName GraphRefRelationalExpr

276type RelationVariables = M.Map RelVarName GraphRefRelationalExpr

281

277

282data GraphRefTransactionMarker = TransactionMarker TransactionId |

278data GraphRefTransactionMarker = TransactionMarker TransactionId |

283 UncommittedContextMarker

279 UncommittedContextMarker

284− deriving (Eq, Show, Generic, NFData, Ord)

280+ deriving (Eq, Show, Binary, Generic, NFData, Ord)

285

281

286-- a fundamental relational expr to which other relational expressions compile

282-- a fundamental relational expr to which other relational expressions compile

287type GraphRefRelationalExpr = RelationalExprBase GraphRefTransactionMarker

283type GraphRefRelationalExpr = RelationalExprBase GraphRefTransactionMarker

@@ -292,18 +288,17 @@ type Subschemas = M.Map SchemaName Schema

292

288

293-- | Every transaction has one concrete database context and any number of isomorphic subschemas.

289-- | Every transaction has one concrete database context and any number of isomorphic subschemas.

294data Schemas = Schemas DatabaseContext Subschemas

290data Schemas = Schemas DatabaseContext Subschemas

295− deriving (Generic)

296

291

297-- | The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time.

292-- | The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time.

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.

293-- 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.

299newtype Schema = Schema SchemaIsomorphs

294newtype Schema = Schema SchemaIsomorphs

300− deriving (Generic)

295+ deriving (Generic, Binary)

301

296

302data SchemaIsomorph = IsoRestrict RelVarName RestrictionPredicateExpr (RelVarName, RelVarName) |

297data SchemaIsomorph = IsoRestrict RelVarName RestrictionPredicateExpr (RelVarName, RelVarName) |

303 IsoRename RelVarName RelVarName |

298 IsoRename RelVarName RelVarName |

304 IsoUnion (RelVarName, RelVarName) RestrictionPredicateExpr RelVarName --maps two relvars to one relvar

299 IsoUnion (RelVarName, RelVarName) RestrictionPredicateExpr RelVarName --maps two relvars to one relvar

305 -- IsoTypeConstructor in morphAttrExpr

300 -- IsoTypeConstructor in morphAttrExpr

306− deriving (Generic, Show)

301+ deriving (Generic, Binary, Show)

307

302

308type SchemaIsomorphs = [SchemaIsomorph]

303type SchemaIsomorphs = [SchemaIsomorph]

309

304

@@ -319,7 +314,9 @@ data DatabaseContext = DatabaseContext {

319type IncDepName = StringType

314type IncDepName = StringType

320

315

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.

316-- | Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.

322−data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData, Hashable, Read)

317+data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData)

318+

319+instance Binary InclusionDependency

323

320

324type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr

321type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr

325

322

@@ -328,10 +325,10 @@ type DatabaseContextExprName = StringType

328

325

329type DatabaseContextExpr = DatabaseContextExprBase ()

326type DatabaseContextExpr = DatabaseContextExprBase ()

330

327

331−instance Hashable DatabaseContextExpr

332−

333type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker

328type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker

334

329

330+instance Binary GraphRefDatabaseContextExpr

331+

335-- | Database context expressions modify the database context.

332-- | Database context expressions modify the database context.

336data DatabaseContextExprBase a =

333data DatabaseContextExprBase a =

337 NoOperation |

334 NoOperation |

@@ -359,10 +356,9 @@ data DatabaseContextExprBase a =

359 ExecuteDatabaseContextFunction DatabaseContextFunctionName [AtomExprBase a] |

356 ExecuteDatabaseContextFunction DatabaseContextFunctionName [AtomExprBase a] |

360

357

361 MultipleExpr [DatabaseContextExprBase a]

358 MultipleExpr [DatabaseContextExprBase a]

362− deriving (Show, Read, Eq, Generic, NFData)

359+ deriving (Show, Eq, Generic)

363

360

364−instance Hashable (M.Map AttributeName AtomExpr) where

361+instance Binary DatabaseContextExpr

365− hashWithSalt salt m = salt `hashWithSalt` M.toList m

366

362

367type ObjModuleName = StringType

363type ObjModuleName = StringType

368type ObjFunctionName = StringType

364type ObjFunctionName = StringType

@@ -374,7 +370,7 @@ data DatabaseContextIOExprBase a =

374 AddDatabaseContextFunction DatabaseContextFunctionName [TypeConstructor] DatabaseContextFunctionBodyScript |

370 AddDatabaseContextFunction DatabaseContextFunctionName [TypeConstructor] DatabaseContextFunctionBodyScript |

375 LoadDatabaseContextFunctions ObjModuleName ObjFunctionName FilePath |

371 LoadDatabaseContextFunctions ObjModuleName ObjFunctionName FilePath |

376 CreateArbitraryRelation RelVarName [AttributeExprBase a] Range

372 CreateArbitraryRelation RelVarName [AttributeExprBase a] Range

377− deriving (Show, Eq, Generic)

373+ deriving (Show, Eq, Generic, Binary)

378

374

379type GraphRefDatabaseContextIOExpr = DatabaseContextIOExprBase GraphRefTransactionMarker

375type GraphRefDatabaseContextIOExpr = DatabaseContextIOExprBase GraphRefTransactionMarker

380

376

@@ -382,8 +378,6 @@ type DatabaseContextIOExpr = DatabaseContextIOExprBase ()

382

378

383type RestrictionPredicateExpr = RestrictionPredicateExprBase ()

379type RestrictionPredicateExpr = RestrictionPredicateExprBase ()

384

380

385−instance Hashable RestrictionPredicateExpr

386−

387type GraphRefRestrictionPredicateExpr = RestrictionPredicateExprBase GraphRefTransactionMarker

381type GraphRefRestrictionPredicateExpr = RestrictionPredicateExprBase GraphRefTransactionMarker

388

382

389-- | Restriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.

383-- | Restriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.

@@ -395,7 +389,9 @@ data RestrictionPredicateExprBase a =

395 RelationalExprPredicate (RelationalExprBase a) | --type must be same as true and false relations (no attributes)

389 RelationalExprPredicate (RelationalExprBase a) | --type must be same as true and false relations (no attributes)

396 AtomExprPredicate (AtomExprBase a) | --atom must evaluate to boolean

390 AtomExprPredicate (AtomExprBase a) | --atom must evaluate to boolean

397 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple

391 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple

398− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

392+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

393+

394+instance Binary RestrictionPredicateExpr

399

395

400-- child + parent links

396-- child + parent links

401-- | A transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.

397-- | A transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.

@@ -405,7 +401,6 @@ type TransactionHeads = M.Map HeadName Transaction

405

401

406-- | The transaction graph is the global database's state which references every committed transaction.

402-- | The transaction graph is the global database's state which references every committed transaction.

407data TransactionGraph = TransactionGraph TransactionHeads (S.Set Transaction)

403data TransactionGraph = TransactionGraph TransactionHeads (S.Set Transaction)

408− deriving Generic

409

404

410transactionHeadsForGraph :: TransactionGraph -> TransactionHeads

405transactionHeadsForGraph :: TransactionGraph -> TransactionHeads

411transactionHeadsForGraph (TransactionGraph hs _) = hs

406transactionHeadsForGraph (TransactionGraph hs _) = hs

@@ -417,8 +412,7 @@ transactionsForGraph (TransactionGraph _ ts) = ts

417-- The `TransactionDiff`s represent child/edge relationships to previous transactions (branches or continuations of the same branch).

412-- The `TransactionDiff`s represent child/edge relationships to previous transactions (branches or continuations of the same branch).

418data TransactionInfo = TransactionInfo {

413data TransactionInfo = TransactionInfo {

419 parents :: TransactionParents,

414 parents :: TransactionParents,

420− stamp :: UTCTime,

415+ stamp :: UTCTime

421− merkleHash :: MerkleHash

422 } deriving (Show, Generic)

416 } deriving (Show, Generic)

423

417

424type TransactionParents = NE.NonEmpty TransactionId

418type TransactionParents = NE.NonEmpty TransactionId

@@ -428,15 +422,16 @@ data TransactionInfo = TransactionInfo TransactionId TransactionDiffs UTCTime |

428 deriving (Show, Generic)

422 deriving (Show, Generic)

429-}

423-}

430

424

425+instance Binary TransactionInfo

426+

431-- | Every set of modifications made to the database are atomically committed to the transaction graph as a transaction.

427-- | Every set of modifications made to the database are atomically committed to the transaction graph as a transaction.

432type TransactionId = UUID

428type TransactionId = UUID

433

429

434data Transaction = Transaction TransactionId TransactionInfo Schemas

430data Transaction = Transaction TransactionId TransactionInfo Schemas

435− deriving Generic

436

431

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.

432-- | 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.

438−data DisconnectedTransaction = DisconnectedTransaction TransactionId Schemas DirtyFlag

433+data DisconnectedTransaction = DisconnectedTransaction TransactionId Schemas DatabaseContextExpr

439−--the database context expression represents a difference between the disconnected transaction and its immutable parent transaction- is this diff expr used at all?

434+--the database context expression represents a difference between the disconnected transaction and its immutable parent transaction

440

435

441type DirtyFlag = Bool

436type DirtyFlag = Bool

442

437

@@ -456,8 +451,6 @@ instance Ord Transaction where

456

451

457type AtomExpr = AtomExprBase ()

452type AtomExpr = AtomExprBase ()

458

453

459−instance Hashable AtomExpr

460−

461type GraphRefAtomExpr = AtomExprBase GraphRefTransactionMarker

454type GraphRefAtomExpr = AtomExprBase GraphRefTransactionMarker

462

455

463-- | An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.

456-- | An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.

@@ -466,18 +459,19 @@ data AtomExprBase a = AttributeAtomExpr AttributeName |

466 FunctionAtomExpr AtomFunctionName [AtomExprBase a] a |

459 FunctionAtomExpr AtomFunctionName [AtomExprBase a] a |

467 RelationAtomExpr (RelationalExprBase a) |

460 RelationAtomExpr (RelationalExprBase a) |

468 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a

461 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a

469− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

462+ deriving (Eq,Show,Generic, NFData, Foldable, Functor, Traversable)

470

463

464+instance Binary AtomExpr

465+

471-- | Used in tuple creation when creating a relation.

466-- | Used in tuple creation when creating a relation.

472data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)

467data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)

473− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

468+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

474

469

475type ExtendTupleExpr = ExtendTupleExprBase ()

470type ExtendTupleExpr = ExtendTupleExprBase ()

476−

477−instance Hashable ExtendTupleExpr

478−

479type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker

471type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker

480

472

473+instance Binary ExtendTupleExpr

474+

481--enumerates the list of functions available to be run as part of tuple expressions

475--enumerates the list of functions available to be run as part of tuple expressions

482type AtomFunctions = HS.HashSet AtomFunction

476type AtomFunctions = HS.HashSet AtomFunction

483

477

@@ -488,7 +482,6 @@ type AtomFunctionBodyScript = StringType

488type AtomFunctionBodyType = [Atom] -> Either AtomFunctionError Atom

482type AtomFunctionBodyType = [Atom] -> Either AtomFunctionError Atom

489

483

490data AtomFunctionBody = AtomFunctionBody (Maybe AtomFunctionBodyScript) AtomFunctionBodyType

484data AtomFunctionBody = AtomFunctionBody (Maybe AtomFunctionBodyScript) AtomFunctionBodyType

491− deriving Generic

492

485

493instance NFData AtomFunctionBody where

486instance NFData AtomFunctionBody where

494 rnf (AtomFunctionBody mScript _) = rnf mScript

487 rnf (AtomFunctionBody mScript _) = rnf mScript

@@ -523,17 +516,14 @@ data AttributeNamesBase a = AttributeNames (S.Set AttributeName) |

523 UnionAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

516 UnionAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

524 IntersectAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

517 IntersectAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

525 RelationalExprAttributeNames (RelationalExprBase a) -- use attribute names from the relational expression's type

518 RelationalExprAttributeNames (RelationalExprBase a) -- use attribute names from the relational expression's type

526− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

519+ deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)

527−

528−instance Hashable AttributeNames

529−

530−instance Hashable (S.Set AttributeName) where

531− hashWithSalt salt s = salt `hashWithSalt` S.toList s

532

520

533type AttributeNames = AttributeNamesBase ()

521type AttributeNames = AttributeNamesBase ()

534

522

535type GraphRefAttributeNames = AttributeNamesBase GraphRefTransactionMarker

523type GraphRefAttributeNames = AttributeNamesBase GraphRefTransactionMarker

536

524

525+instance Binary AttributeNames

526+

537-- | The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.

527-- | The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.

538data PersistenceStrategy = NoPersistence | -- ^ no filesystem persistence/memory-only database

528data PersistenceStrategy = NoPersistence | -- ^ no filesystem persistence/memory-only database

539 MinimalPersistence FilePath | -- ^ fsync off, not crash-safe

529 MinimalPersistence FilePath | -- ^ fsync off, not crash-safe

@@ -546,27 +536,18 @@ type GraphRefAttributeExpr = AttributeExprBase GraphRefTransactionMarker

546-- | Create attributes dynamically.

536-- | Create attributes dynamically.

547data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |

537data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |

548 NakedAttributeExpr Attribute

538 NakedAttributeExpr Attribute

549− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable, Hashable)

539+ deriving (Eq, Show, Generic, Binary, NFData, Foldable, Functor, Traversable)

550

540

551-- | Dynamically create a tuple from attribute names and 'AtomExpr's.

541-- | Dynamically create a tuple from attribute names and 'AtomExpr's.

552newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))

542newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))

553− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

543+ deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)

554−

544+

555−instance Hashable TupleExpr

545+instance Binary TupleExpr

556

546

557type TupleExpr = TupleExprBase ()

547type TupleExpr = TupleExprBase ()

558

548

559type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker

549type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker

560

550

561−data TupleExprsBase a = TupleExprs a [TupleExprBase a]

562− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

563−

564−instance Hashable TupleExprs

565−

566−type GraphRefTupleExprs = TupleExprsBase GraphRefTransactionMarker

567−

568−type TupleExprs = TupleExprsBase ()

569−

570data MergeStrategy =

551data MergeStrategy =

571 -- | After a union merge, the merge transaction is a result of union'ing relvars of the same name, introducing all uniquely-named relvars, union of constraints, union of atom functions, notifications, and types (unless the names and definitions collide, e.g. two types of the same name with different definitions)

552 -- | 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)

572 UnionMergeStrategy |

553 UnionMergeStrategy |

@@ -574,7 +555,7 @@ data MergeStrategy =

574 UnionPreferMergeStrategy HeadName |

555 UnionPreferMergeStrategy HeadName |

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.

556 -- | 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.

576 SelectedBranchMergeStrategy HeadName

557 SelectedBranchMergeStrategy HeadName

577− deriving (Eq, Show, Generic, NFData)

558+ deriving (Eq, Show, Binary, Generic, NFData)

578

559

579type DatabaseContextFunctionName = StringType

560type DatabaseContextFunctionName = StringType

580

561

@@ -611,8 +592,7 @@ attrTypeVars (Attribute _ aType) = case aType of

611 DateTimeAtomType -> S.empty

592 DateTimeAtomType -> S.empty

612 ByteStringAtomType -> S.empty

593 ByteStringAtomType -> S.empty

613 BoolAtomType -> S.empty

594 BoolAtomType -> S.empty

614− RelationalExprAtomType -> S.empty

615− (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

595+ (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList attrs))

616 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap

596 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap

617 (TypeVariableType nam) -> S.singleton nam

597 (TypeVariableType nam) -> S.singleton nam

618

598

@@ -635,12 +615,26 @@ atomTypeVars DayAtomType = S.empty

635atomTypeVars DateTimeAtomType = S.empty

615atomTypeVars DateTimeAtomType = S.empty

636atomTypeVars ByteStringAtomType = S.empty

616atomTypeVars ByteStringAtomType = S.empty

637atomTypeVars BoolAtomType = S.empty

617atomTypeVars BoolAtomType = S.empty

638−atomTypeVars RelationalExprAtomType = S.empty

639−atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

618+atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList attrs))

640atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap

619atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap

641atomTypeVars (TypeVariableType nam) = S.singleton nam

620atomTypeVars (TypeVariableType nam) = S.singleton nam

642

621

643unimplemented :: HasCallStack => a

622unimplemented :: HasCallStack => a

644−unimplemented = error "unimplemented"

623+unimplemented = undefined

624+

625+--for serializing GraphRefRelationalExpr as part of transaction serialization

626+instance Binary (TupleExprBase GraphRefTransactionMarker)

627+

628+instance Binary GraphRefRelationalExpr

629+

630+instance Binary (AtomExprBase GraphRefTransactionMarker)

631+

632+instance Binary (AttributeNamesBase GraphRefTransactionMarker)

633+

634+instance Binary (RestrictionPredicateExprBase GraphRefTransactionMarker)

635+

636+instance Binary (ExtendTupleExprBase GraphRefTransactionMarker)

637+

638+instance Binary GraphRefWithNameExpr

645

639

646−makeBaseFunctor ''RelationalExprBase

640+

src/lib/ProjectM36/Client.hs+312−201

@@ -1,4 +1,4 @@

1−{-# LANGUAGE DeriveGeneric, ScopedTypeVariables, MonoLocalBinds, DerivingVia #-}

1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, ScopedTypeVariables, BangPatterns, PackageImports #-}

2{-|

3Module: ProjectM36.Client

4

@@ -9,7 +9,6 @@ module ProjectM36.Client

9 Connection(..),

10 Port,

11 Hostname,

12− ServiceName,

13 DatabaseName,

12 DatabaseName,

14 ConnectionError(..),

13 ConnectionError(..),

15 connectProjectM36,

14 connectProjectM36,

@@ -44,7 +43,6 @@ module ProjectM36.Client

44 defaultDatabaseName,

43 defaultDatabaseName,

45 defaultRemoteConnectionInfo,

44 defaultRemoteConnectionInfo,

46 defaultHeadName,

45 defaultHeadName,

47− addClientNode,

48 PersistenceStrategy(..),

46 PersistenceStrategy(..),

49 RelationalExpr,

47 RelationalExpr,

50 RelationalExprBase(..),

48 RelationalExprBase(..),

@@ -55,9 +53,11 @@ module ProjectM36.Client

55 Attribute(..),

53 Attribute(..),

56 MergeStrategy(..),

54 MergeStrategy(..),

57 attributesFromList,

55 attributesFromList,

56+ createNodeId,

58 createSessionAtCommit,

57 createSessionAtCommit,

59 createSessionAtHead,

58 createSessionAtHead,

60 closeSession,

59 closeSession,

60+ addClientNode,

61 callTestTimeout_,

62 RelationCardinality(..),

63 TransactionGraphOperator(..),

@@ -67,6 +67,7 @@ module ProjectM36.Client

67 TransGraphRelationalExpr,

68 TransactionIdLookup(..),

69 TransactionIdHeadBacktrack(..),

70+ NodeId(..),

70 Atom(..),

71 Atom(..),

71 Session,

72 Session,

72 SessionId,

73 SessionId,

@@ -79,7 +80,6 @@ module ProjectM36.Client

79 databaseContextExprForUniqueKey,

80 databaseContextExprForUniqueKey,

80 databaseContextExprForForeignKey,

81 databaseContextExprForForeignKey,

81 createScriptedAtomFunction,

82 createScriptedAtomFunction,

82− ProjectM36.Client.validateMerkleHashes,

83 AttributeExprBase(..),

84 TypeConstructorBase(..),

85 TypeConstructorDef(..),

@@ -99,14 +99,12 @@ module ProjectM36.Client

99 AtomType(..),

100 Atomable(..),

101 TupleExprBase(..),

102− TupleExprsBase(..),

103 AtomExprBase(..),

102 AtomExprBase(..),

104 RestrictionPredicateExprBase(..),

103 RestrictionPredicateExprBase(..),

105 withTransaction

104 withTransaction

106 ) where

105 ) where

107import ProjectM36.Base hiding (inclusionDependencies) --defined in this module as well

106import ProjectM36.Base hiding (inclusionDependencies) --defined in this module as well

108import qualified ProjectM36.Base as B

107import qualified ProjectM36.Base as B

109−import ProjectM36.Serialise.Error ()

110import ProjectM36.Error

108import ProjectM36.Error

111import ProjectM36.Atomable

109import ProjectM36.Atomable

112import ProjectM36.AtomFunction as AF

110import ProjectM36.AtomFunction as AF

@@ -119,7 +117,7 @@ import Control.Monad.State

119import qualified ProjectM36.RelationalExpression as RE

117import qualified ProjectM36.RelationalExpression as RE

120import ProjectM36.DatabaseContext (basicDatabaseContext)

118import ProjectM36.DatabaseContext (basicDatabaseContext)

121import qualified ProjectM36.TransactionGraph as Graph

119import qualified ProjectM36.TransactionGraph as Graph

122−import ProjectM36.TransactionGraph as TG

120+import ProjectM36.TransactionGraph

123import qualified ProjectM36.Transaction as Trans

121import qualified ProjectM36.Transaction as Trans

124import ProjectM36.TransactionGraph.Persist

122import ProjectM36.TransactionGraph.Persist

125import ProjectM36.Attribute

123import ProjectM36.Attribute

@@ -134,16 +132,28 @@ import ProjectM36.Relation (typesAsRelation)

134import ProjectM36.ScriptSession (initScriptSession, ScriptSession)

132import ProjectM36.ScriptSession (initScriptSession, ScriptSession)

135import qualified ProjectM36.Relation as R

133import qualified ProjectM36.Relation as R

136import Control.Exception.Base

134import Control.Exception.Base

137−import Control.Concurrent.STM

135+import GHC.Conc.Sync

138−import Control.Concurrent.Async

136+

137+import Network.Transport (Transport(closeTransport))

138+#if MIN_VERSION_network_transport_tcp(0,7,0)

139+import Network.Transport.TCP (createTransport, defaultTCPParameters, TCPAddr(..), TCPAddrInfo(..))

140+import Network.Transport.TCP.Internal (encodeEndPointAddress)

141+#elif MIN_VERSION_network_transport_tcp(0,6,0)

142+import Network.Transport.TCP (createTransport, defaultTCPParameters)

143+import Network.Transport.TCP.Internal (encodeEndPointAddress)

144+#else

145+import Network.Transport.TCP (encodeEndPointAddress, createTransport, defaultTCPParameters)

146+#endif

139

147

148+import Control.Distributed.Process.Node (newLocalNode, initRemoteTable, runProcess, LocalNode, forkProcess, closeLocalNode)

149+import Control.Distributed.Process.Extras.Internal.Types (whereisRemote)

150+import Control.Distributed.Process.ManagedProcess.Client (call, safeCall)

140import Data.Either (isRight)

151import Data.Either (isRight)

141import Data.UUID.V4 (nextRandom)

152import Data.UUID.V4 (nextRandom)

142import Data.Word

153import Data.Word

143−import Data.Hashable

154+import Control.Distributed.Process (ProcessId, Process, receiveWait, send, match, NodeId(..), reconnect)

144import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)

155import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)

145import Control.Concurrent.MVar

156import Control.Concurrent.MVar

146−import Codec.Winery hiding (Schema, schema)

147import qualified Data.Map as M

157import qualified Data.Map as M

148#if MIN_VERSION_stm_containers(1,0,0)

158#if MIN_VERSION_stm_containers(1,0,0)

149import qualified StmContainers.Map as StmMap

159import qualified StmContainers.Map as StmMap

@@ -155,19 +165,20 @@ import qualified STMContainers.Set as StmSet

155import qualified ProjectM36.Session as Sess

165import qualified ProjectM36.Session as Sess

156import ProjectM36.Session

166import ProjectM36.Session

157import ProjectM36.Sessions

167import ProjectM36.Sessions

168+--import "list-t" ListT

169+import Data.Binary (Binary)

158import GHC.Generics (Generic)

170import GHC.Generics (Generic)

159import Control.DeepSeq (force)

171import Control.DeepSeq (force)

160import System.IO

172import System.IO

161import Data.Time.Clock

173import Data.Time.Clock

162−import qualified Network.RPC.Curryer.Client as RPC

174+import Data.Typeable

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)

166

175

167type Hostname = String

176type Hostname = String

168

177

169type Port = Word16

178type Port = Word16

170

179

180+type DatabaseName = String

181+

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.

182-- | 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.

172type NotificationCallback = NotificationName -> EvaluatedNotification -> IO ()

183type NotificationCallback = NotificationName -> EvaluatedNotification -> IO ()

173

184

@@ -187,16 +198,15 @@ data RequestTimeoutException = RequestTimeoutException

187

198

188instance Exception RequestTimeoutException

199instance Exception RequestTimeoutException

189

200

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.

201+-- | 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.

191−data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCallback [GhcPkgPath] |

202+data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCallback [GhcPkgPath]|

192− RemoteConnectionInfo DatabaseName Hostname ServiceName NotificationCallback

203+ RemoteProcessConnectionInfo DatabaseName NodeId NotificationCallback

193

204

194type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification

205type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification

195

206

196-- | Used for callbacks from the server when monitored changes have been made.

207-- | Used for callbacks from the server when monitored changes have been made.

197newtype NotificationMessage = NotificationMessage EvaluatedNotifications

208newtype NotificationMessage = NotificationMessage EvaluatedNotifications

198− deriving (Eq, Show, Generic)

209+ deriving (Binary, Eq, Show, Generic)

199− deriving Serialise via WineryVariant NotificationMessage

200

210

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.

211-- | 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.

202data EvaluatedNotification = EvaluatedNotification {

212data EvaluatedNotification = EvaluatedNotification {

@@ -204,10 +214,13 @@ data EvaluatedNotification = EvaluatedNotification {

204 reportOldRelation :: Either RelationalError Relation,

214 reportOldRelation :: Either RelationalError Relation,

205 reportNewRelation :: Either RelationalError Relation

215 reportNewRelation :: Either RelationalError Relation

206 }

216 }

207− deriving (Eq, Show, Generic)

217+ deriving(Binary, Eq, Show, Generic)

208− deriving Serialise via WineryRecord EvaluatedNotification

209

218

210

219

220+-- | Create a 'NodeId' for use in connecting to a remote server using distributed-process.

221+createNodeId :: Hostname -> Port -> NodeId

222+createNodeId host port = NodeId $ encodeEndPointAddress host (show port) 1

223+

211-- | Use this for connecting to remote servers on the default port.

224-- | Use this for connecting to remote servers on the default port.

212defaultServerPort :: Port

225defaultServerPort :: Port

213defaultServerPort = 6543

226defaultServerPort = 6543

@@ -222,36 +235,87 @@ defaultHeadName = "master"

222

235

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.

236-- | 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.

224defaultRemoteConnectionInfo :: ConnectionInfo

237defaultRemoteConnectionInfo :: ConnectionInfo

225−defaultRemoteConnectionInfo =

226− RemoteConnectionInfo defaultDatabaseName defaultServerHostname (show defaultServerPort) emptyNotificationCallback

238+defaultRemoteConnectionInfo = RemoteProcessConnectionInfo defaultDatabaseName (createNodeId "127.0.0.1" defaultServerPort) emptyNotificationCallback

227

239

228−defaultServerHostname :: Hostname

240+-- | The 'Connection' represents either local or remote access to a database. All operations flow through the connection.

229−defaultServerHostname = "localhost"

241+type ClientNodes = StmSet.Set ProcessId

230

242

231−newtype RemoteConnectionConf = RemoteConnectionConf RPC.Connection

243+-- internal structure specific to in-process connections

244+data InProcessConnectionConf = InProcessConnectionConf {

245+ ipPersistenceStrategy :: PersistenceStrategy,

246+ ipClientNodes :: ClientNodes,

247+ ipSessions :: Sessions,

248+ ipTransactionGraph :: TVar TransactionGraph,

249+ ipScriptSession :: Maybe ScriptSession,

250+ ipLocalNode :: LocalNode,

251+ ipTransport :: Transport, -- we hold onto this so that we can close it gracefully

252+ ipLocks :: Maybe (LockFile, MVar LockFileHash) -- nothing when NoPersistence

253+ }

254+

255+data RemoteProcessConnectionConf = RemoteProcessConnectionConf {

256+ rLocalNode :: LocalNode,

257+ rProcessId :: ProcessId, --remote processId

258+ rTransport :: Transport --the TCP socket transport

259+ }

232

260

233data Connection = InProcessConnection InProcessConnectionConf |

261data Connection = InProcessConnection InProcessConnectionConf |

234− RemoteConnection RemoteConnectionConf

262+ RemoteProcessConnection RemoteProcessConnectionConf

235

263

236-- | There are several reasons why a connection can fail.

264-- | There are several reasons why a connection can fail.

237data ConnectionError = SetupDatabaseDirectoryError PersistenceError |

265data ConnectionError = SetupDatabaseDirectoryError PersistenceError |

238 IOExceptionError IOException |

266 IOExceptionError IOException |

239 NoSuchDatabaseByNameError DatabaseName |

267 NoSuchDatabaseByNameError DatabaseName |

240− DatabaseValidationError [MerkleValidationError] |

241 LoginError

268 LoginError

242 deriving (Show, Eq, Generic)

269 deriving (Show, Eq, Generic)

243

270

244remoteDBLookupName :: DatabaseName -> String

271remoteDBLookupName :: DatabaseName -> String

245remoteDBLookupName = (++) "db-"

272remoteDBLookupName = (++) "db-"

246

273

274+createLocalNode :: IO (LocalNode, Transport)

275+createLocalNode = do

276+#if MIN_VERSION_network_transport_tcp(0,7,0)

277+ let addrInfo = TCPAddrInfo {

278+ tcpBindHost = "127.0.0.1",

279+ tcpBindPort = "0",

280+ tcpExternalAddress = \sn -> ("127.0.0.1", sn)

281+ }

282+ eLocalTransport <- createTransport (Addressable addrInfo) defaultTCPParameters

283+#elif MIN_VERSION_network_transport_tcp(0,6,0)

284+ eLocalTransport <- createTransport "127.0.0.1" "0" ) defaultTCPParameters

285+#else

286+ eLocalTransport <- createTransport "127.0.0.1" "0" defaultTCPParameters

287+#endif

288+ case eLocalTransport of

289+ Left err -> error ("failed to create transport: " ++ show err)

290+ Right localTransport -> do

291+ localNode <- newLocalNode localTransport initRemoteTable

292+ pure (localNode, localTransport)

293+

294+notificationListener :: NotificationCallback -> Process ()

295+notificationListener callback = do

296+ --pid <- getSelfPid

297+ --liftIO $ putStrLn $ "LISTENER THREAD START " ++ show pid

298+ _ <- forever $

299+ receiveWait [

300+ match (\(NotificationMessage eNots) ->

301+ --say $ "NOTIFICATION: " ++ show eNots

302+ -- 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

303+ liftIO $ mapM_ (uncurry callback) (M.toList eNots)

304+ )

305+ ]

306+ --say "LISTENER THREAD EXIT"

307+ pure ()

308+

309+startNotificationListener :: LocalNode -> NotificationCallback -> IO ProcessId

310+startNotificationListener localNode callback = forkProcess localNode (notificationListener callback)

311+

247createScriptSession :: [String] -> IO (Maybe ScriptSession)

312createScriptSession :: [String] -> IO (Maybe ScriptSession)

248createScriptSession ghcPkgPaths = do

313createScriptSession ghcPkgPaths = do

249 eScriptSession <- initScriptSession ghcPkgPaths

314 eScriptSession <- initScriptSession ghcPkgPaths

250 case eScriptSession of

315 case eScriptSession of

251− Left err -> hPutStrLn stderr ("Warning: Haskell scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled

316+ Left err -> hPutStrLn stderr ("Failed to load scripting engine- scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled

252 Right s -> pure (Just s)

317 Right s -> pure (Just s)

253

318

254−

255-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.

319-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.

256connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)

320connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)

257--create a new in-memory database/transaction graph

321--create a new in-memory database/transaction graph

@@ -266,63 +330,42 @@ connectProjectM36 (InProcessConnectionInfo strat notificationCallback ghcPkgPath

266 graphTvar <- newTVarIO freshGraph

330 graphTvar <- newTVarIO freshGraph

267 clientNodes <- StmSet.newIO

331 clientNodes <- StmSet.newIO

268 sessions <- StmMap.newIO

332 sessions <- StmMap.newIO

333+ (localNode, transport) <- createLocalNode

334+ notificationPid <- startNotificationListener localNode notificationCallback

269 mScriptSession <- createScriptSession ghcPkgPaths

335 mScriptSession <- createScriptSession ghcPkgPaths

270− notifAsync <- startNotificationListener clientNodes notificationCallback

336+

271 let conn = InProcessConnection InProcessConnectionConf {

337 let conn = InProcessConnection InProcessConnectionConf {

272 ipPersistenceStrategy = strat,

338 ipPersistenceStrategy = strat,

273 ipClientNodes = clientNodes,

339 ipClientNodes = clientNodes,

274 ipSessions = sessions,

340 ipSessions = sessions,

275 ipTransactionGraph = graphTvar,

341 ipTransactionGraph = graphTvar,

276 ipScriptSession = mScriptSession,

342 ipScriptSession = mScriptSession,

343+ ipLocalNode = localNode,

344+ ipTransport = transport,

277− ipLocks = Nothing,

345+ ipLocks = Nothing}

278− ipCallbackAsync = notifAsync

346+ addClientNode conn notificationPid

279− }

280 pure (Right conn)

347 pure (Right conn)

281 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

348 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

282 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

349 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

283

350

284−connectProjectM36 (RemoteConnectionInfo dbName hostName servicePort notificationCallback) = do

351+connectProjectM36 (RemoteProcessConnectionInfo databaseName serverNodeId notificationCallback) = do

285− --TODO- add notification callback thread

352+ connStatus <- newEmptyMVar

286− let resolutionHints = defaultHints { addrFlags = [AI_NUMERICHOST, AI_NUMERICSERV],

353+ (localNode, transport) <- createLocalNode

287− addrSocketType = Stream

354+ let dbName = remoteDBLookupName databaseName

288− }

355+ --putStrLn $ "Connecting to " ++ show serverNodeId ++ " " ++ dbName

289− resolved <- getAddrInfo (Just resolutionHints) (Just hostName) (Just servicePort)

356+ notificationListenerPid <- startNotificationListener localNode notificationCallback

290− case resolved of

357+ runProcess localNode $ do

291− [] -> error ("DNS resolution failed for" <> hostName <> ":" <> servicePort)

358+ --even a failed connection retains an open socket!

292− addrInfo:_ -> do

359+ mServerProcessId <- whereisRemote serverNodeId dbName

293− --supports IPv4 only for now

360+ case mServerProcessId of

294− let (SockAddrInet port addr) = addrAddress addrInfo

361+ Nothing -> liftIO $ putMVar connStatus $ Left (NoSuchDatabaseByNameError databaseName)

295− notificationHandlers =

362+ Just serverProcessId -> do

296− [RPC.ClientAsyncRequestHandler $

363+ loginConfirmation <- safeLogin (Login notificationListenerPid) serverProcessId

297− \(NotificationMessage notifications') ->

364+ if not loginConfirmation then

298− forM_ (M.toList notifications') (uncurry notificationCallback)

365+ liftIO $ putMVar connStatus (Left LoginError)

299− ]

366+ else

300− let connectExcHandler (e :: IOException) = pure $ Left (IOExceptionError e)

367+ liftIO $ putMVar connStatus (Right $ RemoteProcessConnection RemoteProcessConnectionConf {rLocalNode = localNode, rProcessId = serverProcessId, rTransport = transport})

301− eConn <- (Right <$> RPC.connect notificationHandlers (hostAddressToTuple addr) port) `catch` connectExcHandler

368+ takeMVar connStatus

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

326

369

327connectPersistentProjectM36 :: PersistenceStrategy ->

370connectPersistentProjectM36 :: PersistenceStrategy ->

328 DiskSync ->

371 DiskSync ->

@@ -341,40 +384,32 @@ connectPersistentProjectM36 strat sync dbdir freshGraph notificationCallback ghc

341 case graph of

384 case graph of

342 Left err' -> return $ Left (SetupDatabaseDirectoryError err')

385 Left err' -> return $ Left (SetupDatabaseDirectoryError err')

343 Right graph' -> do

386 Right graph' -> do

344− case TG.validateMerkleHashes graph' of

345− Left merkleErrs -> pure (Left (DatabaseValidationError merkleErrs))

346− Right _ -> do

347− tvarGraph <- newTVarIO graph'

387+ tvarGraph <- newTVarIO graph'

348− sessions <- StmMap.newIO

388+ sessions <- StmMap.newIO

349− clientNodes <- StmSet.newIO

389+ clientNodes <- StmSet.newIO

390+ (localNode, transport) <- createLocalNode

350− lockMVar <- newMVar digest

391+ lockMVar <- newMVar digest

351− notifAsync <- startNotificationListener clientNodes notificationCallback

352− let conn = InProcessConnection InProcessConnectionConf {

392+ let conn = InProcessConnection InProcessConnectionConf {

353 ipPersistenceStrategy = strat,

393 ipPersistenceStrategy = strat,

354 ipClientNodes = clientNodes,

394 ipClientNodes = clientNodes,

355 ipSessions = sessions,

395 ipSessions = sessions,

356 ipTransactionGraph = tvarGraph,

396 ipTransactionGraph = tvarGraph,

357 ipScriptSession = mScriptSession,

397 ipScriptSession = mScriptSession,

398+ ipLocalNode = localNode,

399+ ipTransport = transport,

358− ipLocks = Just (lockFileH, lockMVar),

400+ ipLocks = Just (lockFileH, lockMVar)

359− ipCallbackAsync = notifAsync

360 }

401 }

361− pure (Right conn)

362−

363−--startup local async process to handle notification callbacks

364−startNotificationListener :: ClientNodes -> NotificationCallback -> IO (Async ())

365−startNotificationListener cNodes notificationCallback = do

366− inProcessClientInfo@(InProcessClientInfo notifMVar) <- InProcessClientInfo <$> newEmptyMVar

367− atomically $ StmSet.insert inProcessClientInfo cNodes

368− async $ forever $ do

369− notifs <- takeMVar notifMVar

370− forM_ (M.toList notifs) $ uncurry notificationCallback

371

402

403+ notificationPid <- startNotificationListener localNode notificationCallback

404+ addClientNode conn notificationPid

405+ pure (Right conn)

406+

372-- | Create a new session at the transaction id and return the session's Id.

407-- | Create a new session at the transaction id and return the session's Id.

373createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)

408createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)

374createSessionAtCommit conn@(InProcessConnection _) commitId = do

409createSessionAtCommit conn@(InProcessConnection _) commitId = do

375 newSessionId <- nextRandom

410 newSessionId <- nextRandom

376 atomically $ createSessionAtCommit_ commitId newSessionId conn

411 atomically $ createSessionAtCommit_ commitId newSessionId conn

377−createSessionAtCommit conn@(RemoteConnection _) uuid = remoteCall conn (CreateSessionAtCommit uuid)

412+createSessionAtCommit conn@(RemoteProcessConnection _) uuid = remoteCall conn (CreateSessionAtCommit uuid)

378

413

379createSessionAtCommit_ :: TransactionId -> SessionId -> Connection -> STM (Either RelationalError SessionId)

414createSessionAtCommit_ :: TransactionId -> SessionId -> Connection -> STM (Either RelationalError SessionId)

380createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do

415createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do

@@ -384,14 +419,14 @@ createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do

384 case RE.transactionForId commitId graph of

419 case RE.transactionForId commitId graph of

385 Left err -> pure (Left err)

420 Left err -> pure (Left err)

386 Right transaction -> do

421 Right transaction -> do

387− let freshDiscon = DisconnectedTransaction commitId (Trans.schemas transaction) False

422+ let freshDiscon = DisconnectedTransaction commitId (Trans.schemas transaction) NoOperation

388 keyDuplication <- StmMap.lookup newSessionId sessions

423 keyDuplication <- StmMap.lookup newSessionId sessions

389 case keyDuplication of

424 case keyDuplication of

390 Just _ -> pure $ Left (SessionIdInUseError newSessionId)

425 Just _ -> pure $ Left (SessionIdInUseError newSessionId)

391 Nothing -> do

426 Nothing -> do

392 StmMap.insert (Session freshDiscon defaultSchemaName) newSessionId sessions

427 StmMap.insert (Session freshDiscon defaultSchemaName) newSessionId sessions

393 pure $ Right newSessionId

428 pure $ Right newSessionId

394−createSessionAtCommit_ _ _ (RemoteConnection _) = error "createSessionAtCommit_ called on remote connection"

429+createSessionAtCommit_ _ _ (RemoteProcessConnection _) = error "createSessionAtCommit_ called on remote connection"

395

430

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.

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.

397createSessionAtHead :: Connection -> HeadName -> IO (Either RelationalError SessionId)

432createSessionAtHead :: Connection -> HeadName -> IO (Either RelationalError SessionId)

@@ -403,18 +438,22 @@ createSessionAtHead conn@(InProcessConnection conf) headn = do

403 case transactionForHead headn graph of

438 case transactionForHead headn graph of

404 Nothing -> pure $ Left (NoSuchHeadNameError headn)

439 Nothing -> pure $ Left (NoSuchHeadNameError headn)

405 Just trans -> createSessionAtCommit_ (transactionId trans) newSessionId conn

440 Just trans -> createSessionAtCommit_ (transactionId trans) newSessionId conn

406−createSessionAtHead conn@(RemoteConnection _) headn = remoteCall conn (CreateSessionAtHead headn)

441+createSessionAtHead conn@(RemoteProcessConnection _) headn = remoteCall conn (CreateSessionAtHead headn)

442+

443+-- | Used internally for server connections to keep track of remote nodes for the purpose of sending notifications later.

444+addClientNode :: Connection -> ProcessId -> IO ()

445+addClientNode (RemoteProcessConnection _) _ = error "addClientNode called on remote connection"

446+addClientNode (InProcessConnection conf) newProcessId = atomically (StmSet.insert newProcessId (ipClientNodes conf))

407

447

408-- | Discards a session, eliminating any uncommitted changes present in the session.

448-- | Discards a session, eliminating any uncommitted changes present in the session.

409closeSession :: SessionId -> Connection -> IO ()

449closeSession :: SessionId -> Connection -> IO ()

410closeSession sessionId (InProcessConnection conf) =

450closeSession sessionId (InProcessConnection conf) =

411 atomically $ StmMap.delete sessionId (ipSessions conf)

451 atomically $ StmMap.delete sessionId (ipSessions conf)

412−closeSession sessionId conn@(RemoteConnection _) = remoteCall conn (CloseSession sessionId)

452+closeSession sessionId conn@(RemoteProcessConnection _) = remoteCall conn (CloseSession sessionId)

413

453

414-- | 'close' cleans up the database access connection and closes any relevant sockets.

454-- | 'close' cleans up the database access connection and closes any relevant sockets.

415close :: Connection -> IO ()

455close :: Connection -> IO ()

416close (InProcessConnection conf) = do

456close (InProcessConnection conf) = do

417− cancel (ipCallbackAsync conf)

418 atomically $ do

457 atomically $ do

419 let sessions = ipSessions conf

458 let sessions = ipSessions conf

420#if MIN_VERSION_stm_containers(1,0,0)

459#if MIN_VERSION_stm_containers(1,0,0)

@@ -423,18 +462,22 @@ close (InProcessConnection conf) = do

423 StmMap.deleteAll sessions

462 StmMap.deleteAll sessions

424#endif

463#endif

425 pure ()

464 pure ()

465+ closeLocalNode (ipLocalNode conf)

466+ closeTransport (ipTransport conf)

426 let mLocks = ipLocks conf

467 let mLocks = ipLocks conf

427 case mLocks of

468 case mLocks of

428 Nothing -> pure ()

469 Nothing -> pure ()

429 Just (lockFileH, _) -> closeLockFile lockFileH

470 Just (lockFileH, _) -> closeLockFile lockFileH

430

471

431−close (RemoteConnection (RemoteConnectionConf conn)) =

472+close conn@(RemoteProcessConnection conf) = do

432− RPC.close conn

473+ _ <- remoteCall conn Logout :: IO Bool

474+ closeLocalNode (rLocalNode conf)

475+ closeTransport (rTransport conf)

433

476

434--used only by the server EntryPoints

477--used only by the server EntryPoints

435closeRemote_ :: Connection -> IO ()

478closeRemote_ :: Connection -> IO ()

436closeRemote_ (InProcessConnection _) = error "invalid call of closeRemote_ on InProcessConnection"

479closeRemote_ (InProcessConnection _) = error "invalid call of closeRemote_ on InProcessConnection"

437−closeRemote_ (RemoteConnection (RemoteConnectionConf conn)) = RPC.close conn

480+closeRemote_ (RemoteProcessConnection conf) = runProcess (rLocalNode conf) (reconnect (rProcessId conf))

438

481

439 --we need to actually close the localNode's connection to the remote

482 --we need to actually close the localNode's connection to the remote

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

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

@@ -445,15 +488,35 @@ excEither = handle handler

445 where

488 where

446 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc

489 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc

447 | otherwise = pure (Left (UnhandledExceptionError (show exc)))

490 | 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

448

506

449−

450−remoteCall :: (Serialise a, Serialise b) => Connection -> a -> IO b

507+remoteCall :: (Binary a, Binary b, Typeable a, Typeable b) => Connection -> a -> IO b

451remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"

508remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"

452−remoteCall (RemoteConnection (RemoteConnectionConf rpcConn)) arg = do

509+remoteCall (RemoteProcessConnection conf) arg = runProcessResult localNode $ do

453− eRet <- RPC.call rpcConn arg

510+ ret <- safeCall serverProcessId arg

454− case eRet of

511+ case ret of

455− Left err -> convertRPCErrors err

512+ Left err -> error ("server died: " ++ show err)

513+ Right ret' -> case ret' of

514+ Left RequestTimeoutError -> liftIO (throwIO RequestTimeoutException)

515+ Left (ProcessDiedError _) -> liftIO (throwIO RemoteProcessDiedException)

456− Right val -> pure val

516+ Right val -> pure val

517+ where

518+ localNode = rLocalNode conf

519+ serverProcessId = rProcessId conf

457

520

458sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)

521sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)

459sessionForSessionId sessionId sessions =

522sessionForSessionId sessionId sessions =

@@ -488,7 +551,7 @@ currentSchemaName sessionId (InProcessConnection conf) = atomically $ do

488 case eSession of

551 case eSession of

489 Left err -> pure (Left err)

552 Left err -> pure (Left err)

490 Right session -> pure (Right (Sess.schemaName session))

553 Right session -> pure (Right (Sess.schemaName session))

491−currentSchemaName sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveCurrentSchemaName sessionId)

554+currentSchemaName sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveCurrentSchemaName sessionId)

492

555

493-- | Switch to the named isomorphic schema.

556-- | Switch to the named isomorphic schema.

494setCurrentSchemaName :: SessionId -> Connection -> SchemaName -> IO (Either RelationalError ())

557setCurrentSchemaName :: SessionId -> Connection -> SchemaName -> IO (Either RelationalError ())

@@ -500,7 +563,7 @@ setCurrentSchemaName sessionId (InProcessConnection conf) sname = atomically $ d

500 Right session -> case Sess.setSchemaName sname session of

563 Right session -> case Sess.setSchemaName sname session of

501 Left err -> pure (Left err)

564 Left err -> pure (Left err)

502 Right newSession -> StmMap.insert newSession sessionId sessions >> pure (Right ())

565 Right newSession -> StmMap.insert newSession sessionId sessions >> pure (Right ())

503−setCurrentSchemaName sessionId conn@(RemoteConnection _) sname = remoteCall conn (ExecuteSetCurrentSchema sessionId sname)

566+setCurrentSchemaName sessionId conn@(RemoteProcessConnection _) sname = remoteCall conn (ExecuteSetCurrentSchema sessionId sname)

504

567

505-- | Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.

568-- | Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.

506executeRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

569executeRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

@@ -524,7 +587,7 @@ executeRelationalExpr sessionId (InProcessConnection conf) expr = excEither $ at

524 Right rel -> pure (force (Right rel)) -- this is necessary so that any undefined/error exceptions are spit out here

587 Right rel -> pure (force (Right rel)) -- this is necessary so that any undefined/error exceptions are spit out here

525 Left err -> pure (Left err)

588 Left err -> pure (Left err)

526

589

527−executeRelationalExpr sessionId conn@(RemoteConnection _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)

590+executeRelationalExpr sessionId conn@(RemoteProcessConnection _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)

528

591

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.

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.

530executeDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())

593executeDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())

@@ -551,14 +614,14 @@ executeDatabaseContextExpr sessionId (InProcessConnection conf) expr = excEither

551 if not (RE.dbc_dirty newState) then --nothing dirtied, nothing to do

614 if not (RE.dbc_dirty newState) then --nothing dirtied, nothing to do

552 pure (Right ())

615 pure (Right ())

553 else do

616 else do

554− let newDiscon = DisconnectedTransaction (Sess.parentId session) newSchemas True

617+ let newDiscon = DisconnectedTransaction (Sess.parentId session) newSchemas NoOperation

555 context' = RE.dbc_context newState

618 context' = RE.dbc_context newState

556 newSubschemas = Schema.processDatabaseContextExprSchemasUpdate (Sess.subschemas session) expr

619 newSubschemas = Schema.processDatabaseContextExprSchemasUpdate (Sess.subschemas session) expr

557 newSchemas = Schemas context' newSubschemas

620 newSchemas = Schemas context' newSubschemas

558 newSession = Session newDiscon (Sess.schemaName session)

621 newSession = Session newDiscon (Sess.schemaName session)

559 StmMap.insert newSession sessionId sessions

622 StmMap.insert newSession sessionId sessions

560 pure (Right ())

623 pure (Right ())

561−executeDatabaseContextExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)

624+executeDatabaseContextExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)

562

625

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.

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.

564autoMergeToHead :: SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

627autoMergeToHead :: SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

@@ -587,7 +650,7 @@ autoMergeToHead sessionId (InProcessConnection conf) strat headName' = do

587 Left err -> pure (Left err)

650 Left err -> pure (Left err)

588 Right ((discon', graph'), transactionIdsAdded) ->

651 Right ((discon', graph'), transactionIdsAdded) ->

589 pure (Right (discon', graph', transactionIdsAdded))

652 pure (Right (discon', graph', transactionIdsAdded))

590−autoMergeToHead sessionId conn@(RemoteConnection _) strat headName' = remoteCall conn (ExecuteAutoMergeToHead sessionId strat headName')

653+autoMergeToHead sessionId conn@(RemoteProcessConnection _) strat headName' = remoteCall conn (ExecuteAutoMergeToHead sessionId strat headName')

591

654

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.

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.

593--this is almost completely identical to executeDatabaseContextExpr above

656--this is almost completely identical to executeDatabaseContextExpr above

@@ -607,14 +670,28 @@ executeDatabaseContextIOExpr sessionId (InProcessConnection conf) expr = excEith

607 case res of

670 case res of

608 Left err -> pure (Left err)

671 Left err -> pure (Left err)

609 Right newState -> do

672 Right newState -> do

610− let newDiscon = DisconnectedTransaction (Sess.parentId session) newSchemas False

673+ let newDiscon = DisconnectedTransaction (Sess.parentId session) newSchemas NoOperation

611 newSchemas = Schemas context' (Sess.subschemas session)

674 newSchemas = Schemas context' (Sess.subschemas session)

612 newSession = Session newDiscon (Sess.schemaName session)

675 newSession = Session newDiscon (Sess.schemaName session)

613 context' = RE.dbc_context newState

676 context' = RE.dbc_context newState

614 atomically $ StmMap.insert newSession sessionId sessions

677 atomically $ StmMap.insert newSession sessionId sessions

615 pure (Right ())

678 pure (Right ())

616−executeDatabaseContextIOExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)

679+executeDatabaseContextIOExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)

617

680

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+

618-- process notifications for commits

695-- process notifications for commits

619executeCommitExprSTM_

696executeCommitExprSTM_

620 :: TransactionGraph

697 :: TransactionGraph

@@ -655,8 +732,78 @@ executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do

655 --if freshId appears in the graph, then we need to pass it on

732 --if freshId appears in the graph, then we need to pass it on

656 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]

733 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]

657 pure (Right (discon', graph', transIds))

734 pure (Right (discon', graph', transIds))

658−

735+{-

736+executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do

737+ let strat = ipPersistenceStrategy conf

738+ clientNodes = ipClientNodes conf

739+ sessions = ipSessions conf

740+ graphTvar = ipTransactionGraph conf

741+ mLockFileH = ipLocks conf

742+ lockHandler body = case graphExpr of

743+ Commit -> case mLockFileH of

744+ Nothing -> body False

745+ Just (lockFileH, lockMVar) -> let acquireLocks = do

746+ lastWrittenDigest <- takeMVar lockMVar

747+ lockFile lockFileH WriteLock

748+ latestDigest <- readGraphTransactionIdDigest strat

749+ pure (latestDigest /= lastWrittenDigest)

750+

751+ releaseLocks _ = do

752+ --still holding the lock- get the latest digest

753+ gDigest <- readGraphTransactionIdDigest strat

754+ unlockFile lockFileH

755+ putMVar lockMVar gDigest

756+ in bracket acquireLocks releaseLocks body

757+ _ -> body False

758+ freshId <- nextRandom

759+ lockHandler $ \dbWrittenByOtherProcess -> do

760+ --if the database file has been updated since we wrote it last, load it before trying to sync our version done- this can result in TransactionNotAHeadErrors

761+ --read transaction data and compare to existing graph

762+ --in the future, we can detect if updated transaction graph can be safely merged (such as with a transaction on a separate head) (rebase-able commits should force the user to rebase from the client to confirm that the action makes sense)

763+ manip <- atomically $ do

764+ eSession <- sessionForSessionId sessionId sessions

765+ --handle graph update by other process

766+ oldGraph <- readTVar graphTvar

767+ case eSession of

768+ Left err -> pure (Left err)

769+ Right session -> do

770+ let mScriptSession = ipScriptSession conf

771+ dbdir = case strat of

772+ MinimalPersistence x -> x

773+ CrashSafePersistence x -> x

774+ _ -> error "accessing dbdir on non-persisted connection"

775+ eRefreshedGraph <- if dbWrittenByOtherProcess then

776+ unsafeIOToSTM (transactionGraphLoad dbdir oldGraph mScriptSession)

777+ else

778+ pure (Right oldGraph)

779+ case eRefreshedGraph of

780+ Left err -> pure (Left (DatabaseLoadError err))

781+ Right refreshedGraph -> do

782+ --snip it

783+ eGraph <- executeGraphExprSTM_ dbWrittenByOtherProcess freshId sessionId session sessions graphExpr refreshedGraph graphTvar

784+ --snip it

785+ case eGraph of

786+ Left err -> pure (Left err)

787+ Right newGraph -> do

788+ --handle commit

789+ if isCommit graphExpr then do

790+ case transactionForId (Sess.parentId session) oldGraph of

791+ Left err -> pure $ Left err

792+ Right previousTrans -> do

793+ (evaldNots, nodes) <- executeCommitExprSTM_ (Trans.concreteDatabaseContext previousTrans) (Sess.concreteDatabaseContext session) clientNodes

794+ nodesToNotify <- toList (StmSet.stream nodes)

795+ pure $ Right (evaldNots, nodesToNotify, newGraph)

796+ else

797+ pure $ Right (M.empty, [], newGraph)

798+ case manip of

799+ Left err -> return $ Just err

800+ Right (notsToFire, nodesToNotify, newGraph) -> do

801+ --update filesystem database, if necessary

802+ processTransactionGraphPersistence strat newGraph

803+ sendNotifications nodesToNotify (ipLocalNode conf) notsToFire

804+ pure Nothing

805+-}

659−executeGraphExpr sessionId conn@(RemoteConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)

806+executeGraphExpr sessionId conn@(RemoteProcessConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)

660

807

661-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.

808-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.

662executeTransGraphRelationalExpr :: SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

809executeTransGraphRelationalExpr :: SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

@@ -664,7 +811,10 @@ executeTransGraphRelationalExpr _ (InProcessConnection conf) tgraphExpr = excEit

664 let graphTvar = ipTransactionGraph conf

811 let graphTvar = ipTransactionGraph conf

665 graph <- readTVar graphTvar

812 graph <- readTVar graphTvar

666 pure $ force $ optimizeAndEvalTransGraphRelationalExpr graph tgraphExpr

813 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))-}

667−executeTransGraphRelationalExpr sessionId conn@(RemoteConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)

817+executeTransGraphRelationalExpr sessionId conn@(RemoteProcessConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)

668

818

669-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.

819-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.

670executeSchemaExpr :: SessionId -> Connection -> Schema.SchemaExpr -> IO (Either RelationalError ())

820executeSchemaExpr :: SessionId -> Connection -> Schema.SchemaExpr -> IO (Either RelationalError ())

@@ -684,27 +834,26 @@ executeSchemaExpr sessionId (InProcessConnection conf) schemaExpr = atomically $

684 --hm- maybe we should start using lenses

834 --hm- maybe we should start using lenses

685 let discon = Sess.disconnectedTransaction session

835 let discon = Sess.disconnectedTransaction session

686 newSchemas = Schemas newContext newSubschemas

836 newSchemas = Schemas newContext newSubschemas

687− newSession = Session (DisconnectedTransaction (Discon.parentId discon) newSchemas False) (Sess.schemaName session)

837+ newSession = Session (DisconnectedTransaction (Discon.parentId discon) newSchemas NoOperation) (Sess.schemaName session)

688 StmMap.insert newSession sessionId sessions

838 StmMap.insert newSession sessionId sessions

689 pure (Right ())

839 pure (Right ())

690−executeSchemaExpr sessionId conn@(RemoteConnection _) schemaExpr = remoteCall conn (ExecuteSchemaExpr sessionId schemaExpr)

840+executeSchemaExpr sessionId conn@(RemoteProcessConnection _) schemaExpr = remoteCall conn (ExecuteSchemaExpr sessionId schemaExpr)

691

841

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.

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.

693commit :: SessionId -> Connection -> IO (Either RelationalError ())

843commit :: SessionId -> Connection -> IO (Either RelationalError ())

694commit sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Commit

844commit sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Commit

695−commit sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Commit)

845+commit sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Commit)

696−

846+

697−sendNotifications :: [ClientInfo] -> EvaluatedNotifications -> IO ()

847+sendNotifications :: [ProcessId] -> LocalNode -> EvaluatedNotifications -> IO ()

698−sendNotifications clients notifs =

848+sendNotifications pids localNode nots = mapM_ sendNots pids

699− unless (M.null notifs) $ forM_ clients sender

849+ where

700− where

850+ sendNots remoteClientPid =

701− sender (RemoteClientInfo sock) = RPC.sendMessage sock (NotificationMessage notifs)

851+ unless (M.null nots) $ runProcess localNode $ send remoteClientPid (NotificationMessage nots)

702− sender (InProcessClientInfo tvar) = putMVar tvar notifs

852+

703−

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.

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.

705rollback :: SessionId -> Connection -> IO (Either RelationalError ())

854rollback :: SessionId -> Connection -> IO (Either RelationalError ())

706rollback sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Rollback

855rollback sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Rollback

707−rollback sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)

856+rollback sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)

708

857

709-- | Write the transaction graph to disk. This function can be used to incrementally write new transactions to disk.

858-- | Write the transaction graph to disk. This function can be used to incrementally write new transactions to disk.

710processTransactionGraphPersistence :: PersistenceStrategy -> [TransactionId] -> TransactionGraph -> IO ()

859processTransactionGraphPersistence :: PersistenceStrategy -> [TransactionId] -> TransactionGraph -> IO ()

@@ -720,7 +869,7 @@ readGraphTransactionIdDigest (CrashSafePersistence dbdir) = readGraphTransaction

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.

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.

721typeForRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

870typeForRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

722typeForRelationalExpr sessionId conn@(InProcessConnection _) relExpr = atomically $ typeForRelationalExprSTM sessionId conn relExpr

871typeForRelationalExpr sessionId conn@(InProcessConnection _) relExpr = atomically $ typeForRelationalExprSTM sessionId conn relExpr

723−typeForRelationalExpr sessionId conn@(RemoteConnection _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)

872+typeForRelationalExpr sessionId conn@(RemoteProcessConnection _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)

724

873

725typeForRelationalExprSTM :: SessionId -> Connection -> RelationalExpr -> STM (Either RelationalError Relation)

874typeForRelationalExprSTM :: SessionId -> Connection -> RelationalExpr -> STM (Either RelationalError Relation)

726typeForRelationalExprSTM sessionId (InProcessConnection conf) relExpr = do

875typeForRelationalExprSTM sessionId (InProcessConnection conf) relExpr = do

@@ -757,7 +906,7 @@ inclusionDependencies sessionId (InProcessConnection conf) = do

757 else

906 else

758 pure (Schema.inclusionDependenciesInSchema schema (B.inclusionDependencies context))

907 pure (Schema.inclusionDependenciesInSchema schema (B.inclusionDependencies context))

759

908

760−inclusionDependencies sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveInclusionDependencies sessionId)

909+inclusionDependencies sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveInclusionDependencies sessionId)

761

910

762typeConstructorMapping :: SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

911typeConstructorMapping :: SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

763typeConstructorMapping sessionId (InProcessConnection conf) = do

912typeConstructorMapping sessionId (InProcessConnection conf) = do

@@ -768,7 +917,7 @@ typeConstructorMapping sessionId (InProcessConnection conf) = do

768 Left err -> pure $ Left err

917 Left err -> pure $ Left err

769 Right (session, _) -> --warning, no schema support for typeconstructors

918 Right (session, _) -> --warning, no schema support for typeconstructors

770 pure (Right (B.typeConstructorMapping (Sess.concreteDatabaseContext session)))

919 pure (Right (B.typeConstructorMapping (Sess.concreteDatabaseContext session)))

771−typeConstructorMapping sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveTypeConstructorMapping sessionId)

920+typeConstructorMapping sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveTypeConstructorMapping sessionId)

772

921

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.

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.

774planForDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

923planForDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

@@ -782,13 +931,12 @@ planForDatabaseContextExpr sessionId (InProcessConnection conf) dbExpr = do

782 Right (session, _) ->

931 Right (session, _) ->

783 if schemaName session == defaultSchemaName then do

932 if schemaName session == defaultSchemaName then do

784 let ctx = Sess.concreteDatabaseContext session

933 let ctx = Sess.concreteDatabaseContext session

785− transId = Sess.parentId session

786 gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextExpr dbExpr)

934 gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextExpr dbExpr)

787− pure $ runGraphRefSOptDatabaseContextExprM transId ctx graph (optimizeGraphRefDatabaseContextExpr gfExpr)

935+ pure $ runGraphRefStaticOptimizerMonad (Just ctx) graph (optimizeGraphRefDatabaseContextExpr gfExpr)

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-}

936 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-}

789 pure (Left NonConcreteSchemaPlanError)

937 pure (Left NonConcreteSchemaPlanError)

790

938

791−planForDatabaseContextExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)

939+planForDatabaseContextExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)

792

940

793-- | Return a relation which represents the current state of the global transaction graph. The attributes are

941-- | Return a relation which represents the current state of the global transaction graph. The attributes are

794-- * current- boolean attribute representing whether or not the current session references this transaction

942-- * current- boolean attribute representing whether or not the current session references this transaction

@@ -806,7 +954,7 @@ transactionGraphAsRelation sessionId (InProcessConnection conf) = do

806 Right session ->

954 Right session ->

807 graphAsRelation (Sess.disconnectedTransaction session) <$> readTVar tvar

955 graphAsRelation (Sess.disconnectedTransaction session) <$> readTVar tvar

808

956

809−transactionGraphAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveTransactionGraph sessionId)

957+transactionGraphAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveTransactionGraph sessionId)

810

958

811-- | Returns the names and types of the relation variables in the current 'Session'.

959-- | Returns the names and types of the relation variables in the current 'Session'.

812relationVariablesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

960relationVariablesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -820,15 +968,13 @@ relationVariablesAsRelation sessionId (InProcessConnection conf) = do

820 Right (session, schema) -> do

968 Right (session, schema) -> do

821 let context = Sess.concreteDatabaseContext session

969 let context = Sess.concreteDatabaseContext session

822 if Sess.schemaName session == defaultSchemaName then

970 if Sess.schemaName session == defaultSchemaName then

823− pure $ RE.relationVariablesAsRelation context graph

971+ pure $ RE.relationVariablesAsRelation (relationVariables context) graph

824 else

972 else

825 case Schema.relationVariablesInSchema schema of

973 case Schema.relationVariablesInSchema schema of

826 Left err -> pure (Left err)

974 Left err -> pure (Left err)

827− Right relvars -> do

828− let schemaContext = context {relationVariables = relvars }

829− pure $ RE.relationVariablesAsRelation schemaContext graph

975+ Right relvars -> pure $ RE.relationVariablesAsRelation relvars graph

830

976

831−relationVariablesAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)

977+relationVariablesAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)

832

978

833-- | Returns the names and types of the atom functions in the current 'Session'.

979-- | Returns the names and types of the atom functions in the current 'Session'.

834atomFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

980atomFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -841,7 +987,7 @@ atomFunctionsAsRelation sessionId (InProcessConnection conf) = do

841 Right (session, _) ->

987 Right (session, _) ->

842 pure (AF.atomFunctionsAsRelation (atomFunctions (concreteDatabaseContext session)))

988 pure (AF.atomFunctionsAsRelation (atomFunctions (concreteDatabaseContext session)))

843

989

844−atomFunctionsAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveAtomFunctionSummary sessionId)

990+atomFunctionsAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveAtomFunctionSummary sessionId)

845

991

846databaseContextFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

992databaseContextFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

847databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do

993databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do

@@ -853,7 +999,7 @@ databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do

853 Right (session, _) ->

999 Right (session, _) ->

854 pure (DCF.databaseContextFunctionsAsRelation (dbcFunctions (concreteDatabaseContext session)))

1000 pure (DCF.databaseContextFunctionsAsRelation (dbcFunctions (concreteDatabaseContext session)))

855

1001

856−databaseContextFunctionsAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveDatabaseContextFunctionSummary sessionId)

1002+databaseContextFunctionsAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveDatabaseContextFunctionSummary sessionId)

857

1003

858-- | Returns the transaction id for the connection's disconnected transaction committed parent transaction.

1004-- | Returns the transaction id for the connection's disconnected transaction committed parent transaction.

859headTransactionId :: SessionId -> Connection -> IO (Either RelationalError TransactionId)

1005headTransactionId :: SessionId -> Connection -> IO (Either RelationalError TransactionId)

@@ -864,7 +1010,7 @@ headTransactionId sessionId (InProcessConnection conf) = do

864 case eSession of

1010 case eSession of

865 Left err -> pure (Left err)

1011 Left err -> pure (Left err)

866 Right session -> pure $ Right (Sess.parentId session)

1012 Right session -> pure $ Right (Sess.parentId session)

867−headTransactionId sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveHeadTransactionId sessionId)

1013+headTransactionId sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveHeadTransactionId sessionId)

868

1014

869headNameSTM_ :: SessionId -> Sessions -> TVar TransactionGraph -> STM (Either RelationalError HeadName)

1015headNameSTM_ :: SessionId -> Sessions -> TVar TransactionGraph -> STM (Either RelationalError HeadName)

870headNameSTM_ sessionId sessions graphTvar = do

1016headNameSTM_ sessionId sessions graphTvar = do

@@ -884,7 +1030,7 @@ headName sessionId (InProcessConnection conf) = do

884 let sessions = ipSessions conf

1030 let sessions = ipSessions conf

885 graphTvar = ipTransactionGraph conf

1031 graphTvar = ipTransactionGraph conf

886 atomically (headNameSTM_ sessionId sessions graphTvar)

1032 atomically (headNameSTM_ sessionId sessions graphTvar)

887−headName sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteHeadName sessionId)

1033+headName sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteHeadName sessionId)

888

1034

889-- | Returns a listing of all available atom types.

1035-- | Returns a listing of all available atom types.

890atomTypesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

1036atomTypesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -898,7 +1044,7 @@ atomTypesAsRelation sessionId (InProcessConnection conf) = do

898 case typesAsRelation (B.typeConstructorMapping (Sess.concreteDatabaseContext session)) of

1044 case typesAsRelation (B.typeConstructorMapping (Sess.concreteDatabaseContext session)) of

899 Left err -> pure (Left err)

1045 Left err -> pure (Left err)

900 Right rel -> pure (Right rel)

1046 Right rel -> pure (Right rel)

901−atomTypesAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)

1047+atomTypesAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)

902

1048

903disconnectedTransactionIsDirty :: SessionId -> Connection -> IO (Either RelationalError Bool)

1049disconnectedTransactionIsDirty :: SessionId -> Connection -> IO (Either RelationalError Bool)

904disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do

1050disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do

@@ -909,12 +1055,12 @@ disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do

909 Left err -> pure (Left err)

1055 Left err -> pure (Left err)

910 Right session ->

1056 Right session ->

911 pure (Right (isDirty session))

1057 pure (Right (isDirty session))

912−disconnectedTransactionIsDirty sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveSessionIsDirty sessionId)

1058+disconnectedTransactionIsDirty sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveSessionIsDirty sessionId)

913

1059

914--used only for testing- we expect this to throw an exception

1060--used only for testing- we expect this to throw an exception

915callTestTimeout_ :: SessionId -> Connection -> IO Bool

1061callTestTimeout_ :: SessionId -> Connection -> IO Bool

916callTestTimeout_ _ (InProcessConnection _) = error "bad testing call"

1062callTestTimeout_ _ (InProcessConnection _) = error "bad testing call"

917−callTestTimeout_ sessionId conn@(RemoteConnection _) = remoteCall conn (TestTimeout sessionId)

1063+callTestTimeout_ sessionId conn@(RemoteProcessConnection _) = remoteCall conn (TestTimeout sessionId)

918

1064

919--used in tests only

1065--used in tests only

920transactionGraph_ :: Connection -> IO TransactionGraph

1066transactionGraph_ :: Connection -> IO TransactionGraph

@@ -999,8 +1145,15 @@ commitLock_ sessionId conf stmBlock = do

999 Right (notsToFire, nodesToNotify, newGraph, transactionIdsToPersist) -> do

1145 Right (notsToFire, nodesToNotify, newGraph, transactionIdsToPersist) -> do

1000 --update filesystem database, if necessary

1146 --update filesystem database, if necessary

1001 processTransactionGraphPersistence strat transactionIdsToPersist newGraph

1147 processTransactionGraphPersistence strat transactionIdsToPersist newGraph

1002− sendNotifications nodesToNotify notsToFire

1148+ sendNotifications nodesToNotify (ipLocalNode conf) notsToFire

1003 pure (Right ())

1149 pure (Right ())

1150+{-

1151+writeDisconAndGraph_ :: TVar TransactionGraph -> SessionId -> Session -> Sessions -> DisconnectedTransaction -> TransactionGraph -> STM ()

1152+writeDisconAndGraph_ graphTvar sessionId session sessions discon graph = do

1153+ writeTVar graphTvar graph

1154+ let newSession = Session discon (Sess.schemaName session)

1155+ StmMap.insert newSession sessionId sessions

1156+-}

1004

1157

1005-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.

1158-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.

1006withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)

1159withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)

@@ -1042,54 +1195,12 @@ executeDataFrameExpr sessionId conn@(InProcessConnection _) dfExpr = do

1042 case verified of

1195 case verified of

1043 Left err -> pure (Left err)

1196 Left err -> pure (Left err)

1044 Right attrs -> do

1197 Right attrs -> do

1045− let attrOrders = zipWith

1046− (DF.AttributeOrder . attributeName)

1198+ let attrOrders = map (\(attr',order') -> DF.AttributeOrder (attributeName attr') order') (zip attrs orders)

1047− attrs

1048− orders

1049 case DF.sortDataFrameBy attrOrders . DF.toDataFrame $ rel of

1199 case DF.sortDataFrameBy attrOrders . DF.toDataFrame $ rel of

1050 Left err -> pure (Left err)

1200 Left err -> pure (Left err)

1051 Right dFrame -> do

1201 Right dFrame -> do

1052 let dFrame' = maybe dFrame (`DF.drop'` dFrame) (DF.offset dfExpr)

1202 let dFrame' = maybe dFrame (`DF.drop'` dFrame) (DF.offset dfExpr)

1053 dFrame'' = maybe dFrame' (`DF.take'` dFrame') (DF.limit dfExpr)

1203 dFrame'' = maybe dFrame' (`DF.take'` dFrame') (DF.limit dfExpr)

1054 pure (Right dFrame'')

1204 pure (Right dFrame'')

1055−executeDataFrameExpr sessionId conn@(RemoteConnection _) dfExpr = remoteCall conn (ExecuteDataFrameExpr sessionId dfExpr)

1205+executeDataFrameExpr sessionId conn@(RemoteProcessConnection _) dfExpr = remoteCall conn (ExecuteDataFrameExpr sessionId dfExpr)

1056

1206

1057−validateMerkleHashes :: SessionId -> Connection -> IO (Either RelationalError ())

1058−validateMerkleHashes sessionId (InProcessConnection conf) = do

1059− let sessions = ipSessions conf

1060− atomically $ do

1061− eSession <- sessionForSessionId sessionId sessions

1062− case eSession of

1063− Left err -> pure (Left err)

1064− Right _ -> do

1065− graph <- readTVar (ipTransactionGraph conf)

1066− case Graph.validateMerkleHashes graph of

1067− Left merkleErrs -> pure $ Left $ someErrors (map (\(MerkleValidationError tid expected actual) -> MerkleHashValidationError tid expected actual) merkleErrs)

1068− Right () -> pure (Right ())

1069−validateMerkleHashes sessionId conn@RemoteConnection{} = remoteCall conn (ExecuteValidateMerkleHashes sessionId)

1070−

1071−type ClientNodes = StmSet.Set ClientInfo

1072−

1073−-- internal structure specific to in-process connections

1074−data InProcessConnectionConf = InProcessConnectionConf {

1075− ipPersistenceStrategy :: PersistenceStrategy,

1076− ipClientNodes :: ClientNodes,

1077− ipSessions :: Sessions,

1078− ipTransactionGraph :: TVar TransactionGraph,

1079− ipScriptSession :: Maybe ScriptSession,

1080− ipLocks :: Maybe (LockFile, MVar LockFileHash), -- nothing when NoPersistence

1081− ipCallbackAsync :: Async ()

1082− }

1083−

1084−-- clients may connect associate one socket/mvar with the server to register for change callbacks

1085−data ClientInfo = RemoteClientInfo (RPC.Locking Socket) |

1086− InProcessClientInfo (MVar EvaluatedNotifications)

1087−

1088−instance Eq ClientInfo where

1089− (RemoteClientInfo a) == (RemoteClientInfo b) = RPC.lockless a == RPC.lockless b

1090− (InProcessClientInfo a) == (InProcessClientInfo b) = a == b

1091− _ == _ = False

1092−

1093−instance Hashable ClientInfo where

1094− hashWithSalt salt (RemoteClientInfo sock) = hashWithSalt salt (show (RPC.lockless sock))

1095− hashWithSalt salt (InProcessClientInfo _) = hashWithSalt salt (1::Int)

src/lib/ProjectM36/DataFrame.hs+15−23

@@ -1,8 +1,8 @@

1−{-# LANGUAGE DeriveGeneric, DerivingVia #-}

1+{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

2{- A dataframe is a strongly-typed, ordered list of named tuples. A dataframe differs from a relation in that its tuples are ordered.-}

3module ProjectM36.DataFrame where

4import ProjectM36.Base

5−import ProjectM36.Attribute as A hiding (drop)

5+import ProjectM36.Attribute as A

6import ProjectM36.Error

7import qualified ProjectM36.Relation as R

8import ProjectM36.Relation.Show.Term

@@ -16,19 +16,15 @@ 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

19import Control.Arrow

20import Control.Arrow

20−#if __GLASGOW_HASKELL__ < 804

21+#if __GLASGOW_HASKELL__ <= 802

21import Data.Monoid

22import Data.Monoid

22#endif

23#endif

23

24

24−data AttributeOrderExpr = AttributeOrderExpr AttributeName Order

25+data AttributeOrderExpr = AttributeOrderExpr AttributeName Order deriving (Show, Generic, Binary)

25− deriving (Show, Generic)

26−

27−data AttributeOrder = AttributeOrder AttributeName Order

26+data AttributeOrder = AttributeOrder AttributeName Order deriving (Show, Generic, Binary)

28− deriving (Show, Generic)

29−

30−data Order = AscendingOrder | DescendingOrder

27+data Order = AscendingOrder | DescendingOrder deriving (Eq, Show, Generic, Binary)

31− deriving (Eq, Show, Generic)

32

28

33ascending :: T.Text

29ascending :: T.Text

34ascending = "⬆"

30ascending = "⬆"

@@ -43,11 +39,9 @@ data DataFrame = DataFrame {

43 orders :: [AttributeOrder],

39 orders :: [AttributeOrder],

44 attributes :: Attributes,

40 attributes :: Attributes,

45 tuples :: [DataFrameTuple]

41 tuples :: [DataFrameTuple]

46− }

47− deriving (Show, Generic)

42+ } deriving (Show, Generic, Binary)

48

43

49−data DataFrameTuple = DataFrameTuple Attributes (V.Vector Atom)

44+data DataFrameTuple = DataFrameTuple Attributes (V.Vector Atom) deriving (Eq, Show, Generic, Binary)

50− deriving (Eq, Show, Generic)

51

45

52sortDataFrameBy :: [AttributeOrder] -> DataFrame -> Either RelationalError DataFrame

46sortDataFrameBy :: [AttributeOrder] -> DataFrame -> Either RelationalError DataFrame

53sortDataFrameBy attrOrders frame = do

47sortDataFrameBy attrOrders frame = do

@@ -81,7 +75,7 @@ compareTupleByOneAttributeName attr tuple1 tuple2 =

81 Right atom2 -> compareAtoms atom1 atom2

75 Right atom2 -> compareAtoms atom1 atom2

82

76

83atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom

77atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom

84−atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of

78+atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of

85 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

79 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

86 Just index -> case tupVec V.!? index of

80 Just index -> case tupVec V.!? index of

87 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

81 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

@@ -128,18 +122,17 @@ data DataFrameExpr = DataFrameExpr {

128 orderExprs :: [AttributeOrderExpr],

122 orderExprs :: [AttributeOrderExpr],

129 offset :: Maybe Integer,

123 offset :: Maybe Integer,

130 limit :: Maybe Integer

124 limit :: Maybe Integer

131− }

132− deriving (Show, Generic)

125+ } deriving (Show, Binary, Generic)

133

126

134dataFrameAsHTML :: DataFrame -> T.Text

127dataFrameAsHTML :: DataFrame -> T.Text

135-- web browsers don't display tables with empty cells or empty headers, so we have to insert some placeholders- it's not technically the same, but looks as expected in the browser

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

136dataFrameAsHTML df

129dataFrameAsHTML df

137− | length (tuples df) == 1 && A.null (attributes df) = style <>

130+ | length (tuples df) == 1 && L.null (attributes df) = style <>

138 tablestart <>

131 tablestart <>

139 "<tr><th></th></tr>" <>

132 "<tr><th></th></tr>" <>

140 "<tr><td></td></tr>" <>

133 "<tr><td></td></tr>" <>

141 tablefooter <> "</table>"

134 tablefooter <> "</table>"

142− | L.null (tuples df) && A.null (attributes df) = style <>

135+ | L.null (tuples df) && L.null (attributes df) = style <>

143 tablestart <>

136 tablestart <>

144 "<tr><th></th></tr>" <>

137 "<tr><th></th></tr>" <>

145 tablefooter <>

138 tablefooter <>

@@ -162,7 +155,7 @@ tuplesAsHTML = foldr folder ""

162 folder tuple acc = acc <> tupleAsHTML tuple

155 folder tuple acc = acc <> tupleAsHTML tuple

163

156

164tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]

157tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]

165−tupleAssocs (DataFrameTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)

158+tupleAssocs (DataFrameTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)

166

159

167

160

168tupleAsHTML :: DataFrameTuple -> T.Text

161tupleAsHTML :: DataFrameTuple -> T.Text

@@ -170,11 +163,10 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>

170 where

163 where

171 tupleFrag tup = "<td>" <> atomAsHTML (snd tup) <> "</td>"

164 tupleFrag tup = "<td>" <> atomAsHTML (snd tup) <> "</td>"

172 atomAsHTML (RelationAtom rel) = RelHTML.relationAsHTML rel

165 atomAsHTML (RelationAtom rel) = RelHTML.relationAsHTML rel

173− atomAsHTML (TextAtom t) = """ <> t <> """

174 atomAsHTML atom = atomToText atom

166 atomAsHTML atom = atomToText atom

175

167

176attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text

168attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text

177−attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"

169+attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"

178 where

170 where

179 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"

171 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"

180 ordering attrName = " " <> case L.find (\(AttributeOrder nam _) -> nam == attrName) orders' of

172 ordering attrName = " " <> case L.find (\(AttributeOrder nam _) -> nam == attrName) orders' of

src/lib/ProjectM36/DataTypes/Interval.hs−2

@@ -37,7 +37,6 @@ supportsInterval typ = case typ of

37 BoolAtomType -> False

38 RelationAtomType _ -> False

39 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this

40− RelationalExprAtomType -> False

41 TypeVariableType _ -> False

40 TypeVariableType _ -> False

42

41

43supportsOrdering :: AtomType -> Bool

42supportsOrdering :: AtomType -> Bool

@@ -51,7 +50,6 @@ supportsOrdering typ = case typ of

51 ByteStringAtomType -> False

50 ByteStringAtomType -> False

52 BoolAtomType -> False

51 BoolAtomType -> False

53 RelationAtomType _ -> False

52 RelationAtomType _ -> False

54− RelationalExprAtomType -> False

55 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this

53 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this

56 TypeVariableType _ -> False

54 TypeVariableType _ -> False

57

55

src/lib/ProjectM36/DataTypes/Primitive.hs−1

@@ -42,4 +42,3 @@ atomTypeForAtom (ByteStringAtom _) = ByteStringAtomType

42atomTypeForAtom (BoolAtom _) = BoolAtomType

43atomTypeForAtom (RelationAtom (Relation attrs _)) = RelationAtomType attrs

44atomTypeForAtom (ConstructedAtom _ aType _) = aType

45−atomTypeForAtom (RelationalExprAtom _) = RelationalExprAtomType

src/lib/ProjectM36/DataTypes/Sorting.hs−1

@@ -24,7 +24,6 @@ isSortableAtomType typ = case typ of

24 DateTimeAtomType -> True

25 ByteStringAtomType -> False

26 BoolAtomType -> True

27− RelationalExprAtomType -> False

28 RelationAtomType _ -> False

27 RelationAtomType _ -> False

29 ConstructedAtomType _ _ -> False

28 ConstructedAtomType _ _ -> False

30 TypeVariableType _ -> False

29 TypeVariableType _ -> False

src/lib/ProjectM36/DatabaseContext.hs+2−17

@@ -1,15 +1,11 @@

1module ProjectM36.DatabaseContext where

2import ProjectM36.Base

3−import Control.Monad (void)

4import qualified Data.Map as M

3import qualified Data.Map as M

5import qualified Data.HashSet as HS

4import qualified Data.HashSet as HS

6import ProjectM36.DataTypes.Basic

5import ProjectM36.DataTypes.Basic

7import ProjectM36.AtomFunctions.Basic

6import ProjectM36.AtomFunctions.Basic

7+import ProjectM36.DatabaseContextFunction

8import ProjectM36.Relation

9−import qualified Data.ByteString.Lazy as BL

10−import ProjectM36.AtomFunction as AF

11−import ProjectM36.DatabaseContextFunction as DBCF

12−import Codec.Winery

13

9

14empty :: DatabaseContext

10empty :: DatabaseContext

15empty = DatabaseContext { inclusionDependencies = M.empty,

11empty = DatabaseContext { inclusionDependencies = M.empty,

@@ -21,7 +17,7 @@ empty = DatabaseContext { inclusionDependencies = M.empty,

21

17

22-- | Remove TransactionId markers on GraphRefRelationalExpr

18-- | Remove TransactionId markers on GraphRefRelationalExpr

23stripGraphRefRelationalExpr :: GraphRefRelationalExpr -> RelationalExpr

19stripGraphRefRelationalExpr :: GraphRefRelationalExpr -> RelationalExpr

24−stripGraphRefRelationalExpr = void

20+stripGraphRefRelationalExpr = fmap (const ())

25

21

26-- | convert an existing database context into its constituent expression.

22-- | convert an existing database context into its constituent expression.

27databaseContextAsDatabaseContextExpr :: DatabaseContext -> DatabaseContextExpr

23databaseContextAsDatabaseContextExpr :: DatabaseContext -> DatabaseContextExpr

@@ -41,14 +37,3 @@ basicDatabaseContext = DatabaseContext { inclusionDependencies = M.empty,

41 notifications = M.empty,

37 notifications = M.empty,

42 typeConstructorMapping = basicTypeConstructorMapping

38 typeConstructorMapping = basicTypeConstructorMapping

43 }

39 }

44−

45−--for building the Merkle hash

46−hashBytes :: DatabaseContext -> BL.ByteString

47−hashBytes ctx = BL.fromChunks [incDeps, rvs, nots, tConsMap] <> atomFs <> dbcFs

48− where

49− incDeps = serialise (inclusionDependencies ctx)

50− rvs = serialise (relationVariables ctx)

51− atomFs = HS.foldr (mappend . AF.hashBytes) mempty (atomFunctions ctx)

52− dbcFs = HS.foldr (mappend . DBCF.hashBytes) mempty (dbcFunctions ctx)

53− nots = serialise (notifications ctx)

54− tConsMap = serialise (typeConstructorMapping ctx)

src/lib/ProjectM36/DatabaseContextFunction.hs+1−17

@@ -1,9 +1,7 @@

1−{-# LANGUAGE CPP #-}

2module ProjectM36.DatabaseContextFunction where

1module ProjectM36.DatabaseContextFunction where

3--implements functions which operate as: [Atom] -> DatabaseContextExpr -> Either RelationalError DatabaseContextExpr

2--implements functions which operate as: [Atom] -> DatabaseContextExpr -> Either RelationalError DatabaseContextExpr

4import ProjectM36.Base

3import ProjectM36.Base

5import ProjectM36.Error

4import ProjectM36.Error

6−import ProjectM36.Serialise.Base ()

7import ProjectM36.Attribute as A

5import ProjectM36.Attribute as A

8import ProjectM36.Relation

6import ProjectM36.Relation

9import ProjectM36.AtomType

7import ProjectM36.AtomType

@@ -11,8 +9,6 @@ import qualified Data.HashSet as HS

11import qualified Data.Map as M

9import qualified Data.Map as M

12import ProjectM36.ScriptSession

10import ProjectM36.ScriptSession

13import qualified Data.Text as T

11import qualified Data.Text as T

14−import qualified Data.ByteString.Lazy as BL

15−import Codec.Winery

16

12

17emptyDatabaseContextFunction :: DatabaseContextFunctionName -> DatabaseContextFunction

13emptyDatabaseContextFunction :: DatabaseContextFunctionName -> DatabaseContextFunction

18emptyDatabaseContextFunction name = DatabaseContextFunction {

14emptyDatabaseContextFunction name = DatabaseContextFunction {

@@ -65,11 +61,7 @@ createScriptedDatabaseContextFunction :: DatabaseContextFunctionName -> [TypeCon

65createScriptedDatabaseContextFunction funcName argsIn retArg = AddDatabaseContextFunction funcName (argsIn ++ [databaseContextFunctionReturnType retArg])

61createScriptedDatabaseContextFunction funcName argsIn retArg = AddDatabaseContextFunction funcName (argsIn ++ [databaseContextFunctionReturnType retArg])

66

62

67loadDatabaseContextFunctions :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError [DatabaseContextFunction])

63loadDatabaseContextFunctions :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError [DatabaseContextFunction])

68−#ifdef PM36_HASKELL_SCRIPTING

69loadDatabaseContextFunctions = loadFunction

64loadDatabaseContextFunctions = loadFunction

70−#else

71−loadDatabaseContextFunctions _ _ _ = pure (Left LoadSymbolError)

72−#endif

73

65

74databaseContextFunctionsAsRelation :: DatabaseContextFunctions -> Either RelationalError Relation

66databaseContextFunctionsAsRelation :: DatabaseContextFunctions -> Either RelationalError Relation

75databaseContextFunctionsAsRelation dbcFuncs = mkRelationFromList attrs tups

67databaseContextFunctionsAsRelation dbcFuncs = mkRelationFromList attrs tups

@@ -80,12 +72,4 @@ databaseContextFunctionsAsRelation dbcFuncs = mkRelationFromList attrs tups

80 dbcFuncToTuple func = [TextAtom (dbcFuncName func),

72 dbcFuncToTuple func = [TextAtom (dbcFuncName func),

81 TextAtom (dbcTextType (dbcFuncType func))]

73 TextAtom (dbcTextType (dbcFuncType func))]

82 dbcTextType typ = T.intercalate " -> " (map prettyAtomType typ ++ ["DatabaseContext", "DatabaseContext"])

74 dbcTextType typ = T.intercalate " -> " (map prettyAtomType typ ++ ["DatabaseContext", "DatabaseContext"])

83−

75+

84−-- for merkle hash

85−hashBytes :: DatabaseContextFunction -> BL.ByteString

86−hashBytes func = BL.fromChunks [fname, ftype, fbody]

87− where

88− fname = serialise (dbcFuncName func)

89− ftype = serialise (dbcFuncType func)

90− fbody = case dbcFuncBody func of

91− DatabaseContextFunctionBody mBody _ -> serialise mBody

src/lib/ProjectM36/DatabaseContextFunctionError.hs+2−1

@@ -1,8 +1,9 @@

1{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

2module ProjectM36.DatabaseContextFunctionError where

3import GHC.Generics

4+import Data.Binary

4import Control.DeepSeq

5import Control.DeepSeq

5

6

6{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

7{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

7data DatabaseContextFunctionError = DatabaseContextFunctionUserError String

8data DatabaseContextFunctionError = DatabaseContextFunctionUserError String

8− deriving (Generic, Eq, Show, NFData)

9+ deriving (Generic, Eq, Show, Binary, NFData)

src/lib/ProjectM36/DisconnectedTransaction.hs+6−2

@@ -11,7 +11,11 @@ parentId :: DisconnectedTransaction -> TransactionId

11parentId (DisconnectedTransaction pid _ _) = pid

12

13isDirty :: DisconnectedTransaction -> Bool

14−isDirty (DisconnectedTransaction _ _ flag) = flag

14+isDirty (DisconnectedTransaction _ _ NoOperation) = False

15+isDirty _ = True

16+

17+diffExpr :: DisconnectedTransaction -> DatabaseContextExpr

18+diffExpr (DisconnectedTransaction _ _ expr) = expr

15

19

16freshTransaction :: TransactionId -> Schemas -> DisconnectedTransaction

20freshTransaction :: TransactionId -> Schemas -> DisconnectedTransaction

17−freshTransaction tid schemas' = DisconnectedTransaction tid schemas' False

21+freshTransaction tid schemas' = DisconnectedTransaction tid schemas' NoOperation

src/lib/ProjectM36/Error.hs+14−20

@@ -1,7 +1,6 @@

1{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

2module ProjectM36.Error where

3import ProjectM36.Base

4−import ProjectM36.MerkleHash

5import ProjectM36.DatabaseContextFunctionError

4import ProjectM36.DatabaseContextFunctionError

6import ProjectM36.AtomFunctionError

5import ProjectM36.AtomFunctionError

7import qualified Data.Set as S

6import qualified Data.Set as S

@@ -9,6 +8,7 @@ import Control.DeepSeq (NFData, rnf)

9import Control.DeepSeq.Generics (genericRnf)

8import Control.DeepSeq.Generics (genericRnf)

10import GHC.Generics (Generic)

9import GHC.Generics (Generic)

11import qualified Data.Text as T

10import qualified Data.Text as T

11+import Data.Binary

12import Data.Typeable

13import Control.Exception

14

@@ -81,7 +81,7 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)

81 | RelationValuedAttributesNotSupportedError [AttributeName]

82 | NotificationNameInUseError NotificationName

83 | NotificationNameNotInUseError NotificationName

84− | ImportError ImportError'

84+ | ImportError T.Text -- really? This should be broken out into some other error type- this has nothing to do with relational algebra

85 | ExportError T.Text

86 | UnhandledExceptionError String

87 | MergeTransactionError MergeError

@@ -100,17 +100,14 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)

100 | NonConcreteSchemaPlanError

101

102 | NoUncommittedContextInEvalError

103− | TupleExprsReferenceMultipleMarkersError

103+

104−

105− | MerkleHashValidationError TransactionId MerkleHash MerkleHash

106−

107 | MultipleErrors [RelationalError]

104 | MultipleErrors [RelationalError]

108− deriving (Show,Eq,Generic,Typeable, NFData)

105+ deriving (Show,Eq,Generic,Binary,Typeable, NFData)

109

106

110data PersistenceError = InvalidDirectoryError FilePath |

107data PersistenceError = InvalidDirectoryError FilePath |

111 MissingTransactionError TransactionId |

108 MissingTransactionError TransactionId |

112 WrongDatabaseFormatVersionError String String

109 WrongDatabaseFormatVersionError String String

113− deriving (Show, Eq, Generic, NFData)

110+ deriving (Show, Eq, Generic, Binary, NFData)

114

111

115--collapse list of errors into normal error- if there is just one, just return one

112--collapse list of errors into normal error- if there is just one, just return one

116someErrors :: [RelationalError] -> RelationalError

113someErrors :: [RelationalError] -> RelationalError

@@ -128,7 +125,7 @@ data MergeError = SelectedHeadMismatchMergeError |

128 StrategyViolatesComponentMergeError | --failed merge in inc deps, relvars, etc.

125 StrategyViolatesComponentMergeError | --failed merge in inc deps, relvars, etc.

129 StrategyViolatesRelationVariableMergeError |

126 StrategyViolatesRelationVariableMergeError |

130 StrategyViolatesTypeConstructorMergeError

127 StrategyViolatesTypeConstructorMergeError

131− deriving (Show, Eq, Generic, Typeable)

128+ deriving (Show, Eq, Generic, Binary, Typeable)

132

129

133instance NFData MergeError where rnf = genericRnf

130instance NFData MergeError where rnf = genericRnf

134

131

@@ -136,20 +133,17 @@ data ScriptCompilationError = TypeCheckCompilationError String String | --expect

136 SyntaxErrorCompilationError String |

133 SyntaxErrorCompilationError String |

137 ScriptCompilationDisabledError |

134 ScriptCompilationDisabledError |

138 OtherScriptCompilationError String

135 OtherScriptCompilationError String

139− deriving (Show, Eq, Generic, Typeable, NFData)

136+ deriving (Show, Eq, Generic, Binary, Typeable, NFData)

140

137

141instance Exception ScriptCompilationError

138instance Exception ScriptCompilationError

142

139

143data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |

140data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |

144 RelVarInReferencedMoreThanOnce RelVarName |

141 RelVarInReferencedMoreThanOnce RelVarName |

145 RelVarOutReferencedMoreThanOnce RelVarName

142 RelVarOutReferencedMoreThanOnce RelVarName

146− deriving (Show, Eq, Generic, Typeable, NFData)

143+ deriving (Show, Eq, Generic, Binary, Typeable, NFData)

147−

144+

148−

145+

149−data ImportError' = InvalidSHA256Error T.Text

146+-- errors returned from the distributed-process call handlers

150− | SHA256MismatchError T.Text T.Text

147+data ServerError = RequestTimeoutError |

151− | InvalidFileURIError T.Text

148+ ProcessDiedError String

152− | ImportFileDecodeError T.Text

153− | ImportFileError T.Text

154− | ImportDownloadError T.Text

155− deriving (Show, Eq, Generic, Typeable, NFData)

149+ deriving (Generic, Binary, Eq)

src/lib/ProjectM36/FileLock.hs+1−1

@@ -1,4 +1,4 @@

1−{-# LANGUAGE CPP #-}

1+{-# LANGUAGE CPP, NamedFieldPuns #-}

2--cross-platform file locking utilizing POSIX file locking on Unix/Linux and Windows file locking

3--hackage's System.FileLock doesn't support POSIX advisory locks nor locking file based on file descriptors, hence this needless rewrite

4module ProjectM36.FileLock where

src/lib/ProjectM36/GraphRefRelationalExpr.hs+25−24

@@ -1,37 +1,41 @@

1module ProjectM36.GraphRefRelationalExpr where

2--evaluate relational expressions across the entire transaction graph to support cross-transaction referencing

3import ProjectM36.Base

4+import ProjectM36.Error

4import qualified Data.Set as S

5import qualified Data.Set as S

5

6

6−--import Debug.Trace

7+-- core evaluation function- all other relational expr forms compile to GraphRefRelationalExpr

8+eval :: GraphRefRelationalExpr -> TransactionGraph -> Either RelationalError Relation

9+eval = undefined

10+{-eval (MakeRelationFromExprs mAttrExprs tupleExprs) graph = do

11+ mAttrs <- case mAttrExprs of

12+ Just _ ->

13+ Just . A.attributesFromList <$> mapM (evalAttrExpr tConss) (fromMaybe [] mAttrExprs)

14+ Nothing -> pure Nothing

15+ tuples <- mapM (evalTupleExpr mAttrs) tupleExprs

16+ let attrs = fromMaybe firstTupleAttrs mAttrs

17+ firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)

18+ mkRelation attrs (RelationTupleSet tuples)

19+

20+

21+-}

7

22

8data SingularTransactionRef = SingularTransactionRef GraphRefTransactionMarker |

23data SingularTransactionRef = SingularTransactionRef GraphRefTransactionMarker |

9 MultipleTransactionsRef |

24 MultipleTransactionsRef |

10 NoTransactionsRef

25 NoTransactionsRef

11 deriving (Eq, Show)

26 deriving (Eq, Show)

12−

13−instance Semigroup SingularTransactionRef where

14− NoTransactionsRef <> x = x

15− MultipleTransactionsRef <> _ = MultipleTransactionsRef

16− SingularTransactionRef tidA <> s@(SingularTransactionRef tidB) =

17− if tidA == tidB then

18− s

19− else

20− MultipleTransactionsRef

21− s@SingularTransactionRef{} <> NoTransactionsRef = s

22− _ <> MultipleTransactionsRef = MultipleTransactionsRef

23−

24−instance Monoid SingularTransactionRef where

25− mempty = NoTransactionsRef

26

27

27-- | return `Just transid` if this GraphRefRelationalExpr refers to just one transaction in the graph. This is useful for determining if certain optimizations can apply.

28-- | return `Just transid` if this GraphRefRelationalExpr refers to just one transaction in the graph. This is useful for determining if certain optimizations can apply.

28−singularTransaction :: Foldable t => t GraphRefTransactionMarker -> SingularTransactionRef

29+singularTransaction :: GraphRefRelationalExpr -> SingularTransactionRef

29−singularTransaction expr

30+singularTransaction expr =

31+ if S.null transSet then

30− | S.null transSet = NoTransactionsRef

32+ NoTransactionsRef

33+ else if S.size transSet == 1 then

31− | S.size transSet == 1 = SingularTransactionRef (head (S.toList transSet))

34+ SingularTransactionRef (head (S.toList transSet))

35+ else

32− | otherwise = MultipleTransactionsRef

36+ MultipleTransactionsRef

33 where

37 where

34− transSet = foldr S.insert S.empty expr

38+ transSet = foldr (\transId acc -> S.insert transId acc) S.empty expr

35

39

36-- | Return True if two 'GraphRefRelationalExpr's both refer exclusively to the same transaction (or none at all).

40-- | Return True if two 'GraphRefRelationalExpr's both refer exclusively to the same transaction (or none at all).

37inSameTransaction :: GraphRefRelationalExpr -> GraphRefRelationalExpr -> Maybe GraphRefTransactionMarker

41inSameTransaction :: GraphRefRelationalExpr -> GraphRefRelationalExpr -> Maybe GraphRefTransactionMarker

@@ -40,6 +44,3 @@ inSameTransaction exprA exprB = case (stA, stB) of

40 _ -> Nothing

44 _ -> Nothing

41 where stA = singularTransaction exprA

45 where stA = singularTransaction exprA

42 stB = singularTransaction exprB

46 stB = singularTransaction exprB

43−

44−singularTransactions :: (Foldable f, Foldable t) => f (t GraphRefTransactionMarker) -> SingularTransactionRef

45−singularTransactions = foldMap singularTransaction

src/lib/ProjectM36/InclusionDependency.hs+6−5

@@ -4,16 +4,17 @@ import ProjectM36.Attribute

4import ProjectM36.Error

5import ProjectM36.Relation

6import qualified Data.Map as M

7+import qualified Data.Text as T

7

8

8inclusionDependenciesAsRelation :: InclusionDependencies -> Either RelationalError Relation

9inclusionDependenciesAsRelation :: InclusionDependencies -> Either RelationalError Relation

9inclusionDependenciesAsRelation incDeps =

10inclusionDependenciesAsRelation incDeps =

10 mkRelationFromList attrs (map incDepAsAtoms (M.toList incDeps))

11 mkRelationFromList attrs (map incDepAsAtoms (M.toList incDeps))

11 where

12 where

12 attrs = attributesFromList [Attribute "name" TextAtomType,

13 attrs = attributesFromList [Attribute "name" TextAtomType,

13− Attribute "sub" RelationalExprAtomType,

14+ Attribute "sub" TextAtomType,

14− Attribute "super" RelationalExprAtomType

15+ Attribute "super" TextAtomType

15 ]

16 ]

16 incDepAsAtoms (name, InclusionDependency exprA exprB) = [TextAtom name,

17 incDepAsAtoms (name, InclusionDependency exprA exprB) = [TextAtom name,

17− RelationalExprAtom exprA,

18+ TextAtom (T.pack (show exprA)),

18− RelationalExprAtom exprB]

19+ TextAtom (T.pack (show exprB))]

19−

20+

src/lib/ProjectM36/IsomorphicSchema.hs+6−3

@@ -1,4 +1,4 @@

1−{-# LANGUAGE DeriveGeneric, LambdaCase, DerivingVia #-}

1+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, LambdaCase #-}

2module ProjectM36.IsomorphicSchema where

3import ProjectM36.Base

4import ProjectM36.Error

@@ -9,12 +9,14 @@ import ProjectM36.RelationalExpression

9import qualified ProjectM36.AttributeNames as AN

10import Control.Monad

11import GHC.Generics

12+import Data.Binary

12import qualified Data.Map as M

13import qualified Data.Map as M

13import qualified Data.Set as S

14import qualified Data.Set as S

14import qualified Data.List as L

15import qualified Data.List as L

15−#if __GLASGOW_HASKELL__ < 804

16+#if __GLASGOW_HASKELL__ <= 802

16import Data.Monoid

17import Data.Monoid

17#endif

18#endif

19+

18-- isomorphic schemas offer bi-directional functors between two schemas

20-- isomorphic schemas offer bi-directional functors between two schemas

19

21

20--TODO: note that renaming a relvar should alter any stored isomorphisms as well

22--TODO: note that renaming a relvar should alter any stored isomorphisms as well

@@ -27,7 +29,8 @@ import Data.Monoid

27

29

28data SchemaExpr = AddSubschema SchemaName SchemaIsomorphs |

30data SchemaExpr = AddSubschema SchemaName SchemaIsomorphs |

29 RemoveSubschema SchemaName

31 RemoveSubschema SchemaName

30− deriving (Generic, Show)

32+ deriving (Generic, Binary, Show)

33+

31

34

32isomorphs :: Schema -> SchemaIsomorphs

35isomorphs :: Schema -> SchemaIsomorphs

33isomorphs (Schema i) = i

36isomorphs (Schema i) = i

src/lib/ProjectM36/Key.hs+1−1

@@ -2,7 +2,7 @@ module ProjectM36.Key where

2import ProjectM36.Base

3import ProjectM36.Relation

4import qualified Data.Set as S

5−#if __GLASGOW_HASKELL__ < 804

5+#if __GLASGOW_HASKELL__ <= 802

6import Data.Monoid

7#endif

8

src/lib/ProjectM36/MerkleHash.hsdeleted−9

@@ -1,9 +0,0 @@

1−{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveGeneric, DerivingVia #-}

2−module ProjectM36.MerkleHash where

3−import Data.ByteString (ByteString)

4−import GHC.Generics

5−import Control.DeepSeq (NFData)

6−

7−newtype MerkleHash = MerkleHash { _unMerkleHash :: ByteString }

8− deriving (Show, Eq, Generic, Monoid, Semigroup, NFData)

9−

src/lib/ProjectM36/NormalizeExpr.hs+2−7

@@ -21,7 +21,7 @@ processRelationalExpr (MakeRelationFromExprs mAttrs tupleExprs) = do

21 mAttrs' <- case mAttrs of

22 Nothing -> pure Nothing

23 Just mAttrs'' -> Just <$> mapM processAttributeExpr mAttrs''

24− MakeRelationFromExprs mAttrs' <$> processTupleExprs tupleExprs

24+ MakeRelationFromExprs mAttrs' <$> mapM processTupleExpr tupleExprs

25processRelationalExpr (MakeStaticRelation attrs tupSet) = pure (MakeStaticRelation attrs tupSet)

26processRelationalExpr (ExistingRelation rel) = pure (ExistingRelation rel)

27--requires current trans id and graph

@@ -115,13 +115,8 @@ processAtomExpr (FunctionAtomExpr fName atomExprs ()) =

115processAtomExpr (RelationAtomExpr expr) = RelationAtomExpr <$> processRelationalExpr expr

116processAtomExpr (ConstructedAtomExpr dConsName atomExprs ()) = ConstructedAtomExpr dConsName <$> mapM processAtomExpr atomExprs <*> askMarker

117

118−processTupleExprs :: TupleExprs -> ProcessExprM GraphRefTupleExprs

119−processTupleExprs (TupleExprs () tupleExprs) = do

120− marker <- askMarker

121− TupleExprs marker <$> mapM processTupleExpr tupleExprs

122−

123processTupleExpr :: TupleExpr -> ProcessExprM GraphRefTupleExpr

118processTupleExpr :: TupleExpr -> ProcessExprM GraphRefTupleExpr

124−processTupleExpr (TupleExpr tMap) =

119+processTupleExpr (TupleExpr tMap) =

125 TupleExpr . M.fromList <$> mapM (\(k,v) -> (,) k <$> processAtomExpr v) (M.toList tMap)

120 TupleExpr . M.fromList <$> mapM (\(k,v) -> (,) k <$> processAtomExpr v) (M.toList tMap)

126

121

127--convert AttributeExpr to GraphRefAttributeExpr

122--convert AttributeExpr to GraphRefAttributeExpr

src/lib/ProjectM36/Persist.hs+4−3

@@ -36,6 +36,7 @@ import Foreign.C

36#endif

37

38import System.IO (withFile, IOMode(WriteMode), Handle)

39+import qualified Data.ByteString.Lazy as BS

39import qualified Data.ByteString as BS'

40import qualified Data.ByteString as BS'

40import qualified Data.Text.Encoding as TE

41import qualified Data.Text.Encoding as TE

41

42

@@ -99,10 +100,10 @@ syncDirectory :: DiskSync -> FilePath -> IO ()

99syncDirectory FsyncDiskSync path = directoryFsync path

100syncDirectory FsyncDiskSync path = directoryFsync path

100syncDirectory NoDiskSync _ = pure ()

101syncDirectory NoDiskSync _ = pure ()

101

102

102−writeBSFileSync :: DiskSync -> FilePath -> BS'.ByteString -> IO ()

103+writeBSFileSync :: DiskSync -> FilePath -> BS.ByteString -> IO ()

103writeBSFileSync sync path bstring =

104writeBSFileSync sync path bstring =

104 withFile path WriteMode $ \handle -> do

105 withFile path WriteMode $ \handle -> do

105− BS'.hPut handle bstring

106+ BS.hPut handle bstring

106 syncHandle sync handle

107 syncHandle sync handle

107

108

108directoryFsync :: FilePath -> IO ()

109directoryFsync :: FilePath -> IO ()

@@ -130,4 +131,4 @@ fdCount = do

130 fds <- getDirectoryContents FDDIR

131 fds <- getDirectoryContents FDDIR

131 pure ((length fds) - 2)

132 pure ((length fds) - 2)

132--not supported on non-linux

133--not supported on non-linux

133−#endif

134+#endif

src/lib/ProjectM36/Relation.hs+22−17

@@ -9,6 +9,7 @@ import ProjectM36.Tuple

9import qualified ProjectM36.Attribute as A

10import ProjectM36.TupleSet

11import ProjectM36.Error

12+import ProjectM36.MiscUtils

12--import qualified Control.Parallel.Strategies as P

13--import qualified Control.Parallel.Strategies as P

13import qualified ProjectM36.TypeConstructorDef as TCD

14import qualified ProjectM36.TypeConstructorDef as TCD

14import qualified ProjectM36.DataConstructorDef as DCD

15import qualified ProjectM36.DataConstructorDef as DCD

@@ -16,6 +17,7 @@ import qualified Data.Text as T

16import Data.Either (isRight)

17import Data.Either (isRight)

17import System.Random.Shuffle

18import System.Random.Shuffle

18import Control.Monad.Random

19import Control.Monad.Random

20+import Data.List (sort)

19

21

20attributes :: Relation -> Attributes

22attributes :: Relation -> Attributes

21attributes (Relation attrs _ ) = attrs

23attributes (Relation attrs _ ) = attrs

@@ -33,7 +35,7 @@ atomTypeForName :: AttributeName -> Relation -> Either RelationalError AtomType

33atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrName attrs

35atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrName attrs

34

36

35mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation

37mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation

36−mkRelationFromList attrs atomMatrix = do

38+mkRelationFromList attrs atomMatrix =

37 Relation attrs <$> mkTupleSetFromList attrs atomMatrix

39 Relation attrs <$> mkTupleSetFromList attrs atomMatrix

38

40

39emptyRelationWithAttrs :: Attributes -> Relation

41emptyRelationWithAttrs :: Attributes -> Relation

@@ -41,6 +43,11 @@ emptyRelationWithAttrs attrs = Relation attrs emptyTupleSet

41

43

42mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation

44mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation

43mkRelation attrs tupleSet =

45mkRelation attrs tupleSet =

46+ --check that all attributes are unique- this cannot be done when creating attributes because the check can become expensive

47+ let duplicateAttrNames = dupes (sort (map A.attributeName (V.toList attrs))) in

48+ if not (null duplicateAttrNames) then

49+ Left (DuplicateAttributeNamesError (S.fromList duplicateAttrNames))

50+ else

44 --check that all tuples have the same keys

51 --check that all tuples have the same keys

45 --check that all tuples have keys (1-N) where N is the attribute count

52 --check that all tuples have keys (1-N) where N is the attribute count

46 case verifyTupleSet attrs tupleSet of

53 case verifyTupleSet attrs tupleSet of

@@ -86,12 +93,13 @@ union (Relation attrs1 tupSet1) (Relation attrs2 tupSet2) =

86 else

93 else

87 Right $ Relation attrs1 newtuples

94 Right $ Relation attrs1 newtuples

88 where

95 where

89− newtuples = tupleSetUnion attrs1 tupSet1 tupSet2

96+ newtuples = RelationTupleSet $ HS.toList . HS.fromList $ asList tupSet1 ++ map (reorderTuple attrs1) (asList tupSet2)

90−

97+

91project :: S.Set AttributeName -> Relation -> Either RelationalError Relation

98project :: S.Set AttributeName -> Relation -> Either RelationalError Relation

92project attrNames rel@(Relation _ tupSet) = do

99project attrNames rel@(Relation _ tupSet) = do

93 newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)

100 newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)

101+ let newAttrNameSet = A.attributeNameSet newAttrs

94− newTupleList <- mapM (tupleProject newAttrs) (asList tupSet)

102+ newTupleList = map (tupleProject newAttrNameSet) (asList tupSet)

95 pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))

103 pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))

96

104

97rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation

105rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation

@@ -146,7 +154,7 @@ group groupAttrNames newAttrName rel = do

146 groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)

154 groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)

147 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)

155 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)

148 matchingRelTuple tupIn = case imageRelationFor tupIn rel of

156 matchingRelTuple tupIn = case imageRelationFor tupIn rel of

149− Right rel2 -> RelationTuple (A.singleton groupAttr) (V.singleton (RelationAtom rel2))

157+ Right rel2 -> RelationTuple (V.singleton groupAttr) (V.singleton (RelationAtom rel2))

150 Left _ -> undefined

158 Left _ -> undefined

151 mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))

159 mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))

152 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes

160 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes

@@ -160,8 +168,7 @@ restrictEq :: RelationTuple -> Relation -> Either RelationalError Relation

160restrictEq tuple = restrict rfilter

168restrictEq tuple = restrict rfilter

161 where

169 where

162 rfilter :: RelationTuple -> Either RelationalError Bool

170 rfilter :: RelationTuple -> Either RelationalError Bool

163− rfilter tupleIn = do

164− pure (tupleIntersection tuple tupleIn == tuple)

171+ rfilter tupleIn = pure (tupleIntersection tuple tupleIn == tuple)

165

172

166-- unwrap relation-valued attribute

173-- unwrap relation-valued attribute

167-- return error if relval attrs and nongroup attrs overlap

174-- return error if relval attrs and nongroup attrs overlap

@@ -183,13 +190,13 @@ ungroup relvalAttrName rel = case attributesForRelval relvalAttrName rel of

183tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation

190tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation

184tupleUngroup relvalAttrName newAttrs tuple = do

191tupleUngroup relvalAttrName newAttrs tuple = do

185 relvalRelation <- relationForAttributeName relvalAttrName tuple

192 relvalRelation <- relationForAttributeName relvalAttrName tuple

186− let nonGroupAttrs = A.intersection newAttrs (tupleAttributes tuple)

187− nonGroupTupleProjection <- tupleProject nonGroupAttrs tuple

188− let folder tupleIn acc = case acc of

189− Left err -> Left err

190− Right accRel ->

191− union accRel $ Relation newAttrs (RelationTupleSet [tupleExtend nonGroupTupleProjection tupleIn])

192 relFold folder (Right $ Relation newAttrs emptyTupleSet) relvalRelation

193 relFold folder (Right $ Relation newAttrs emptyTupleSet) relvalRelation

194+ where

195+ nonGroupTupleProjection = tupleProject nonGroupAttrNames tuple

196+ nonGroupAttrNames = A.attributeNameSet newAttrs

197+ folder tupleIn acc = case acc of

198+ Left err -> Left err

199+ Right accRel -> union accRel $ Relation newAttrs (RelationTupleSet [tupleExtend nonGroupTupleProjection tupleIn])

193

200

194attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes

201attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes

195attributesForRelval relvalAttrName (Relation attrs _) = do

202attributesForRelval relvalAttrName (Relation attrs _) = do

@@ -244,8 +251,7 @@ relMap mapper (Relation attrs tupleSet) =

244

251

245relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation

252relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation

246relMogrify mapper newAttributes (Relation _ tupSet) = do

253relMogrify mapper newAttributes (Relation _ tupSet) = do

247− newTuples <- mapM (fmap (reorderTuple newAttributes) . mapper) (asList tupSet)

254+ newTuples <- mapM mapper (asList tupSet)

248−

249 mkRelationFromTuples newAttributes newTuples

255 mkRelationFromTuples newAttributes newTuples

250

256

251relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a

257relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a

@@ -291,8 +297,7 @@ typesAsRelation types = mkRelationFromTuples attrs tuples

291 dConsType = RelationAtomType subAttrs

297 dConsType = RelationAtomType subAttrs

292 tuples = map mkTypeConsDescription types

298 tuples = map mkTypeConsDescription types

293

299

294− mkTypeConsDescription (tCons, dConsList) =

295− RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])

300+ mkTypeConsDescription (tCons, dConsList) = RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])

296

301

297 mkDataConsRelation dConsList = case mkRelationFromTuples subAttrs $ map (\dCons -> RelationTuple subAttrs (V.singleton $ TextAtom $ T.intercalate " " (DCD.name dCons:map (T.pack . show) (DCD.fields dCons)))) dConsList of

302 mkDataConsRelation dConsList = case mkRelationFromTuples subAttrs $ map (\dCons -> RelationTuple subAttrs (V.singleton $ TextAtom $ T.intercalate " " (DCD.name dCons:map (T.pack . show) (DCD.fields dCons)))) dConsList of

298 Left err -> error ("mkRelationFromTuples pooped " ++ show err)

303 Left err -> error ("mkRelationFromTuples pooped " ++ show err)

src/lib/ProjectM36/Relation/Parse/CSV.hs+3−7

@@ -38,7 +38,8 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode

38 let strHeader = V.map decodeUtf8 headerRaw

39 strMapRecords = V.map convertMap vecMapsRaw

40 convertMap hmap = HM.fromList $ L.map (decodeUtf8 *** (T.unpack . decodeUtf8)) (HM.toList hmap)

41− attrNameSet = A.attributeNameSet attrs

41+ attrNames = V.map A.attributeName attrs

42+ attrNameSet = S.fromList (V.toList attrNames)

42 headerSet = S.fromList (V.toList strHeader)

43 headerSet = S.fromList (V.toList strHeader)

43 parseAtom attrName aType textIn = case APT.parseOnly (parseCSVAtomP attrName tConsMap aType <* APT.endOfInput) textIn of

44 parseAtom attrName aType textIn = case APT.parseOnly (parseCSVAtomP attrName tConsMap aType <* APT.endOfInput) textIn of

44 Left err -> Left (ParseError (T.pack err))

45 Left err -> Left (ParseError (T.pack err))

@@ -46,7 +47,7 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode

46 makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]

47 makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]

47 makeTupleList tupMap = V.toList $ V.map (\attr ->

48 makeTupleList tupMap = V.toList $ V.map (\attr ->

48 either (Left . AttributeMappingError) Right $

49 either (Left . AttributeMappingError) Right $

49− parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) (attributesVec attrs)

50+ parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) attrs

50 if attrNameSet == headerSet then do

51 if attrNameSet == headerSet then do

51 tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)

52 tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)

52 case mkRelationFromList attrs tupleList of

53 case mkRelationFromList attrs tupleList of

@@ -82,11 +83,6 @@ parseCSVAtomP _ _ BoolAtomType = do

82 case readMaybe bString of

83 case readMaybe bString of

83 Nothing -> fail ("invalid BoolAtom string: " ++ bString)

84 Nothing -> fail ("invalid BoolAtom string: " ++ bString)

84 Just b -> pure (Right (BoolAtom b))

85 Just b -> pure (Right (BoolAtom b))

85−parseCSVAtomP _ _ RelationalExprAtomType = do

86− reString <- T.unpack <$> takeToEndOfData

87− case readMaybe reString of

88− Nothing -> fail ("invalid RelationalExprAtom string: " ++ reString)

89− Just b -> pure (Right (RelationalExprAtom b))

90parseCSVAtomP attrName tConsMap typ@(ConstructedAtomType _ tvmap)

86parseCSVAtomP attrName tConsMap typ@(ConstructedAtomType _ tvmap)

91 | isIntervalAtomType typ = do

87 | isIntervalAtomType typ = do

92 begin <- (APT.char '[' >> pure False) <|> (APT.char '(' >> pure True)

88 begin <- (APT.char '[' >> pure False) <|> (APT.char '(' >> pure True)

src/lib/ProjectM36/Relation/Show/CSV.hs+5−5

@@ -1,7 +1,7 @@

1{-# OPTIONS_GHC -fno-warn-orphans #-}

2module ProjectM36.Relation.Show.CSV where

3import ProjectM36.Base

4−import ProjectM36.Attribute as A

4+import ProjectM36.Attribute

5import Data.Csv

6import ProjectM36.Tuple

7import qualified Data.ByteString.Lazy as BS

@@ -17,13 +17,13 @@ relationAsCSV (Relation attrs tupleSet)

17 | relValAttrs /= [] =

18 Left $ RelationValuedAttributesNotSupportedError (map attributeName relValAttrs)

19 --check that there is at least one attribute

20− | A.null attrs =

20+ | V.null attrs =

21 Left $ TupleAttributeCountMismatchError 0

22 | otherwise =

23 Right $ encodeByName bsAttrNames $ map RecordRelationTuple (asList tupleSet)

24 where

25− relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) (attributesVec attrs)

25+ relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) attrs

26− bsAttrNames = V.map (TE.encodeUtf8 . attributeName) (attributesVec attrs)

26+ bsAttrNames = V.map (TE.encodeUtf8 . attributeName) attrs

27

28{-

29instance ToRecord RelationTuple where

@@ -36,7 +36,7 @@ instance ToNamedRecord RecordRelationTuple where

36 toNamedRecord rTuple = namedRecord $ map (\(k,v) -> TE.encodeUtf8 k .= RecordAtom v) (tupleAssocs $ unTuple rTuple)

37

38instance DefaultOrdered RecordRelationTuple where

39− headerOrder (RecordRelationTuple tuple) = V.map (TE.encodeUtf8 . attributeName) (attributesVec (tupleAttributes tuple))

39+ headerOrder (RecordRelationTuple tuple) = V.map (TE.encodeUtf8 . attributeName) (tupleAttributes tuple)

40

41newtype RecordAtom = RecordAtom {unAtom :: Atom}

42

src/lib/ProjectM36/Relation/Show/HTML.hs+3−4

@@ -3,18 +3,18 @@ import ProjectM36.Base

3import ProjectM36.Relation

4import ProjectM36.Tuple

5import ProjectM36.Atom

6−import ProjectM36.Attribute as A

7import ProjectM36.AtomType

6import ProjectM36.AtomType

8import qualified Data.List as L

7import qualified Data.List as L

9import Data.Text (Text, pack)

8import Data.Text (Text, pack)

10import qualified Data.Text as T

9import qualified Data.Text as T

11import qualified Data.Text.IO as TIO

10import qualified Data.Text.IO as TIO

11+import qualified Data.Vector as V

12−#if __GLASGOW_HASKELL__ < 804

12+#if __GLASGOW_HASKELL__ <= 802

13import Data.Monoid

14#endif

15

16attributesAsHTML :: Attributes -> Text

17−attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"

17+attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"

18 where

19 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> "</th>"

20

@@ -53,7 +53,6 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>

53 where

54 tupleFrag tup = "<td>" <> atomAsHTML (snd tup) <> "</td>"

55 atomAsHTML (RelationAtom rel) = relationAsHTML rel

56− atomAsHTML (TextAtom t) = """ <> t <> """

57 atomAsHTML atom = atomToText atom

56 atomAsHTML atom = atomToText atom

58

57

59tupleSetAsHTML :: RelationTupleSet -> Text

58tupleSetAsHTML :: RelationTupleSet -> Text

src/lib/ProjectM36/Relation/Show/Term.hs+1−4

@@ -9,9 +9,7 @@ import ProjectM36.Attribute hiding (null)

9import qualified Data.List as L

10import qualified Data.Text as T

11import Control.Arrow hiding (left)

12−import Data.ByteString.Base64 as B64

13−import qualified Data.Text.Encoding as TE

14−#if __GLASGOW_HASKELL__ < 804

12+#if __GLASGOW_HASKELL__ <= 802

15import Data.Monoid

13import Data.Monoid

16#endif

14#endif

17import ProjectM36.WCWidth --guess the width that the character will appear as in the terminal

15import ProjectM36.WCWidth --guess the width that the character will appear as in the terminal

@@ -99,7 +97,6 @@ showAtom :: Int -> Atom -> StringType

99showAtom _ (RelationAtom rel) = renderTable $ relationAsTable rel

97showAtom _ (RelationAtom rel) = renderTable $ relationAsTable rel

100showAtom level (ConstructedAtom dConsName _ atoms) = showParens (level >= 1 && not (null atoms)) $ T.concat (L.intersperse " " (dConsName : map (showAtom 1) atoms))

98showAtom level (ConstructedAtom dConsName _ atoms) = showParens (level >= 1 && not (null atoms)) $ T.concat (L.intersperse " " (dConsName : map (showAtom 1) atoms))

101showAtom _ (TextAtom t) = "\"" <> t <> "\""

99showAtom _ (TextAtom t) = "\"" <> t <> "\""

102−showAtom _ (ByteStringAtom bs) = TE.decodeUtf8 (B64.encode bs)

103showAtom _ atom = atomToText atom

100showAtom _ atom = atomToText atom

104

101

105renderTable :: Table -> StringType

102renderTable :: Table -> StringType

src/lib/ProjectM36/RelationalExpression.hs+377−331

@@ -1,7 +1,4 @@

1{-# LANGUAGE ScopedTypeVariables #-}

2−{-# LANGUAGE FlexibleInstances #-}

3−{-# LANGUAGE FlexibleContexts #-}

4−{-# LANGUAGE OverloadedStrings #-}

5module ProjectM36.RelationalExpression where

2module ProjectM36.RelationalExpression where

6import ProjectM36.Relation

3import ProjectM36.Relation

7import ProjectM36.Tuple

4import ProjectM36.Tuple

@@ -16,38 +13,32 @@ import ProjectM36.DataTypes.Primitive

16import ProjectM36.AtomFunction

13import ProjectM36.AtomFunction

17import ProjectM36.DatabaseContextFunction

14import ProjectM36.DatabaseContextFunction

18import ProjectM36.Arbitrary

15import ProjectM36.Arbitrary

19−import ProjectM36.GraphRefRelationalExpr

20import ProjectM36.Transaction

16import ProjectM36.Transaction

21import qualified ProjectM36.Attribute as A

17import qualified ProjectM36.Attribute as A

22import qualified Data.Map as M

18import qualified Data.Map as M

23import qualified Data.HashSet as HS

19import qualified Data.HashSet as HS

24import qualified Data.Set as S

20import qualified Data.Set as S

25−import Control.Monad.State hiding (join)

21+import Control.Monad.RWS.Strict as RWS hiding (join)

26−import Data.Bifunctor (second)

22+import Control.Monad.Trans.Class (lift)

23+import Control.Exception

27import Data.Maybe

24import Data.Maybe

28import Data.Either

25import Data.Either

29import Data.Char (isUpper)

26import Data.Char (isUpper)

30−import Data.Time

31−import qualified Data.List.NonEmpty as NE

32−import Data.Functor.Identity

33import qualified Data.Text as T

27import qualified Data.Text as T

34import qualified Data.Vector as V

28import qualified Data.Vector as V

35import qualified ProjectM36.TypeConstructorDef as TCD

29import qualified ProjectM36.TypeConstructorDef as TCD

36−import qualified Control.Monad.RWS.Strict as RWS

37−import Control.Monad.RWS.Strict (RWST, execRWST, runRWST)

38import Control.Monad.Except hiding (join)

30import Control.Monad.Except hiding (join)

39import Control.Monad.Trans.Except (except)

31import Control.Monad.Trans.Except (except)

40import Control.Monad.Reader as R hiding (join)

32import Control.Monad.Reader as R hiding (join)

41import ProjectM36.NormalizeExpr

33import ProjectM36.NormalizeExpr

42import ProjectM36.WithNameExpr

34import ProjectM36.WithNameExpr

43import Test.QuickCheck

35import Test.QuickCheck

44−import qualified Data.Functor.Foldable as Fold

36+import GHC

45−import Control.Applicative

46−#ifdef PM36_HASKELL_SCRIPTING

47−import GHC hiding (getContext)

48−import Control.Exception

49import GHC.Paths

37import GHC.Paths

50−#endif

38+import Data.Time.Clock

39+import Data.Time.Calendar

40+import qualified Data.List.NonEmpty as NE

41+import Data.Functor.Identity

51

42

52data DatabaseContextExprDetails = CountUpdatedTuples

43data DatabaseContextExprDetails = CountUpdatedTuples

53

44

@@ -94,10 +85,10 @@ runRelationalExprM :: RelationalExprEnv -> RelationalExprM a -> Either Relationa

94runRelationalExprM env m = runIdentity (runExceptT (runReaderT m env))

85runRelationalExprM env m = runIdentity (runExceptT (runReaderT m env))

95

86

96reGraph :: RelationalExprM TransactionGraph

87reGraph :: RelationalExprM TransactionGraph

97−reGraph = asks re_graph

88+reGraph = re_graph <$> R.ask

98

89

99reContext :: RelationalExprM DatabaseContext

90reContext :: RelationalExprM DatabaseContext

100−reContext = asks re_context

91+reContext = re_context <$> R.ask

101

92

102mkRelationalExprEnv :: DatabaseContext -> TransactionGraph -> RelationalExprEnv

93mkRelationalExprEnv :: DatabaseContext -> TransactionGraph -> RelationalExprEnv

103mkRelationalExprEnv ctx graph =

94mkRelationalExprEnv ctx graph =

@@ -110,13 +101,13 @@ askEnv :: GraphRefRelationalExprM GraphRefRelationalExprEnv

110askEnv = R.ask

101askEnv = R.ask

111

102

112mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

103mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

113−mergeTuplesIntoGraphRefRelationalExprEnv tupIn env =

104+mergeTuplesIntoGraphRefRelationalExprEnv tupIn e =

114− env { gre_extra = new_elems }

105+ e{ gre_extra = new_elems }

115 where

106 where

116 new_elems = Just (Left newTuple)

107 new_elems = Just (Left newTuple)

117− mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple env))

108+ mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple e))

118 newTuple = mkRelationTupleFromMap mergedTupMap

109 newTuple = mkRelationTupleFromMap mergedTupMap

119−

110+

120mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

111mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

121mergeAttributesIntoGraphRefRelationalExprEnv attrsIn e = e { gre_extra = newattrs }

112mergeAttributesIntoGraphRefRelationalExprEnv attrsIn e = e { gre_extra = newattrs }

122 where

113 where

@@ -142,12 +133,12 @@ data DatabaseContextEvalEnv = DatabaseContextEvalEnv

142 }

133 }

143

134

144mkDatabaseContextEvalEnv :: TransactionId -> TransactionGraph -> DatabaseContextEvalEnv

135mkDatabaseContextEvalEnv :: TransactionId -> TransactionGraph -> DatabaseContextEvalEnv

145−mkDatabaseContextEvalEnv = DatabaseContextEvalEnv

136+mkDatabaseContextEvalEnv tid graph = DatabaseContextEvalEnv tid graph

146

137

147type DatabaseContextEvalMonad a = RWST DatabaseContextEvalEnv () DatabaseContextEvalState (ExceptT RelationalError Identity) a

138type DatabaseContextEvalMonad a = RWST DatabaseContextEvalEnv () DatabaseContextEvalState (ExceptT RelationalError Identity) a

148

139

149runDatabaseContextEvalMonad :: DatabaseContext -> DatabaseContextEvalEnv -> DatabaseContextEvalMonad () -> Either RelationalError DatabaseContextEvalState

140runDatabaseContextEvalMonad :: DatabaseContext -> DatabaseContextEvalEnv -> DatabaseContextEvalMonad () -> Either RelationalError DatabaseContextEvalState

150−runDatabaseContextEvalMonad ctx env m = runIdentity (runExceptT (fst <$> execRWST m env freshEnv))

141+runDatabaseContextEvalMonad ctx env m = runIdentity (runExceptT (fst <$> (execRWST m env freshEnv)))

151 where

142 where

152 freshEnv = mkDatabaseContextEvalState ctx

143 freshEnv = mkDatabaseContextEvalState ctx

153

144

@@ -163,7 +154,7 @@ dbcRelationalExprEnv =

163 mkRelationalExprEnv <$> getStateContext <*> dbcGraph

154 mkRelationalExprEnv <$> getStateContext <*> dbcGraph

164

155

165getStateContext :: DatabaseContextEvalMonad DatabaseContext

156getStateContext :: DatabaseContextEvalMonad DatabaseContext

166−getStateContext = gets dbc_context

157+getStateContext = dbc_context <$> get

167

158

168putStateContext :: DatabaseContext -> DatabaseContextEvalMonad ()

159putStateContext :: DatabaseContext -> DatabaseContextEvalMonad ()

169putStateContext ctx' = do

160putStateContext ctx' = do

@@ -204,7 +195,7 @@ freshGraphRefRelationalExprEnv mctx graph = GraphRefRelationalExprEnv {

204 }

195 }

205

196

206gfGraph :: GraphRefRelationalExprM TransactionGraph

197gfGraph :: GraphRefRelationalExprM TransactionGraph

207−gfGraph = asks gre_graph

198+gfGraph = gre_graph <$> R.ask

208

199

209envContext :: RelationalExprEnv -> DatabaseContext

200envContext :: RelationalExprEnv -> DatabaseContext

210envContext = re_context

201envContext = re_context

@@ -212,27 +203,173 @@ envContext = re_context

212setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv

203setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv

213setEnvContext e ctx = e { re_context = ctx }

204setEnvContext e ctx = e { re_context = ctx }

214

205

206+{-

207+--full evaluation down the graph

208+eval :: RelationalExpr -> RelationalExprState (Either RelationalError Relation)

209+eval expr = do

210+ env <- askEnv

211+ eGfExpr <- processRelationalExpr expr

212+ case eGfExpr of

213+ Left err -> pure (Left err)

214+ Right gfExpr -> pure $ evalGraphRefRelationalExpr gfExpr (re_graph env)

215+-}

216+{-

217+--relvar state is needed in evaluation of relational expression but only as read-only in order to extract current relvar values

218+evalRelationalExpr :: RelationalExpr -> RelationalExprState (Either RelationalError GraphRefRelationalExpr)

219+evalRelationalExpr (RelationVariable name _) = do

220+ relvarTable <- fmap (relationVariables . envContext) askEnv

221+ return $ case M.lookup name relvarTable of

222+ Just res -> Right res

223+ Nothing -> Left $ RelVarNotDefinedError name

224+

225+evalRelationalExpr (Project attrNames expr) = do

226+ eAttrNameSet <- evalAttributeNames attrNames expr

227+ case eAttrNameSet of

228+ Left err -> pure (Left err)

229+ Right attrNameSet -> do

230+ rel <- evalRelationalExpr expr

231+ case rel of

232+ Right rel2 -> pure $ Right (Project (AttributeNames attrNameSet) rel2)

233+ Left err -> pure $ Left err

234+

235+evalRelationalExpr (Union exprA exprB) = do

236+ relA <- evalRelationalExpr exprA

237+ relB <- evalRelationalExpr exprB

238+ case relA of

239+ Left err -> return $ Left err

240+ Right relA2 -> case relB of

241+ Left err -> return $ Left err

242+ Right relB2 -> return $ Right (Union relA2 relB2)

243+

244+evalRelationalExpr (Join exprA exprB) = do

245+ relA <- evalRelationalExpr exprA

246+ relB <- evalRelationalExpr exprB

247+ case relA of

248+ Left err -> return $ Left err

249+ Right relA2 -> case relB of

250+ Left err -> return $ Left err

251+ Right relB2 -> return $ Right (Join relA2 relB2)

252+

253+evalRelationalExpr (Difference exprA exprB) = do

254+ relA <- evalRelationalExpr exprA

255+ relB <- evalRelationalExpr exprB

256+ case relA of

257+ Left err -> return $ Left err

258+ Right relA2 -> case relB of

259+ Left err -> return $ Left err

260+ Right relB2 -> return $ Right (Difference relA2 relB2)

261+

262+evalRelationalExpr (MakeStaticRelation attributeSet tupleSet) =

263+ case mkRelation attributeSet tupleSet of

264+ Right rel -> return $ Right (ExistingRelation rel)

265+ Left err -> return $ Left err

266+

267+evalRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

268+ currentContext <- fmap envContext askEnv

269+ let tConss = typeConstructorMapping currentContext

270+ -- 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

271+ runExceptT $ do

272+ mAttrs <- case mAttrExprs of

273+ Just _ ->

274+ Just . A.attributesFromList <$> mapM evalGraphRefAttrExpr (fromMaybe [] mAttrExprs)

275+ Nothing -> pure Nothing

276+ tuples <- mapM (liftE . evalTupleExpr mAttrs) tupleExprs

277+ let attrs = fromMaybe firstTupleAttrs mAttrs

278+ firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)

279+ expr <- either throwE pure (mkRelation attrs (RelationTupleSet tuples))

280+ pure (ExistingRelation expr)

281+

282+evalRelationalExpr (ExistingRelation rel) = pure (Right (ExistingRelation rel))

283+

284+evalRelationalExpr (Rename oldAttrName newAttrName relExpr) = do

285+ evald <- evalRelationalExpr relExpr

286+ case evald of

287+ Right expr -> return $ Right (Rename oldAttrName newAttrName expr)

288+ Left err -> return $ Left err

289+

290+evalRelationalExpr (Group oldAttrNames newAttrName relExpr) = do

291+ eOldAttrNameSet <- evalAttributeNames oldAttrNames relExpr

292+ case eOldAttrNameSet of

293+ Left err -> pure (Left err)

294+ Right oldAttrNameSet -> do

295+ evald <- evalRelationalExpr relExpr

296+ case evald of

297+ Right expr -> return $ Right (Group (AttributeNames oldAttrNameSet) newAttrName expr)

298+ Left err -> return $ Left err

299+

300+evalRelationalExpr (Ungroup attrName relExpr) = do

301+ evald <- evalRelationalExpr relExpr

302+ case evald of

303+ Right expr -> return $ Right (Ungroup attrName expr)

304+ Left err -> return $ Left err

305+

306+evalRelationalExpr (Restrict predicateExpr relExpr) = do

307+ evald <- evalRelationalExpr relExpr

308+ pred <- processRestrictionPredicateExpr predicateExpr

309+ case evald of

310+ Left err -> return $ Left err

311+ Right expr ->

312+ pure $ Right (Restrict pred expr)

313+

314+evalRelationalExpr (Equals relExprA relExprB) = do

315+ evaldA <- evalRelationalExpr relExprA

316+ evaldB <- evalRelationalExpr relExprB

317+ case evaldA of

318+ Left err -> return $ Left err

319+ Right exprA -> case evaldB of

320+ Left err -> return $ Left err

321+ Right exprB -> return $ Right (Equals exprA exprB)

322+{-

323+evalRelationalExpr (With views mainExpr) = do

324+ rstate <- ask

325+

326+ let addScopedView ctx (vname,vexpr) = if vname `M.member` relationVariables ctx then

327+ Left (RelVarAlreadyDefinedError vname)

328+ else

329+ case runState (evalDatabaseContextExpr (Assign vname vexpr)) (freshDatabaseState ctx) of

330+ (Left err,_) -> Left err

331+ (Right (), (ctx',_,_)) -> Right ctx'

332+

333+ case foldM addScopedView (stateElemsContext rstate) views of

334+ Left err -> return $ Left err

335+ Right ctx'' -> do

336+ let evalMainExpr expr = runReader (evalRelationalExpr expr) (RelationalExprEnv ctx'')

337+ case evalMainExpr mainExpr of

338+ Left err -> return $ Left err

339+ Right rel -> return $ Right rel

340+-}

341+--warning: copy-pasta from above- refactor

342+evalRelationalExpr (NotEquals relExprA relExprB) = do

343+ evaldA <- evalRelationalExpr relExprA

344+ evaldB <- evalRelationalExpr relExprB

345+ case evaldA of

346+ Left err -> return $ Left err

347+ Right exprA -> case evaldB of

348+ Left err -> return $ Left err

349+ Right exprB -> return $ Right (NotEquals exprA exprB)

350+

351+-- extending a relation adds a single attribute with the results of the per-tuple expression evaluated

352+evalRelationalExpr (Extend tupleExpression relExpr) = do

353+ eExpr <- evalRelationalExpr relExpr

354+ case eExpr of

355+ Left err -> pure (Left err)

356+ Right expr -> do

357+ tupProc <- processExtendTupleExpr tupleExpression

358+ pure (Right (Extend tupProc expr))

359+-}

215--helper function to process relation variable creation/assignment

360--helper function to process relation variable creation/assignment

216setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

361setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

217setRelVar relVarName relExpr = do

362setRelVar relVarName relExpr = do

363+

218 currentContext <- getStateContext

364 currentContext <- getStateContext

219− --prevent recursive relvar definition by resolving references to relvars in previous states

220− relExpr' <- resolve relExpr

221− let newRelVars = M.insert relVarName relExpr' $ relationVariables currentContext

365+ let newRelVars = M.insert relVarName relExpr $ relationVariables currentContext

222 potentialContext = currentContext { relationVariables = newRelVars }

366 potentialContext = currentContext { relationVariables = newRelVars }

223− --optimization: if the relexpr is unchanged, skip the update

224− if M.lookup relVarName (relationVariables currentContext) == Just relExpr then

225− pure ()

226− else do

227− --determine when to check constraints

367+ --determine when to check constraints

228− graph <- dbcGraph

368+ graph <- dbcGraph

229− tid <- dbcTransId

369+ tid <- dbcTransId

230− case checkConstraints potentialContext tid graph of

370+ case checkConstraints potentialContext tid graph of

231− Left err -> dbErr err

371+ Left err -> dbErr err

232− Right _ -> putStateContext potentialContext

372+ Right _ -> putStateContext potentialContext

233−

234−--fast-path insertion- we already know that the previous relvar validated correctly, so we can validate just the relation that is being inserted for attribute matches- without this, even a single tuple relation inserted causes the entire relation to be re-validated unnecessarily

235−--insertIntoRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

236

373

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

374-- it is not an error to delete a relvar which does not exist, just like it is not an error to insert a pre-existing tuple into a relation

238deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()

375deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()

@@ -258,10 +395,13 @@ evalGraphRefDatabaseContextExpr (Define relVarName attrExprs) = do

258 let eAttrs = runGraphRefRelationalExprM gfEnv (mapM evalGraphRefAttrExpr attrExprs)

395 let eAttrs = runGraphRefRelationalExprM gfEnv (mapM evalGraphRefAttrExpr attrExprs)

259 gfEnv = freshGraphRefRelationalExprEnv (Just context) graph

396 gfEnv = freshGraphRefRelationalExprEnv (Just context) graph

260 case eAttrs of

397 case eAttrs of

261− Left err -> dbErr err

398+ Left err -> dbErr err

262 Right attrsList -> do

399 Right attrsList -> do

263− lift $ except $ validateAttributes tConss (A.attributesFromList attrsList)

400+ let atomTypeErrs = lefts $ map ((`validateAtomType` tConss) . A.atomType) attrsList

401+ if not (null atomTypeErrs) then

402+ dbErr (someErrors atomTypeErrs)

403+ else

264− case M.member relVarName relvars of

404+ case M.member relVarName relvars of

265 True -> dbErr (RelVarAlreadyDefinedError relVarName)

405 True -> dbErr (RelVarAlreadyDefinedError relVarName)

266 False -> setRelVar relVarName (ExistingRelation emptyRelation)

406 False -> setRelVar relVarName (ExistingRelation emptyRelation)

267 where

407 where

@@ -274,17 +414,13 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do

274 graph <- re_graph <$> dbcRelationalExprEnv

414 graph <- re_graph <$> dbcRelationalExprEnv

275 context <- getStateContext

415 context <- getStateContext

276 let existingRelVar = M.lookup relVarName (relationVariables context)

416 let existingRelVar = M.lookup relVarName (relationVariables context)

277− reEnv = freshGraphRefRelationalExprEnv (Just context) graph

278− eNewExprType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr expr)

279 case existingRelVar of

417 case existingRelVar of

280 Nothing -> do

418 Nothing -> do

281− case runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr expr) of

282− Left err -> dbErr err

283− Right reltype -> do

284− lift $ except $ validateAttributes (typeConstructorMapping context) (attributes reltype)

285− setRelVar relVarName expr

419+ setRelVar relVarName expr

286 Just existingRel -> do

420 Just existingRel -> do

287 let eExpectedType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr existingRel)

421 let eExpectedType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr existingRel)

422+ eNewExprType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr expr)

423+ reEnv = freshGraphRefRelationalExprEnv (Just context) graph

288 case eExpectedType of

424 case eExpectedType of

289 Left err -> dbErr err

425 Left err -> dbErr err

290 Right expectedType ->

426 Right expectedType ->

@@ -292,53 +428,42 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do

292 Left err -> dbErr err

428 Left err -> dbErr err

293 Right newExprType -> do

429 Right newExprType -> do

294 if newExprType == expectedType then do

430 if newExprType == expectedType then do

295− lift $ except $ validateAttributes (typeConstructorMapping context) (attributes newExprType)

296 setRelVar relVarName expr

431 setRelVar relVarName expr

297 else

432 else

298 dbErr (RelationTypeMismatchError (attributes expectedType) (attributes newExprType))

433 dbErr (RelationTypeMismatchError (attributes expectedType) (attributes newExprType))

299

434

300evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do

435evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do

301− gfExpr <- relVarByName relVarName

302− let optExpr = applyUnionCollapse (Union

303− relExpr

304− gfExpr)

305− evalGraphRefDatabaseContextExpr (Assign relVarName optExpr)

436+ evalGraphRefDatabaseContextExpr (Assign relVarName

437+ (Union

438+ (RelationVariable relVarName UncommittedContextMarker)

439+ relExpr))

306

440

307evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do

441evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do

308− gfExpr <- relVarByName relVarName

442+ transId <- dbcTransId

443+ let rv = RelationVariable relVarName (TransactionMarker transId)

309− let optExpr = applyRestrictionCollapse (Restrict (NotPredicate predicate) gfExpr)

444+ setRelVar relVarName (Restrict (NotPredicate predicate) rv)

310− setRelVar relVarName optExpr

311

445

312--union of restricted+updated portion and the unrestricted+unupdated portion

446--union of restricted+updated portion and the unrestricted+unupdated portion

313evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do

447evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do

314− rvExpr <- relVarByName relVarName

315− graph <- re_graph <$> dbcRelationalExprEnv

316 context <- getStateContext

448 context <- getStateContext

317− let reEnv = freshGraphRefRelationalExprEnv (Just context) graph

449+ transId <- dbcTransId

318− --get the current attributes name in the relvar to ensure that we don't conflict when renaming

450+ let relVarMap = relationVariables context

319− eExprType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr rvExpr)

451+ case M.lookup relVarName relVarMap of

320− exprType' <- case eExprType of

452+ Nothing -> dbErr (RelVarNotDefinedError relVarName)

321− Left err -> throwError err

453+ Just _ -> do

322− Right t -> pure t

323− let unrestrictedPortion = Restrict (NotPredicate pred') rvExpr

454+ let unrestrictedPortion = Restrict (NotPredicate pred') rv

324− tmpAttr = tmpAttrC 1

455+ rv = RelationVariable relVarName (TransactionMarker transId)

325− tmpAttrC :: Int -> AttributeName -> AttributeName

456+ tmpAttr attr = "_tmp_" <> attr --this could certainly be improved to verify that there is no attribute name conflict

326− tmpAttrC c attr =

327− let tmpAttrName = "_tmp_" <> T.pack (show c) <> attr in

328− if tmpAttrName `S.member` A.attributeNameSet (attributes exprType') then

329− tmpAttrC (c+1) attr

330− else

331− tmpAttrName

332− updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)

457+ updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)

333− projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)

458+ projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)

334− restrictedPortion = Restrict pred' rvExpr

459+ --TODO restrictedPortion = Restrict pred'

335− updated = foldr (\(oldname, atomExpr) accum ->

460+ updated = foldr (\(oldname, atomExpr) accum ->

336 let procAtomExpr = runProcessExprM UncommittedContextMarker (processAtomExpr atomExpr) in

461 let procAtomExpr = runProcessExprM UncommittedContextMarker (processAtomExpr atomExpr) in

337 updateAttr oldname procAtomExpr accum

462 updateAttr oldname procAtomExpr accum

338− ) restrictedPortion (M.toList atomExprMap)

463+ ) rv (M.toList atomExprMap)

339 -- the atomExprMap could reference other attributes, so we must perform multi-pass folds

464 -- the atomExprMap could reference other attributes, so we must perform multi-pass folds

340− updatedPortion = foldr projectAndRename updated (M.keys atomExprMap)

465+ updatedPortion = foldr projectAndRename updated (M.keys atomExprMap)

341− setRelVar relVarName (Union unrestrictedPortion updatedPortion)

466+ setRelVar relVarName (Union unrestrictedPortion updatedPortion)

342

467

343evalGraphRefDatabaseContextExpr (AddInclusionDependency newDepName newDep) = do

468evalGraphRefDatabaseContextExpr (AddInclusionDependency newDepName newDep) = do

344 currContext <- getStateContext

469 currContext <- getStateContext

@@ -350,8 +475,6 @@ evalGraphRefDatabaseContextExpr (AddInclusionDependency newDepName newDep) = do

350 dbErr (InclusionDependencyNameInUseError newDepName)

475 dbErr (InclusionDependencyNameInUseError newDepName)

351 else do

476 else do

352 let potentialContext = currContext { inclusionDependencies = newDeps }

477 let potentialContext = currContext { inclusionDependencies = newDeps }

353− -- if the potential context passes all constraints, then save it

354− -- potential optimization: validate only the new constraint- all old constraints must already hold

355 case checkConstraints potentialContext transId graph of

478 case checkConstraints potentialContext transId graph of

356 Left err -> dbErr err

479 Left err -> dbErr err

357 Right _ ->

480 Right _ ->

@@ -396,9 +519,9 @@ evalGraphRefDatabaseContextExpr (AddTypeConstructor tConsDef dConsDefList) = do

396 let oldTypes = typeConstructorMapping currentContext

519 let oldTypes = typeConstructorMapping currentContext

397 tConsName = TCD.name tConsDef

520 tConsName = TCD.name tConsDef

398 -- validate that the constructor's types exist

521 -- validate that the constructor's types exist

399− case validateTypeConstructorDef tConsDef dConsDefList oldTypes of

522+ case validateTypeConstructorDef tConsDef dConsDefList of

400− Left err -> throwError err

523+ errs@(_:_) -> dbErr (someErrors errs)

401− Right () | T.null tConsName || not (isUpper (T.head tConsName)) -> dbErr (InvalidAtomTypeName tConsName)

524+ [] | T.null tConsName || not (isUpper (T.head tConsName)) -> dbErr (InvalidAtomTypeName tConsName)

402 | isJust (findTypeConstructor tConsName oldTypes) -> dbErr (AtomTypeNameInUseError tConsName)

525 | isJust (findTypeConstructor tConsName oldTypes) -> dbErr (AtomTypeNameInUseError tConsName)

403 | otherwise -> do

526 | otherwise -> do

404 let newTypes = oldTypes ++ [(tConsDef, dConsDefList)]

527 let newTypes = oldTypes ++ [(tConsDef, dConsDefList)]

@@ -414,9 +537,9 @@ evalGraphRefDatabaseContextExpr (RemoveTypeConstructor tConsName) = do

414 let newTypes = filter (\(tCons, _) -> TCD.name tCons /= tConsName) oldTypes

537 let newTypes = filter (\(tCons, _) -> TCD.name tCons /= tConsName) oldTypes

415 putStateContext $ currentContext { typeConstructorMapping = newTypes }

538 putStateContext $ currentContext { typeConstructorMapping = newTypes }

416

539

417−evalGraphRefDatabaseContextExpr (MultipleExpr exprs) =

540+evalGraphRefDatabaseContextExpr (MultipleExpr exprs) = do

418 --the multiple expressions must pass the same context around- not the old unmodified context

541 --the multiple expressions must pass the same context around- not the old unmodified context

419− mapM_ evalGraphRefDatabaseContextExpr exprs

542+ mapM_ (\expr -> evalGraphRefDatabaseContextExpr expr) exprs

420

543

421evalGraphRefDatabaseContextExpr (RemoveAtomFunction funcName) = do

544evalGraphRefDatabaseContextExpr (RemoveAtomFunction funcName) = do

422 currentContext <- getStateContext

545 currentContext <- getStateContext

@@ -446,7 +569,7 @@ evalGraphRefDatabaseContextExpr (ExecuteDatabaseContextFunction funcName atomArg

446 context <- getStateContext

569 context <- getStateContext

447 graph <- dbcGraph

570 graph <- dbcGraph

448 --resolve atom arguments

571 --resolve atom arguments

449− let eAtomTypes = mapM (runGraphRefRelationalExprM gfEnv . typeForGraphRefAtomExpr emptyAttributes) atomArgExprs

572+ let eAtomTypes = mapM (\atomExpr -> runGraphRefRelationalExprM gfEnv (typeForGraphRefAtomExpr emptyAttributes atomExpr)) atomArgExprs

450 eFunc = databaseContextFunctionForName funcName (dbcFunctions context)

573 eFunc = databaseContextFunctionForName funcName (dbcFunctions context)

451 gfEnv = freshGraphRefRelationalExprEnv (Just context) graph

574 gfEnv = freshGraphRefRelationalExprEnv (Just context) graph

452 case eFunc of

575 case eFunc of

@@ -461,13 +584,11 @@ evalGraphRefDatabaseContextExpr (ExecuteDatabaseContextFunction funcName atomArg

461 case eAtomTypes of

584 case eAtomTypes of

462 Left err -> dbErr err

585 Left err -> dbErr err

463 Right atomTypes -> do

586 Right atomTypes -> do

464− let mValidTypes = zipWith (\ expType actType

465− -> case atomTypeVerify expType actType of

587+ let mValidTypes = map (\(expType, actType) -> case atomTypeVerify expType actType of

466− Left err -> Just err

588+ Left err -> Just err

467− Right _ -> Nothing)

468− (dbcFuncType func) atomTypes

589+ Right _ -> Nothing) (zip (dbcFuncType func) atomTypes)

469 typeErrors = catMaybes mValidTypes

590 typeErrors = catMaybes mValidTypes

470− eAtomArgs = map (runGraphRefRelationalExprM gfEnv . evalGraphRefAtomExpr emptyTuple) atomArgExprs

591+ eAtomArgs = map (\arg -> runGraphRefRelationalExprM gfEnv (evalGraphRefAtomExpr emptyTuple arg)) atomArgExprs

471 if length (lefts eAtomArgs) > 1 then

592 if length (lefts eAtomArgs) > 1 then

472 dbErr (someErrors (lefts eAtomArgs))

593 dbErr (someErrors (lefts eAtomArgs))

473 else if not (null typeErrors) then

594 else if not (null typeErrors) then

@@ -476,6 +597,7 @@ evalGraphRefDatabaseContextExpr (ExecuteDatabaseContextFunction funcName atomArg

476 case evalDatabaseContextFunction func (rights eAtomArgs) context of

597 case evalDatabaseContextFunction func (rights eAtomArgs) context of

477 Left err -> dbErr err

598 Left err -> dbErr err

478 Right newContext -> putStateContext newContext

599 Right newContext -> putStateContext newContext

600+

479data DatabaseContextIOEvalEnv = DatabaseContextIOEvalEnv

601data DatabaseContextIOEvalEnv = DatabaseContextIOEvalEnv

480 { dbcio_transId :: TransactionId,

602 { dbcio_transId :: TransactionId,

481 dbcio_graph :: TransactionGraph,

603 dbcio_graph :: TransactionGraph,

@@ -511,15 +633,10 @@ getDBCIOContext = dbc_context <$> RWS.get

511getDBCIORelationalExprEnv :: DatabaseContextIOEvalMonad RelationalExprEnv

633getDBCIORelationalExprEnv :: DatabaseContextIOEvalMonad RelationalExprEnv

512getDBCIORelationalExprEnv = do

634getDBCIORelationalExprEnv = do

513 context <- getDBCIOContext

635 context <- getDBCIOContext

636+ env <- RWS.ask

514− mkRelationalExprEnv context . dbcio_graph <$> RWS.ask

637+ pure $ mkRelationalExprEnv context (dbcio_graph env)

515

638

516evalGraphRefDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> DatabaseContextIOEvalMonad (Either RelationalError ())

639evalGraphRefDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> DatabaseContextIOEvalMonad (Either RelationalError ())

517−#if !defined(PM36_HASKELL_SCRIPTING)

518−evalGraphRefDatabaseContextIOExpr AddAtomFunction{} = pure (Left (ScriptError ScriptCompilationDisabledError))

519−evalGraphRefDatabaseContextIOExpr AddDatabaseContextFunction{} = pure (Left (ScriptError ScriptCompilationDisabledError))

520−evalGraphRefDatabaseContextIOExpr LoadAtomFunctions{} = pure (Left (ScriptError ScriptCompilationDisabledError))

521−evalGraphRefDatabaseContextIOExpr LoadDatabaseContextFunctions{} = pure (Left (ScriptError ScriptCompilationDisabledError))

522−#else

523evalGraphRefDatabaseContextIOExpr (AddAtomFunction funcName funcType script) = do

640evalGraphRefDatabaseContextIOExpr (AddAtomFunction funcName funcType script) = do

524 eScriptSession <- requireScriptSession

641 eScriptSession <- requireScriptSession

525 currentContext <- getDBCIOContext

642 currentContext <- getDBCIOContext

@@ -553,6 +670,7 @@ evalGraphRefDatabaseContextIOExpr (AddAtomFunction funcName funcType script) = d

553 Right eContext -> case eContext of

670 Right eContext -> case eContext of

554 Left err -> pure (Left err)

671 Left err -> pure (Left err)

555 Right context' -> putDBCIOContext context'

672 Right context' -> putDBCIOContext context'

673+

556evalGraphRefDatabaseContextIOExpr (AddDatabaseContextFunction funcName funcType script) = do

674evalGraphRefDatabaseContextIOExpr (AddDatabaseContextFunction funcName funcType script) = do

557 eScriptSession <- requireScriptSession

675 eScriptSession <- requireScriptSession

558 currentContext <- getDBCIOContext

676 currentContext <- getDBCIOContext

@@ -594,6 +712,7 @@ evalGraphRefDatabaseContextIOExpr (AddDatabaseContextFunction funcName funcType

594 Right eContext -> case eContext of

712 Right eContext -> case eContext of

595 Left err -> pure (Left err)

713 Left err -> pure (Left err)

596 Right context' -> putDBCIOContext context'

714 Right context' -> putDBCIOContext context'

715+

597evalGraphRefDatabaseContextIOExpr (LoadAtomFunctions modName funcName modPath) = do

716evalGraphRefDatabaseContextIOExpr (LoadAtomFunctions modName funcName modPath) = do

598 currentContext <- getDBCIOContext

717 currentContext <- getDBCIOContext

599 eLoadFunc <- liftIO $ loadAtomFunctions (T.unpack modName) (T.unpack funcName) modPath

718 eLoadFunc <- liftIO $ loadAtomFunctions (T.unpack modName) (T.unpack funcName) modPath

@@ -610,7 +729,7 @@ evalGraphRefDatabaseContextIOExpr (LoadDatabaseContextFunctions modName funcName

610 Right dbcListFunc -> let newContext = currentContext { dbcFunctions = mergedFuncs }

729 Right dbcListFunc -> let newContext = currentContext { dbcFunctions = mergedFuncs }

611 mergedFuncs = HS.union (dbcFunctions currentContext) (HS.fromList dbcListFunc)

730 mergedFuncs = HS.union (dbcFunctions currentContext) (HS.fromList dbcListFunc)

612 in putDBCIOContext newContext

731 in putDBCIOContext newContext

613−#endif

732+

614evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs range) = do

733evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs range) = do

615 --Define

734 --Define

616 currentContext <- getDBCIOContext

735 currentContext <- getDBCIOContext

@@ -642,20 +761,28 @@ evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs

642 Left err -> pure (Left err)

761 Left err -> pure (Left err)

643 Right dbstate' -> putDBCIOContext (dbc_context dbstate')

762 Right dbstate' -> putDBCIOContext (dbc_context dbstate')

644

763

764+{-

765+updateTupleWithAtomExprs :: M.Map AttributeName AtomExpr -> DatabaseContext -> TransactionGraph -> RelationTuple -> Either RelationalError RelationTuple

766+updateTupleWithAtomExprs exprMap context graph tupIn = do

767+ --resolve all atom exprs

768+ let

769+ atomsAssoc <- mapM (\(attrName, atomExpr) -> do

770+ let atom = unimplemented

771+ --atom <- runReader (evalAtomExpr tupIn atomExpr) (mkRelationalExprState context graph)

772+ pure (attrName, atom)

773+ ) (M.toList exprMap)

774+ pure (updateTupleWithAtoms (M.fromList atomsAssoc) tupIn)

775+-}

645--run verification on all constraints

776--run verification on all constraints

646checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()

777checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()

647−checkConstraints context transId graph@(TransactionGraph graphHeads transSet) = do

778+checkConstraints context transId graph@(TransactionGraph graphHeads transSet) =

648 mapM_ (uncurry checkIncDep) (M.toList deps)

779 mapM_ (uncurry checkIncDep) (M.toList deps)

649 where

780 where

650 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)

781 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)

651 tempStamp = UTCTime { utctDay = fromGregorian 2000 1 1,

782 tempStamp = UTCTime { utctDay = fromGregorian 2000 1 1,

652 utctDayTime = secondsToDiffTime 0 }

783 utctDayTime = secondsToDiffTime 0 }

653 tempSchemas = Schemas context M.empty

784 tempSchemas = Schemas context M.empty

654− tempTrans = Transaction U.nil tempTransInfo tempSchemas

655− tempTransInfo = TransactionInfo { parents = transId NE.:| [],

785+ tempTrans = Transaction U.nil (TransactionInfo (transId NE.:| []) tempStamp) tempSchemas

656− stamp = tempStamp,

657− merkleHash = mempty

658− }

659

786

660 deps = inclusionDependencies context

787 deps = inclusionDependencies context

661 -- no optimization available here, really? perhaps the optimizer should be passed down to here or the eval function should be passed through the environment

788 -- no optimization available here, really? perhaps the optimizer should be passed down to here or the eval function should be passed through the environment

@@ -691,7 +818,16 @@ typeForRelationalExpr expr = do

691 let gfExpr = runProcessExprM UncommittedContextMarker (processRelationalExpr expr)

818 let gfExpr = runProcessExprM UncommittedContextMarker (processRelationalExpr expr)

692 gfEnv = freshGraphRefRelationalExprEnv (Just context) graph

819 gfEnv = freshGraphRefRelationalExprEnv (Just context) graph

693 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

820 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

694− lift $ except runGf

821+ lift $ except $ runGf

822+

823+--returns a database context with all tuples removed

824+--this is useful for type checking and optimization

825+{-

826+contextWithEmptyTupleSets :: DatabaseContext -> DatabaseContext

827+contextWithEmptyTupleSets contextIn = contextIn { relationVariables = relVars }

828+ where

829+ relVars = M.map (\rel -> ExistingRelation (Relation (attributes rel) emptyTupleSet)) (relationVariables contextIn)

830+-}

695

831

696liftE :: (Monad m) => m (Either a b) -> ExceptT a m b

832liftE :: (Monad m) => m (Either a b) -> ExceptT a m b

697liftE v = do

833liftE v = do

@@ -740,7 +876,7 @@ predicateRestrictionFilter _ (RelationalExprPredicate relExpr) = do

740

876

741predicateRestrictionFilter attrs (AttributeEqualityPredicate attrName atomExpr) = do

877predicateRestrictionFilter attrs (AttributeEqualityPredicate attrName atomExpr) = do

742 env <- askEnv

878 env <- askEnv

743− let attrs' = A.union attrs (envAttributes env)

879+ let attrs' = envAttributes env

744 ctxtup' = envTuple env

880 ctxtup' = envTuple env

745 atomExprType <- typeForGraphRefAtomExpr attrs' atomExpr

881 atomExprType <- typeForGraphRefAtomExpr attrs' atomExpr

746 attr <- lift $ except $ case A.attributeForName attrName attrs of

882 attr <- lift $ except $ case A.attributeForName attrName attrs of

@@ -784,7 +920,7 @@ tupleExprCheckNewAttrName attrName rel = if isRight (attributeForName attrName r

784 Right rel

920 Right rel

785

921

786extendGraphRefTupleExpressionProcessor :: Relation -> GraphRefExtendTupleExpr -> GraphRefRelationalExprM (Attributes, RelationTuple -> Either RelationalError RelationTuple)

922extendGraphRefTupleExpressionProcessor :: Relation -> GraphRefExtendTupleExpr -> GraphRefRelationalExprM (Attributes, RelationTuple -> Either RelationalError RelationTuple)

787−extendGraphRefTupleExpressionProcessor relIn (AttributeExtendTupleExpr newAttrName atomExpr) =

923+extendGraphRefTupleExpressionProcessor relIn (AttributeExtendTupleExpr newAttrName atomExpr) = do

788-- renv <- askEnv

924-- renv <- askEnv

789 -- check that the attribute name is not in use

925 -- check that the attribute name is not in use

790 case tupleExprCheckNewAttrName newAttrName relIn of

926 case tupleExprCheckNewAttrName newAttrName relIn of

@@ -826,7 +962,7 @@ evalGraphRefAtomExpr tupIn (FunctionAtomExpr funcName arguments tid) = do

826 throwError (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)

962 throwError (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)

827 else do

963 else do

828 let zippedArgs = zip (safeInit (atomFuncType func)) argTypes

964 let zippedArgs = zip (safeInit (atomFuncType func)) argTypes

829− mapM_ (\(expType, actType) ->

965+ mapM_ (\(expType, actType) -> do

830 lift $ except (atomTypeVerify expType actType)) zippedArgs

966 lift $ except (atomTypeVerify expType actType)) zippedArgs

831 evaldArgs <- mapM (evalGraphRefAtomExpr tupIn) arguments

967 evaldArgs <- mapM (evalGraphRefAtomExpr tupIn) arguments

832 case evalAtomFunction func evaldArgs of

968 case evalAtomFunction func evaldArgs of

@@ -848,6 +984,58 @@ evalGraphRefAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs _) = do

848 mapM (evalGraphRefAtomExpr tupIn) dConsArgs

984 mapM (evalGraphRefAtomExpr tupIn) dConsArgs

849 pure (ConstructedAtom dConsName aType argAtoms)

985 pure (ConstructedAtom dConsName aType argAtoms)

850

986

987+{-

988+evalAtomExpr :: RelationTuple -> AtomExpr -> RelationalExprM Atom

989+evalAtomExpr tupIn expr =

990+ -}

991+{-

992+

993+evalAtomExpr tupIn (AttributeAtomExpr attrName) = case atomForAttributeName attrName tupIn of

994+ Right atom -> pure (Right atom)

995+ err@(Left (NoSuchAttributeNamesError _)) -> do

996+ rstate <- ask

997+ let stateTup = stateTuple rstate

998+ pure (atomForAttributeName attrName stateTup)

999+ Left err -> pure (Left err)

1000+evalAtomExpr _ (NakedAtomExpr atom) = pure (Right atom)

1001+evalAtomExpr tupIn (FunctionAtomExpr funcName arguments ()) = do

1002+ argTypes <- mapM (typeFromAtomExpr (tupleAttributes tupIn)) arguments

1003+ context <- fmap stateElemsContext ask

1004+ runExceptT $ do

1005+ let functions = atomFunctions context

1006+ func <- either throwE pure (atomFunctionForName funcName functions)

1007+ let expectedArgCount = length (atomFuncType func) - 1

1008+ actualArgCount = length argTypes

1009+ safeInit [] = [] -- different behavior from normal init

1010+ safeInit xs = init xs

1011+ if expectedArgCount /= actualArgCount then

1012+ throwE (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)

1013+ else do

1014+ let zippedArgs = zip (safeInit (atomFuncType func)) argTypes

1015+ mapM_ (\(expType, eActType) -> do

1016+ actType <- either throwE pure eActType

1017+ either throwE pure (atomTypeVerify expType actType)) zippedArgs

1018+ evaldArgs <- mapM (liftE . evalAtomExpr tupIn) arguments

1019+ case evalAtomFunction func evaldArgs of

1020+ Left err -> throwE (AtomFunctionUserError err)

1021+ Right result -> do

1022+ --validate that the result matches the expected type

1023+ _ <- either throwE pure (atomTypeVerify (last (atomFuncType func)) (atomTypeForAtom result))

1024+ pure result

1025+evalAtomExpr tupIn (RelationAtomExpr relExpr) = do

1026+ --merge existing state tuple context into new state tuple context to support an arbitrary number of levels, but new attributes trounce old attributes

1027+ rstate <- ask

1028+ runExceptT $ do

1029+ let newState = mergeTuplesIntoRelationalExprState tupIn rstate

1030+ relAtom <- either throwE pure (runReader (evalRelationalExpr relExpr) newState)

1031+ pure (RelationAtom relAtom)

1032+evalAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs ()) = runExceptT $ do

1033+ rstate <- lift ask

1034+ let newState = mergeTuplesIntoRelationalExprState tupIn rstate

1035+ aType <- either throwE pure (runReader (typeFromAtomExpr (tupleAttributes tupIn) cons) newState)

1036+ argAtoms <- mapM (\arg -> either throwE pure (runReader (evalAtomExpr tupIn arg) newState)) dConsArgs

1037+ pure (ConstructedAtom dConsName aType argAtoms)

1038+-}

851typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType

1039typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType

852typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

1040typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

853 renv <- askEnv

1041 renv <- askEnv

@@ -860,8 +1048,7 @@ typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

860 Right attr -> pure (A.atomType attr)

1048 Right attr -> pure (A.atomType attr)

861 Left _ -> case atomForAttributeName attrName envTup of

1049 Left _ -> case atomForAttributeName attrName envTup of

862 Right atom -> pure (atomTypeForAtom atom)

1050 Right atom -> pure (atomTypeForAtom atom)

863− Left _ -> --throwError (traceStack (show ("typeForGRAtomExpr", attrs, envTup)) err)

864− throwError err

1051+ Left _ -> throwError err

865 Left err -> throwError err

1052 Left err -> throwError err

866

1053

867typeForGraphRefAtomExpr _ (NakedAtomExpr atom) = pure (atomTypeForAtom atom)

1054typeForGraphRefAtomExpr _ (NakedAtomExpr atom) = pure (atomTypeForAtom atom)

@@ -914,7 +1101,7 @@ verifyGraphRefAtomExprTypes relIn (FunctionAtomExpr funcName funcArgExprs tid) e

914 let handler :: RelationalError -> GraphRefRelationalExprM AtomType

1101 let handler :: RelationalError -> GraphRefRelationalExprM AtomType

915 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)

1102 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)

916 handler err = throwError err

1103 handler err = throwError err

917− verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

1104+ verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

918 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]

1105 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]

919 if length funcArgTypes /= length expectedArgTypes - 1 then

1106 if length funcArgTypes /= length expectedArgTypes - 1 then

920 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)

1107 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)

@@ -938,55 +1125,7 @@ evalGraphRefAttrExpr (AttributeAndTypeNameExpr attrName tCons transId) = do

938 pure $ Attribute attrName aType

1125 pure $ Attribute attrName aType

939

1126

940evalGraphRefAttrExpr (NakedAttributeExpr attr) = pure attr

1127evalGraphRefAttrExpr (NakedAttributeExpr attr) = pure attr

941−

1128+

942−-- for tuple type concrete resolution (Nothing ==> Maybe Int) when the attributes hint is Nothing, we need to first process all the tuples, then extract the concrete types on a per-attribute basis, then reprocess the tuples to include the concrete types

943−evalGraphRefTupleExprs :: Maybe Attributes -> GraphRefTupleExprs -> GraphRefRelationalExprM [RelationTuple]

944−evalGraphRefTupleExprs _ (TupleExprs _ []) = pure []

945−evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do

946− tuples <- mapM (evalGraphRefTupleExpr mAttrs) tupleExprL

947− finalAttrs <- case mAttrs of

948− Just attrs -> pure attrs

949− Nothing ->

950− case tuples of

951− [] -> pure emptyAttributes

952− (headTuple:tailTuples) -> do

953− --gather up resolved atom types or throw an error if an attribute cannot be made concrete from the inferred types- this could still fail if the type cannot be inferred (e.g. from [Nothing, Nothing])

954− let

955− processTupleAttrs (tupAttr, accAttr) =

956− --if the attribute is a constructedatomtype, we can recurse into it to potentially resolve type variables

957− if isResolvedAttribute accAttr && tupAttr == accAttr then

958− pure accAttr

959− else

960− lift $ except $ resolveAttributes accAttr tupAttr

961− mostResolvedTypes <-

962− foldM (\acc tup -> do

963− let zipped = zip (V.toList . attributesVec $ tupleAttributes tup) acc

964− accNames = S.fromList $ map A.attributeName acc

965− tupNames = A.attributeNameSet (tupleAttributes tup)

966− attrNamesDiff = S.union (S.difference accNames tupNames) (S.difference tupNames accNames)

967− unless (null attrNamesDiff) (throwError (AttributeNamesMismatchError attrNamesDiff))

968− nextTupleAttrs <- mapM processTupleAttrs zipped

969− let diff = A.attributesDifference (A.attributesFromList nextTupleAttrs) (A.attributesFromList acc)

970− if diff == A.emptyAttributes then

971− pure nextTupleAttrs

972− else

973− throwError (TupleAttributeTypeMismatchError diff)

974− ) (V.toList . attributesVec $ tupleAttributes headTuple) tailTuples

975− pure (A.attributesFromList mostResolvedTypes)

976− --strategy: if all the tuple expr transaction markers refer to one location, then we can pass the type constructor mapping from that location, otherwise, we cannot assume that the types are the same

977− tConsMap <- case singularTransactions tupleExprL of

978− SingularTransactionRef commonTransId ->

979− typeConstructorMapping <$> gfDatabaseContextForMarker commonTransId

980− NoTransactionsRef ->

981− typeConstructorMapping <$> gfDatabaseContextForMarker fixedMarker

982− -- if there are multiple transaction markers in the TupleExprs, then we can't assume a single type constructor mapping- this could be improved in the future, but if all the tuples are fully resolved, then we don't need further resolution

983− _ -> throwError TupleExprsReferenceMultipleMarkersError

984− lift $ except $ validateAttributes tConsMap finalAttrs

985− mapM (lift . except . resolveTypesInTuple finalAttrs tConsMap) tuples

986−

987−

988−--resolveAttributes (Attribute "gonk" (ConstructedAtomType "Either" (fromList [("a",IntegerAtomType),("b",TypeVariableType "b")]))) (Attribute "gonk" (ConstructedAtomType "Either" (fromList [("a",TypeVariableType "a"),("b",TextAtomType)])))

989−

990evalGraphRefTupleExpr :: Maybe Attributes -> GraphRefTupleExpr -> GraphRefRelationalExprM RelationTuple

1129evalGraphRefTupleExpr :: Maybe Attributes -> GraphRefTupleExpr -> GraphRefRelationalExprM RelationTuple

991evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do

1130evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do

992 -- it's not possible for AtomExprs in tuple constructors to reference other Attributes' atoms due to the necessary order-of-operations (need a tuple to pass to evalAtomExpr)- it may be possible with some refactoring of type usage or delayed evaluation- needs more thought, but not a priority

1131 -- it's not possible for AtomExprs in tuple constructors to reference other Attributes' atoms due to the necessary order-of-operations (need a tuple to pass to evalAtomExpr)- it may be possible with some refactoring of type usage or delayed evaluation- needs more thought, but not a priority

@@ -1011,12 +1150,62 @@ evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do

1011 --verify that the attributes match

1150 --verify that the attributes match

1012 when (A.attributeNameSet finalAttrs /= A.attributeNameSet tupAttrs) $ throwError (TupleAttributeTypeMismatchError tupAttrs)

1151 when (A.attributeNameSet finalAttrs /= A.attributeNameSet tupAttrs) $ throwError (TupleAttributeTypeMismatchError tupAttrs)

1013 --we can't resolve types here- they have to be resolved at the atom level where the graph ref is held

1152 --we can't resolve types here- they have to be resolved at the atom level where the graph ref is held

1014− --tup' <- lift $ except (resolveTypesInTuple finalAttrs tConss (reorderTuple finalAttrs tup))

1153+-- tup' <- lift $ except (resolveTypesInTuple finalAttrs tConss (reorderTuple finalAttrs tup))

1015 let tup' = reorderTuple finalAttrs tup

1154 let tup' = reorderTuple finalAttrs tup

1016 --TODO: restore type resolution

1155 --TODO: restore type resolution

1017-- _ <- lift $ except (validateTuple tup' tConss)

1156-- _ <- lift $ except (validateTuple tup' tConss)

1018 pure tup'

1157 pure tup'

1019

1158

1159+{-

1160+evalAttributeNames :: AttributeNames -> RelationalExpr -> RelationalExprM (Either RelationalError (S.Set AttributeName))

1161+evalAttributeNames attrNames expr = do

1162+ eExprType <- typeForRelationalExpr expr

1163+ case eExprType of

1164+ Left err -> throwError err

1165+ Right exprTyp -> do

1166+ let typeNameSet = S.fromList (V.toList (A.attributeNames (attributes exprTyp)))

1167+ case attrNames of

1168+ AttributeNames names ->

1169+ case A.projectionAttributesForNames names (attributes exprTyp) of

1170+ Left err -> pure (Left err)

1171+ Right attrs -> pure (Right (S.fromList (V.toList (A.attributeNames attrs))))

1172+

1173+ InvertedAttributeNames names -> do

1174+ let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet

1175+ if not (S.null nonExistentAttributeNames) then

1176+ pure (Left (AttributeNamesMismatchError nonExistentAttributeNames))

1177+ else

1178+ pure (Right (A.nonMatchingAttributeNameSet names typeNameSet))

1179+

1180+ UnionAttributeNames namesA namesB -> do

1181+ eNameSetA <- evalAttributeNames namesA expr

1182+ case eNameSetA of

1183+ Left err -> pure (Left err)

1184+ Right nameSetA -> do

1185+ eNameSetB <- evalAttributeNames namesB expr

1186+ case eNameSetB of

1187+ Left err -> pure (Left err)

1188+ Right nameSetB ->

1189+ pure (Right (S.union nameSetA nameSetB))

1190+

1191+ IntersectAttributeNames namesA namesB -> do

1192+ eNameSetA <- evalAttributeNames namesA expr

1193+ case eNameSetA of

1194+ Left err -> pure (Left err)

1195+ Right nameSetA -> do

1196+ eNameSetB <- evalAttributeNames namesB expr

1197+ case eNameSetB of

1198+ Left err -> pure (Left err)

1199+ Right nameSetB ->

1200+ pure (Right (S.intersection nameSetA nameSetB))

1201+

1202+ RelationalExprAttributeNames attrExpr -> do

1203+ eAttrExprType <- typeForRelationalExpr attrExpr

1204+ case eAttrExprType of

1205+ Left err -> pure (Left err)

1206+ Right attrExprType -> pure (Right (A.attributeNameSet (attributes attrExprType)))

1207+-}

1208+

1020--temporary implementation until we have a proper planner+executor

1209--temporary implementation until we have a proper planner+executor

1021evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation

1210evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation

1022evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

1211evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

@@ -1024,7 +1213,7 @@ evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

1024 Just _ ->

1213 Just _ ->

1025 Just . A.attributesFromList <$> mapM evalGraphRefAttrExpr (fromMaybe [] mAttrExprs)

1214 Just . A.attributesFromList <$> mapM evalGraphRefAttrExpr (fromMaybe [] mAttrExprs)

1026 Nothing -> pure Nothing

1215 Nothing -> pure Nothing

1027− tuples <- evalGraphRefTupleExprs mAttrs tupleExprs

1216+ tuples <- mapM (evalGraphRefTupleExpr mAttrs) tupleExprs

1028 let attrs = fromMaybe firstTupleAttrs mAttrs

1217 let attrs = fromMaybe firstTupleAttrs mAttrs

1029 firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)

1218 firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)

1030 lift $ except $ mkRelation attrs (RelationTupleSet tuples)

1219 lift $ except $ mkRelation attrs (RelationTupleSet tuples)

@@ -1078,7 +1267,7 @@ evalGraphRefRelationalExpr (Extend extendTupleExpr expr) = do

1078 rel <- evalGraphRefRelationalExpr expr

1267 rel <- evalGraphRefRelationalExpr expr

1079 (newAttrs, tupProc) <- extendGraphRefTupleExpressionProcessor rel extendTupleExpr

1268 (newAttrs, tupProc) <- extendGraphRefTupleExpressionProcessor rel extendTupleExpr

1080 lift $ except $ relMogrify tupProc newAttrs rel

1269 lift $ except $ relMogrify tupProc newAttrs rel

1081−evalGraphRefRelationalExpr expr@With{} =

1270+evalGraphRefRelationalExpr expr@With{} = do

1082 --strategy A: add relation variables to the contexts in the graph

1271 --strategy A: add relation variables to the contexts in the graph

1083 --strategy B: drop in macros in place (easier programmatically)

1272 --strategy B: drop in macros in place (easier programmatically)

1084 --strategy B implementation

1273 --strategy B implementation

@@ -1106,10 +1295,10 @@ typeForGraphRefRelationalExpr (ExistingRelation rel) = pure (emptyRelationWithAt

1106typeForGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

1295typeForGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

1107 mAttrs <- case mAttrExprs of

1296 mAttrs <- case mAttrExprs of

1108 Just attrExprs -> do

1297 Just attrExprs -> do

1109− attrs <- mapM evalGraphRefAttributeExpr attrExprs

1298+ attrs <- mapM (\e -> evalGraphRefAttributeExpr e) attrExprs

1110 pure (Just (attributesFromList attrs))

1299 pure (Just (attributesFromList attrs))

1111 Nothing -> pure Nothing

1300 Nothing -> pure Nothing

1112− tuples <- evalGraphRefTupleExprs mAttrs tupleExprs

1301+ tuples <- mapM (evalGraphRefTupleExpr mAttrs) tupleExprs

1113 let retAttrs = case tuples of

1302 let retAttrs = case tuples of

1114 (tup:_) -> tupleAttributes tup

1303 (tup:_) -> tupleAttributes tup

1115 [] -> fromMaybe A.emptyAttributes mAttrs

1304 [] -> fromMaybe A.emptyAttributes mAttrs

@@ -1119,8 +1308,7 @@ typeForGraphRefRelationalExpr (RelationVariable rvName tid) = do

1119 relVars <- relationVariables <$> gfDatabaseContextForMarker tid

1308 relVars <- relationVariables <$> gfDatabaseContextForMarker tid

1120 case M.lookup rvName relVars of

1309 case M.lookup rvName relVars of

1121 Nothing -> throwError (RelVarNotDefinedError rvName)

1310 Nothing -> throwError (RelVarNotDefinedError rvName)

1122− Just rvExpr ->

1123− typeForGraphRefRelationalExpr rvExpr

1311+ Just rvExpr -> typeForGraphRefRelationalExpr rvExpr

1124typeForGraphRefRelationalExpr (Project attrNames expr) = do

1312typeForGraphRefRelationalExpr (Project attrNames expr) = do

1125 exprType' <- typeForGraphRefRelationalExpr expr

1313 exprType' <- typeForGraphRefRelationalExpr expr

1126 projectionAttrs <- evalGraphRefAttributeNames attrNames expr

1314 projectionAttrs <- evalGraphRefAttributeNames attrNames expr

@@ -1151,21 +1339,15 @@ typeForGraphRefRelationalExpr (Restrict pred' expr) = do

1151 expr' <- typeForGraphRefRelationalExpr expr

1339 expr' <- typeForGraphRefRelationalExpr expr

1152 filt <- predicateRestrictionFilter (attributes expr') pred'

1340 filt <- predicateRestrictionFilter (attributes expr') pred'

1153 lift $ except $ restrict filt expr'

1341 lift $ except $ restrict filt expr'

1154−typeForGraphRefRelationalExpr Equals{} =

1342+typeForGraphRefRelationalExpr Equals{} = do

1155 pure relationFalse

1343 pure relationFalse

1156−typeForGraphRefRelationalExpr NotEquals{} =

1344+typeForGraphRefRelationalExpr NotEquals{} = do

1157 pure relationFalse

1345 pure relationFalse

1158typeForGraphRefRelationalExpr (Extend extendTupleExpr expr) = do

1346typeForGraphRefRelationalExpr (Extend extendTupleExpr expr) = do

1159 rel <- typeForGraphRefRelationalExpr expr

1347 rel <- typeForGraphRefRelationalExpr expr

1160 evalGraphRefRelationalExpr (Extend extendTupleExpr (ExistingRelation rel))

1348 evalGraphRefRelationalExpr (Extend extendTupleExpr (ExistingRelation rel))

1161−typeForGraphRefRelationalExpr expr@(With withs _) = do

1349+typeForGraphRefRelationalExpr expr@With{} = do

1162 let expr' = substituteWithNameMacros [] expr

1350 let expr' = substituteWithNameMacros [] expr

1163− checkMacroName (WithNameExpr macroName tid) = do

1164− rvs <- relationVariables <$> gfDatabaseContextForMarker tid

1165− case M.lookup macroName rvs of

1166− Just _ -> lift $ except $ Left (RelVarAlreadyDefinedError macroName) --this error does not include the transaction marker, but should be good enough to identify the cause

1167− Nothing -> pure ()

1168− mapM_ (checkMacroName . fst) withs

1169 typeForGraphRefRelationalExpr expr'

1351 typeForGraphRefRelationalExpr expr'

1170

1352

1171evalGraphRefAttributeNames :: GraphRefAttributeNames -> GraphRefRelationalExpr -> GraphRefRelationalExprM (S.Set AttributeName)

1353evalGraphRefAttributeNames :: GraphRefAttributeNames -> GraphRefRelationalExpr -> GraphRefRelationalExprM (S.Set AttributeName)

@@ -1181,7 +1363,7 @@ evalGraphRefAttributeNames attrNames expr = do

1181 InvertedAttributeNames names -> do

1363 InvertedAttributeNames names -> do

1182 let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet

1364 let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet

1183 if not (S.null nonExistentAttributeNames) then

1365 if not (S.null nonExistentAttributeNames) then

1184− throwError $ AttributeNamesMismatchError nonExistentAttributeNames

1366+ throwError (AttributeNamesMismatchError nonExistentAttributeNames)

1185 else

1367 else

1186 pure (A.nonMatchingAttributeNameSet names typeNameSet)

1368 pure (A.nonMatchingAttributeNameSet names typeNameSet)

1187

1369

@@ -1211,9 +1393,9 @@ evalGraphRefAttributeExpr (AttributeAndTypeNameExpr attrName tCons tid) = do

1211evalGraphRefAttributeExpr (NakedAttributeExpr attr) = pure attr

1393evalGraphRefAttributeExpr (NakedAttributeExpr attr) = pure attr

1212

1394

1213mkEmptyRelVars :: RelationVariables -> RelationVariables

1395mkEmptyRelVars :: RelationVariables -> RelationVariables

1214−mkEmptyRelVars = M.map mkEmptyRelVar

1396+mkEmptyRelVars rvMap = M.map mkEmptyRelVar rvMap

1215 where

1397 where

1216− mkEmptyRelVar expr@MakeRelationFromExprs{} = expr --do not truncate here because we might lose essential type information in emptying the tuples

1398+ mkEmptyRelVar (MakeRelationFromExprs mAttrs _) = MakeRelationFromExprs mAttrs []

1217 mkEmptyRelVar (MakeStaticRelation attrs _) = MakeStaticRelation attrs emptyTupleSet

1399 mkEmptyRelVar (MakeStaticRelation attrs _) = MakeStaticRelation attrs emptyTupleSet

1218 mkEmptyRelVar (ExistingRelation rel) = ExistingRelation (emptyRelationWithAttrs (attributes rel))

1400 mkEmptyRelVar (ExistingRelation rel) = ExistingRelation (emptyRelationWithAttrs (attributes rel))

1219 mkEmptyRelVar rv@RelationVariable{} = Restrict (NotPredicate TruePredicate) rv

1401 mkEmptyRelVar rv@RelationVariable{} = Restrict (NotPredicate TruePredicate) rv

@@ -1228,165 +1410,29 @@ mkEmptyRelVars = M.map mkEmptyRelVar

1228 mkEmptyRelVar (Equals exprA exprB) = Equals (mkEmptyRelVar exprA) (mkEmptyRelVar exprB)

1410 mkEmptyRelVar (Equals exprA exprB) = Equals (mkEmptyRelVar exprA) (mkEmptyRelVar exprB)

1229 mkEmptyRelVar (NotEquals exprA exprB) = NotEquals (mkEmptyRelVar exprA) (mkEmptyRelVar exprB)

1411 mkEmptyRelVar (NotEquals exprA exprB) = NotEquals (mkEmptyRelVar exprA) (mkEmptyRelVar exprB)

1230 mkEmptyRelVar (Extend extTuple expr) = Extend extTuple (mkEmptyRelVar expr)

1412 mkEmptyRelVar (Extend extTuple expr) = Extend extTuple (mkEmptyRelVar expr)

1231− mkEmptyRelVar (With macros expr) = With (map (second mkEmptyRelVar) macros) (mkEmptyRelVar expr)

1413+ mkEmptyRelVar (With macros expr) = With (map (\(rv, expr') -> (rv, mkEmptyRelVar expr')) macros) (mkEmptyRelVar expr)

1232

1414

1233

1415

1234dbErr :: RelationalError -> DatabaseContextEvalMonad ()

1416dbErr :: RelationalError -> DatabaseContextEvalMonad ()

1235dbErr err = lift (except (Left err))

1417dbErr err = lift (except (Left err))

1236

1418

1237-- | Return a Relation describing the relation variables.

1419-- | Return a Relation describing the relation variables.

1238−relationVariablesAsRelation :: DatabaseContext -> TransactionGraph -> Either RelationalError Relation

1420+relationVariablesAsRelation :: RelationVariables -> TransactionGraph -> Either RelationalError Relation

1239−relationVariablesAsRelation ctx graph = do

1421+relationVariablesAsRelation relVarMap graph = do

1240 let subrelAttrs = A.attributesFromList [Attribute "attribute" TextAtomType, Attribute "type" TextAtomType]

1422 let subrelAttrs = A.attributesFromList [Attribute "attribute" TextAtomType, Attribute "type" TextAtomType]

1241 attrs = A.attributesFromList [Attribute "name" TextAtomType,

1423 attrs = A.attributesFromList [Attribute "name" TextAtomType,

1242 Attribute "attributes" (RelationAtomType subrelAttrs)]

1424 Attribute "attributes" (RelationAtomType subrelAttrs)]

1243− relVars = relationVariables ctx

1244 mkRvDesc (rvName, gfExpr) = do

1425 mkRvDesc (rvName, gfExpr) = do

1245− let gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph

1426+ let gfEnv = freshGraphRefRelationalExprEnv Nothing graph

1246 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

1427 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

1247 pure (rvName, gfType)

1428 pure (rvName, gfType)

1248− relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributesVec (attributes rel))]

1429+ relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributes rel)]

1249 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]

1430 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]

1250 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of

1431 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of

1251 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)

1432 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)

1252 Right rel -> RelationAtom rel

1433 Right rel -> RelationAtom rel

1253− rvs <- mapM mkRvDesc (M.toList relVars)

1434+ rvs <- mapM mkRvDesc (M.toList relVarMap)

1254 let tups = map relVarToAtomList rvs

1435 let tups = map relVarToAtomList rvs

1255 mkRelationFromList attrs tups

1436 mkRelationFromList attrs tups

1256

1437

1257−-- | An unoptimized variant of evalGraphRefRelationalExpr for testing.

1258−evalRelationalExpr :: RelationalExpr -> RelationalExprM Relation

1259−evalRelationalExpr expr = do

1260− graph <- reGraph

1261− context <- reContext

1262− let expr' = runProcessExprM UncommittedContextMarker (processRelationalExpr expr)

1263− gfEnv = freshGraphRefRelationalExprEnv (Just context) graph

1264− case runGraphRefRelationalExprM gfEnv (evalGraphRefRelationalExpr expr') of

1265− Left err -> throwError err

1266− Right rel -> pure rel

1267−

1268−class (MonadError RelationalError m, Monad m) => DatabaseContextM m where

1269− getContext :: m DatabaseContext

1270

1438

1271−instance DatabaseContextM (ReaderT GraphRefRelationalExprEnv (ExceptT RelationalError Identity)) where

1272− getContext = gfDatabaseContextForMarker UncommittedContextMarker

1273−

1274−instance DatabaseContextM (RWST DatabaseContextEvalEnv () DatabaseContextEvalState (ExceptT RelationalError Identity)) where

1275− getContext = getStateContext

1276−

1277−relVarByName :: DatabaseContextM m => RelVarName -> m GraphRefRelationalExpr

1278−relVarByName rvName = do

1279− relvars <- relationVariables <$> getContext

1280− case M.lookup rvName relvars of

1281− Nothing -> throwError (RelVarNotDefinedError rvName)

1282− Just gfexpr -> pure gfexpr

1283−

1284−-- | resolve UncommittedTransactionMarker whenever possible- this is important in the DatabaseContext in order to mitigate self-referencing loops for updates

1285−class ResolveGraphRefTransactionMarker a where

1286− resolve :: a -> DatabaseContextEvalMonad a

1287−

1288−-- s := s union t

1289−instance ResolveGraphRefTransactionMarker GraphRefRelationalExpr where

1290− resolve (MakeRelationFromExprs mAttrs tupleExprs) =

1291− MakeRelationFromExprs mAttrs <$> resolve tupleExprs

1292− resolve orig@MakeStaticRelation{} = pure orig

1293− resolve orig@ExistingRelation{} = pure orig

1294− resolve orig@(RelationVariable rvName UncommittedContextMarker) = do

1295− rvMap <- relationVariables <$> getStateContext

1296− case M.lookup rvName rvMap of

1297− Nothing -> pure orig

1298− Just resolvedRv -> resolve resolvedRv

1299− resolve orig@RelationVariable{} = pure orig

1300− resolve (Project attrNames relExpr) = Project <$> resolve attrNames <*> resolve relExpr

1301− resolve (Union exprA exprB) = Union <$> resolve exprA <*> resolve exprB

1302− resolve (Join exprA exprB) = Join <$> resolve exprA <*> resolve exprB

1303− resolve (Rename attrA attrB expr) = Rename attrA attrB <$> resolve expr

1304− resolve (Difference exprA exprB) = Difference <$> resolve exprA <*> resolve exprB

1305− resolve (Group namesA nameB expr) = Group <$> resolve namesA <*> pure nameB <*> resolve expr

1306− resolve (Ungroup nameA expr) = Ungroup nameA <$> resolve expr

1307− resolve (Restrict restrictExpr relExpr) = Restrict <$> resolve restrictExpr <*> resolve relExpr

1308− resolve (Equals exprA exprB) = Equals <$> resolve exprA <*> resolve exprB

1309− resolve (NotEquals exprA exprB) = NotEquals <$> resolve exprA <*> resolve exprB

1310− resolve (Extend extendExpr relExpr) = Extend <$> resolve extendExpr <*> resolve relExpr

1311− resolve (With withExprs relExpr) = With <$> mapM (\(nam, expr) -> (,) <$> resolve nam <*> resolve expr) withExprs <*> resolve relExpr

1312−

1313−instance ResolveGraphRefTransactionMarker GraphRefTupleExprs where

1314− resolve (TupleExprs marker tupleExprs) =

1315− TupleExprs marker <$> mapM resolve tupleExprs

1316−

1317−instance ResolveGraphRefTransactionMarker GraphRefTupleExpr where

1318− resolve (TupleExpr tupMap) = do

1319− tupMap' <- mapM (\(attrName, expr) -> (,) attrName <$> resolve expr ) (M.toList tupMap)

1320− pure (TupleExpr (M.fromList tupMap'))

1321−

1322−instance ResolveGraphRefTransactionMarker GraphRefAttributeNames where

1323− resolve orig@AttributeNames{} = pure orig

1324− resolve orig@InvertedAttributeNames{} = pure orig

1325− resolve (UnionAttributeNames namesA namesB) = UnionAttributeNames <$> resolve namesA <*> resolve namesB

1326− resolve (IntersectAttributeNames namesA namesB) = IntersectAttributeNames <$> resolve namesA <*> resolve namesB

1327− resolve (RelationalExprAttributeNames expr) = RelationalExprAttributeNames <$> resolve expr

1328−

1329−instance ResolveGraphRefTransactionMarker GraphRefRestrictionPredicateExpr where

1330− resolve TruePredicate = pure TruePredicate

1331− resolve (AndPredicate exprA exprB) = AndPredicate <$> resolve exprA <*> resolve exprB

1332− resolve (OrPredicate exprA exprB) = OrPredicate <$> resolve exprA <*> resolve exprB

1333− resolve (NotPredicate expr) = NotPredicate <$> resolve expr

1334− resolve (RelationalExprPredicate expr) = RelationalExprPredicate <$> resolve expr

1335− resolve (AtomExprPredicate expr) = AtomExprPredicate <$> resolve expr

1336− resolve (AttributeEqualityPredicate nam expr)= AttributeEqualityPredicate nam <$> resolve expr

1337−

1338−instance ResolveGraphRefTransactionMarker GraphRefExtendTupleExpr where

1339− resolve (AttributeExtendTupleExpr nam atomExpr) = AttributeExtendTupleExpr nam <$> resolve atomExpr

1340−

1341−instance ResolveGraphRefTransactionMarker GraphRefWithNameExpr where

1342− resolve orig@WithNameExpr{} = pure orig -- match uncommitted marker?

1343−

1344−instance ResolveGraphRefTransactionMarker GraphRefAtomExpr where

1345− resolve orig@AttributeAtomExpr{} = pure orig

1346− resolve orig@NakedAtomExpr{} = pure orig

1347− resolve (FunctionAtomExpr nam atomExprs marker) =

1348− FunctionAtomExpr nam <$> mapM resolve atomExprs <*> pure marker

1349− resolve (RelationAtomExpr expr) = RelationAtomExpr <$> resolve expr

1350− resolve (ConstructedAtomExpr dConsName atomExprs marker) =

1351− ConstructedAtomExpr dConsName <$> mapM resolve atomExprs <*> pure marker

1352−

1353−--convert series of simple Union queries into MakeStaticRelation

1354−-- this is especially useful for long, nested applications of Union with simple tuples

1355−-- Union (MakeRelation x y) (MakeRelation x y') -> MakeRelation x (y + y')

1356−

1357−--MakeRelationFromExprs Nothing (TupleExprs UncommittedContextMarker [TupleExpr (fromList [("name", NakedAtomExpr (TextAtom "steve"))])])

1358−

1359−applyUnionCollapse :: GraphRefRelationalExpr -> GraphRefRelationalExpr

1360−applyUnionCollapse = Fold.cata opt

1361− where

1362− opt :: RelationalExprBaseF GraphRefTransactionMarker GraphRefRelationalExpr -> GraphRefRelationalExpr

1363− opt (UnionF exprA exprB) | exprA == exprB = exprA

1364− opt (UnionF

1365− exprA@(MakeRelationFromExprs mAttrs1 tupExprs1)

1366− exprB@(MakeRelationFromExprs mAttrs2 tupExprs2)) | tupExprs1 == tupExprs2 = MakeRelationFromExprs (mAttrs1 <|> mAttrs2) tupExprs1

1367− | tupExprsNull tupExprs1 = exprB

1368− | tupExprsNull tupExprs2 = exprA

1369− opt x = Fold.embed x

1370− tupExprsNull (TupleExprs _ []) = True

1371− tupExprsNull _ = False

1372−

1373−

1374−--UPDATE optimization- find matching where clause in "lower" levels of renaming

1375−--update x where y=1 set (x:=5,z:=10); update x where y=1 set(x:=6,z:=11)

1376−-- =>

1377−-- update x where y=1 set (x:=6,z:=11)

1378−-- future opt: match individual attributes update x where y=1 set (x:=5); update x where y=1 set (z:=11) => update x where y=1 set (x:=5,z:=11)

1379−

1380−--strategy: try to collapse the top-level update (union (restrict pred MakeRelationFromExpr) expr) if it contains the same predicate and resultant relation

1381−

1382−--DELETE optimization

1383−-- if a restriction matches a previous restriction, combine them

1384−-- O(1) since it only scans at the top level, critical in benchmarks generating redundant deletions

1385−applyRestrictionCollapse :: GraphRefRelationalExpr -> GraphRefRelationalExpr

1386−applyRestrictionCollapse orig@(Restrict npred@(NotPredicate _) expr) =

1387− case expr of

1388− orig'@(Restrict npred'@(NotPredicate _) _) | npred == npred' -> orig'

1389− _ -> orig

1390−applyRestrictionCollapse expr = expr

1391−

1392−

src/lib/ProjectM36/ScriptSession.hs+44−72

@@ -1,12 +1,8 @@

1−{-# LANGUAGE UnboxedTuples, KindSignatures, DataKinds #-}

1+{-# LANGUAGE MagicHash, UnboxedTuples #-}

2−#ifdef PM36_HASKELL_SCRIPTING

3−{-# LANGUAGE MagicHash #-}

4−#endif

5module ProjectM36.ScriptSession where

2module ProjectM36.ScriptSession where

6

3

7−#ifdef PM36_HASKELL_SCRIPTING

8import ProjectM36.Error

4import ProjectM36.Error

9−import GHC

5+

10import Control.Exception

6import Control.Exception

11import Control.Monad

7import Control.Monad

12import System.IO.Error

8import System.IO.Error

@@ -17,8 +13,9 @@ import System.FilePath

17import System.Info (os, arch)

13import System.Info (os, arch)

18import Data.Text (Text, unpack)

14import Data.Text (Text, unpack)

19import Data.Maybe

15import Data.Maybe

16+

17+import GHC

20import GHC.Paths (libdir)

18import GHC.Paths (libdir)

21−import System.Environment

22#if __GLASGOW_HASKELL__ >= 800

19#if __GLASGOW_HASKELL__ >= 800

23import GHC.LanguageExtensions

20import GHC.LanguageExtensions

24import GHCi.ObjLink

21import GHCi.ObjLink

@@ -36,41 +33,25 @@ import Unsafe.Coerce

36#if __GLASGOW_HASKELL__ >= 802

33#if __GLASGOW_HASKELL__ >= 802

37import Type

34import Type

38#elif __GLASGOW_HASKELL__ >= 710

35#elif __GLASGOW_HASKELL__ >= 710

39−import Type hiding (pprTyThing)

36+import Type hiding (pprTyThing)

40#else

37#else

41#endif

38#endif

39+

42import GHC.Exts (addrToAny#)

40import GHC.Exts (addrToAny#)

43import GHC.Ptr (Ptr(..))

41import GHC.Ptr (Ptr(..))

44import Encoding

42import Encoding

45−#endif

46−

47

43

48data ScriptSession = ScriptSession {

44data ScriptSession = ScriptSession {

49−#ifdef PM36_HASKELL_SCRIPTING

50− hscEnv :: HscEnv,

45+ hscEnv :: HscEnv,

51 atomFunctionBodyType :: Type,

46 atomFunctionBodyType :: Type,

52 dbcFunctionBodyType :: Type

47 dbcFunctionBodyType :: Type

53−#endif

54 }

48 }

55−

49+

56−#ifdef PM36_HASKELL_SCRIPTING

57−data ScriptSessionError = ScriptSessionLoadError GhcException

50+newtype ScriptSessionError = ScriptSessionLoadError GhcException

58− | ScriptingDisabled

59 deriving (Show)

51 deriving (Show)

60−#else

61−data ScriptSessionError = ScriptingDisabled

62− deriving (Show)

63−#endif

64−

65−data LoadSymbolError = LoadSymbolError

66−type ModName = String

67−type FuncName = String

68

52

69-- | Configure a GHC environment/session which we will use for all script compilation.

53-- | Configure a GHC environment/session which we will use for all script compilation.

70initScriptSession :: [String] -> IO (Either ScriptSessionError ScriptSession)

54initScriptSession :: [String] -> IO (Either ScriptSessionError ScriptSession)

71−#if !defined(PM36_HASKELL_SCRIPTING)

72−initScriptSession _ = pure (Left ScriptingDisabled)

73−#else

74initScriptSession ghcPkgPaths = do

55initScriptSession ghcPkgPaths = do

75 --for the sake of convenience, for developers' builds, include the local cabal sandbox package database and the cabal new-build package database

56 --for the sake of convenience, for developers' builds, include the local cabal sandbox package database and the cabal new-build package database

76 eHomeDir <- tryJust (guard . isDoesNotExistError) getHomeDirectory

57 eHomeDir <- tryJust (guard . isDoesNotExistError) getHomeDirectory

@@ -79,30 +60,28 @@ initScriptSession ghcPkgPaths = do

79 handleGhcException excHandler $ runGhc (Just libdir) $ do

60 handleGhcException excHandler $ runGhc (Just libdir) $ do

80 dflags <- getSessionDynFlags

61 dflags <- getSessionDynFlags

81 let ghcVersion = projectVersion dflags

62 let ghcVersion = projectVersion dflags

82− -- get nix packages dir, if available

83− mNixLibDir <- liftIO $ lookupEnv "NIX_GHC_LIBDIR"

84

63

85 sandboxPkgPaths <- liftIO $ concat <$> mapM glob [

64 sandboxPkgPaths <- liftIO $ concat <$> mapM glob [

86− --"./dist-newstyle/packagedb/ghc-" ++ ghcVersion, --rely on cabal 3's ghc.environment install: "cabal install --lib project-m36"

65+ "./dist-newstyle/packagedb/ghc-" ++ ghcVersion,

87 ".cabal-sandbox/*ghc-" ++ ghcVersion ++ "-packages.conf.d",

66 ".cabal-sandbox/*ghc-" ++ ghcVersion ++ "-packages.conf.d",

88 ".stack-work/install/*/*/" ++ ghcVersion ++ "/pkgdb",

67 ".stack-work/install/*/*/" ++ ghcVersion ++ "/pkgdb",

89 ".stack-work/install/*/pkgdb/", --windows stack build

68 ".stack-work/install/*/pkgdb/", --windows stack build

90 "C:/sr/snapshots/b201cfe6/pkgdb", --windows stack build- ideally, we could run `stack path --snapshot-pkg-db, but this is sufficient to pass CI

69 "C:/sr/snapshots/b201cfe6/pkgdb", --windows stack build- ideally, we could run `stack path --snapshot-pkg-db, but this is sufficient to pass CI

91− homeDir </> ".stack/snapshots/*/*/" ++ ghcVersion ++ "/pkgdb"

70+ homeDir </> ".stack/snapshots/*/*/" ++ ghcVersion ++ "/pkgdb",

92− --homeDir </> ".cabal/store/ghc-" ++ ghcVersion ++ "/package.db"

71+ homeDir </> ".cabal/store/ghc-" ++ ghcVersion ++ "/package.db"

93 ]

72 ]

94−

73+

95− let localPkgPaths = map PkgConfFile (ghcPkgPaths ++ sandboxPkgPaths ++ maybeToList mNixLibDir)

74+ let localPkgPaths = map PkgConfFile (ghcPkgPaths ++ sandboxPkgPaths)

96−

75+

97− let dflags' = applyGopts . applyXopts $ dflags { hscTarget = HscInterpreted ,

76+ let dflags' = applyGopts . applyXopts $ dflags { hscTarget = HscInterpreted ,

98− ghcLink = LinkInMemory,

77+ ghcLink = LinkInMemory,

99 safeHaskell = Sf_Trustworthy,

78 safeHaskell = Sf_Trustworthy,

100 safeInfer = True,

79 safeInfer = True,

101 safeInferred = True,

80 safeInferred = True,

102 --verbosity = 3,

81 --verbosity = 3,

103−#if __GLASGOW_HASKELL__ >= 800

82+#if __GLASGOW_HASKELL__ >= 800

104 trustFlags = map TrustPackage required_packages,

83 trustFlags = map TrustPackage required_packages,

105−#endif

84+#endif

106 packageFlags = packageFlags dflags ++ packages,

85 packageFlags = packageFlags dflags ++ packages,

107#if __GLASGOW_HASKELL__ >= 802

86#if __GLASGOW_HASKELL__ >= 802

108 packageDBFlags = map PackageDB localPkgPaths

87 packageDBFlags = map PackageDB localPkgPaths

@@ -115,11 +94,11 @@ initScriptSession ghcPkgPaths = do

115 applyXopts flags = foldl xopt_set flags xopts

94 applyXopts flags = foldl xopt_set flags xopts

116#if __GLASGOW_HASKELL__ >= 800

95#if __GLASGOW_HASKELL__ >= 800

117 xopts = [OverloadedStrings, ExtendedDefaultRules, ImplicitPrelude, ScopedTypeVariables]

96 xopts = [OverloadedStrings, ExtendedDefaultRules, ImplicitPrelude, ScopedTypeVariables]

118−#else

97+#else

119 xopts = [Opt_OverloadedStrings, Opt_ExtendedDefaultRules, Opt_ImplicitPrelude, Opt_ScopedTypeVariables]

98 xopts = [Opt_OverloadedStrings, Opt_ExtendedDefaultRules, Opt_ImplicitPrelude, Opt_ScopedTypeVariables]

120#endif

99#endif

121 gopts = [] --[Opt_DistrustAllPackages, Opt_PackageTrust]

100 gopts = [] --[Opt_DistrustAllPackages, Opt_PackageTrust]

122− required_packages = ["base",

101+ required_packages = ["base",

123 "containers",

102 "containers",

124 "Glob",

103 "Glob",

125 "directory",

104 "directory",

@@ -128,6 +107,8 @@ initScriptSession ghcPkgPaths = do

128 "uuid",

107 "uuid",

129 "vector",

108 "vector",

130 "text",

109 "text",

110+ "binary",

111+ "vector-binary-instances",

131 "time",

112 "time",

132 "project-m36",

113 "project-m36",

133 "bytestring"]

114 "bytestring"]

@@ -139,33 +120,20 @@ initScriptSession ghcPkgPaths = do

139 --liftIO $ traceShowM (showSDoc dflags' (ppr packages))

120 --liftIO $ traceShowM (showSDoc dflags' (ppr packages))

140 _ <- setSessionDynFlags dflags'

121 _ <- setSessionDynFlags dflags'

141 let safeImportDecl mn mQual = ImportDecl {

122 let safeImportDecl mn mQual = ImportDecl {

142−#if __GLASGOW_HASKELL__ >= 802

123+#if __GLASGOW_HASKELL__ >= 802

143 ideclSourceSrc = NoSourceText,

124 ideclSourceSrc = NoSourceText,

144#else

125#else

145 ideclSourceSrc = Nothing,

126 ideclSourceSrc = Nothing,

146#endif

127#endif

147−

148−#if __GLASGOW_HASKELL__ >= 810

149− ideclExt = noExtField,

150−#elif __GLASGOW_HASKELL__ >= 806

151− ideclExt = NoExt,

152−#endif

153 ideclName = noLoc mn,

128 ideclName = noLoc mn,

154 ideclPkgQual = Nothing,

129 ideclPkgQual = Nothing,

155 ideclSource = False,

130 ideclSource = False,

156 ideclSafe = True,

131 ideclSafe = True,

157 ideclImplicit = False,

132 ideclImplicit = False,

158−#if __GLASGOW_HASKELL__ >= 810

159− ideclQualified = if isJust mQual then QualifiedPre else NotQualified,

160−#else

161 ideclQualified = isJust mQual,

133 ideclQualified = isJust mQual,

162−#endif

163 ideclAs = mQual,

134 ideclAs = mQual,

164 ideclHiding = Nothing

135 ideclHiding = Nothing

165 }

136 }

166−#if __GLASGOW_HASKELL__ >= 806

167− :: ImportDecl (GhcPass (c :: Pass))

168−#endif

169 unqualifiedModules = map (\modn -> IIDecl $ safeImportDecl (mkModuleName modn) Nothing) [

137 unqualifiedModules = map (\modn -> IIDecl $ safeImportDecl (mkModuleName modn) Nothing) [

170 "Prelude",

138 "Prelude",

171 "Data.Map",

139 "Data.Map",

@@ -182,7 +150,7 @@ initScriptSession ghcPkgPaths = do

182 mkModName = noLoc . mkModuleName

150 mkModName = noLoc . mkModuleName

183#else

151#else

184 mkModName = mkModuleName

152 mkModName = mkModuleName

185−#endif

153+#endif

186 qualifiedModules = map (\(modn, qualNam) -> IIDecl $ safeImportDecl (mkModuleName modn) (Just (mkModName qualNam))) [

154 qualifiedModules = map (\(modn, qualNam) -> IIDecl $ safeImportDecl (mkModuleName modn) (Just (mkModName qualNam))) [

187 ("Data.Text", "T")

155 ("Data.Text", "T")

188 ]

156 ]

@@ -195,8 +163,8 @@ initScriptSession ghcPkgPaths = do

195addImport :: String -> Ghc ()

163addImport :: String -> Ghc ()

196addImport moduleNam = do

164addImport moduleNam = do

197 ctx <- getContext

165 ctx <- getContext

198− setContext (IIDecl (simpleImportDecl (mkModuleName moduleNam)) : ctx)

166+ setContext ( (IIDecl $ simpleImportDecl (mkModuleName moduleNam)) : ctx )

199−

167+

200showType :: DynFlags -> Type -> String

168showType :: DynFlags -> Type -> String

201showType dflags ty = showSDocForUser dflags alwaysQualify (pprTypeForUser ty)

169showType dflags ty = showSDocForUser dflags alwaysQualify (pprTypeForUser ty)

202

170

@@ -221,36 +189,41 @@ compileScript funcType script = do

221 mErr <- typeCheckScript funcType script

189 mErr <- typeCheckScript funcType script

222 case mErr of

190 case mErr of

223 Just err -> pure (Left err)

191 Just err -> pure (Left err)

224− Nothing ->

192+ Nothing ->

225 --catch exception here

193 --catch exception here

226 --we could potentially wrap the script with Atom pattern matching so that the script doesn't have to do it, but the change to an Atom ADT should make it easier. Still, it would be nice if the script didn't have to handle a list of arguments, for example.

194 --we could potentially wrap the script with Atom pattern matching so that the script doesn't have to do it, but the change to an Atom ADT should make it easier. Still, it would be nice if the script didn't have to handle a list of arguments, for example.

227 -- we can't use dynCompileExpr here because

195 -- we can't use dynCompileExpr here because

228 Right . unsafeCoerce <$> compileExpr sScript

196 Right . unsafeCoerce <$> compileExpr sScript

229−

197+

230−typeCheckScript :: Type -> Text -> Ghc (Maybe ScriptCompilationError)

198+typeCheckScript :: Type -> Text -> Ghc (Maybe ScriptCompilationError)

231typeCheckScript expectedType inp = do

199typeCheckScript expectedType inp = do

232− dflags <- getSessionDynFlags

200+ dflags <- getSessionDynFlags

233 --catch exception for SyntaxError

201 --catch exception for SyntaxError

234#if __GLASGOW_HASKELL__ >= 802

202#if __GLASGOW_HASKELL__ >= 802

235− funcType <- GHC.exprType TM_Inst (unpack inp)

203+ funcType <- GHC.exprType TM_Inst (unpack inp)

236−#else

204+#else

237 funcType <- GHC.exprType (unpack inp)

205 funcType <- GHC.exprType (unpack inp)

238#endif

206#endif

239− --liftIO $ putStrLn $ showType dflags expectedType ++ ":::" ++ showType dflags funcType

207+ --liftIO $ putStrLn $ showType dflags expectedType ++ ":::" ++ showType dflags funcType

240 if eqType funcType expectedType then

208 if eqType funcType expectedType then

241 pure Nothing

209 pure Nothing

242 else

210 else

243 pure (Just (TypeCheckCompilationError (showType dflags expectedType) (showType dflags funcType)))

211 pure (Just (TypeCheckCompilationError (showType dflags expectedType) (showType dflags funcType)))

244−

212+

245mangleSymbol :: Maybe String -> String -> String -> String

213mangleSymbol :: Maybe String -> String -> String -> String

246mangleSymbol pkg module' valsym =

214mangleSymbol pkg module' valsym =

247 prefixUnderscore ++

215 prefixUnderscore ++

248 maybe "" (\p -> zEncodeString p ++ "_") pkg ++

216 maybe "" (\p -> zEncodeString p ++ "_") pkg ++

249 zEncodeString module' ++ "_" ++ zEncodeString valsym ++ "_closure"

217 zEncodeString module' ++ "_" ++ zEncodeString valsym ++ "_closure"

218+

219+type ModName = String

220+type FuncName = String

221+

222+data LoadSymbolError = LoadSymbolError

250

223

251loadFunction :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError a)

224loadFunction :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError a)

252loadFunction modName funcName objPath = do

225loadFunction modName funcName objPath = do

253−#if __GLASGOW_HASKELL__ >= 802

226+#if __GLASGOW_HASKELL__ >= 802

254 initObjLinker RetainCAFs

227 initObjLinker RetainCAFs

255#else

228#else

256 initObjLinker

229 initObjLinker

@@ -262,8 +235,8 @@ loadFunction modName funcName objPath = do

262 Nothing -> pure (Left LoadSymbolError)

235 Nothing -> pure (Left LoadSymbolError)

263 Just (Ptr addr) -> case addrToAny# addr of

236 Just (Ptr addr) -> case addrToAny# addr of

264 (# hval #) -> pure (Right hval)

237 (# hval #) -> pure (Right hval)

265−

238+

266−prefixUnderscore :: String

239+prefixUnderscore :: String

267prefixUnderscore =

240prefixUnderscore =

268 case (os,arch) of

241 case (os,arch) of

269 ("mingw32","x86_64") -> ""

242 ("mingw32","x86_64") -> ""

@@ -271,5 +244,4 @@ prefixUnderscore =

271 ("mingw32",_) -> "_"

244 ("mingw32",_) -> "_"

272 ("darwin",_) -> "_"

245 ("darwin",_) -> "_"

273 ("cygwin",_) -> "_"

246 ("cygwin",_) -> "_"

274− _ -> ""

247+ _ -> ""

275−#endif

src/lib/ProjectM36/Serialise/AtomFunctionError.hsdeleted−7

@@ -1,7 +0,0 @@

1−{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

2−{-# OPTIONS_GHC -fno-warn-orphans #-}

3−module ProjectM36.Serialise.AtomFunctionError where

4−import Codec.Winery

5−import ProjectM36.AtomFunctionError

6−

7−deriving via WineryVariant AtomFunctionError instance Serialise AtomFunctionError

src/lib/ProjectM36/Serialise/Base.hsdeleted−85

@@ -1,85 +0,0 @@

1−{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeApplications, TypeSynonymInstances, ScopedTypeVariables #-}

2−{-# OPTIONS_GHC -fno-warn-orphans #-}

3−--Serialise instances for ProjectM36.Base data types- orphan instance city

4−module ProjectM36.Serialise.Base where

5−import Codec.Winery hiding (Schema)

6−import Codec.Winery.Internal

7−import Control.Monad

8−import ProjectM36.Base

9−import ProjectM36.MerkleHash

10−import Data.UUID

11−import Data.Proxy

12−import Data.Word

13−import ProjectM36.Attribute as A

14−import qualified Data.List.NonEmpty as NE

15−import qualified Data.Vector as V

16−import Data.Time.Calendar (Day,toGregorian,fromGregorian)

17−

18−deriving via WineryVariant Atom instance Serialise Atom

19−deriving via WineryVariant AtomType instance Serialise AtomType

20−deriving via WineryVariant Attribute instance Serialise Attribute

21−deriving via WineryVariant RelationTupleSet instance Serialise RelationTupleSet

22−deriving via WineryVariant RelationTuple instance Serialise RelationTuple

23−deriving via WineryVariant Relation instance Serialise Relation

24−deriving via WineryVariant RelationCardinality instance Serialise RelationCardinality

25−deriving via WineryVariant (RelationalExprBase a) instance Serialise a => Serialise (RelationalExprBase a)

26−deriving via WineryVariant (WithNameExprBase a) instance Serialise a => Serialise (WithNameExprBase a)

27−deriving via WineryVariant Notification instance Serialise Notification

28−deriving via WineryVariant TypeConstructorDef instance Serialise TypeConstructorDef

29−deriving via WineryVariant (TypeConstructorBase a) instance Serialise a => Serialise (TypeConstructorBase a)

30−deriving via WineryVariant DataConstructorDef instance Serialise DataConstructorDef

31−deriving via WineryVariant DataConstructorDefArg instance Serialise DataConstructorDefArg

32−deriving via WineryVariant GraphRefTransactionMarker instance Serialise GraphRefTransactionMarker

33−deriving via WineryVariant SchemaIsomorph instance Serialise SchemaIsomorph

34−deriving via WineryVariant InclusionDependency instance Serialise InclusionDependency

35−deriving via WineryVariant (DatabaseContextExprBase a) instance Serialise a => Serialise (DatabaseContextExprBase a)

36−deriving via WineryVariant (DatabaseContextIOExprBase a) instance Serialise a => Serialise (DatabaseContextIOExprBase a)

37−deriving via WineryVariant (RestrictionPredicateExprBase a) instance Serialise a => Serialise (RestrictionPredicateExprBase a)

38−deriving via WineryVariant TransactionInfo instance Serialise TransactionInfo

39−deriving via WineryVariant (AtomExprBase a) instance Serialise a => Serialise (AtomExprBase a)

40−deriving via WineryVariant MerkleHash instance Serialise MerkleHash

41−deriving via WineryVariant (AttributeExprBase a) instance Serialise a => Serialise (AttributeExprBase a)

42−deriving via WineryVariant (TupleExprsBase a) instance Serialise a => Serialise (TupleExprsBase a)

43−deriving via WineryVariant (TupleExprBase a) instance Serialise a => Serialise (TupleExprBase a)

44−deriving via WineryVariant (AttributeNamesBase a) instance Serialise a => Serialise (AttributeNamesBase a)

45−deriving via WineryVariant (ExtendTupleExprBase a) instance Serialise a => Serialise (ExtendTupleExprBase a)

46−deriving via WineryVariant Schema instance Serialise Schema

47−deriving via WineryVariant MergeStrategy instance Serialise MergeStrategy

48−

49−fromWordsTup :: (Word32, Word32, Word32, Word32) -> TransactionId

50−fromWordsTup (a,b,c,d) = fromWords a b c d

51−

52−instance Serialise TransactionId where

53− schemaGen _ = getSchema (Proxy @(Word32, Word32, Word32, Word32))

54− toBuilder uuid = toBuilder (toWords uuid)

55− extractor = fromWordsTup <$> extractor

56− decodeCurrent = fromWordsTup <$> decodeCurrent

57−

58−instance Serialise a => Serialise (NE.NonEmpty a) where

59− schemaGen _ = SVector <$> getSchema (Proxy @a)

60− toBuilder xs = varInt (length xs) <> foldMap toBuilder xs

61− extractor = NE.fromList . V.toList <$> extractListBy extractor --use nonempty instead to replace error with winery error

62− decodeCurrent = do

63− n <- decodeVarInt

64− l <- replicateM n decodeCurrent

65− pure (NE.fromList l)

66−

67−fromGregorianTup :: (Integer, Int, Int) -> Day

68−fromGregorianTup (a, b, c) = fromGregorian a b c

69−

70−instance Serialise Day where

71− schemaGen _ = getSchema (Proxy @(Integer, Int, Int))

72− toBuilder day = toBuilder (toGregorian day)

73− extractor = fromGregorianTup <$> extractor

74− decodeCurrent = fromGregorianTup <$> decodeCurrent

75−

76−instance Serialise Attributes where

77− schemaGen _ = SVector <$> getSchema (Proxy @Attribute)

78− toBuilder attrs = varInt (V.length (attributesVec attrs)) <> foldMap toBuilder (V.toList (attributesVec attrs))

79− extractor =

80− attributesFromList . V.toList <$> extractListBy extractor

81−

82− decodeCurrent = do

83− n <- decodeVarInt

84− l <- replicateM n decodeCurrent

85− pure (A.attributesFromList l)

src/lib/ProjectM36/Serialise/DataFrame.hsdeleted−13

@@ -1,13 +0,0 @@

1−{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

2−{-# OPTIONS_GHC -fno-warn-orphans #-}

3−module ProjectM36.Serialise.DataFrame where

4−import Codec.Winery

5−import ProjectM36.DataFrame

6−import ProjectM36.Serialise.Base ()

7−

8−deriving via WineryVariant AttributeOrderExpr instance Serialise AttributeOrderExpr

9−deriving via WineryVariant AttributeOrder instance Serialise AttributeOrder

10−deriving via WineryVariant Order instance Serialise Order

11−deriving via WineryRecord DataFrame instance Serialise DataFrame

12−deriving via WineryVariant DataFrameTuple instance Serialise DataFrameTuple

13−deriving via WineryRecord DataFrameExpr instance Serialise DataFrameExpr

src/lib/ProjectM36/Serialise/DatabaseContextFunctionError.hsdeleted−7

@@ -1,7 +0,0 @@

1−{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

2−{-# OPTIONS_GHC -fno-warn-orphans #-}

3−module ProjectM36.Serialise.DatabaseContextFunctionError where

4−import Codec.Winery

5−import ProjectM36.DatabaseContextFunctionError

6−

7−deriving via WineryVariant DatabaseContextFunctionError instance Serialise DatabaseContextFunctionError

src/lib/ProjectM36/Serialise/Error.hsdeleted−15

@@ -1,15 +0,0 @@

1−{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

2−{-# OPTIONS_GHC -fno-warn-orphans #-}

3−module ProjectM36.Serialise.Error where

4−import ProjectM36.Error

5−import Codec.Winery

6−import ProjectM36.Serialise.Base ()

7−import ProjectM36.Serialise.AtomFunctionError ()

8−import ProjectM36.Serialise.DatabaseContextFunctionError ()

9−

10−deriving via WineryVariant RelationalError instance Serialise RelationalError

11−deriving via WineryVariant MergeError instance Serialise MergeError

12−deriving via WineryVariant ScriptCompilationError instance Serialise ScriptCompilationError

13−deriving via WineryVariant PersistenceError instance Serialise PersistenceError

14−deriving via WineryVariant SchemaError instance Serialise SchemaError

15−deriving via WineryVariant ImportError' instance Serialise ImportError'

src/lib/ProjectM36/Serialise/IsomorphicSchema.hsdeleted−7

@@ -1,7 +0,0 @@

1−{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeSynonymInstances, ScopedTypeVariables #-}

2−{-# OPTIONS_GHC -fno-warn-orphans #-}

3−module ProjectM36.Serialise.IsomorphicSchema where

4−import Codec.Winery

5−import ProjectM36.IsomorphicSchema

6−

7−deriving via WineryVariant SchemaExpr instance Serialise SchemaExpr

src/lib/ProjectM36/Serialise/MergeError.hsdeleted−1

@@ -1 +0,0 @@

1−

src/lib/ProjectM36/Server.hs+99−166

@@ -7,119 +7,80 @@ import ProjectM36.Server.RemoteCallTypes

7import ProjectM36.Server.Config (ServerConfig(..))

8import ProjectM36.FSType

9

10+import Control.Monad.IO.Class (liftIO)

11+#if MIN_VERSION_network_transport_tcp(0,7,0)

12+import Network.Transport.TCP (createTransport, defaultTCPParameters, TCPAddr(..), TCPAddrInfo(..))

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(..))

10−import Control.Concurrent.MVar (MVar)

21+import Control.Concurrent.MVar (putMVar, MVar)

11import System.IO (stderr, hPutStrLn)

22import System.IO (stderr, hPutStrLn)

12import System.FilePath (takeDirectory)

23import System.FilePath (takeDirectory)

13import System.Directory (doesDirectoryExist)

24import System.Directory (doesDirectoryExist)

14−import Network.RPC.Curryer.Server

15−import Network.Socket

16−import qualified StmContainers.Map as StmMap

17−import Control.Concurrent.STM

18−

19−type TestMode = Bool

20−

21−requestHandlers :: TestMode -> Maybe Timeout -> RequestHandlers ServerState

22−requestHandlers testFlag ti =

23− [

24− RequestHandler (\sState (Login dbName) -> do

25− addClientLogin dbName sState

26− conn <- getConn sState

27− handleLogin conn (connectionSocket sState)),

28− RequestHandler (\sState Logout -> do

29− conn <- getConn sState

30− handleLogout ti conn),

31− RequestHandler $ \sState (ExecuteHeadName sessionId) -> do

32− --socket -> dbname --maybe create a socket->client state mapping in the server state, too

33− conn <- getConn sState

34− handleExecuteHeadName ti sessionId conn,

35− RequestHandler (\sState (ExecuteRelationalExpr sessionId expr) -> do

36− conn <- getConn sState

37− handleExecuteRelationalExpr ti sessionId conn expr),

38− RequestHandler (\sState (ExecuteDataFrameExpr sessionId expr) -> do

39− conn <- getConn sState

40− handleExecuteDataFrameExpr ti sessionId conn expr),

41− RequestHandler (\sState (ExecuteDatabaseContextExpr sessionId expr) -> do

42− conn <- getConn sState

43− handleExecuteDatabaseContextExpr ti sessionId conn expr),

44− RequestHandler (\sState (ExecuteDatabaseContextIOExpr sessionId expr) -> do

45− conn <- getConn sState

46− handleExecuteDatabaseContextIOExpr ti sessionId conn expr),

47− RequestHandler (\sState (ExecuteGraphExpr sessionId expr) -> do

48− conn <- getConn sState

49− handleExecuteGraphExpr ti sessionId conn expr),

50− RequestHandler (\sState (ExecuteTransGraphRelationalExpr sessionId expr) -> do

51− conn <- getConn sState

52− handleExecuteTransGraphRelationalExpr ti sessionId conn expr),

53− RequestHandler (\sState (ExecuteTypeForRelationalExpr sessionId expr) -> do

54− conn <- getConn sState

55− handleExecuteTypeForRelationalExpr ti sessionId conn expr),

56− RequestHandler (\sState (RetrieveInclusionDependencies sessionId) -> do

57− conn <- getConn sState

58− handleRetrieveInclusionDependencies ti sessionId conn),

59− RequestHandler (\sState (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> do

60− conn <- getConn sState

61− handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr),

62− RequestHandler (\sState (RetrieveHeadTransactionId sessionId) -> do

63− conn <- getConn sState

64− handleRetrieveHeadTransactionId ti sessionId conn),

65− RequestHandler (\sState (RetrieveTransactionGraph sessionId) -> do

66− conn <- getConn sState

67− handleRetrieveTransactionGraph ti sessionId conn),

68− RequestHandler (\sState (CreateSessionAtHead headn) -> do

69− conn <- getConn sState

70− handleCreateSessionAtHead ti conn headn),

71− RequestHandler (\sState (CreateSessionAtCommit commitId) -> do

72− conn <- getConn sState

73− handleCreateSessionAtCommit ti conn commitId),

74− RequestHandler (\sState (CloseSession sessionId) -> do

75− conn <- getConn sState

76− handleCloseSession sessionId conn),

77− RequestHandler (\sState (RetrieveAtomTypesAsRelation sessionId) -> do

78− conn <- getConn sState

79− handleRetrieveAtomTypesAsRelation ti sessionId conn),

80− RequestHandler (\sState (RetrieveRelationVariableSummary sessionId) -> do

81− conn <- getConn sState

82− handleRetrieveRelationVariableSummary ti sessionId conn),

83− RequestHandler (\sState (RetrieveAtomFunctionSummary sessionId) -> do

84− conn <- getConn sState

85− handleRetrieveAtomFunctionSummary ti sessionId conn),

86− RequestHandler (\sState (RetrieveDatabaseContextFunctionSummary sessionId) -> do

87− conn <- getConn sState

88− handleRetrieveDatabaseContextFunctionSummary ti sessionId conn), RequestHandler (\sState (RetrieveCurrentSchemaName sessionId) -> do

89− conn <- getConn sState

90− handleRetrieveCurrentSchemaName ti sessionId conn),

91− RequestHandler (\sState (ExecuteSchemaExpr sessionId schemaExpr) -> do

92− conn <- getConn sState

93− handleExecuteSchemaExpr ti sessionId conn schemaExpr),

94− RequestHandler (\sState (RetrieveSessionIsDirty sessionId) -> do

95− conn <- getConn sState

96− handleRetrieveSessionIsDirty ti sessionId conn),

97− RequestHandler (\sState (ExecuteAutoMergeToHead sessionId strat headName') -> do

98− conn <- getConn sState

99− handleExecuteAutoMergeToHead ti sessionId conn strat headName'),

100− RequestHandler (\sState (RetrieveTypeConstructorMapping sessionId) -> do

101− conn <- getConn sState

102− handleRetrieveTypeConstructorMapping ti sessionId conn),

103− RequestHandler (\sState (ExecuteValidateMerkleHashes sessionId) -> do

104− conn <- getConn sState

105− handleValidateMerkleHashes ti sessionId conn)

106− ] ++ if testFlag then testModeHandlers ti else []

107−

108−getConn :: ConnectionState ServerState -> IO Connection

109−getConn connState = do

110− let sock = lockless (connectionSocket connState)

111− sState = connectionServerState connState

112− mConn <- connectionForClient sock sState

113− case mConn of

114− Nothing -> error "failed to find socket in client map"

115− Just conn -> pure conn

116−

117−testModeHandlers :: Maybe Timeout -> RequestHandlers ServerState

118−testModeHandlers ti = [RequestHandler (\sState (TestTimeout sessionId) -> do

119− conn <- getConn sState

120− handleTestTimeout ti sessionId conn)]

121

25

26+-- the state should be a mapping of remote connection to the disconnected transaction- the graph should be the same, so discon must be removed from the stm tuple

27+--trying to refactor this for less repetition is very challenging because the return type cannot be polymorphic or the distributed-process call gets confused and drops messages

28+serverDefinition :: Bool -> Timeout -> ProcessDefinition Connection

29+serverDefinition testBool ti = defaultProcess {

30+ apiHandlers = [

31+ handleCall (\conn (ExecuteHeadName sessionId) -> handleExecuteHeadName ti sessionId conn),

32+ handleCall (\conn (ExecuteRelationalExpr sessionId expr) -> handleExecuteRelationalExpr ti sessionId conn expr),

33+ handleCall (\conn (ExecuteDataFrameExpr sessionId expr) -> handleExecuteDataFrameExpr ti sessionId conn expr),

34+ handleCall (\conn (ExecuteDatabaseContextExpr sessionId expr) -> handleExecuteDatabaseContextExpr ti sessionId conn expr),

35+ handleCall (\conn (ExecuteDatabaseContextIOExpr sessionId expr) -> handleExecuteDatabaseContextIOExpr ti sessionId conn expr),

36+ handleCall (\conn (ExecuteGraphExpr sessionId expr) -> handleExecuteGraphExpr ti sessionId conn expr),

37+ handleCall (\conn (ExecuteTransGraphRelationalExpr sessionId expr) -> handleExecuteTransGraphRelationalExpr ti sessionId conn expr),

38+ handleCall (\conn (ExecuteTypeForRelationalExpr sessionId expr) -> handleExecuteTypeForRelationalExpr ti sessionId conn expr),

39+ handleCall (\conn (RetrieveInclusionDependencies sessionId) -> handleRetrieveInclusionDependencies ti sessionId conn),

40+ handleCall (\conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr),

41+ handleCall (\conn (RetrieveHeadTransactionId sessionId) -> handleRetrieveHeadTransactionId ti sessionId conn),

42+ handleCall (\conn (RetrieveTransactionGraph sessionId) -> handleRetrieveTransactionGraph ti sessionId conn),

43+ handleCall (\conn (Login procId) -> handleLogin ti conn procId),

44+ handleCall (\conn (CreateSessionAtHead headn) -> handleCreateSessionAtHead ti conn headn),

45+ handleCall (\conn (CreateSessionAtCommit commitId) -> handleCreateSessionAtCommit ti conn commitId),

46+ handleCall (\conn (CloseSession sessionId) -> handleCloseSession ti sessionId conn),

47+ handleCall (\conn (RetrieveAtomTypesAsRelation sessionId) -> handleRetrieveAtomTypesAsRelation ti sessionId conn),

48+ handleCall (\conn (RetrieveRelationVariableSummary sessionId) -> handleRetrieveRelationVariableSummary ti sessionId conn),

49+ handleCall (\conn (RetrieveAtomFunctionSummary sessionId) -> handleRetrieveAtomFunctionSummary ti sessionId conn),

50+ handleCall (\conn (RetrieveDatabaseContextFunctionSummary sessionId) -> handleRetrieveDatabaseContextFunctionSummary ti sessionId conn),

51+ handleCall (\conn (RetrieveCurrentSchemaName sessionId) -> handleRetrieveCurrentSchemaName ti sessionId conn),

52+ handleCall (\conn (ExecuteSchemaExpr sessionId schemaExpr) -> handleExecuteSchemaExpr ti sessionId conn schemaExpr),

53+ handleCall (\conn (RetrieveSessionIsDirty sessionId) -> handleRetrieveSessionIsDirty ti sessionId conn),

54+ handleCall (\conn (ExecuteAutoMergeToHead sessionId strat headName') -> handleExecuteAutoMergeToHead ti sessionId conn strat headName'),

55+ handleCall (\conn (RetrieveTypeConstructorMapping sessionId) -> handleRetrieveTypeConstructorMapping ti sessionId conn),

56+ handleCall (\conn Logout -> handleLogout ti conn)

57+ ] ++ testModeHandlers,

58+ unhandledMessagePolicy = Terminate

59+ --unhandledMessagePolicy = Log

60+ }

61+ where

62+ testModeHandlers = if not testBool then

63+ []

64+ else

65+ [handleCall (\conn (TestTimeout sessionId) -> handleTestTimeout ti sessionId conn)]

66+

122

67

68+initServer :: InitHandler (Connection, DatabaseName, Maybe (MVar EndPointAddress), EndPointAddress) Connection

69+initServer (conn, dbname, mAddressMVar, saddress) = do

70+ registerDB dbname

71+ case mAddressMVar of

72+ Nothing -> pure ()

73+ Just addressMVar -> liftIO $ putMVar addressMVar saddress

74+ --traceShowM ("server started on " ++ show saddress)

75+ pure $ InitOk conn Infinity

76+

77+registerDB :: DatabaseName -> Process ()

78+registerDB dbname = do

79+ self <- getSelfPid

80+ let dbname' = remoteDBLookupName dbname

81+ register dbname' self

82+ --liftIO $ putStrLn $ "registered " ++ (show self) ++ " " ++ dbname'

83+

123-- | A notification callback which logs the notification to stderr and does nothing else.

84-- | A notification callback which logs the notification to stderr and does nothing else.

124loggingNotificationCallback :: NotificationCallback

85loggingNotificationCallback :: NotificationCallback

125loggingNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received \"" ++ show notName ++ "\": " ++ show evaldNot

86loggingNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received \"" ++ show notName ++ "\": " ++ show evaldNot

@@ -144,47 +105,9 @@ checkFSType performCheck strat =

144checkFSErrorMsg :: String

105checkFSErrorMsg :: String

145checkFSErrorMsg = "The filesystem does not support journaling so writes may not be crash-safe. Use --disable-fscheck to disable this fatal error."

106checkFSErrorMsg = "The filesystem does not support journaling so writes may not be crash-safe. Use --disable-fscheck to disable this fatal error."

146

107

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 })

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.

108-- | A synchronous function to start the project-m36 daemon given an appropriate 'ServerConfig'. Note that this function only returns if the server exits. Returns False if the daemon exited due to an error. If the second argument is not Nothing, the port is put after the server is ready to service the port.

186−launchServer :: ServerConfig -> Maybe (MVar SockAddr) -> IO Bool

109+launchServer :: ServerConfig -> Maybe (MVar EndPointAddress) -> IO Bool

187−launchServer daemonConfig mAddr = do

110+launchServer daemonConfig mAddressMVar = do

188 checkFSResult <- checkFSType (checkFS daemonConfig) (persistenceStrategy daemonConfig)

111 checkFSResult <- checkFSType (checkFS daemonConfig) (persistenceStrategy daemonConfig)

189 if not checkFSResult then do

112 if not checkFSResult then do

190 hPutStrLn stderr checkFSErrorMsg

113 hPutStrLn stderr checkFSErrorMsg

@@ -197,21 +120,31 @@ launchServer daemonConfig mAddr = do

197 pure False

120 pure False

198 Right conn -> do

121 Right conn -> do

199 let hostname = bindHost daemonConfig

122 let hostname = bindHost daemonConfig

200− port = fromIntegral (bindPort daemonConfig)

123+ port = bindPort daemonConfig

201−

124+#if MIN_VERSION_network_transport_tcp(0,7,0)

202−

125+ addrInfo = TCPAddrInfo {

203− --curryer only supports IPv4 for now

126+ tcpBindHost = hostname,

204− let addrHints = defaultHints { addrSocketType = Stream, addrFamily = AF_INET }

127+ tcpBindPort = show port,

205− hostAddrs <- getAddrInfo (Just addrHints) (Just hostname) Nothing

128+ tcpExternalAddress = \sn -> (hostname, sn)

206− case hostAddrs of

129+ }

130+ etransport <- createTransport (Addressable addrInfo) defaultTCPParameters

131+#elif MIN_VERSION_network_transport_tcp(0,6,0)

132+ etransport <- createTransport hostname (show port) (\nam -> (hostname, nam)) defaultTCPParameters

133+#else

134+ etransport <- createTransport hostname (show port) defaultTCPParameters

135+#endif

136+ case etransport of

137+ Left err -> error ("failed to create transport: " ++ show err)

138+ Right transport -> do

139+ eEndpoint <- newEndPoint transport

140+ case eEndpoint of

207− [] -> hPutStrLn stderr ("Failed to resolve: " <> hostname) >> pure False

141+ Left err -> hPutStrLn stderr ("Failed to create transport: " ++ show err) >> pure False

208− (AddrInfo _ _ _ _ (SockAddrInet _ addr32) _):_ -> do

142+ Right endpoint -> do

209− let hostAddr = hostAddressToTuple addr32

143+ localTCPNode <- newLocalNode transport initRemoteTable

144+ --traceShowM ("newLocalNode in Server " ++ show (localNodeId localTCPNode))

145+ runProcess localTCPNode $ do

146+ let testBool = testMode daemonConfig

210− mTimeout = fromIntegral <$> case perRequestTimeout daemonConfig of

147+ reqTimeout = perRequestTimeout daemonConfig

211− 0 -> Nothing

148+ serve (conn, databaseName daemonConfig, mAddressMVar, address endpoint) initServer (serverDefinition testBool reqTimeout)

212− v -> Just v

149+ liftIO $ putStrLn "serve returned"

213−

150+ pure True

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,12 +12,6 @@ data ServerConfig = ServerConfig { persistenceStrategy :: PersistenceStrategy,

12 }

13 deriving (Show)

14

15−data WebsocketServerConfig = WebsocketServerConfig { wsServerConfig :: ServerConfig,

16− tlsCertificatePath :: Maybe String,

17− tlsKeyPath :: Maybe String

18− }

19− deriving (Show)

20−

21defaultServerConfig :: ServerConfig

15defaultServerConfig :: ServerConfig

22defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,

16defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,

23 checkFS = True,

17 checkFS = True,

src/lib/ProjectM36/Server/EntryPoints.hs+153−126

@@ -1,146 +1,173 @@

1−{-# LANGUAGE MonoLocalBinds #-}

2module ProjectM36.Server.EntryPoints where

1module ProjectM36.Server.EntryPoints where

3import ProjectM36.Base hiding (inclusionDependencies)

2import ProjectM36.Base hiding (inclusionDependencies)

4import ProjectM36.IsomorphicSchema

3import ProjectM36.IsomorphicSchema

5import ProjectM36.Client as C

4import ProjectM36.Client as C

5+import ProjectM36.Error

6+import Control.Distributed.Process (Process, ProcessId)

7+import Control.Distributed.Process.ManagedProcess (ProcessReply)

8+import Control.Distributed.Process.ManagedProcess.Server (reply)

9+import Control.Distributed.Process.Async (async, task, waitCancelTimeout, AsyncResult(..))

10+import Control.Monad.IO.Class (liftIO)

6import Data.Map

11import Data.Map

7import Control.Concurrent (threadDelay)

12import Control.Concurrent (threadDelay)

8−import Network.RPC.Curryer.Server

13+import Data.Typeable

9−import System.Timeout hiding (Timeout)

14+import Data.Binary

10−import Network.Socket

11−import Control.Exception

12

15

13−timeoutOrDie :: Maybe Timeout -> IO a -> IO (Maybe a)

16+timeoutOrDie :: (Binary a, Typeable a) => Timeout -> IO a -> Process (Either ServerError a)

14−timeoutOrDie mMicros act =

17+timeoutOrDie micros act =

15− case mMicros of

18+ if micros == 0 then

16− Nothing -> Just <$> act

19+ liftIO act >>= \x -> pure (Right x)

17− Just micros ->

20+ else do

18− timeout (fromIntegral micros) act

21+ asyncUnit <- async (task (liftIO act))

19−

22+ asyncRes <- waitCancelTimeout micros asyncUnit

20−timeoutRelErr :: Maybe Timeout -> IO (Either RelationalError a) -> IO (Either RelationalError a)

21−timeoutRelErr mMicros act = do

22− ret <- timeoutOrDie mMicros act

23− case ret of

23+ case asyncRes of

24− Nothing -> throw TimeoutException

24+ AsyncDone x -> pure (Right x)

25− Just v -> pure v

25+ AsyncCancelled -> pure (Left RequestTimeoutError)

26−

26+ AsyncFailed reason -> pure (Left (ProcessDiedError (show reason)))

27+ AsyncLinkFailed reason -> pure (Left (ProcessDiedError (show reason)))

28+ AsyncPending -> pure (Left (ProcessDiedError "process pending"))

29+

30+type Timeout = Int

27

31

32+type Reply a = Process (ProcessReply (Either ServerError a) Connection)

33+

28−handleExecuteRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

34+handleExecuteRelationalExpr :: Timeout -> SessionId -> Connection -> RelationalExpr -> Reply (Either RelationalError Relation)

29−handleExecuteRelationalExpr ti sessionId conn expr =

35+handleExecuteRelationalExpr ti sessionId conn expr = do

30− timeoutRelErr ti (executeRelationalExpr sessionId conn expr)

36+ ret <- timeoutOrDie ti (executeRelationalExpr sessionId conn expr)

37+ reply ret conn

31

38

32−handleExecuteDataFrameExpr :: Maybe Timeout -> SessionId -> Connection -> DataFrameExpr -> IO (Either RelationalError DataFrame)

39+handleExecuteDataFrameExpr :: Timeout -> SessionId -> Connection -> DataFrameExpr -> Reply (Either RelationalError DataFrame)

33−handleExecuteDataFrameExpr ti sessionId conn expr =

40+handleExecuteDataFrameExpr ti sessionId conn expr = do

34− timeoutRelErr ti (executeDataFrameExpr sessionId conn expr)

41+ ret <- timeoutOrDie ti (executeDataFrameExpr sessionId conn expr)

35−

42+ reply ret conn

43+

36−handleExecuteDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())

44+handleExecuteDatabaseContextExpr :: Timeout -> SessionId -> Connection -> DatabaseContextExpr -> Reply (Either RelationalError ())

37−handleExecuteDatabaseContextExpr ti sessionId conn dbexpr =

45+handleExecuteDatabaseContextExpr ti sessionId conn dbexpr = do

38− timeoutRelErr ti (executeDatabaseContextExpr sessionId conn dbexpr)

46+ ret <- timeoutOrDie ti (executeDatabaseContextExpr sessionId conn dbexpr)

39−

47+ reply ret conn

48+

40−handleExecuteDatabaseContextIOExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextIOExpr -> IO (Either RelationalError ())

49+handleExecuteDatabaseContextIOExpr :: Timeout -> SessionId -> Connection -> DatabaseContextIOExpr -> Reply (Either RelationalError ())

41−handleExecuteDatabaseContextIOExpr ti sessionId conn dbexpr =

50+handleExecuteDatabaseContextIOExpr ti sessionId conn dbexpr = do

42− timeoutRelErr ti (executeDatabaseContextIOExpr sessionId conn dbexpr)

51+ ret <- timeoutOrDie ti (executeDatabaseContextIOExpr sessionId conn dbexpr)

43−

52+ reply ret conn

53+

44−handleExecuteHeadName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError HeadName)

54+handleExecuteHeadName :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError HeadName)

45−handleExecuteHeadName ti sessionId conn =

55+handleExecuteHeadName ti sessionId conn = do

46− timeoutRelErr ti (headName sessionId conn)

56+ ret <- timeoutOrDie ti (headName sessionId conn)

47−

57+ reply ret conn

48−handleLogin :: Connection -> Locking Socket -> IO Bool

58+

59+handleLogin :: Timeout -> Connection -> ProcessId -> Reply Bool

49−handleLogin conn lockSock = do

60+handleLogin ti conn newClientProcessId = do

50− addClientNode conn lockSock

61+ ret <- timeoutOrDie ti (addClientNode conn newClientProcessId)

51− pure True

62+ case ret of

52−

63+ Right () -> reply (Right True) conn

64+ Left err -> reply (Left err) conn

65+

53−handleExecuteGraphExpr :: Maybe Timeout -> SessionId -> Connection -> TransactionGraphOperator -> IO (Either RelationalError ())

66+handleExecuteGraphExpr :: Timeout -> SessionId -> Connection -> TransactionGraphOperator -> Reply (Either RelationalError ())

54−handleExecuteGraphExpr ti sessionId conn graphExpr =

67+handleExecuteGraphExpr ti sessionId conn graphExpr = do

55− timeoutRelErr ti (executeGraphExpr sessionId conn graphExpr)

68+ ret <- timeoutOrDie ti (executeGraphExpr sessionId conn graphExpr)

56−

69+ reply ret conn

70+

57−handleExecuteTransGraphRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

71+handleExecuteTransGraphRelationalExpr :: Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> Reply (Either RelationalError Relation)

58−handleExecuteTransGraphRelationalExpr ti sessionId conn graphExpr =

72+handleExecuteTransGraphRelationalExpr ti sessionId conn graphExpr = do

59− timeoutRelErr ti (executeTransGraphRelationalExpr sessionId conn graphExpr)

73+ ret <- timeoutOrDie ti (executeTransGraphRelationalExpr sessionId conn graphExpr)

74+ reply ret conn

60

75

61−handleExecuteTypeForRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

76+handleExecuteTypeForRelationalExpr :: Timeout -> SessionId -> Connection -> RelationalExpr -> Reply (Either RelationalError Relation)

62−handleExecuteTypeForRelationalExpr ti sessionId conn relExpr =

77+handleExecuteTypeForRelationalExpr ti sessionId conn relExpr = do

63− timeoutRelErr ti (typeForRelationalExpr sessionId conn relExpr)

78+ ret <- timeoutOrDie ti (typeForRelationalExpr sessionId conn relExpr)

64−

79+ reply ret conn

80+

65−handleRetrieveInclusionDependencies :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError (Map IncDepName InclusionDependency))

81+handleRetrieveInclusionDependencies :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError (Map IncDepName InclusionDependency))

66−handleRetrieveInclusionDependencies ti sessionId conn =

82+handleRetrieveInclusionDependencies ti sessionId conn = do

67− timeoutRelErr ti (inclusionDependencies sessionId conn)

83+ ret <- timeoutOrDie ti (inclusionDependencies sessionId conn)

68−

84+ reply ret conn

85+

69−handleRetrievePlanForDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

86+handleRetrievePlanForDatabaseContextExpr :: Timeout -> SessionId -> Connection -> DatabaseContextExpr -> Reply (Either RelationalError GraphRefDatabaseContextExpr)

70−handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr =

87+handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr = do

71− timeoutRelErr ti (planForDatabaseContextExpr sessionId conn dbExpr)

88+ ret <- timeoutOrDie ti (planForDatabaseContextExpr sessionId conn dbExpr)

72−

89+ reply ret conn

90+

73−handleRetrieveTransactionGraph :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

91+handleRetrieveTransactionGraph :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

74−handleRetrieveTransactionGraph ti sessionId conn =

92+handleRetrieveTransactionGraph ti sessionId conn = do

75− timeoutRelErr ti (transactionGraphAsRelation sessionId conn)

93+ ret <- timeoutOrDie ti (transactionGraphAsRelation sessionId conn)

76−

94+ reply ret conn

95+

77−handleRetrieveHeadTransactionId :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TransactionId)

96+handleRetrieveHeadTransactionId :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError TransactionId)

78−handleRetrieveHeadTransactionId ti sessionId conn =

97+handleRetrieveHeadTransactionId ti sessionId conn = do

79− timeoutRelErr ti (headTransactionId sessionId conn)

98+ ret <- timeoutOrDie ti (headTransactionId sessionId conn)

80−

99+ reply ret conn

100+

81−handleCreateSessionAtCommit :: Maybe Timeout -> Connection -> TransactionId -> IO (Either RelationalError SessionId)

101+handleCreateSessionAtCommit :: Timeout -> Connection -> TransactionId -> Reply (Either RelationalError SessionId)

82−handleCreateSessionAtCommit ti conn commitId =

102+handleCreateSessionAtCommit ti conn commitId = do

83− timeoutRelErr ti (createSessionAtCommit conn commitId)

103+ ret <- timeoutOrDie ti (createSessionAtCommit conn commitId)

84−

104+ reply ret conn

105+

85−handleCreateSessionAtHead :: Maybe Timeout -> Connection -> HeadName -> IO (Either RelationalError SessionId)

106+handleCreateSessionAtHead :: Timeout -> Connection -> HeadName -> Reply (Either RelationalError SessionId)

86−handleCreateSessionAtHead ti conn headn =

107+handleCreateSessionAtHead ti conn headn = do

87− timeoutRelErr ti (createSessionAtHead conn headn)

108+ ret <- timeoutOrDie ti (createSessionAtHead conn headn)

88−

109+ reply ret conn

110+

89−handleCloseSession :: SessionId -> Connection -> IO ()

111+handleCloseSession :: Timeout -> SessionId -> Connection -> Reply ()

90−handleCloseSession =

112+handleCloseSession ti sessionId conn = do

91− closeSession

113+ ret <- timeoutOrDie ti (closeSession sessionId conn)

114+ case ret of

115+ Right () -> reply (Right ()) conn

116+ Left err -> reply (Left err) conn

92

117

93−handleRetrieveAtomTypesAsRelation :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

118+handleRetrieveAtomTypesAsRelation :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

94−handleRetrieveAtomTypesAsRelation ti sessionId conn =

119+handleRetrieveAtomTypesAsRelation ti sessionId conn = do

95− timeoutRelErr ti (atomTypesAsRelation sessionId conn)

120+ ret <- timeoutOrDie ti (atomTypesAsRelation sessionId conn)

121+ reply ret conn

96

122

97-- | Returns a relation which lists the names of relvars in the current session as well as its types.

123-- | Returns a relation which lists the names of relvars in the current session as well as its types.

98−handleRetrieveRelationVariableSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

124+handleRetrieveRelationVariableSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

99−handleRetrieveRelationVariableSummary ti sessionId conn =

125+handleRetrieveRelationVariableSummary ti sessionId conn = do

100− timeoutRelErr ti (relationVariablesAsRelation sessionId conn)

126+ ret <- timeoutOrDie ti (relationVariablesAsRelation sessionId conn)

101−

127+ reply ret conn

128+

102−handleRetrieveAtomFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

129+handleRetrieveAtomFunctionSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

103−handleRetrieveAtomFunctionSummary ti sessionId conn =

130+handleRetrieveAtomFunctionSummary ti sessionId conn = do

104− timeoutRelErr ti (atomFunctionsAsRelation sessionId conn)

131+ ret <- timeoutOrDie ti (atomFunctionsAsRelation sessionId conn)

105−

132+ reply ret conn

133+

106−handleRetrieveDatabaseContextFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

134+handleRetrieveDatabaseContextFunctionSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

107−handleRetrieveDatabaseContextFunctionSummary ti sessionId conn =

135+handleRetrieveDatabaseContextFunctionSummary ti sessionId conn = do

108− timeoutRelErr ti (databaseContextFunctionsAsRelation sessionId conn)

136+ ret <- timeoutOrDie ti (databaseContextFunctionsAsRelation sessionId conn)

109−

137+ reply ret conn

138+

110−handleRetrieveCurrentSchemaName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError SchemaName)

139+handleRetrieveCurrentSchemaName :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError SchemaName)

111−handleRetrieveCurrentSchemaName ti sessionId conn =

140+handleRetrieveCurrentSchemaName ti sessionId conn = do

112− timeoutRelErr ti (currentSchemaName sessionId conn)

141+ ret <- timeoutOrDie ti (currentSchemaName sessionId conn)

142+ reply ret conn

113

143

114−handleExecuteSchemaExpr :: Maybe Timeout -> SessionId -> Connection -> SchemaExpr -> IO (Either RelationalError ())

144+handleExecuteSchemaExpr :: Timeout -> SessionId -> Connection -> SchemaExpr -> Reply (Either RelationalError ())

115−handleExecuteSchemaExpr ti sessionId conn schemaExpr =

145+handleExecuteSchemaExpr ti sessionId conn schemaExpr = do

116− timeoutRelErr ti (executeSchemaExpr sessionId conn schemaExpr)

146+ ret <- timeoutOrDie ti (executeSchemaExpr sessionId conn schemaExpr)

147+ reply ret conn

117

148

118−handleLogout :: Maybe Timeout -> Connection -> IO Bool

149+handleLogout :: Timeout -> Connection -> Reply Bool

119−handleLogout _ _ =

150+handleLogout _ =

120 --liftIO $ closeRemote_ conn

151 --liftIO $ closeRemote_ conn

121− pure True

152+ reply (pure True)

122

153

123−handleTestTimeout :: Maybe Timeout -> SessionId -> Connection -> IO Bool

154+handleTestTimeout :: Timeout -> SessionId -> Connection -> Reply Bool

124−handleTestTimeout ti _ _ = do

155+handleTestTimeout ti _ conn = do

125− ret <- timeoutRelErr ti (threadDelay 100000 >> pure (Right ()))

156+ ret <- timeoutOrDie ti (threadDelay 100000 >> pure True)

126− case ret of

157+ reply ret conn

127− Right () -> pure True

128− Left _ -> pure False

129

158

130−

131−

132−handleRetrieveSessionIsDirty :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Bool)

159+handleRetrieveSessionIsDirty :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Bool)

133−handleRetrieveSessionIsDirty ti sessionId conn =

160+handleRetrieveSessionIsDirty ti sessionId conn = do

134− timeoutRelErr ti (disconnectedTransactionIsDirty sessionId conn)

161+ ret <- timeoutOrDie ti (disconnectedTransactionIsDirty sessionId conn)

135−

162+ reply ret conn

163+

136−handleExecuteAutoMergeToHead :: Maybe Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

164+handleExecuteAutoMergeToHead :: Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> Reply (Either RelationalError ())

137−handleExecuteAutoMergeToHead ti sessionId conn strat headName' =

165+handleExecuteAutoMergeToHead ti sessionId conn strat headName' = do

138− timeoutRelErr ti (autoMergeToHead sessionId conn strat headName')

166+ ret <- timeoutOrDie ti (autoMergeToHead sessionId conn strat headName')

167+ reply ret conn

139

168

140−handleRetrieveTypeConstructorMapping :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

169+handleRetrieveTypeConstructorMapping :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError TypeConstructorMapping)

141−handleRetrieveTypeConstructorMapping ti sessionId conn =

170+handleRetrieveTypeConstructorMapping ti sessionId conn = do

142− timeoutRelErr ti (C.typeConstructorMapping sessionId conn)

171+ ret <- timeoutOrDie ti (C.typeConstructorMapping sessionId conn)

172+ reply ret conn

143

173

144−handleValidateMerkleHashes :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError ())

145−handleValidateMerkleHashes ti sessionId conn =

146− timeoutRelErr ti (C.validateMerkleHashes sessionId conn)

src/lib/ProjectM36/Server/ParseArgs.hs+16−39

@@ -3,7 +3,7 @@ import ProjectM36.Base

3import ProjectM36.Client

4import Options.Applicative

5import ProjectM36.Server.Config

6−#if __GLASGOW_HASKELL__ < 804

6+#if __GLASGOW_HASKELL__ <= 802

7import Data.Monoid

8#endif

9

@@ -17,14 +17,14 @@ parseArgsWithDefaults defaults = ServerConfig <$>

17 many parseGhcPkgPath <*>

18 parseTimeout (perRequestTimeout defaults) <*>

19 parseTestMode

20−

20+

21parsePersistenceStrategy :: Parser PersistenceStrategy

22parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>

23 MinimalPersistence <$> dbdirOpt <|>

24 pure NoPersistence

25− where

25+ where

26− dbdirOpt = strOption (short 'd' <>

26+ dbdirOpt = strOption (short 'd' <>

27− long "database-directory" <>

27+ long "database-directory" <>

28 metavar "DIRECTORY" <>

29 showDefaultWith show

30 )

@@ -34,69 +34,46 @@ parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>

34

35parseTestMode :: Parser Bool

36parseTestMode = flag True False (long "test-mode" <> hidden)

37−

37+

38−parseCheckFS :: Parser Bool

38+parseCheckFS :: Parser Bool

39parseCheckFS = flag True False (long "disable-fscheck" <>

40 help "Disable filesystem check for journaling.")

41−

41+

42parseDatabaseName :: Parser DatabaseName

43parseDatabaseName = strOption (short 'n' <>

44 long "database" <>

45 metavar "DATABASE_NAME")

46

47−parseHostname :: Hostname -> Parser Hostname

47+parseHostname :: Hostname -> Parser Hostname

48parseHostname defHostname = strOption (short 'h' <>

49 long "hostname" <>

50 metavar "HOST_NAME" <>

51 value defHostname)

52−

52+

53−parsePort :: Port -> Parser Port

53+parsePort :: Port -> Parser Port

54parsePort defPort = option auto (short 'p' <>

55 long "port" <>

56 metavar "PORT_NUMBER" <>

57 value defPort)

58−

58+

59parseGhcPkgPath :: Parser String

60parseGhcPkgPath = strOption (long "ghc-pkg-dir" <>

61 metavar "GHC_PACKAGE_DIRECTORY")

62−

62+

63−parseTimeout :: Int -> Parser Int

63+parseTimeout :: Int -> Parser Int

64parseTimeout defTimeout = option auto (long "timeout" <>

65 metavar "MICROSECONDS" <>

66 value defTimeout)

67

68parseConfig :: IO ServerConfig

69parseConfig = parseConfigWithDefaults defaultServerConfig

70−

70+

71parseConfigWithDefaults :: ServerConfig -> IO ServerConfig

72parseConfigWithDefaults defaults = execParser (info (parseArgsWithDefaults defaults <**> helpOption) idm)

73

74−parseWSConfigWithDefaults :: ServerConfig -> IO WebsocketServerConfig

75−parseWSConfigWithDefaults defaults = execParser (info (parseWSArgsWithDefaults defaults <**> helpOption) idm)

76−

77−parseWSArgsWithDefaults :: ServerConfig -> Parser WebsocketServerConfig

78−parseWSArgsWithDefaults defaults = WebsocketServerConfig <$>

79− parseArgsWithDefaults defaults <*>

80− parseTlsCertificatePath <*>

81− parseTlsKeyPath

82−

83−

84−parseTlsCertificatePath :: Parser (Maybe String)

85−parseTlsCertificatePath = optional $ strOption (long "tls-certificate-path" <>

86− metavar "TLS_CERTIFICATE_PATH")

87−

88−parseTlsKeyPath :: Parser (Maybe String)

89−parseTlsKeyPath = optional $ strOption (long "tls-key-path" <>

90− metavar "TLS_KEY_PATH")

91

74

92helpOption :: Parser (a -> a)

75helpOption :: Parser (a -> a)

93−helpOption = abortOption helpText $ mconcat

76+helpOption = abortOption ShowHelpText $ mconcat

94 [ long "help"

77 [ long "help"

95 , help "Show this help text"

78 , help "Show this help text"

96 , hidden ]

79 , hidden ]

97− where

98−#if MIN_VERSION_optparse_applicative(0,16,0)

99− helpText = ShowHelpText Nothing

100−#else

101− helpText = ShowHelpText

102−#endif

src/lib/ProjectM36/Server/RemoteCallTypes.hs+35−67

@@ -1,4 +1,4 @@

1−{-# LANGUAGE DeriveGeneric, DerivingVia, CPP #-}

1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}

2module ProjectM36.Server.RemoteCallTypes where

3import ProjectM36.Base

4import ProjectM36.IsomorphicSchema

@@ -6,98 +6,66 @@ import ProjectM36.TransactionGraph

6import ProjectM36.DataFrame

7import ProjectM36.TransGraphRelationalExpression

8import ProjectM36.Session

9−import ProjectM36.Serialise.DataFrame ()

10−import ProjectM36.Serialise.IsomorphicSchema ()

11import GHC.Generics

9import GHC.Generics

12−import Codec.Winery

10+import Data.Binary

13−

11+import Control.Distributed.Process (ProcessId)

14−#define RPCData(typeName) deriving Generic \

15− deriving Serialise via WineryVariant typeName

16

12

17{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

13{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

18-- | The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.

14-- | The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.

19−data Login = Login DatabaseName

15+data Login = Login ProcessId

20− RPCData(Login)

16+ deriving (Binary, Generic)

21

17

22data Logout = Logout

18data Logout = Logout

23− RPCData(Logout)

19+ deriving (Binary, Generic)

24−

25−data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr

20+data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr

26− RPCData(ExecuteRelationalExpr)

21+ deriving (Binary, Generic)

27−

28data ExecuteDataFrameExpr = ExecuteDataFrameExpr SessionId DataFrameExpr

22data ExecuteDataFrameExpr = ExecuteDataFrameExpr SessionId DataFrameExpr

29− RPCData(ExecuteDataFrameExpr)

23+ deriving (Binary, Generic)

30−

31data ExecuteDatabaseContextExpr = ExecuteDatabaseContextExpr SessionId DatabaseContextExpr

24data ExecuteDatabaseContextExpr = ExecuteDatabaseContextExpr SessionId DatabaseContextExpr

32− RPCData(ExecuteDatabaseContextExpr)

25+ deriving (Binary, Generic)

33−

34data ExecuteDatabaseContextIOExpr = ExecuteDatabaseContextIOExpr SessionId DatabaseContextIOExpr

26data ExecuteDatabaseContextIOExpr = ExecuteDatabaseContextIOExpr SessionId DatabaseContextIOExpr

35− RPCData(ExecuteDatabaseContextIOExpr)

27+ deriving (Binary, Generic)

36−

37data ExecuteGraphExpr = ExecuteGraphExpr SessionId TransactionGraphOperator

28data ExecuteGraphExpr = ExecuteGraphExpr SessionId TransactionGraphOperator

38− RPCData(ExecuteGraphExpr)

29+ deriving (Binary, Generic)

39−

40data ExecuteTransGraphRelationalExpr = ExecuteTransGraphRelationalExpr SessionId TransGraphRelationalExpr

30data ExecuteTransGraphRelationalExpr = ExecuteTransGraphRelationalExpr SessionId TransGraphRelationalExpr

41− RPCData(ExecuteTransGraphRelationalExpr)

31+ deriving (Binary, Generic)

42−

43data ExecuteHeadName = ExecuteHeadName SessionId

32data ExecuteHeadName = ExecuteHeadName SessionId

44− RPCData(ExecuteHeadName)

33+ deriving (Binary, Generic)

45−

46data ExecuteTypeForRelationalExpr = ExecuteTypeForRelationalExpr SessionId RelationalExpr

34data ExecuteTypeForRelationalExpr = ExecuteTypeForRelationalExpr SessionId RelationalExpr

47− RPCData(ExecuteTypeForRelationalExpr)

35+ deriving (Binary, Generic)

48−

49−data ExecuteSchemaExpr = ExecuteSchemaExpr SessionId SchemaExpr RPCData(ExecuteSchemaExpr)

36+data ExecuteSchemaExpr = ExecuteSchemaExpr SessionId SchemaExpr

50−

37+ deriving (Binary, Generic)

51data ExecuteSetCurrentSchema = ExecuteSetCurrentSchema SessionId SchemaName

38data ExecuteSetCurrentSchema = ExecuteSetCurrentSchema SessionId SchemaName

52− RPCData(ExecuteSetCurrentSchema)

39+ deriving (Binary, Generic)

53−

54data RetrieveInclusionDependencies = RetrieveInclusionDependencies SessionId

40data RetrieveInclusionDependencies = RetrieveInclusionDependencies SessionId

55− RPCData(RetrieveInclusionDependencies)

41+ deriving (Binary, Generic)

56−

57data RetrievePlanForDatabaseContextExpr = RetrievePlanForDatabaseContextExpr SessionId DatabaseContextExpr

42data RetrievePlanForDatabaseContextExpr = RetrievePlanForDatabaseContextExpr SessionId DatabaseContextExpr

58− RPCData(RetrievePlanForDatabaseContextExpr)

43+ deriving (Binary, Generic)

59−

60data RetrieveTransactionGraph = RetrieveTransactionGraph SessionId

44data RetrieveTransactionGraph = RetrieveTransactionGraph SessionId

61− RPCData(RetrieveTransactionGraph)

45+ deriving (Binary, Generic)

62−

63data RetrieveHeadTransactionId = RetrieveHeadTransactionId SessionId

46data RetrieveHeadTransactionId = RetrieveHeadTransactionId SessionId

64− RPCData(RetrieveHeadTransactionId)

47+ deriving (Binary, Generic)

65−

66data CreateSessionAtCommit = CreateSessionAtCommit TransactionId

48data CreateSessionAtCommit = CreateSessionAtCommit TransactionId

67− RPCData(CreateSessionAtCommit)

49+ deriving (Binary, Generic)

68−

69data CreateSessionAtHead = CreateSessionAtHead HeadName

50data CreateSessionAtHead = CreateSessionAtHead HeadName

70− RPCData(CreateSessionAtHead)

51+ deriving (Binary, Generic)

71−

72data CloseSession = CloseSession SessionId

52data CloseSession = CloseSession SessionId

73− RPCData(CloseSession)

53+ deriving (Binary, Generic)

74−

75data RetrieveAtomTypesAsRelation = RetrieveAtomTypesAsRelation SessionId

54data RetrieveAtomTypesAsRelation = RetrieveAtomTypesAsRelation SessionId

76− RPCData(RetrieveAtomTypesAsRelation)

55+ deriving (Binary, Generic)

77−

78data RetrieveRelationVariableSummary = RetrieveRelationVariableSummary SessionId

56data RetrieveRelationVariableSummary = RetrieveRelationVariableSummary SessionId

79− RPCData(RetrieveRelationVariableSummary)

57+ deriving (Binary, Generic)

80−

81data RetrieveAtomFunctionSummary = RetrieveAtomFunctionSummary SessionId

58data RetrieveAtomFunctionSummary = RetrieveAtomFunctionSummary SessionId

82− RPCData(RetrieveAtomFunctionSummary)

59+ deriving (Binary, Generic)

83−

84data RetrieveDatabaseContextFunctionSummary = RetrieveDatabaseContextFunctionSummary SessionId

60data RetrieveDatabaseContextFunctionSummary = RetrieveDatabaseContextFunctionSummary SessionId

85− RPCData(RetrieveDatabaseContextFunctionSummary)

61+ deriving (Binary, Generic)

86−

87data RetrieveCurrentSchemaName = RetrieveCurrentSchemaName SessionId

62data RetrieveCurrentSchemaName = RetrieveCurrentSchemaName SessionId

88− RPCData(RetrieveCurrentSchemaName)

63+ deriving (Binary, Generic)

89−

90data TestTimeout = TestTimeout SessionId

64data TestTimeout = TestTimeout SessionId

91− RPCData(TestTimeout)

65+ deriving (Binary, Generic)

92−

93−data RetrieveSessionIsDirty = RetrieveSessionIsDirty SessionId

66+data RetrieveSessionIsDirty = RetrieveSessionIsDirty SessionId

94− RPCData(RetrieveSessionIsDirty)

67+ deriving (Binary, Generic)

95−

96data ExecuteAutoMergeToHead = ExecuteAutoMergeToHead SessionId MergeStrategy HeadName

68data ExecuteAutoMergeToHead = ExecuteAutoMergeToHead SessionId MergeStrategy HeadName

97− RPCData(ExecuteAutoMergeToHead)

69+ deriving (Binary, Generic)

98−

99data RetrieveTypeConstructorMapping = RetrieveTypeConstructorMapping SessionId

70data RetrieveTypeConstructorMapping = RetrieveTypeConstructorMapping SessionId

100− RPCData(RetrieveTypeConstructorMapping)

71+ deriving (Binary, Generic)

101−

102−data ExecuteValidateMerkleHashes = ExecuteValidateMerkleHashes SessionId

103− RPCData(ExecuteValidateMerkleHashes)

src/lib/ProjectM36/Sessions.hs+3−3

@@ -14,11 +14,9 @@ import ProjectM36.Session

14import ProjectM36.Relation

15import ProjectM36.Error

16import qualified Data.UUID as U

17−#if MIN_VERSION_stm_containers(1,0,0)

18import qualified Control.Foldl as Foldl

17import qualified Control.Foldl as Foldl

18+#if MIN_VERSION_stm_containers(1,0,0)

19import qualified DeferredFolds.UnfoldlM as UF

20−#else

21−import "list-t" ListT

22#endif

20#endif

23

21

24type Sessions = StmMap.Map SessionId Session

22type Sessions = StmMap.Map SessionId Session

@@ -47,3 +45,5 @@ sessionsAsRelation sessions = do

47 let atomMatrix = map (\(sessionId, session) -> [uuidAtom sessionId, uuidAtom (parentId session)]) sessionAssocs

45 let atomMatrix = map (\(sessionId, session) -> [uuidAtom sessionId, uuidAtom (parentId session)]) sessionAssocs

48 pure $ mkRelationFromList (attributesFromList [Attribute "sessionid" TextAtomType,

46 pure $ mkRelationFromList (attributesFromList [Attribute "sessionid" TextAtomType,

49 Attribute "parentCommit" TextAtomType]) atomMatrix

47 Attribute "parentCommit" TextAtomType]) atomMatrix

48+

49+

src/lib/ProjectM36/Shortcuts.hsdeleted−247

@@ -1,247 +0,0 @@

1−{-# OPTIONS_GHC -fno-warn-orphans #-}

2−{-# LANGUAGE ScopedTypeVariables #-}

3−{-# LANGUAGE TypeApplications #-}

4−{-# LANGUAGE FlexibleInstances #-}

5−{-# LANGUAGE MultiParamTypeClasses #-}

6−{-# LANGUAGE TypeFamilies #-}

7−{-# LANGUAGE ExtendedDefaultRules #-}

8−{-# LANGUAGE ExistentialQuantification #-}

9−{-# LANGUAGE FlexibleContexts #-}

10−{-# LANGUAGE GADTs #-}

11−{-# LANGUAGE UndecidableInstances #-}

12−module ProjectM36.Shortcuts where

13−-- users need OverloadedLabels, OverloadedLists, and default(Int,Text) to use these shortcuts.

14−import Data.Text hiding (foldl, map)

15−import ProjectM36.Base

16−import ProjectM36.Relation

17−import ProjectM36.Atomable

18−import Prelude hiding ((!!))

19−import Data.Proxy

20−import GHC.OverloadedLabels

21−import GHC.TypeLits hiding (Text)

22−import qualified Data.Text as T

23−import qualified Data.Map as M

24−import qualified Data.Set as S

25−import GHC.Exts (IsList(..))

26−import Data.Convertible

27−

28−default (Text)

29−

30−instance IsList (AttributeNamesBase ()) where

31− type Item (AttributeNamesBase ()) = AttributeName

32− fromList = AttributeNames . S.fromList

33− toList (AttributeNames ns) = S.toList ns

34− toList _ = error "needs AttributeNames"

35−

36−instance IsList (TupleExprsBase ()) where

37− type Item TupleExprs = TupleExpr

38− fromList ts = TupleExprs () ts

39− toList (TupleExprs _ ts) = ts

40−

41−instance IsList TupleExpr where

42− type Item TupleExpr = (AttributeName, AtomExpr)

43− fromList attributeValues = TupleExpr (M.fromList attributeValues)

44− toList (TupleExpr attributeValues) = M.toList attributeValues

45−

46−

47−-- #xxx :: Text

48−instance KnownSymbol x => IsLabel x Text where

49− fromLabel = T.pack $ symbolVal @x Proxy

50−

51−-- #relvarName :: RelationalExpr

52−instance KnownSymbol x => IsLabel x RelationalExpr where

53− fromLabel = RelationVariable (T.pack $ symbolVal @x Proxy) ()

54−

55−-- *Main> #a Int :: AttributeExpr

56−-- NakedAttributeExpr (Attribute "a" IntAtomType)

57−-- *Main> #a (Attr @[Int]) :: AttributeExpr

58−-- NakedAttributeExpr (Attribute "a" (ConstructedAtomType "List" (fromList [("a",IntAtomType)])))

59−-- can't offer a Relation atomtype -- don't know how to express a Relation type in haskell type. Maybe something a HList of (Text, a) ?

60−--

61−-- ps. I don't understand the usage of "AttributeAndTypeNameExpr AttributeName TypeConstructor a"

62−instance (KnownSymbol x, Atomable a)=> IsLabel x (HaskAtomType a -> AttributeExpr) where

63− fromLabel = (NakedAttributeExpr . Attribute name) . toAtomType''

64− where name = T.pack $ symbolVal @x Proxy

65−

66−-- (#a 1) :: ExtendTupleExpr

67−-- no need for :=

68−instance (Convertible a AtomExpr, KnownSymbol x) => IsLabel x (a -> ExtendTupleExpr) where

69− fromLabel x = AttributeExtendTupleExpr name (convert x)

70− where name = T.pack $ symbolVal @x Proxy

71−

72−-- #name AtomExpr

73−-- ex. tuple [ #name 3 ]

74−-- default(Text) is needed in client code to avoid `no Atomable Char`

75−instance (Convertible a AtomExpr, KnownSymbol x) => IsLabel x (a -> (AttributeName, AtomExpr)) where

76− fromLabel = \x -> (name, convert x)

77− where name = T.pack $ symbolVal @x Proxy

78−

79−-- *Main> #a [1] :: AtomExpr

80−-- FunctionAtomExpr "a" [NakedAtomExpr (IntegerAtom 1)] ()

81−--

82−-- This usage is not working in RestrictionPredicateExpr and AttributeExtendTupleExpr. Use f "a" [1] instead.

83−instance (KnownSymbol x, Convertible a AtomExpr) => IsLabel x ([a] -> AtomExpr) where

84− fromLabel = \as' -> FunctionAtomExpr name (map convert as') ()

85− where name = T.pack $ symbolVal @x Proxy

86−

87−instance (KnownSymbol x) => IsLabel x AtomExpr where

88− fromLabel = AttributeAtomExpr name

89− where name = T.pack $ symbolVal @x Proxy

90−

91−

92−data HaskAtomType a where

93− Int :: HaskAtomType Int

94− Integer :: HaskAtomType Integer

95− Double :: HaskAtomType Double

96− Text :: HaskAtomType Text

97−-- Day :: HaskAtomType Day

98−-- DateTime :: HaskAtomType DateTime

99−-- ByteString :: HaskAtomType ByteString

100− Bool :: HaskAtomType Bool

101− Attr :: Atomable a => HaskAtomType a -- a Proxy-like value for type application.

102−

103−toAtomType'' :: Atomable a => HaskAtomType a -> AtomType

104−toAtomType'' (_ :: HaskAtomType a) = toAtomType (Proxy @a)

105−

106−-- usage: relation [tuple [#a 1, #b "b"], tuple [#a 2, #b "b"]]

107−relation :: [TupleExpr] -> RelationalExpr

108−relation ts = MakeRelationFromExprs Nothing (TupleExprs () ts)

109−

110−relation' :: [AttributeExprBase ()] -> [TupleExpr] -> RelationalExpr

111−relation' as' ts = MakeRelationFromExprs (Just as') (TupleExprs () ts)

112−

113−-- usage: tuple [#name "Mike",#age 6]

114−tuple :: [(AttributeName, AtomExpr)] -> TupleExprBase ()

115−tuple as' = TupleExpr (M.fromList as')

116−

117−-- #a rename [#b `as` #c]

118−rename :: RelationalExpr -> [(AttributeName,AttributeName)] -> RelationalExpr

119−rename relExpr renameList = case renameList of

120− [] -> Restrict TruePredicate relExpr

121− renames ->

122− foldl (\acc (old,new) -> Rename old new acc) relExpr renames

123−

124−--project !!

125−-- #a !! [#b,#c]

126−infix 9 !!

127−(!!) :: RelationalExpr -> AttributeNames -> RelationalExpr

128−relExpr !! xs = Project xs relExpr

129−

130−--join ><

131−-- #a >< #b

132−(><) :: RelationalExpr -> RelationalExpr -> RelationalExpr

133−a >< b = Join a b

134−

135−allBut :: AttributeNames -> AttributeNames

136−allBut (AttributeNames ns) = InvertedAttributeNames ns

137−allBut _ = error "give allBut something other than attribute names."

138−

139−allFrom :: RelationalExpr -> AttributeNames

140−allFrom = RelationalExprAttributeNames

141−

142−as :: AttributeNames -> AttributeName -> (AttributeNames, AttributeName)

143−as = (,)

144−

145−-- #a `group` ([#b,#c] `as` #d)

146−group :: RelationalExpr -> (AttributeNames, AttributeName) -> RelationalExpr

147−group relExpr (aNames, aName) = Group aNames aName relExpr

148−

149−-- #a `ungroup` #b

150−ungroup :: RelationalExpr -> AttributeName -> RelationalExpr

151−ungroup relExpr aName = Ungroup aName relExpr

152−

153−-- *Main> #a #:= true #: ( #b (f "count" [1,2]))

154−-- Assign "a" (Extend (AttributeExtendTupleExpr "b" (FunctionAtomExpr "count" [NakedAtomExpr (IntegerAtom 1),NakedAtomExpr (IntegerAtom 2)] ())) (ExistingRelation (Relation attributesFromList [] (RelationTupleSet {asList = [RelationTuple attributesFromList [] []]}))))

155−(#:) :: RelationalExpr -> ExtendTupleExpr -> RelationalExpr

156−a #: b = Extend b a

157−infix 8 #:

158−

159−instance Convertible AtomExpr AtomExpr where

160− safeConvert n = Right n

161−

162−instance Convertible RelVarName AtomExpr where

163− safeConvert n = Right $ RelationAtomExpr (RelationVariable n ())

164−

165−instance Convertible RelationalExpr AtomExpr where

166− safeConvert relExpr = Right $ RelationAtomExpr relExpr

167−

168−instance Convertible RelVarName RelationalExpr where

169− safeConvert n = Right $ RelationVariable n ()

170−

171−-- @ in tutd

172−-- (@@) "aaa"

173−(@@) :: AttributeName -> AtomExpr

174−(@@) = AttributeAtomExpr

175−

176−-- works in RestrictedPredicateExpr and AttributeExtendTupleExpr

177−-- usage: f "gte" [1]

178−f :: Convertible a AtomExpr => AtomFunctionName -> [a] -> AtomExpr

179−f n as' = FunctionAtomExpr n (map convert as') ()

180−

181−-- DatabaseContextExpr

182−-- define

183−(#::) :: RelVarName -> [AttributeExpr] -> DatabaseContextExpr

184−s #:: xs = Define s xs

185−infix 5 #::

186−

187−-- assign

188−(#:=) :: RelVarName -> RelationalExpr -> DatabaseContextExpr

189−s #:= r = Assign s r

190−infix 5 #:=

191−

192−class Boolean a b where

193− (&&&) :: a -> b -> RestrictionPredicateExpr

194− infixl 6 &&&

195− (|||) :: a -> b -> RestrictionPredicateExpr

196− infixl 5 |||

197−

198−-- where: @~ mimics the restriction symbol in algebra

199−-- usage: true #: (#a 1) @~ #a ?= 1 &&& not' false ||| (f "gte" [1])

200−(@~) :: Convertible a RestrictionPredicateExpr => RelationalExpr -> a -> RelationalExpr

201−(@~) relExpr resPreExpr = Restrict (convert resPreExpr) relExpr

202−infix 4 @~

203−

204−true :: RelationalExpr

205−true = ExistingRelation relationTrue

206−

207−false :: RelationalExpr

208−false = ExistingRelation relationFalse

209−

210−trueP :: RestrictionPredicateExprBase a

211−trueP = TruePredicate

212−

213−falseP :: RestrictionPredicateExprBase a

214−falseP = NotPredicate TruePredicate

215−

216−(?=) :: Convertible a AtomExpr => AttributeName -> a -> RestrictionPredicateExpr

217−(?=) name a = AttributeEqualityPredicate name (convert a)

218−infix 9 ?=

219−

220−not' :: Convertible a RestrictionPredicateExpr => a -> RestrictionPredicateExpr

221−not' = NotPredicate . convert

222−

223−instance (Convertible a RestrictionPredicateExpr, Convertible b RestrictionPredicateExpr) => Boolean a b where

224− a &&& b = AndPredicate (convert a) (convert b)

225− a ||| b = OrPredicate (convert a) (convert b)

226−

227−instance {-# Incoherent #-} Atomable a => Convertible a RestrictionPredicateExpr where

228− safeConvert n = Right $ AtomExprPredicate $ toAtomExpr . toAtom $ n

229−

230−instance {-# Incoherent #-} Convertible RelationalExpr RestrictionPredicateExpr where

231− safeConvert a = Right $ RelationalExprPredicate a

232−

233−instance {-# Incoherent #-} Convertible AtomExpr RestrictionPredicateExpr where

234− safeConvert a = Right $ AtomExprPredicate a

235−

236−instance {-# Incoherent #-} Convertible RestrictionPredicateExpr RestrictionPredicateExpr where

237− safeConvert a = Right a

238−

239−instance {-# Incoherent #-} Atomable a => Convertible a AtomExpr where

240− safeConvert n = Right $ toAtomExpr . toAtom $ n

241−

242−toAtomExpr :: Atom -> AtomExpr

243−toAtomExpr (ConstructedAtom n _ xs) = ConstructedAtomExpr n (toAtomExpr <$> xs) ()

244−toAtomExpr a = NakedAtomExpr a

245−

246−

247−

src/lib/ProjectM36/StaticOptimizer.hs+49−143

@@ -1,5 +1,3 @@

1−{-# LANGUAGE FlexibleInstances #-}

2−{-# LANGUAGE FlexibleContexts #-}

3module ProjectM36.StaticOptimizer where

1module ProjectM36.StaticOptimizer where

4import ProjectM36.Base

2import ProjectM36.Base

5import ProjectM36.GraphRefRelationalExpr

3import ProjectM36.GraphRefRelationalExpr

@@ -20,26 +18,12 @@ import Data.Functor.Identity

20import qualified Data.Map as M

18import qualified Data.Map as M

21import qualified Data.Set as S

19import qualified Data.Set as S

22

20

23−-- the static optimizer performs optimizations which need not take any specific-relation statistics into account

21+type StaticOptimizerEnv = RelationalExprEnv

24−

25−data GraphRefSOptRelationalExprEnv =

26− GraphRefSOptRelationalExprEnv

27− {

28− ore_graph :: TransactionGraph,

29− ore_mcontext :: Maybe DatabaseContext

30− }

31−

32−type GraphRefSOptRelationalExprM a = ReaderT GraphRefSOptRelationalExprEnv (ExceptT RelationalError Identity) a

33

22

34−data GraphRefSOptDatabaseContextExprEnv =

23+type StaticOptimizerMonad a = ReaderT StaticOptimizerEnv (ExceptT RelationalError Identity) a

35− GraphRefSOptDatabaseContextExprEnv

24+-- the static optimizer performs optimizations which need not take any specific-relation statistics into account

36− {

37− odce_graph :: TransactionGraph,

38− odce_context :: DatabaseContext, --not optional for DatabaseContextExpr evaluation

39− odce_transId :: TransactionId -- parent if context is committed- needed because MultipleExpr optimization requires running the DatabaseContextExprs (with empty relvars)

40− }

41

25

42−type GraphRefSOptDatabaseContextExprM a = ReaderT GraphRefSOptDatabaseContextExprEnv (ExceptT RelationalError Identity) a

26+type GraphRefStaticOptimizerMonad a = ReaderT (Maybe DatabaseContext, TransactionGraph) (ExceptT RelationalError Identity) a

43

27

44-- | A temporary function to be replaced by IO-based implementation.

28-- | A temporary function to be replaced by IO-based implementation.

45optimizeAndEvalRelationalExpr :: RelationalExprEnv -> RelationalExpr -> Either RelationalError Relation

29optimizeAndEvalRelationalExpr :: RelationalExprEnv -> RelationalExpr -> Either RelationalError Relation

@@ -48,44 +32,28 @@ optimizeAndEvalRelationalExpr env expr = do

48 graph = re_graph env

32 graph = re_graph env

49 ctx = re_context env

33 ctx = re_context env

50 gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph

34 gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph

51− optExpr <- runGraphRefSOptRelationalExprM (Just ctx) (re_graph env) (fullOptimizeGraphRefRelationalExpr gfExpr)

35+ optExpr <- runGraphRefStaticOptimizerMonad (Just ctx) (re_graph env) (fullOptimizeGraphRefRelationalExpr gfExpr)

52 runGraphRefRelationalExprM gfEnv (evalGraphRefRelationalExpr optExpr)

36 runGraphRefRelationalExprM gfEnv (evalGraphRefRelationalExpr optExpr)

53

37

54−class Monad m => AskGraphContext m where

55− askGraph :: m TransactionGraph

38+askGraph :: GraphRefStaticOptimizerMonad TransactionGraph

56− askContext :: m DatabaseContext

57−

58−instance AskGraphContext (ReaderT GraphRefSOptDatabaseContextExprEnv (ExceptT RelationalError Identity)) where

59− askGraph = asks odce_graph

39+askGraph = snd <$> ask

60− askContext = asks odce_context

61

40

62−instance AskGraphContext (ReaderT GraphRefSOptRelationalExprEnv (ExceptT RelationalError Identity)) where

41+askContext :: GraphRefStaticOptimizerMonad DatabaseContext

63− askGraph = asks ore_graph

64− askContext = do

42+askContext = do

65− mctx <- asks ore_mcontext

43+ mctx <- fst <$> ask

66− case mctx of

44+ case mctx of

67− Nothing -> throwError NoUncommittedContextInEvalError

45+ Nothing -> throwError NoUncommittedContextInEvalError

68− Just ctx -> pure ctx

46+ Just ctx -> pure ctx

69

47

70−askTransId :: GraphRefSOptDatabaseContextExprM TransactionId

48+askMaybeContext :: GraphRefStaticOptimizerMonad (Maybe DatabaseContext)

71−askTransId = asks odce_transId

49+askMaybeContext = fst <$> ask

72

50

73−askMaybeContext :: GraphRefSOptRelationalExprM (Maybe DatabaseContext)

74−askMaybeContext = asks ore_mcontext

75−

76−optimizeDatabaseContextExpr :: DatabaseContextExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextExpr

77−optimizeDatabaseContextExpr expr = do

78− let gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextExpr expr)

79− optimizeGraphRefDatabaseContextExpr gfExpr

80−

81optimizeAndEvalDatabaseContextExpr :: Bool -> DatabaseContextExpr -> DatabaseContextEvalMonad ()

51optimizeAndEvalDatabaseContextExpr :: Bool -> DatabaseContextExpr -> DatabaseContextEvalMonad ()

82optimizeAndEvalDatabaseContextExpr optimize expr = do

52optimizeAndEvalDatabaseContextExpr optimize expr = do

83− graph <- asks dce_graph

53+ graph <- dce_graph <$> ask

84− transId <- asks dce_transId

85− context <- getStateContext

86 let gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextExpr expr)

54 let gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextExpr expr)

87 eOptExpr = if optimize then

55 eOptExpr = if optimize then

88− runGraphRefSOptDatabaseContextExprM transId context graph (optimizeGraphRefDatabaseContextExpr gfExpr)

56+ runGraphRefStaticOptimizerMonad Nothing graph (optimizeGraphRefDatabaseContextExpr gfExpr)

89 else

57 else

90 pure gfExpr

58 pure gfExpr

91 case eOptExpr of

59 case eOptExpr of

@@ -96,76 +64,31 @@ optimizeAndEvalDatabaseContextExpr optimize expr = do

96optimizeAndEvalTransGraphRelationalExpr :: TransactionGraph -> TransGraphRelationalExpr -> Either RelationalError Relation

64optimizeAndEvalTransGraphRelationalExpr :: TransactionGraph -> TransGraphRelationalExpr -> Either RelationalError Relation

97optimizeAndEvalTransGraphRelationalExpr graph tgExpr = do

65optimizeAndEvalTransGraphRelationalExpr graph tgExpr = do

98 gfExpr <- TGRE.process (TransGraphEvalEnv graph) tgExpr

66 gfExpr <- TGRE.process (TransGraphEvalEnv graph) tgExpr

99− optExpr <- runGraphRefSOptRelationalExprM Nothing graph (fullOptimizeGraphRefRelationalExpr gfExpr)

67+ optExpr <- runGraphRefStaticOptimizerMonad Nothing graph (fullOptimizeGraphRefRelationalExpr gfExpr)

100 let gfEnv = freshGraphRefRelationalExprEnv Nothing graph

68 let gfEnv = freshGraphRefRelationalExprEnv Nothing graph

101 runGraphRefRelationalExprM gfEnv (evalGraphRefRelationalExpr optExpr)

69 runGraphRefRelationalExprM gfEnv (evalGraphRefRelationalExpr optExpr)

102

70

103optimizeAndEvalDatabaseContextIOExpr :: DatabaseContextIOExpr -> DatabaseContextIOEvalMonad (Either RelationalError ())

71optimizeAndEvalDatabaseContextIOExpr :: DatabaseContextIOExpr -> DatabaseContextIOEvalMonad (Either RelationalError ())

104optimizeAndEvalDatabaseContextIOExpr expr = do

72optimizeAndEvalDatabaseContextIOExpr expr = do

105− transId <- asks dbcio_transId

73+ env <- getDBCIORelationalExprEnv

106− ctx <- getDBCIOContext

107− graph <- asks dbcio_graph

108 let gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextIOExpr expr)

74 let gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextIOExpr expr)

109− eOptExpr = runGraphRefSOptDatabaseContextExprM transId ctx graph (optimizeDatabaseContextIOExpr gfExpr)

75+ eOptExpr = runStaticOptimizerMonad env (optimizeDatabaseContextIOExpr gfExpr)

110 case eOptExpr of

76 case eOptExpr of

111 Left err -> pure (Left err)

77 Left err -> pure (Left err)

112 Right optExpr ->

78 Right optExpr ->

113 evalGraphRefDatabaseContextIOExpr optExpr

79 evalGraphRefDatabaseContextIOExpr optExpr

114

80

115−{-

81+

116runStaticOptimizerMonad :: RelationalExprEnv -> StaticOptimizerMonad a -> Either RelationalError a

82runStaticOptimizerMonad :: RelationalExprEnv -> StaticOptimizerMonad a -> Either RelationalError a

117runStaticOptimizerMonad env m = runIdentity (runExceptT (runReaderT m env))

83runStaticOptimizerMonad env m = runIdentity (runExceptT (runReaderT m env))

118−-}

119−

120−runGraphRefSOptRelationalExprM ::

121− Maybe DatabaseContext ->

122− TransactionGraph ->

123− GraphRefSOptRelationalExprM a ->

124− Either RelationalError a

125−runGraphRefSOptRelationalExprM mctx graph m = runIdentity (runExceptT (runReaderT m env))

126− where

127− env = GraphRefSOptRelationalExprEnv {

128− ore_graph = graph,

129− ore_mcontext = mctx

130− }

131−

132

84

133−runGraphRefSOptDatabaseContextExprM ::

85+runGraphRefStaticOptimizerMonad :: Maybe DatabaseContext -> TransactionGraph -> GraphRefStaticOptimizerMonad a -> Either RelationalError a

134− TransactionId ->

135− DatabaseContext ->

136− TransactionGraph ->

137− GraphRefSOptDatabaseContextExprM a ->

138− Either RelationalError a

139−runGraphRefSOptDatabaseContextExprM tid ctx graph m =

140− runIdentity (runExceptT (runReaderT m env))

86+runGraphRefStaticOptimizerMonad ctx graph m = runIdentity (runExceptT (runReaderT m (ctx, graph)))

141− where

87+

142− env = GraphRefSOptDatabaseContextExprEnv {

143− odce_graph = graph,

144− odce_context = ctx,

145− odce_transId = tid

146− }

147−

148−optimizeGraphRefRelationalExpr' ::

149− Maybe DatabaseContext ->

150− TransactionGraph ->

151− GraphRefRelationalExpr ->

152− Either RelationalError GraphRefRelationalExpr

88+optimizeGraphRefRelationalExpr' :: Maybe DatabaseContext -> TransactionGraph -> GraphRefRelationalExpr -> Either RelationalError GraphRefRelationalExpr

153−optimizeGraphRefRelationalExpr' mctx graph expr =

154− runIdentity (runExceptT (runReaderT (optimizeGraphRefRelationalExpr expr) env))

89+optimizeGraphRefRelationalExpr' mctx graph expr = runIdentity (runExceptT (runReaderT (optimizeGraphRefRelationalExpr expr) (mctx,graph)))

155− where

90+

156− env = GraphRefSOptRelationalExprEnv {

157− ore_graph = graph,

158− ore_mcontext = mctx

159− }

160−

161−-- | optimize relational expression within database context expr monad

162−liftGraphRefRelExpr :: GraphRefSOptRelationalExprM a -> GraphRefSOptDatabaseContextExprM a

163−liftGraphRefRelExpr m = do

164− context <- asks odce_context

165− graph <- asks odce_graph

166− lift $ except $ runGraphRefSOptRelationalExprM (Just context) graph m

167−

168−fullOptimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

91+fullOptimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefStaticOptimizerMonad GraphRefRelationalExpr

169fullOptimizeGraphRefRelationalExpr expr = do

92fullOptimizeGraphRefRelationalExpr expr = do

170 optExpr <- optimizeGraphRefRelationalExpr expr

93 optExpr <- optimizeGraphRefRelationalExpr expr

171 let optExpr' = applyStaticRestrictionPushdown (applyStaticRestrictionCollapse optExpr)

94 let optExpr' = applyStaticRestrictionPushdown (applyStaticRestrictionCollapse optExpr)

@@ -174,10 +97,10 @@ fullOptimizeGraphRefRelationalExpr expr = do

174-- apply optimizations which merely remove steps to become no-ops: example: projection of a relation across all of its attributes => original relation

97-- apply optimizations which merely remove steps to become no-ops: example: projection of a relation across all of its attributes => original relation

175

98

176--should optimizations offer the possibility to pure errors? If they perform the up-front type-checking, maybe so

99--should optimizations offer the possibility to pure errors? If they perform the up-front type-checking, maybe so

177−optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

100+optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefStaticOptimizerMonad GraphRefRelationalExpr

178optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e

101optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e

179

102

180−optimizeGraphRefRelationalExpr e@MakeRelationFromExprs{} = pure e

103+optimizeGraphRefRelationalExpr e@(MakeRelationFromExprs _ _) = pure e

181

104

182optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e

105optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e

183

106

@@ -186,9 +109,8 @@ optimizeGraphRefRelationalExpr e@(RelationVariable _ _) = pure e

186--remove project of attributes which removes no attributes

109--remove project of attributes which removes no attributes

187optimizeGraphRefRelationalExpr (Project attrNameSet expr) = do

110optimizeGraphRefRelationalExpr (Project attrNameSet expr) = do

188 graph <- askGraph

111 graph <- askGraph

189− mctx <- askMaybeContext

190 let relType = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr expr)

112 let relType = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr expr)

191− gfEnv = freshGraphRefRelationalExprEnv mctx graph

113+ gfEnv = freshGraphRefRelationalExprEnv Nothing graph

192 case relType of

114 case relType of

193 Left err -> throwError err

115 Left err -> throwError err

194 Right relType2

116 Right relType2

@@ -207,8 +129,6 @@ optimizeGraphRefRelationalExpr (Union exprA exprB) = do

207 case (optExprA, optExprB) of

129 case (optExprA, optExprB) of

208 (Restrict predA (RelationVariable nameA sA),

130 (Restrict predA (RelationVariable nameA sA),

209 Restrict predB (RelationVariable nameB sB)) | nameA == nameB && sA == sB -> pure (Restrict (AndPredicate predA predB) (RelationVariable nameA sA))

131 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

132 _ -> if optExprA == optExprB then

213 pure optExprA

133 pure optExprA

214 else

134 else

@@ -251,13 +171,12 @@ optimizeGraphRefRelationalExpr (Ungroup attrName expr) =

251--remove restriction of nothing

171--remove restriction of nothing

252optimizeGraphRefRelationalExpr (Restrict predicate expr) = do

172optimizeGraphRefRelationalExpr (Restrict predicate expr) = do

253 graph <- askGraph

173 graph <- askGraph

254− mctx <- askMaybeContext

255 optimizedPredicate <- applyStaticPredicateOptimization predicate

174 optimizedPredicate <- applyStaticPredicateOptimization predicate

256 case optimizedPredicate of

175 case optimizedPredicate of

257 optimizedPredicate' | isTrueExpr optimizedPredicate' -> optimizeGraphRefRelationalExpr expr -- remove predicate entirely

176 optimizedPredicate' | isTrueExpr optimizedPredicate' -> optimizeGraphRefRelationalExpr expr -- remove predicate entirely

258 optimizedPredicate' | isFalseExpr optimizedPredicate' -> do -- replace where false predicate with empty relation with attributes from relexpr

177 optimizedPredicate' | isFalseExpr optimizedPredicate' -> do -- replace where false predicate with empty relation with attributes from relexpr

259 let attributesRel = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr expr)

178 let attributesRel = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr expr)

260− gfEnv = freshGraphRefRelationalExprEnv mctx graph

179+ gfEnv = freshGraphRefRelationalExprEnv Nothing graph

261 case attributesRel of

180 case attributesRel of

262 Left err -> throwError err

181 Left err -> throwError err

263 Right attributesRelA -> pure $ MakeStaticRelation (attributes attributesRelA) emptyTupleSet

182 Right attributesRelA -> pure $ MakeStaticRelation (attributes attributesRelA) emptyTupleSet

@@ -274,18 +193,18 @@ optimizeGraphRefRelationalExpr e@(Extend _ _) = pure e

274optimizeGraphRefRelationalExpr e@(With _ _) = pure e

193optimizeGraphRefRelationalExpr e@(With _ _) = pure e

275

194

276-- database context expr

195-- database context expr

277−optimizeGraphRefDatabaseContextExpr :: GraphRefDatabaseContextExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextExpr

196+optimizeGraphRefDatabaseContextExpr :: GraphRefDatabaseContextExpr -> GraphRefStaticOptimizerMonad GraphRefDatabaseContextExpr

278optimizeGraphRefDatabaseContextExpr x@NoOperation = pure x

197optimizeGraphRefDatabaseContextExpr x@NoOperation = pure x

279optimizeGraphRefDatabaseContextExpr x@(Define _ _) = pure x

198optimizeGraphRefDatabaseContextExpr x@(Define _ _) = pure x

280

199

281optimizeGraphRefDatabaseContextExpr x@(Undefine _) = pure x

200optimizeGraphRefDatabaseContextExpr x@(Undefine _) = pure x

282

201

283optimizeGraphRefDatabaseContextExpr (Assign name expr) = do

202optimizeGraphRefDatabaseContextExpr (Assign name expr) = do

284− optExpr <- liftGraphRefRelExpr (fullOptimizeGraphRefRelationalExpr expr)

203+ optExpr <- optimizeGraphRefRelationalExpr expr

285 pure $ Assign name optExpr

204 pure $ Assign name optExpr

286

205

287optimizeGraphRefDatabaseContextExpr (Insert targetName expr) = do

206optimizeGraphRefDatabaseContextExpr (Insert targetName expr) = do

288− optimizedExpr <- liftGraphRefRelExpr (fullOptimizeGraphRefRelationalExpr expr)

207+ optimizedExpr <- fullOptimizeGraphRefRelationalExpr expr

289 if isEmptyRelationExpr optimizedExpr then -- if we are trying to insert an empty relation, do nothing

208 if isEmptyRelationExpr optimizedExpr then -- if we are trying to insert an empty relation, do nothing

290 pure NoOperation

209 pure NoOperation

291 else

210 else

@@ -296,10 +215,10 @@ optimizeGraphRefDatabaseContextExpr (Insert targetName expr) = do

296 _ -> pure (Insert targetName optimizedExpr)

215 _ -> pure (Insert targetName optimizedExpr)

297

216

298optimizeGraphRefDatabaseContextExpr (Delete name predicate) =

217optimizeGraphRefDatabaseContextExpr (Delete name predicate) =

299− Delete name <$> liftGraphRefRelExpr (applyStaticPredicateOptimization predicate)

218+ Delete name <$> applyStaticPredicateOptimization predicate

300

219

301optimizeGraphRefDatabaseContextExpr (Update name upmap predicate) =

220optimizeGraphRefDatabaseContextExpr (Update name upmap predicate) =

302− Update name upmap <$> liftGraphRefRelExpr (applyStaticPredicateOptimization predicate)

221+ Update name upmap <$> applyStaticPredicateOptimization predicate

303

222

304optimizeGraphRefDatabaseContextExpr dep@(AddInclusionDependency _ _) = pure dep

223optimizeGraphRefDatabaseContextExpr dep@(AddInclusionDependency _ _) = pure dep

305

224

@@ -321,28 +240,14 @@ optimizeGraphRefDatabaseContextExpr c@(ExecuteDatabaseContextFunction _ _) = pur

321

240

322--applyStaticDatabaseOptimization (MultipleExpr exprs) = pure $ Right $ MultipleExpr exprs

241--applyStaticDatabaseOptimization (MultipleExpr exprs) = pure $ Right $ MultipleExpr exprs

323--for multiple expressions, we must evaluate

242--for multiple expressions, we must evaluate

324−optimizeGraphRefDatabaseContextExpr (MultipleExpr exprs) = do

243+optimizeGraphRefDatabaseContextExpr x@(MultipleExpr _) = pure x

325 --a previous expression in the exprs list could create a relvar; we don't want to miss it, so we clear the tuples and execute the expression to get an empty relation in the relvar

244 --a previous expression in the exprs list could create a relvar; we don't want to miss it, so we clear the tuples and execute the expression to get an empty relation in the relvar

326− context <- askContext

245+-- unimplemented

327− graph <- askGraph

328− parentId <- askTransId

329−

330− let emptyRvs ctx = ctx { relationVariables = mkEmptyRelVars (relationVariables ctx) }

246+{- let processEmptyRelVars env = env { relationVariables = mkEmptyRelVars (relationVariables env) }

331− dbcEnv = mkDatabaseContextEvalEnv parentId graph

247+ MultipleExpr <$> local processEmptyRelVars (mapM applyStaticDatabaseOptimization exprs)-}

332− folder (ctx, expracc) expr = do

333− --optimize the expr and run it against empty relvars to add it to the context

334− case runGraphRefSOptDatabaseContextExprM parentId ctx graph (optimizeGraphRefDatabaseContextExpr expr) of

335− Left err -> throwError err

336− Right optExpr ->

337− case runDatabaseContextEvalMonad ctx dbcEnv (evalGraphRefDatabaseContextExpr optExpr) of

338− Left err -> throwError err

339− Right dbcState ->

340− pure (emptyRvs $ dbc_context dbcState, expracc ++ [optExpr])

341

248

342− (_, exprs') <- foldM folder (context,[]) exprs

343− pure (MultipleExpr exprs')

344

249

345−applyStaticPredicateOptimization :: GraphRefRestrictionPredicateExpr -> GraphRefSOptRelationalExprM GraphRefRestrictionPredicateExpr

250+applyStaticPredicateOptimization :: GraphRefRestrictionPredicateExpr -> GraphRefStaticOptimizerMonad GraphRefRestrictionPredicateExpr

346applyStaticPredicateOptimization predi = do

251applyStaticPredicateOptimization predi = do

347 optPred <- case predi of

252 optPred <- case predi of

348-- where x and x => where x

253-- where x and x => where x

@@ -357,8 +262,10 @@ applyStaticPredicateOptimization predi = do

357 OrPredicate pred1 pred2 -> do

262 OrPredicate pred1 pred2 -> do

358 optPredA <- applyStaticPredicateOptimization pred1

263 optPredA <- applyStaticPredicateOptimization pred1

359 optPredB <- applyStaticPredicateOptimization pred2

264 optPredB <- applyStaticPredicateOptimization pred2

360− if (optPredA == optPredB) || isTrueExpr optPredA then

265+ if optPredA == optPredB then

361 pure optPredA

266 pure optPredA

267+ else if isTrueExpr optPredA then

268+ pure optPredA -- True or x -> True

362 else if isTrueExpr optPredB then

269 else if isTrueExpr optPredB then

363 pure optPredB

270 pure optPredB

364 else

271 else

@@ -390,7 +297,7 @@ isFalseExpr _ = False

390

297

391-- determine if the created relation can statically be determined to be empty

298-- determine if the created relation can statically be determined to be empty

392isEmptyRelationExpr :: RelationalExprBase a -> Bool

299isEmptyRelationExpr :: RelationalExprBase a -> Bool

393−isEmptyRelationExpr (MakeRelationFromExprs _ (TupleExprs _ [])) = True

300+isEmptyRelationExpr (MakeRelationFromExprs _ []) = True

394isEmptyRelationExpr (MakeStaticRelation _ tupSet) = null (asList tupSet)

301isEmptyRelationExpr (MakeStaticRelation _ tupSet) = null (asList tupSet)

395isEmptyRelationExpr (ExistingRelation rel) = rel == emptyRelationWithAttrs (attributes rel)

302isEmptyRelationExpr (ExistingRelation rel) = rel == emptyRelationWithAttrs (attributes rel)

396isEmptyRelationExpr _ = False

303isEmptyRelationExpr _ = False

@@ -433,7 +340,7 @@ isStaticAtomExpr FunctionAtomExpr{} = False

433isStaticAtomExpr RelationAtomExpr{} = False

340isStaticAtomExpr RelationAtomExpr{} = False

434

341

435--if the projection of a join only uses the attributes from one of the expressions and there is a foreign key relationship between the expressions, we know that the join is inconsequential and can be removed

342--if the projection of a join only uses the attributes from one of the expressions and there is a foreign key relationship between the expressions, we know that the join is inconsequential and can be removed

436−applyStaticJoinElimination :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

343+applyStaticJoinElimination :: GraphRefRelationalExpr -> GraphRefStaticOptimizerMonad GraphRefRelationalExpr

437applyStaticJoinElimination expr@(Project attrNameSet (Join exprA exprB)) = do

344applyStaticJoinElimination expr@(Project attrNameSet (Join exprA exprB)) = do

438 graph <- askGraph

345 graph <- askGraph

439 case inSameTransaction exprA exprB of

346 case inSameTransaction exprA exprB of

@@ -573,6 +480,5 @@ applyStaticRestrictionPushdown expr = case expr of

573 Extend n (applyStaticRestrictionPushdown sub)

480 Extend n (applyStaticRestrictionPushdown sub)

574

481

575-- no optimizations available

482-- no optimizations available

576−optimizeDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextIOExpr

483+optimizeDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> StaticOptimizerMonad GraphRefDatabaseContextIOExpr

577−optimizeDatabaseContextIOExpr = pure

484+optimizeDatabaseContextIOExpr x = pure x

578−

src/lib/ProjectM36/TransGraphPlanExpr.hsnew file+5

@@ -0,0 +1,5 @@

1+module ProjectM36.TransGraphPlanExpr where

2+import ProjectM36.Base

3+-- used to create an execution plan which can potentially read from the query cache

4+

5+data TransGraphPlanExpr = ExecuteTransGraphRelationalExprPlan TransGraphRelationalExpr

src/lib/ProjectM36/TransGraphRelationalExpression.hs+18−9

@@ -10,27 +10,40 @@ import Control.Monad.Trans.Reader

10import Control.Monad.Trans.Class

11import Control.Monad.Trans.Except

12import Data.Functor.Identity

13+import Data.Binary

13

14

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).

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).

15type TransGraphRelationalExpr = RelationalExprBase TransactionIdLookup

16type TransGraphRelationalExpr = RelationalExprBase TransactionIdLookup

16

17

18+instance Binary TransGraphRelationalExpr

19+

17type TransGraphAttributeNames = AttributeNamesBase TransactionIdLookup

20type TransGraphAttributeNames = AttributeNamesBase TransactionIdLookup

18

21

22+instance Binary TransGraphAttributeNames

23+

19type TransGraphExtendTupleExpr = ExtendTupleExprBase TransactionIdLookup

24type TransGraphExtendTupleExpr = ExtendTupleExprBase TransactionIdLookup

20

25

26+instance Binary TransGraphExtendTupleExpr

27+

21type TransGraphTupleExpr = TupleExprBase TransactionIdLookup

28type TransGraphTupleExpr = TupleExprBase TransactionIdLookup

22

29

23−type TransGraphTupleExprs = TupleExprsBase TransactionIdLookup

30+instance Binary TransGraphTupleExpr

24

31

25type TransGraphRestrictionPredicateExpr = RestrictionPredicateExprBase TransactionIdLookup

32type TransGraphRestrictionPredicateExpr = RestrictionPredicateExprBase TransactionIdLookup

26

33

34+instance Binary TransGraphRestrictionPredicateExpr

35+

27type TransGraphAtomExpr = AtomExprBase TransactionIdLookup

36type TransGraphAtomExpr = AtomExprBase TransactionIdLookup

28

37

38+instance Binary TransGraphAtomExpr

39+

29type TransGraphAttributeExpr = AttributeExprBase TransactionIdLookup

40type TransGraphAttributeExpr = AttributeExprBase TransactionIdLookup

30

41

31type TransGraphWithNameExpr = WithNameExprBase TransactionIdLookup

42type TransGraphWithNameExpr = WithNameExprBase TransactionIdLookup

32

43

44+instance Binary TransGraphWithNameExpr

45+

33−newtype TransGraphEvalEnv = TransGraphEvalEnv {

46+data TransGraphEvalEnv = TransGraphEvalEnv {

34 tge_graph :: TransactionGraph

47 tge_graph :: TransactionGraph

35 }

48 }

36

49

@@ -56,7 +69,7 @@ findTrans tlook = do

56-- OUTDATED a previous attempt at this function attempted to convert TransGraphRelationalExpr to RelationalExpr by resolving the transaction lookups. However, there is no way to resolve a FunctionAtomExpr to an Atom without fully evaluating the higher levels (TupleExpr, etc.). An anonymous function expression cannot be serialized, so that workaround is out. Still, I suspect we can reuse the existing static optimizer logic to work on both structures. The current conversion reduces the chance of whole-query optimization due to full-evaluation on top of full-evaluation, so this function would benefit from some re-design.

69-- OUTDATED a previous attempt at this function attempted to convert TransGraphRelationalExpr to RelationalExpr by resolving the transaction lookups. However, there is no way to resolve a FunctionAtomExpr to an Atom without fully evaluating the higher levels (TupleExpr, etc.). An anonymous function expression cannot be serialized, so that workaround is out. Still, I suspect we can reuse the existing static optimizer logic to work on both structures. The current conversion reduces the chance of whole-query optimization due to full-evaluation on top of full-evaluation, so this function would benefit from some re-design.

57processTransGraphRelationalExpr :: TransGraphRelationalExpr -> TransGraphEvalMonad GraphRefRelationalExpr

70processTransGraphRelationalExpr :: TransGraphRelationalExpr -> TransGraphEvalMonad GraphRefRelationalExpr

58processTransGraphRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

71processTransGraphRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

59− tupleExprs' <- processTransGraphTupleExprs tupleExprs

72+ tupleExprs' <- mapM processTransGraphTupleExpr tupleExprs

60 case mAttrExprs of

73 case mAttrExprs of

61 Nothing -> pure (MakeRelationFromExprs Nothing tupleExprs')

74 Nothing -> pure (MakeRelationFromExprs Nothing tupleExprs')

62 Just attrExprs -> do

75 Just attrExprs -> do

@@ -106,11 +119,7 @@ processTransGraphRelationalExpr (With views expr) = do

106 ) views

119 ) views

107 expr' <- processTransGraphRelationalExpr expr

120 expr' <- processTransGraphRelationalExpr expr

108 pure (With evaldViews expr')

121 pure (With evaldViews expr')

109−

122+

110−processTransGraphTupleExprs :: TransGraphTupleExprs -> TransGraphEvalMonad GraphRefTupleExprs

111−processTransGraphTupleExprs (TupleExprs marker texprs) =

112− TupleExprs <$> findTransId marker <*> mapM processTransGraphTupleExpr texprs

113−

114processTransGraphTupleExpr :: TransGraphTupleExpr -> TransGraphEvalMonad GraphRefTupleExpr

123processTransGraphTupleExpr :: TransGraphTupleExpr -> TransGraphEvalMonad GraphRefTupleExpr

115processTransGraphTupleExpr (TupleExpr attrMap) = do

124processTransGraphTupleExpr (TupleExpr attrMap) = do

116 let attrAssoc = mapM (\(attrName, atomExpr) -> do

125 let attrAssoc = mapM (\(attrName, atomExpr) -> do

@@ -152,7 +161,7 @@ evalTransGraphRestrictionPredicateExpr (AttributeEqualityPredicate attrName expr

152 AttributeEqualityPredicate attrName <$> expr'

161 AttributeEqualityPredicate attrName <$> expr'

153

162

154processTransGraphExtendTupleExpr :: TransGraphExtendTupleExpr -> TransGraphEvalMonad GraphRefExtendTupleExpr

163processTransGraphExtendTupleExpr :: TransGraphExtendTupleExpr -> TransGraphEvalMonad GraphRefExtendTupleExpr

155−processTransGraphExtendTupleExpr (AttributeExtendTupleExpr attrName expr) =

164+processTransGraphExtendTupleExpr (AttributeExtendTupleExpr attrName expr) = do

156 AttributeExtendTupleExpr attrName <$> processTransGraphAtomExpr expr

165 AttributeExtendTupleExpr attrName <$> processTransGraphAtomExpr expr

157

166

158processTransGraphAttributeExpr :: TransGraphAttributeExpr -> TransGraphEvalMonad GraphRefAttributeExpr

167processTransGraphAttributeExpr :: TransGraphAttributeExpr -> TransGraphEvalMonad GraphRefAttributeExpr

src/lib/ProjectM36/Transaction.hs+5−10

@@ -17,10 +17,11 @@ singleParent tid = tid NE.:| []

17-- | Return the same transaction but referencing only the specific child transactions. This is useful when traversing a graph and returning a subgraph. This doesn't filter parent transactions because it assumes a head-to-root traversal.

18filterTransactionInfoTransactions :: S.Set TransactionId -> TransactionInfo -> TransactionInfo

19filterTransactionInfoTransactions filterIds tinfo =

20− tinfo { parents = case

20+ TransactionInfo { parents = case

21− NE.filter (`S.member` filterIds) (parents tinfo) of

21+ NE.filter (\parent -> S.member parent filterIds) (parents tinfo) of

22 [] -> rootParent

23− xs -> NE.fromList xs}

23+ xs -> NE.fromList xs,

24+ stamp = stamp tinfo }

24

25

25filterParent :: TransactionId -> S.Set TransactionId -> TransactionId

26filterParent :: TransactionId -> S.Set TransactionId -> TransactionId

26filterParent parentId validIds = if S.member parentId validIds then parentId else U.nil

27filterParent parentId validIds = if S.member parentId validIds then parentId else U.nil

@@ -42,13 +43,7 @@ subschemas :: Transaction -> Subschemas

42subschemas (Transaction _ _ (Schemas _ sschemas)) = sschemas

43subschemas (Transaction _ _ (Schemas _ sschemas)) = sschemas

43

44

44fresh :: TransactionId -> UTCTime -> Schemas -> Transaction

45fresh :: TransactionId -> UTCTime -> Schemas -> Transaction

45−fresh freshId stamp' = Transaction freshId tinfo

46+fresh freshId stamp' newSchemas = Transaction freshId (TransactionInfo rootParent stamp') newSchemas

46− where

47− tinfo = TransactionInfo {parents = rootParent,

48− stamp = stamp',

49− merkleHash = mempty

50− }

51

47

52timestamp :: Transaction -> UTCTime

48timestamp :: Transaction -> UTCTime

53timestamp (Transaction _ tinfo _) = stamp tinfo

49timestamp (Transaction _ tinfo _) = stamp tinfo

54−

src/lib/ProjectM36/Transaction/Persist.hs+31−51

@@ -1,4 +1,3 @@

1−{-# LANGUAGE TypeApplications #-}

2module ProjectM36.Transaction.Persist where

1module ProjectM36.Transaction.Persist where

3import ProjectM36.Base

2import ProjectM36.Base

4import ProjectM36.Error

3import ProjectM36.Error

@@ -8,19 +7,17 @@ import ProjectM36.AtomFunction

8import ProjectM36.Persist (writeBSFileSync, DiskSync, renameSync)

7import ProjectM36.Persist (writeBSFileSync, DiskSync, renameSync)

9import qualified Data.Map as M

8import qualified Data.Map as M

10import qualified Data.HashSet as HS

9import qualified Data.HashSet as HS

10+import qualified Data.Binary as B

11+--import qualified Data.ByteString as BS

11import System.FilePath

12import System.FilePath

12import System.Directory

13import System.Directory

13import qualified Data.Text as T

14import qualified Data.Text as T

14import Control.Monad

15import Control.Monad

15import ProjectM36.ScriptSession

16import ProjectM36.ScriptSession

16import ProjectM36.AtomFunctions.Basic (precompiledAtomFunctions)

17import ProjectM36.AtomFunctions.Basic (precompiledAtomFunctions)

17−import Codec.Winery

18−

19−#ifdef PM36_HASKELL_SCRIPTING

20−import GHC

21import Control.Exception

18import Control.Exception

19+import GHC

22import GHC.Paths

20import GHC.Paths

23−#endif

24

21

25getDirectoryNames :: FilePath -> IO [FilePath]

22getDirectoryNames :: FilePath -> IO [FilePath]

26getDirectoryNames path =

23getDirectoryNames path =

@@ -62,7 +59,7 @@ readTransaction dbdir transId mScriptSession = do

62 return $ Left $ MissingTransactionError transId

59 return $ Left $ MissingTransactionError transId

63 else do

60 else do

64 relvars <- readRelVars transDir

61 relvars <- readRelVars transDir

65− transInfo <- readFileDeserialise (transactionInfoPath transDir)

62+ transInfo <- B.decodeFile (transactionInfoPath transDir)

66 incDeps <- readIncDeps transDir

63 incDeps <- readIncDeps transDir

67 typeCons <- readTypeConstructorMapping transDir

64 typeCons <- readTypeConstructorMapping transDir

68 sschemas <- readSubschemas transDir

65 sschemas <- readSubschemas transDir

@@ -92,68 +89,61 @@ writeTransaction sync dbdir trans = do

92 writeDBCFuncs sync tempTransDir (dbcFunctions context)

89 writeDBCFuncs sync tempTransDir (dbcFunctions context)

93 writeTypeConstructorMapping sync tempTransDir (typeConstructorMapping context)

90 writeTypeConstructorMapping sync tempTransDir (typeConstructorMapping context)

94 writeSubschemas sync tempTransDir (subschemas trans)

91 writeSubschemas sync tempTransDir (subschemas trans)

95− writeFileSerialise (transactionInfoPath tempTransDir) (transactionInfo trans)

92+ B.encodeFile (transactionInfoPath tempTransDir) (transactionInfo trans)

96 --move the temp directory to final location

93 --move the temp directory to final location

97 renameSync sync tempTransDir finalTransDir

94 renameSync sync tempTransDir finalTransDir

98

95

99writeRelVars :: DiskSync -> FilePath -> RelationVariables -> IO ()

96writeRelVars :: DiskSync -> FilePath -> RelationVariables -> IO ()

100writeRelVars sync transDir relvars = do

97writeRelVars sync transDir relvars = do

101 let path = relvarsPath transDir

98 let path = relvarsPath transDir

102− writeBSFileSync sync path (serialise relvars)

99+ writeBSFileSync sync path (B.encode relvars)

103

100

104readRelVars :: FilePath -> IO RelationVariables

101readRelVars :: FilePath -> IO RelationVariables

105−readRelVars transDir =

102+readRelVars transDir = do

106− readFileDeserialise (relvarsPath transDir)

103+ B.decodeFile (relvarsPath transDir)

107

104

108writeAtomFuncs :: DiskSync -> FilePath -> AtomFunctions -> IO ()

105writeAtomFuncs :: DiskSync -> FilePath -> AtomFunctions -> IO ()

109writeAtomFuncs sync transDir funcs = do

106writeAtomFuncs sync transDir funcs = do

110 let atomFuncPath = atomFuncsPath transDir

107 let atomFuncPath = atomFuncsPath transDir

111− writeBSFileSync sync atomFuncPath (serialise $ map (\f -> (atomFuncType f, atomFuncName f, atomFunctionScript f)) (HS.toList funcs))

108+ writeBSFileSync sync atomFuncPath (B.encode $ map (\f -> (atomFuncType f, atomFuncName f, atomFunctionScript f)) (HS.toList funcs))

112

109

113--all the atom functions are in one file

110--all the atom functions are in one file

114readAtomFuncs :: FilePath -> Maybe ScriptSession -> IO AtomFunctions

111readAtomFuncs :: FilePath -> Maybe ScriptSession -> IO AtomFunctions

115readAtomFuncs transDir mScriptSession = do

112readAtomFuncs transDir mScriptSession = do

116− atomFuncsList <- readFileDeserialise (atomFuncsPath transDir)

113+ atomFuncsList <- B.decodeFile (atomFuncsPath transDir)

117 --only Haskell script functions can be serialized

114 --only Haskell script functions can be serialized

118 --we always return the pre-compiled functions

115 --we always return the pre-compiled functions

119 funcs <- mapM (\(funcType, funcName, mFuncScript) -> loadAtomFunc precompiledAtomFunctions mScriptSession funcName funcType mFuncScript) atomFuncsList

116 funcs <- mapM (\(funcType, funcName, mFuncScript) -> loadAtomFunc precompiledAtomFunctions mScriptSession funcName funcType mFuncScript) atomFuncsList

120 pure (HS.union precompiledAtomFunctions (HS.fromList funcs))

117 pure (HS.union precompiledAtomFunctions (HS.fromList funcs))

121

118

122loadAtomFunc :: AtomFunctions -> Maybe ScriptSession -> AtomFunctionName -> [AtomType] -> Maybe AtomFunctionBodyScript -> IO AtomFunction

119loadAtomFunc :: AtomFunctions -> Maybe ScriptSession -> AtomFunctionName -> [AtomType] -> Maybe AtomFunctionBodyScript -> IO AtomFunction

123−loadAtomFunc precompiledFuncs _mScriptSession funcName _funcType mFuncScript = case mFuncScript of

120+loadAtomFunc precompiledFuncs mScriptSession funcName funcType mFuncScript = case mFuncScript of

124 --handle pre-compiled case- pull it from the precompiled list

121 --handle pre-compiled case- pull it from the precompiled list

125 Nothing -> case atomFunctionForName funcName precompiledFuncs of

122 Nothing -> case atomFunctionForName funcName precompiledFuncs of

126 --WARNING: possible landmine here if we remove a precompiled atom function in the future, then the transaction cannot be restored

123 --WARNING: possible landmine here if we remove a precompiled atom function in the future, then the transaction cannot be restored

127 Left _ -> error ("expected precompiled atom function: " ++ T.unpack funcName)

124 Left _ -> error ("expected precompiled atom function: " ++ T.unpack funcName)

128 Right realFunc -> pure realFunc

125 Right realFunc -> pure realFunc

129 --handle a real Haskell scripted function- compile and load

126 --handle a real Haskell scripted function- compile and load

130− Just _funcScript ->

127+ Just funcScript ->

131−#ifdef PM36_HASKELL_SCRIPTING

128+ case mScriptSession of

132− case _mScriptSession of

133 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"

129 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"

134 Just scriptSession -> do

130 Just scriptSession -> do

135 --risk of GHC exception during compilation here

131 --risk of GHC exception during compilation here

136 eCompiledScript <- runGhc (Just libdir) $ do

132 eCompiledScript <- runGhc (Just libdir) $ do

137 setSession (hscEnv scriptSession)

133 setSession (hscEnv scriptSession)

138− compileScript (atomFunctionBodyType scriptSession) _funcScript

134+ compileScript (atomFunctionBodyType scriptSession) funcScript

139 case eCompiledScript of

135 case eCompiledScript of

140 Left err -> throwIO err

136 Left err -> throwIO err

141 Right compiledScript -> pure AtomFunction { atomFuncName = funcName,

137 Right compiledScript -> pure AtomFunction { atomFuncName = funcName,

142− atomFuncType = _funcType,

138+ atomFuncType = funcType,

143− atomFuncBody = AtomFunctionBody (Just _funcScript) compiledScript }

139+ atomFuncBody = AtomFunctionBody (Just funcScript) compiledScript }

144−#else

145− error "Haskell scripting is disabled"

146−#endif

147

140

148--if the script session is enabled, compile the script, otherwise, hard error!

141--if the script session is enabled, compile the script, otherwise, hard error!

149

142

150readAtomFunc :: FilePath -> AtomFunctionName -> Maybe ScriptSession -> AtomFunctions -> IO AtomFunction

143readAtomFunc :: FilePath -> AtomFunctionName -> Maybe ScriptSession -> AtomFunctions -> IO AtomFunction

151−#if !defined(PM36_HASKELL_SCRIPTING)

152−readAtomFunc _ _ _ _ = error "Haskell scripting is disabled"

153−#else

154readAtomFunc transDir funcName mScriptSession precompiledFuncs = do

144readAtomFunc transDir funcName mScriptSession precompiledFuncs = do

155 let atomFuncPath = atomFuncsPath transDir

145 let atomFuncPath = atomFuncsPath transDir

156− (funcType, mFuncScript) <- readFileDeserialise @([AtomType],Maybe T.Text) atomFuncPath

146+ (funcType, mFuncScript) <- B.decodeFile atomFuncPath

157 case mFuncScript of

147 case mFuncScript of

158 --handle pre-compiled case- pull it from the precompiled list

148 --handle pre-compiled case- pull it from the precompiled list

159 Nothing -> case atomFunctionForName funcName precompiledFuncs of

149 Nothing -> case atomFunctionForName funcName precompiledFuncs of

@@ -161,8 +151,7 @@ readAtomFunc transDir funcName mScriptSession precompiledFuncs = do

161 Left _ -> error ("expected precompiled atom function: " ++ T.unpack funcName)

151 Left _ -> error ("expected precompiled atom function: " ++ T.unpack funcName)

162 Right realFunc -> pure realFunc

152 Right realFunc -> pure realFunc

163 --handle a real Haskell scripted function- compile and load

153 --handle a real Haskell scripted function- compile and load

164− Just funcScript ->

154+ Just funcScript ->

165−

166 case mScriptSession of

155 case mScriptSession of

167 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"

156 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"

168 Just scriptSession -> do

157 Just scriptSession -> do

@@ -175,7 +164,6 @@ readAtomFunc transDir funcName mScriptSession precompiledFuncs = do

175 Right compiledScript -> pure AtomFunction { atomFuncName = funcName,

164 Right compiledScript -> pure AtomFunction { atomFuncName = funcName,

176 atomFuncType = funcType,

165 atomFuncType = funcType,

177 atomFuncBody = AtomFunctionBody (Just funcScript) compiledScript }

166 atomFuncBody = AtomFunctionBody (Just funcScript) compiledScript }

178−#endif

179

167

180

168

181writeDBCFuncs :: DiskSync -> FilePath -> DatabaseContextFunctions -> IO ()

169writeDBCFuncs :: DiskSync -> FilePath -> DatabaseContextFunctions -> IO ()

@@ -184,7 +172,7 @@ writeDBCFuncs sync transDir funcs = mapM_ (writeDBCFunc sync transDir) (HS.toLis

184writeDBCFunc :: DiskSync -> FilePath -> DatabaseContextFunction -> IO ()

172writeDBCFunc :: DiskSync -> FilePath -> DatabaseContextFunction -> IO ()

185writeDBCFunc sync transDir func = do

173writeDBCFunc sync transDir func = do

186 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack (dbcFuncName func)

174 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack (dbcFuncName func)

187− writeBSFileSync sync dbcFuncPath (serialise (dbcFuncType func, databaseContextFunctionScript func))

175+ writeBSFileSync sync dbcFuncPath (B.encode (dbcFuncType func, databaseContextFunctionScript func))

188

176

189readDBCFuncs :: FilePath -> Maybe ScriptSession -> IO DatabaseContextFunctions

177readDBCFuncs :: FilePath -> Maybe ScriptSession -> IO DatabaseContextFunctions

190readDBCFuncs transDir mScriptSession = do

178readDBCFuncs transDir mScriptSession = do

@@ -194,38 +182,30 @@ readDBCFuncs transDir mScriptSession = do

194 let funcs = mapM ((\name -> readDBCFunc transDir name mScriptSession precompiledDatabaseContextFunctions) . T.pack) funcNames

182 let funcs = mapM ((\name -> readDBCFunc transDir name mScriptSession precompiledDatabaseContextFunctions) . T.pack) funcNames

195 HS.union basicDatabaseContextFunctions . HS.fromList <$> funcs

183 HS.union basicDatabaseContextFunctions . HS.fromList <$> funcs

196

184

197−readDBCFunc :: FilePath -> DatabaseContextFunctionName -> Maybe ScriptSession -> DatabaseContextFunctions -> IO DatabaseContextFunction

185+readDBCFunc :: FilePath -> DatabaseContextFunctionName -> Maybe ScriptSession -> DatabaseContextFunctions -> IO DatabaseContextFunction

198−#if !defined(PM36_HASKELL_SCRIPTING)

199−readDBCFunc transDir funcName _ precompiledFuncs = do

200−#else

201readDBCFunc transDir funcName mScriptSession precompiledFuncs = do

186readDBCFunc transDir funcName mScriptSession precompiledFuncs = do

202−#endif

203 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack funcName

187 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack funcName

204− (_funcType, mFuncScript) <- readFileDeserialise @([AtomType], Maybe T.Text) dbcFuncPath

188+ (funcType, mFuncScript) <- B.decodeFile dbcFuncPath

205 case mFuncScript of

189 case mFuncScript of

206 Nothing -> case databaseContextFunctionForName funcName precompiledFuncs of

190 Nothing -> case databaseContextFunctionForName funcName precompiledFuncs of

207 Left _ -> error ("expected precompiled dbc function: " ++ T.unpack funcName)

191 Left _ -> error ("expected precompiled dbc function: " ++ T.unpack funcName)

208 Right realFunc -> pure realFunc --return precompiled function

192 Right realFunc -> pure realFunc --return precompiled function

209− Just _funcScript ->

193+ Just funcScript ->

210−#ifdef PM36_HASKELL_SCRIPTING

211 case mScriptSession of

194 case mScriptSession of

212 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"

195 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"

213 Just scriptSession -> do

196 Just scriptSession -> do

214 eCompiledScript <- runGhc (Just libdir) $ do

197 eCompiledScript <- runGhc (Just libdir) $ do

215 setSession (hscEnv scriptSession)

198 setSession (hscEnv scriptSession)

216− compileScript (dbcFunctionBodyType scriptSession) _funcScript

199+ compileScript (dbcFunctionBodyType scriptSession) funcScript

217 case eCompiledScript of

200 case eCompiledScript of

218 Left err -> throwIO err

201 Left err -> throwIO err

219 Right compiledScript -> pure DatabaseContextFunction { dbcFuncName = funcName,

202 Right compiledScript -> pure DatabaseContextFunction { dbcFuncName = funcName,

220− dbcFuncType = _funcType,

203+ dbcFuncType = funcType,

221− dbcFuncBody = DatabaseContextFunctionBody (Just _funcScript) compiledScript}

204+ dbcFuncBody = DatabaseContextFunctionBody (Just funcScript) compiledScript}

222−#else

223− error "Haskell scripting is disabled"

224−#endif

225

205

226writeIncDep :: DiskSync -> FilePath -> (IncDepName, InclusionDependency) -> IO ()

206writeIncDep :: DiskSync -> FilePath -> (IncDepName, InclusionDependency) -> IO ()

227writeIncDep sync transDir (incDepName, incDep) =

207writeIncDep sync transDir (incDepName, incDep) =

228− writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ serialise incDep

208+ writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ B.encode incDep

229

209

230writeIncDeps :: DiskSync -> FilePath -> M.Map IncDepName InclusionDependency -> IO ()

210writeIncDeps :: DiskSync -> FilePath -> M.Map IncDepName InclusionDependency -> IO ()

231writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toList incdeps

211writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toList incdeps

@@ -233,7 +213,7 @@ writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toLis

233readIncDep :: FilePath -> IncDepName -> IO (IncDepName, InclusionDependency)

213readIncDep :: FilePath -> IncDepName -> IO (IncDepName, InclusionDependency)

234readIncDep transDir incdepName = do

214readIncDep transDir incdepName = do

235 let incDepPath = incDepsDir transDir </> T.unpack incdepName

215 let incDepPath = incDepsDir transDir </> T.unpack incdepName

236− incDepData <- readFileDeserialise incDepPath

216+ incDepData <- B.decodeFile incDepPath

237 pure (incdepName, incDepData)

217 pure (incdepName, incDepData)

238

218

239readIncDeps :: FilePath -> IO (M.Map IncDepName InclusionDependency)

219readIncDeps :: FilePath -> IO (M.Map IncDepName InclusionDependency)

@@ -245,20 +225,20 @@ readIncDeps transDir = do

245readSubschemas :: FilePath -> IO Subschemas

225readSubschemas :: FilePath -> IO Subschemas

246readSubschemas transDir = do

226readSubschemas transDir = do

247 let sschemasPath = subschemasPath transDir

227 let sschemasPath = subschemasPath transDir

248− readFileDeserialise sschemasPath

228+ B.decodeFile sschemasPath

249

229

250writeSubschemas :: DiskSync -> FilePath -> Subschemas -> IO ()

230writeSubschemas :: DiskSync -> FilePath -> Subschemas -> IO ()

251writeSubschemas sync transDir sschemas = do

231writeSubschemas sync transDir sschemas = do

252 let sschemasPath = subschemasPath transDir

232 let sschemasPath = subschemasPath transDir

253− writeBSFileSync sync sschemasPath (serialise sschemas)

233+ writeBSFileSync sync sschemasPath (B.encode sschemas)

254

234

255writeTypeConstructorMapping :: DiskSync -> FilePath -> TypeConstructorMapping -> IO ()

235writeTypeConstructorMapping :: DiskSync -> FilePath -> TypeConstructorMapping -> IO ()

256writeTypeConstructorMapping sync path types = let atPath = typeConsPath path in

236writeTypeConstructorMapping sync path types = let atPath = typeConsPath path in

257− writeBSFileSync sync atPath $ serialise types

237+ writeBSFileSync sync atPath $ B.encode types

258

238

259readTypeConstructorMapping :: FilePath -> IO TypeConstructorMapping

239readTypeConstructorMapping :: FilePath -> IO TypeConstructorMapping

260readTypeConstructorMapping path = do

240readTypeConstructorMapping path = do

261 let atPath = typeConsPath path

241 let atPath = typeConsPath path

262− readFileDeserialise atPath

242+ B.decodeFile atPath

263

243

264

244

src/lib/ProjectM36/TransactionGraph.hs+82−177

@@ -1,4 +1,4 @@

1−{-# LANGUAGE DeriveGeneric, CPP, FlexibleContexts, DerivingVia #-}

1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}

2module ProjectM36.TransactionGraph where

3import ProjectM36.Base

4import ProjectM36.Error

@@ -9,44 +9,42 @@ import ProjectM36.TupleSet

9import ProjectM36.Tuple

10import ProjectM36.RelationalExpression

11import ProjectM36.TransactionGraph.Merge

12−import ProjectM36.MerkleHash

13import qualified ProjectM36.DisconnectedTransaction as Discon

12import qualified ProjectM36.DisconnectedTransaction as Discon

14−import qualified ProjectM36.Attribute as A

15

13

16−import Codec.Winery

17−import Control.Monad.Except hiding (join)

18−import Control.Monad.Reader hiding (join)

19import qualified Data.Vector as V

14import qualified Data.Vector as V

15+import qualified ProjectM36.Attribute as A

20import qualified Data.UUID as U

16import qualified Data.UUID as U

21import qualified Data.Set as S

17import qualified Data.Set as S

22import qualified Data.Map as M

18import qualified Data.Map as M

23import qualified Data.List.NonEmpty as NE

19import qualified Data.List.NonEmpty as NE

20+import Control.Monad

24import Data.Time.Clock

21import Data.Time.Clock

25import qualified Data.Text as T

22import qualified Data.Text as T

26import GHC.Generics

23import GHC.Generics

24+import Data.Binary

27import Data.Either (lefts, rights, isRight)

25import Data.Either (lefts, rights, isRight)

28−#if __GLASGOW_HASKELL__ < 804

29−import Data.Monoid

30−#endif

31import Control.Arrow

26import Control.Arrow

32import Data.Maybe

27import Data.Maybe

28+#if __GLASGOW_HASKELL__ <= 802

33−import Data.UUID.V4

29+import Data.Monoid

34−import qualified Data.ByteString.Lazy as BL

30+#endif

35−import ProjectM36.DatabaseContext as DBC

31+

36−import Crypto.Hash.SHA256

32+{-

33+--import Debug.Trace

34+import Control.Monad.Reader

35+import qualified ProjectM36.DisconnectedTransaction as D

36+-}

37

38-- | Record a lookup for a specific transaction in the graph.

39data TransactionIdLookup = TransactionIdLookup TransactionId |

40 TransactionIdHeadNameLookup HeadName [TransactionIdHeadBacktrack]

41− deriving (Show, Eq, Generic)

41+ deriving (Show, Eq, Binary, Generic)

42− deriving Serialise via WineryVariant TransactionIdLookup

43

42

44-- | Used for git-style head backtracking such as topic~3^2.

43-- | Used for git-style head backtracking such as topic~3^2.

45−data TransactionIdHeadBacktrack = TransactionIdHeadParentBacktrack Int | -- ^ git equivalent of ~v: walk back n parents, arbitrarily choosing a parent when a choice must be made

44+data TransactionIdHeadBacktrack = TransactionIdHeadParentBacktrack Int | -- ^ git equivalent of ~: walk back n parents, arbitrarily choosing a parent when a choice must be made

46 TransactionIdHeadBranchBacktrack Int | -- ^ git equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent

45 TransactionIdHeadBranchBacktrack Int | -- ^ git equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent

47 TransactionStampHeadBacktrack UTCTime -- ^ git equivalent of 'git-rev-list -n 1 --before X' find the first transaction which was created before the timestamp

46 TransactionStampHeadBacktrack UTCTime -- ^ git equivalent of 'git-rev-list -n 1 --before X' find the first transaction which was created before the timestamp

48− deriving (Show, Eq, Generic)

47+ deriving (Show, Eq, Binary, Generic)

49− deriving Serialise via WineryVariant TransactionIdHeadBacktrack

50

48

51

49

52-- | Operators which manipulate a transaction graph and which transaction the current 'Session' is based upon.

50-- | Operators which manipulate a transaction graph and which transaction the current 'Session' is based upon.

@@ -58,14 +56,13 @@ data TransactionGraphOperator = JumpToHead HeadName |

58 MergeTransactions MergeStrategy HeadName HeadName |

56 MergeTransactions MergeStrategy HeadName HeadName |

59 Commit |

57 Commit |

60 Rollback

58 Rollback

61− deriving (Eq, Show, Generic)

59+ deriving (Eq, Show, Binary, Generic)

62− deriving Serialise via WineryVariant TransactionGraphOperator

63

60

64isCommit :: TransactionGraphOperator -> Bool

61isCommit :: TransactionGraphOperator -> Bool

65isCommit Commit = True

62isCommit Commit = True

66isCommit _ = False

63isCommit _ = False

67

64

68−data ROTransactionGraphOperator = ShowGraph | ValidateMerkleHashes

65+data ROTransactionGraphOperator = ShowGraph

69 deriving Show

66 deriving Show

70

67

71bootstrapTransactionGraph :: UTCTime -> TransactionId -> DatabaseContext -> TransactionGraph

68bootstrapTransactionGraph :: UTCTime -> TransactionId -> DatabaseContext -> TransactionGraph

@@ -74,16 +71,7 @@ bootstrapTransactionGraph stamp' freshId context = TransactionGraph bootstrapHea

74 bootstrapHeads = M.singleton "master" freshTransaction

71 bootstrapHeads = M.singleton "master" freshTransaction

75 newSchemas = Schemas context M.empty

72 newSchemas = Schemas context M.empty

76 freshTransaction = fresh freshId stamp' newSchemas

73 freshTransaction = fresh freshId stamp' newSchemas

77− hashedTransaction = Transaction freshId ((transactionInfo freshTransaction) { merkleHash = calculateMerkleHash freshTransaction emptyTransactionGraph }) newSchemas

78− bootstrapTransactions = S.singleton hashedTransaction

74+ bootstrapTransactions = S.singleton freshTransaction

79−

80−-- | Create a transaction graph from a context.

81−freshTransactionGraph :: DatabaseContext -> IO (TransactionGraph, TransactionId)

82−freshTransactionGraph ctx = do

83− now <- getCurrentTime

84− freshId <- nextRandom

85− pure (bootstrapTransactionGraph now freshId ctx, freshId)

86−

87

75

88emptyTransactionGraph :: TransactionGraph

76emptyTransactionGraph :: TransactionGraph

89emptyTransactionGraph = TransactionGraph M.empty S.empty

77emptyTransactionGraph = TransactionGraph M.empty S.empty

@@ -110,12 +98,9 @@ transactionsForIds idSet graph =

110isRootTransaction :: Transaction -> Bool

98isRootTransaction :: Transaction -> Bool

111isRootTransaction trans = parentIds trans == S.singleton U.nil

99isRootTransaction trans = parentIds trans == S.singleton U.nil

112

100

113−rootTransactions :: TransactionGraph -> S.Set Transaction

114−rootTransactions graph = S.filter isRootTransaction (transactionsForGraph graph)

115−

116-- the first transaction has no parent - all other do have parents- merges have two parents

101-- the first transaction has no parent - all other do have parents- merges have two parents

117parentTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)

102parentTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)

118−parentTransactions trans = transactionsForIds (parentIds trans)

103+parentTransactions trans graph = transactionsForIds (parentIds trans) graph

119

104

120childTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)

105childTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)

121childTransactions trans graph = transactionsForIds childIds graph

106childTransactions trans graph = transactionsForIds childIds graph

@@ -133,13 +118,10 @@ addBranch stamp' newId newBranchName branchPointId graph = do

133

118

134--adds a disconnected transaction to a transaction graph at some head

119--adds a disconnected transaction to a transaction graph at some head

135addDisconnectedTransaction :: UTCTime -> TransactionId -> HeadName -> DisconnectedTransaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)

120addDisconnectedTransaction :: UTCTime -> TransactionId -> HeadName -> DisconnectedTransaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)

136−addDisconnectedTransaction stamp' newId headName (DisconnectedTransaction parentId schemas' _) graph = addTransactionToGraph headName newTrans' graph

121+addDisconnectedTransaction stamp' newId headName (DisconnectedTransaction parentId schemas' _) = addTransactionToGraph headName newTrans

137 where

122 where

138− newTrans = Transaction newId newTInfo schemas'

139− newTInfo = TI.singleParent parentId stamp'

123+ newTrans = Transaction newId (TI.singleParent parentId stamp') schemas'

140− newTrans' = Transaction newId (newTInfo { merkleHash = newHash }) schemas'

124+

141− newHash = calculateMerkleHash newTrans graph--lookup parents in graph to calculate

142−--LOOP

143addTransactionToGraph :: HeadName -> Transaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)

125addTransactionToGraph :: HeadName -> Transaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)

144addTransactionToGraph headName newTrans graph = do

126addTransactionToGraph headName newTrans graph = do

145 let parentIds' = parentIds newTrans

127 let parentIds' = parentIds newTrans

@@ -157,24 +139,10 @@ addTransactionToGraph headName newTrans graph = do

157 unless (S.null childTs) (Left $ NewTransactionMayNotHaveChildrenError newId)

139 unless (S.null childTs) (Left $ NewTransactionMayNotHaveChildrenError newId)

158 --validate that the trasaction's id is unique

140 --validate that the trasaction's id is unique

159 when (isRight (transactionForId newId graph)) (Left (TransactionIdInUseError newId))

141 when (isRight (transactionForId newId graph)) (Left (TransactionIdInUseError newId))

160− --replace all references to UncommittedTransactionMarker to new transaction id

161− let newTrans' = newTransUncommittedReplace newTrans

162− updatedTransSet = S.insert newTrans' (transactionsForGraph graph)

163− updatedHeads = M.insert headName newTrans' (transactionHeadsForGraph graph)

164− pure (newTrans', TransactionGraph updatedHeads updatedTransSet)

165−

166−--replace all occurrences of the uncommitted context marker

167−newTransUncommittedReplace :: Transaction -> Transaction

168−newTransUncommittedReplace trans@(Transaction tid tinfo (Schemas ctx sschemas)) =

169− Transaction tid tinfo (Schemas fixedContext sschemas)

170− where

171− uncommittedReplace UncommittedContextMarker = TransactionMarker tid

172− uncommittedReplace marker = marker

173− relvars = relationVariables (concreteDatabaseContext trans)

174− fixedRelvars = M.map (fmap uncommittedReplace) relvars

175− fixedContext = ctx { relationVariables = fixedRelvars }

176−

177

142

143+ let updatedTransSet = S.insert newTrans (transactionsForGraph graph)

144+ updatedHeads = M.insert headName newTrans (transactionHeadsForGraph graph)

145+ pure (newTrans, TransactionGraph updatedHeads updatedTransSet)

178

146

179validateGraph :: TransactionGraph -> Maybe [RelationalError]

147validateGraph :: TransactionGraph -> Maybe [RelationalError]

180validateGraph graph@(TransactionGraph _ transSet) = do

148validateGraph graph@(TransactionGraph _ transSet) = do

@@ -231,12 +199,12 @@ evalGraphOp _ _ _ graph (JumpToTransaction jumpId) = case transactionForId jumpI

231 Left err -> Left err

199 Left err -> Left err

232 Right parentTrans -> Right (newTrans, graph)

200 Right parentTrans -> Right (newTrans, graph)

233 where

201 where

234− newTrans = DisconnectedTransaction jumpId (schemas parentTrans) False

202+ newTrans = DisconnectedTransaction jumpId (schemas parentTrans) NoOperation

235

203

236-- switch from one head to another

204-- switch from one head to another

237evalGraphOp _ _ _ graph (JumpToHead headName) =

205evalGraphOp _ _ _ graph (JumpToHead headName) =

238 case transactionForHead headName graph of

206 case transactionForHead headName graph of

239− Just newHeadTransaction -> let disconnectedTrans = DisconnectedTransaction (transactionId newHeadTransaction) (schemas newHeadTransaction) False in

207+ Just newHeadTransaction -> let disconnectedTrans = DisconnectedTransaction (transactionId newHeadTransaction) (schemas newHeadTransaction) NoOperation in

240 Right (disconnectedTrans, graph)

208 Right (disconnectedTrans, graph)

241 Nothing -> Left $ NoSuchHeadNameError headName

209 Nothing -> Left $ NoSuchHeadNameError headName

242

210

@@ -290,10 +258,7 @@ evalGraphOp _ _ (DisconnectedTransaction parentId _ _) graph Rollback = case tra

290 where

258 where

291 newDiscon = Discon.freshTransaction parentId (schemas parentTransaction)

259 newDiscon = Discon.freshTransaction parentId (schemas parentTransaction)

292

260

293−evalGraphOp stamp' newId (DisconnectedTransaction parentId _ _) graph (MergeTransactions mergeStrategy headNameA headNameB) =

261+evalGraphOp stamp' newId (DisconnectedTransaction parentId _ _) graph (MergeTransactions mergeStrategy headNameA headNameB) = mergeTransactions stamp' newId parentId mergeStrategy (headNameA, headNameB) graph

294− runGraphRefRelationalExprM env $ mergeTransactions stamp' newId parentId mergeStrategy (headNameA, headNameB)

295− where

296− env = freshGraphRefRelationalExprEnv Nothing graph

297

262

298evalGraphOp _ _ discon graph@(TransactionGraph graphHeads transSet) (DeleteBranch branchName) = case transactionForHead branchName graph of

263evalGraphOp _ _ discon graph@(TransactionGraph graphHeads transSet) (DeleteBranch branchName) = case transactionForHead branchName graph of

299 Nothing -> Left (NoSuchHeadNameError branchName)

264 Nothing -> Left (NoSuchHeadNameError branchName)

@@ -306,7 +271,6 @@ graphAsRelation (DisconnectedTransaction parentId _ _) graph@(TransactionGraph _

306 mkRelationFromList attrs tupleMatrix

271 mkRelationFromList attrs tupleMatrix

307 where

272 where

308 attrs = A.attributesFromList [Attribute "id" TextAtomType,

273 attrs = A.attributesFromList [Attribute "id" TextAtomType,

309− Attribute "hash" ByteStringAtomType,

310 Attribute "stamp" DateTimeAtomType,

274 Attribute "stamp" DateTimeAtomType,

311 Attribute "parents" (RelationAtomType parentAttributes),

275 Attribute "parents" (RelationAtomType parentAttributes),

312 Attribute "current" BoolAtomType,

276 Attribute "current" BoolAtomType,

@@ -316,7 +280,6 @@ graphAsRelation (DisconnectedTransaction parentId _ _) graph@(TransactionGraph _

316 tupleGenerator transaction = case transactionParentsRelation transaction graph of

280 tupleGenerator transaction = case transactionParentsRelation transaction graph of

317 Left err -> Left err

281 Left err -> Left err

318 Right parentTransRel -> Right [TextAtom $ T.pack $ show (transactionId transaction),

282 Right parentTransRel -> Right [TextAtom $ T.pack $ show (transactionId transaction),

319− ByteStringAtom $ _unMerkleHash (merkleHash (transactionInfo transaction)),

320 DateTimeAtom (timestamp transaction),

283 DateTimeAtom (timestamp transaction),

321 RelationAtom parentTransRel,

284 RelationAtom parentTransRel,

322 BoolAtom $ parentId == transactionId transaction,

285 BoolAtom $ parentId == transactionId transaction,

@@ -344,34 +307,29 @@ evalROGraphOp discon graph ShowGraph = do

344-}

307-}

345

308

346-- | Execute the merge strategy against the transactions, returning a new transaction which can be then added to the transaction graph

309-- | Execute the merge strategy against the transactions, returning a new transaction which can be then added to the transaction graph

347−createMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> (Transaction, Transaction) -> GraphRefRelationalExprM Transaction

310+createMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> TransactionGraph -> (Transaction, Transaction) -> Either MergeError Transaction

348−createMergeTransaction stamp' newId (SelectedBranchMergeStrategy selectedBranch) t2@(trans1, trans2) = do

311+createMergeTransaction stamp' newId (SelectedBranchMergeStrategy selectedBranch) graph t2@(trans1, trans2) = do

349− graph <- gfGraph

350− selectedTrans <- validateHeadName selectedBranch graph t2

312+ let selectedTrans = validateHeadName selectedBranch graph t2

351− pure $ addMerkleHash graph $

352− Transaction newId (TransactionInfo {

313+ Transaction newId (TransactionInfo {

353− parents = NE.fromList [transactionId trans1,

314+ parents = NE.fromList [transactionId trans1,

354− transactionId trans2],

315+ transactionId trans2],

355− stamp = stamp',

356− merkleHash = mempty }) (schemas selectedTrans)

316+ stamp = stamp' }) . schemas <$> selectedTrans

357

317

358-- merge functions, relvars, individually

318-- merge functions, relvars, individually

359−createMergeTransaction stamp' newId strat@UnionMergeStrategy t2 =

319+createMergeTransaction stamp' newId strat@UnionMergeStrategy graph t2 = createUnionMergeTransaction stamp' newId strat graph t2

360− createUnionMergeTransaction stamp' newId strat t2

361

320

362-- merge function, relvars, but, on error, just take the component from the preferred branch

321-- merge function, relvars, but, on error, just take the component from the preferred branch

363−createMergeTransaction stamp' newId strat@(UnionPreferMergeStrategy _) t2 =

322+createMergeTransaction stamp' newId strat@(UnionPreferMergeStrategy _) graph t2 = createUnionMergeTransaction stamp' newId strat graph t2

364− createUnionMergeTransaction stamp' newId strat t2

365

323

366-- | Returns the correct Transaction for the branch name in the graph and ensures that it is one of the two transaction arguments in the tuple.

324-- | Returns the correct Transaction for the branch name in the graph and ensures that it is one of the two transaction arguments in the tuple.

367−validateHeadName :: HeadName -> TransactionGraph -> (Transaction, Transaction) -> GraphRefRelationalExprM Transaction

325+validateHeadName :: HeadName -> TransactionGraph -> (Transaction, Transaction) -> Either MergeError Transaction

368validateHeadName headName graph (t1, t2) =

326validateHeadName headName graph (t1, t2) =

369 case transactionForHead headName graph of

327 case transactionForHead headName graph of

370− Nothing -> throwError (MergeTransactionError SelectedHeadMismatchMergeError)

328+ Nothing -> Left SelectedHeadMismatchMergeError

371 Just trans -> if trans /= t1 && trans /= t2 then

329 Just trans -> if trans /= t1 && trans /= t2 then

372− throwError (MergeTransactionError SelectedHeadMismatchMergeError)

330+ Left SelectedHeadMismatchMergeError

373 else

331 else

374− pure trans

332+ Right trans

375

333

376-- Algorithm: start at one transaction and work backwards up the parents. If there is a node we have not yet visited as a child, then walk that up to its head. If that branch contains the goal transaction, then we have completed a valid subgraph traversal.

334-- Algorithm: start at one transaction and work backwards up the parents. If there is a node we have not yet visited as a child, then walk that up to its head. If that branch contains the goal transaction, then we have completed a valid subgraph traversal.

377subGraphOfFirstCommonAncestor :: TransactionGraph -> TransactionHeads -> Transaction -> Transaction -> S.Set Transaction -> Either RelationalError TransactionGraph

335subGraphOfFirstCommonAncestor :: TransactionGraph -> TransactionHeads -> Transaction -> Transaction -> S.Set Transaction -> Either RelationalError TransactionGraph

@@ -384,7 +342,7 @@ subGraphOfFirstCommonAncestor origGraph resultHeads currentTrans' goalTrans trav

384 else do

342 else do

385 currentTransChildren <- childTransactions currentTrans' origGraph

343 currentTransChildren <- childTransactions currentTrans' origGraph

386 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren

344 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren

387− searchChild start' = pathToTransaction origGraph start' goalTrans (S.insert currentTrans' traverseSet)

345+ searchChild start = pathToTransaction origGraph start goalTrans (S.insert currentTrans' traverseSet)

388 childSearches = map searchChild (S.toList searchChildren)

346 childSearches = map searchChild (S.toList searchChildren)

389 errors = lefts childSearches

347 errors = lefts childSearches

390 pathsFound = rights childSearches

348 pathsFound = rights childSearches

@@ -424,28 +382,26 @@ pathToTransaction graph currentTransaction targetTransaction accumTransSet = do

424 else --we have some paths!

382 else --we have some paths!

425 Right (S.unions paths)

383 Right (S.unions paths)

426

384

427−mergeTransactions :: UTCTime -> TransactionId -> TransactionId -> MergeStrategy -> (HeadName, HeadName) -> GraphRefRelationalExprM (DisconnectedTransaction, TransactionGraph)

385+mergeTransactions :: UTCTime -> TransactionId -> TransactionId -> MergeStrategy -> (HeadName, HeadName) -> TransactionGraph -> Either RelationalError (DisconnectedTransaction, TransactionGraph)

428−mergeTransactions stamp' newId parentId mergeStrategy (headNameA, headNameB) = do

386+mergeTransactions stamp' newId parentId mergeStrategy (headNameA, headNameB) graph = do

429− graph <- gfGraph

430 let transactionForHeadErr name = case transactionForHead name graph of

387 let transactionForHeadErr name = case transactionForHead name graph of

431− Nothing -> throwError (NoSuchHeadNameError name)

388+ Nothing -> Left (NoSuchHeadNameError name)

432− Just t -> pure t

389+ Just t -> Right t

433− runE e = case e of

434− Left e' -> throwError e'

435− Right v -> pure v

436− transA <- transactionForHeadErr headNameA

390+ transA <- transactionForHeadErr headNameA

437− transB <- transactionForHeadErr headNameB

391+ transB <- transactionForHeadErr headNameB

438− disconParent <- gfTransForId parentId

392+ disconParent <- transactionForId parentId graph

439 let subHeads = M.filterWithKey (\k _ -> k `elem` [headNameA, headNameB]) (transactionHeadsForGraph graph)

393 let subHeads = M.filterWithKey (\k _ -> k `elem` [headNameA, headNameB]) (transactionHeadsForGraph graph)

440− subGraph <- runE $ subGraphOfFirstCommonAncestor graph subHeads transA transB S.empty

394+ subGraph <- subGraphOfFirstCommonAncestor graph subHeads transA transB S.empty

441− subGraph' <- runE $ filterSubGraph subGraph subHeads

395+ subGraph' <- filterSubGraph subGraph subHeads

442− mergedTrans <- local (const (freshGraphRefRelationalExprEnv Nothing subGraph')) $ createMergeTransaction stamp' newId mergeStrategy (transA, transB)

396+ case createMergeTransaction stamp' newId mergeStrategy subGraph' (transA, transB) of

397+ Left err -> Left (MergeTransactionError err)

398+ Right mergedTrans ->

443− case headNameForTransaction disconParent graph of

399+ case headNameForTransaction disconParent graph of

444− Nothing -> throwError (TransactionIsNotAHeadError parentId)

400+ Nothing -> Left (TransactionIsNotAHeadError parentId)

445 Just headName -> do

401 Just headName -> do

446− (newTrans, newGraph) <- runE $ addTransactionToGraph headName mergedTrans graph

402+ (newTrans, newGraph) <- addTransactionToGraph headName mergedTrans graph

447 case checkConstraints (concreteDatabaseContext mergedTrans) newId graph of

403 case checkConstraints (concreteDatabaseContext mergedTrans) newId graph of

448− Left err -> throwError err

404+ Left err -> Left err

449 Right _ -> do

405 Right _ -> do

450 let newGraph' = TransactionGraph (transactionHeadsForGraph newGraph) (transactionsForGraph newGraph)

406 let newGraph' = TransactionGraph (transactionHeadsForGraph newGraph) (transactionsForGraph newGraph)

451 newDiscon = Discon.freshTransaction newId (schemas newTrans)

407 newDiscon = Discon.freshTransaction newId (schemas newTrans)

@@ -475,29 +431,25 @@ filterSubGraph graph heads = Right $ TransactionGraph newHeads newTransSet

475 newHeads = M.map (filterTransaction validIds) heads

431 newHeads = M.map (filterTransaction validIds) heads

476

432

477--helper function for commonalities in union merge

433--helper function for commonalities in union merge

478−createUnionMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> (Transaction, Transaction) -> GraphRefRelationalExprM Transaction

434+createUnionMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> TransactionGraph -> (Transaction, Transaction) -> Either MergeError Transaction

479−createUnionMergeTransaction stamp' newId strategy (t1,t2) = do

435+createUnionMergeTransaction stamp' newId strategy graph (t1,t2) = do

480 let contextA = concreteDatabaseContext t1

436 let contextA = concreteDatabaseContext t1

481 contextB = concreteDatabaseContext t2

437 contextB = concreteDatabaseContext t2

482− liftMergeE x = case x of

438+

483− Left e -> throwError (MergeTransactionError e)

484− Right t -> pure t

485−

486− graph <- gfGraph

487 preference <- case strategy of

439 preference <- case strategy of

488 UnionMergeStrategy -> pure PreferNeither

440 UnionMergeStrategy -> pure PreferNeither

489 UnionPreferMergeStrategy preferBranch ->

441 UnionPreferMergeStrategy preferBranch ->

490 case transactionForHead preferBranch graph of

442 case transactionForHead preferBranch graph of

491− Nothing -> throwError (MergeTransactionError (PreferredHeadMissingMergeError preferBranch))

443+ Nothing -> Left (PreferredHeadMissingMergeError preferBranch)

492 Just preferredTrans -> pure $ if t1 == preferredTrans then PreferFirst else PreferSecond

444 Just preferredTrans -> pure $ if t1 == preferredTrans then PreferFirst else PreferSecond

493− badStrat -> throwError (MergeTransactionError (InvalidMergeStrategyError badStrat))

445+ badStrat -> Left (InvalidMergeStrategyError badStrat)

494

446

495− incDeps <- liftMergeE $ unionMergeMaps preference (inclusionDependencies contextA) (inclusionDependencies contextB)

447+ incDeps <- unionMergeMaps preference (inclusionDependencies contextA) (inclusionDependencies contextB)

496 relVars <- unionMergeRelVars preference (relationVariables contextA) (relationVariables contextB)

448 relVars <- unionMergeRelVars preference (relationVariables contextA) (relationVariables contextB)

497− atomFuncs <- liftMergeE $ unionMergeAtomFunctions preference (atomFunctions contextA) (atomFunctions contextB)

449+ atomFuncs <- unionMergeAtomFunctions preference (atomFunctions contextA) (atomFunctions contextB)

498− notifs <- liftMergeE $ unionMergeMaps preference (notifications contextA) (notifications contextB)

450+ notifs <- unionMergeMaps preference (notifications contextA) (notifications contextB)

499− types <- liftMergeE $ unionMergeTypeConstructorMapping preference (typeConstructorMapping contextA) (typeConstructorMapping contextB)

451+ types <- unionMergeTypeConstructorMapping preference (typeConstructorMapping contextA) (typeConstructorMapping contextB)

500− dbcFuncs <- liftMergeE $ unionMergeDatabaseContextFunctions preference (dbcFunctions contextA) (dbcFunctions contextB)

452+ dbcFuncs <- unionMergeDatabaseContextFunctions preference (dbcFunctions contextA) (dbcFunctions contextB)

501 -- TODO: add merge of subschemas

453 -- TODO: add merge of subschemas

502 let newContext = DatabaseContext {

454 let newContext = DatabaseContext {

503 inclusionDependencies = incDeps,

455 inclusionDependencies = incDeps,

@@ -508,12 +460,10 @@ createUnionMergeTransaction stamp' newId strategy (t1,t2) = do

508 typeConstructorMapping = types

460 typeConstructorMapping = types

509 }

461 }

510 newSchemas = Schemas newContext (subschemas t1)

462 newSchemas = Schemas newContext (subschemas t1)

511− pure $ addMerkleHash graph $

512− Transaction newId (TransactionInfo {

463+ pure (Transaction newId (TransactionInfo {

513− parents = NE.fromList [transactionId t1,

464+ parents = NE.fromList [transactionId t1,

514− transactionId t2],

465+ transactionId t2],

515− stamp = stamp',

466+ stamp = stamp'}) newSchemas)

516− merkleHash = mempty }) newSchemas

517

467

518lookupTransaction :: TransactionGraph -> TransactionIdLookup -> Either RelationalError Transaction

468lookupTransaction :: TransactionGraph -> TransactionIdLookup -> Either RelationalError Transaction

519lookupTransaction graph (TransactionIdLookup tid) = transactionForId tid graph

469lookupTransaction graph (TransactionIdLookup tid) = transactionForId tid graph

@@ -530,16 +480,15 @@ backtrackGraph :: TransactionGraph -> TransactionId -> TransactionIdHeadBacktrac

530-- tilde, step back one parent link- if a choice must be made, choose the "first" link arbitrarily

480-- tilde, step back one parent link- if a choice must be made, choose the "first" link arbitrarily

531backtrackGraph graph currentTid (TransactionIdHeadParentBacktrack steps) = do

481backtrackGraph graph currentTid (TransactionIdHeadParentBacktrack steps) = do

532 trans <- transactionForId currentTid graph

482 trans <- transactionForId currentTid graph

533−

534− let parentIds' = S.toAscList (parentIds trans)

483+ let parentIds' = S.toList (parentIds trans)

535− case parentIds' of

484+ if length parentIds' < 1 then

536− [] -> Left RootTransactionTraversalError

485+ Left RootTransactionTraversalError

537− firstParentId:_ -> do

486+ else do

538− parentTrans <- transactionForId firstParentId graph

487+ parentTrans <- transactionForId (head parentIds') graph

539− if steps == 1 then

488+ if steps == 1 then

540− pure (transactionId parentTrans)

489+ pure (transactionId parentTrans)

541− else

490+ else

542− backtrackGraph graph (transactionId parentTrans) (TransactionIdHeadParentBacktrack (steps - 1))

491+ backtrackGraph graph (transactionId parentTrans) (TransactionIdHeadParentBacktrack (steps - 1))

543

492

544backtrackGraph graph currentTid (TransactionIdHeadBranchBacktrack steps) = do

493backtrackGraph graph currentTid (TransactionIdHeadBranchBacktrack steps) = do

545 trans <- transactionForId currentTid graph

494 trans <- transactionForId currentTid graph

@@ -589,47 +538,3 @@ autoMergeToHead stamp' (tempBranchTransId, tempCommitTransId, mergeTransId) disc

589 pure (discon''''', graph''''')

538 pure (discon''''', graph''''')

590

539

591

540

592−addMerkleHash :: TransactionGraph -> Transaction -> Transaction

593−addMerkleHash graph trans = Transaction (transactionId trans) newInfo (schemas trans)

594− where

595− newInfo = (transactionInfo trans) { merkleHash = calculateMerkleHash trans graph }

596−

597−-- the new hash includes the parents' ids, the current id, and the hash of the context, and the merkle hashes of the parent transactions

598−calculateMerkleHash :: Transaction -> TransactionGraph -> MerkleHash

599−calculateMerkleHash trans graph = MerkleHash $ hashlazy (BL.fromChunks [transIds,

600− schemasBytes

601− ] <> dbcBytes <> parentMerkleHashes)

602− where

603− parentMerkleHashes = BL.fromChunks $ map (_unMerkleHash . getMerkleHash) parentTranses

604− parentTranses =

605− case transactionsForIds (parentIds trans) graph of

606− Left RootTransactionTraversalError -> []

607− Left e -> error ("failed to find transaction in Merkle hash construction: " ++ show e)

608− Right t -> S.toList t

609− getMerkleHash t = merkleHash (transactionInfo t)

610− transIds = serialise (transactionId trans : S.toList (parentIds trans))

611− dbcBytes = DBC.hashBytes (concreteDatabaseContext trans)

612− schemasBytes = serialise (subschemas trans)

613−

614−validateMerkleHash :: Transaction -> TransactionGraph -> Either MerkleValidationError ()

615−validateMerkleHash trans graph =

616− if expectedHash /= actualHash then

617− Left (MerkleValidationError (transactionId trans) expectedHash actualHash)

618− else

619− pure ()

620− where

621− expectedHash = merkleHash (transactionInfo trans)

622− actualHash = calculateMerkleHash trans graph

623−

624−data MerkleValidationError = MerkleValidationError TransactionId MerkleHash MerkleHash

625− deriving (Show, Eq, Generic)

626−

627−validateMerkleHashes :: TransactionGraph -> Either [MerkleValidationError] ()

628−validateMerkleHashes graph =

629− if null errs then pure () else Left errs

630− where

631− errs = S.foldr validateTrans [] (transactionsForGraph graph)

632− validateTrans trans acc =

633− case validateMerkleHash trans graph of

634− Left err -> err : acc

635− _ -> acc

src/lib/ProjectM36/TransactionGraph/Merge.hs+15−19

@@ -2,11 +2,10 @@

2module ProjectM36.TransactionGraph.Merge where

3import ProjectM36.Base

4import ProjectM36.Error

5−import ProjectM36.RelationalExpression

6−import Control.Monad.Except hiding (join)

7import qualified Data.Set as S

5import qualified Data.Set as S

8import qualified Data.Map as M

6import qualified Data.Map as M

9import qualified ProjectM36.TypeConstructorDef as TCD

7import qualified ProjectM36.TypeConstructorDef as TCD

8+import ProjectM36.Relation

10import Control.Monad (foldM)

9import Control.Monad (foldM)

11import qualified Data.HashSet as HS

10import qualified Data.HashSet as HS

12

11

@@ -23,23 +22,20 @@ unionMergeMaps prefer mapA mapB = case prefer of

23 Left StrategyViolatesComponentMergeError

22 Left StrategyViolatesComponentMergeError

24

23

25-- perform the merge even if the attributes are different- is this what we want? Obviously, we need finer-grained merge options.

24-- perform the merge even if the attributes are different- is this what we want? Obviously, we need finer-grained merge options.

26−unionMergeRelation :: MergePreference -> GraphRefRelationalExpr -> GraphRefRelationalExpr -> GraphRefRelationalExprM GraphRefRelationalExpr

25+unionMergeRelation :: MergePreference -> Relation -> Relation -> Either MergeError Relation

27−unionMergeRelation prefer relA relB = do

26+unionMergeRelation prefer relA relB = case relA `union` relB of

28− let unioned = Union relA relB

27+ Right unionRel -> pure unionRel

28+ Left (AttributeNamesMismatchError _) -> preferredRelVar

29− mergeErr = MergeTransactionError StrategyViolatesRelationVariableMergeError

29+ Left _ -> Left StrategyViolatesRelationVariableMergeError

30+ where

30− preferredRelVar =

31+ preferredRelVar = case prefer of

31− case prefer of

32− PreferFirst -> pure relA

32+ PreferFirst -> Right relA

33− PreferSecond -> pure relB

33+ PreferSecond -> Right relB

34− PreferNeither -> throwError mergeErr

34+ PreferNeither -> Left StrategyViolatesRelationVariableMergeError

35− handler AttributeNamesMismatchError{} = preferredRelVar

36− handler _err' = throwError mergeErr

37− --typecheck first?

38− (evalGraphRefRelationalExpr unioned >> pure (Union relA relB)) `catchError` handler

39

35

40--try to execute unions against the relvars contents -- if a relvar only appears in one context, include it

36--try to execute unions against the relvars contents -- if a relvar only appears in one context, include it

41−unionMergeRelVars :: MergePreference -> RelationVariables -> RelationVariables -> GraphRefRelationalExprM RelationVariables

37+unionMergeRelVars :: MergePreference -> RelationVariables -> RelationVariables -> Either MergeError RelationVariables

42−unionMergeRelVars prefer relvarsA relvarsB = do

38+unionMergeRelVars _ relvarsA relvarsB = do

43 let allNames = S.toList (S.union (M.keysSet relvarsA) (M.keysSet relvarsB))

39 let allNames = S.toList (S.union (M.keysSet relvarsA) (M.keysSet relvarsB))

44 foldM (\acc name -> do

40 foldM (\acc name -> do

45 mergedRel <- do

41 mergedRel <- do

@@ -47,8 +43,8 @@ unionMergeRelVars prefer relvarsA relvarsB = do

47 lookupA = findRel relvarsA

43 lookupA = findRel relvarsA

48 lookupB = findRel relvarsB

44 lookupB = findRel relvarsB

49 case (lookupA, lookupB) of

45 case (lookupA, lookupB) of

50− (Just relA, Just relB) ->

46+ (Just _, Just _) -> unimplemented

51− unionMergeRelation prefer relA relB

47+ --unionMergeRelation prefer relA relB

52 (Nothing, Just relB) -> pure relB

48 (Nothing, Just relB) -> pure relB

53 (Just relA, Nothing) -> pure relA

49 (Just relA, Nothing) -> pure relA

54 (Nothing, Nothing) -> error "impossible relvar naming lookup"

50 (Nothing, Nothing) -> error "impossible relvar naming lookup"

src/lib/ProjectM36/TransactionGraph/Persist.hs+3−3

@@ -24,14 +24,14 @@ import Control.Exception.Base

24import qualified Data.ByteString as BS

25import qualified Data.Text.Encoding as TE

26import Data.ByteString (ByteString)

27−#if __GLASGOW_HASKELL__ < 804

28−import Data.Monoid

29−#endif

30import qualified Crypto.Hash.SHA256 as SHA256

27import qualified Crypto.Hash.SHA256 as SHA256

31import Control.Arrow

28import Control.Arrow

32import Data.Time.Clock

29import Data.Time.Clock

33import Data.Text.Read

30import Data.Text.Read

34import System.FilePath.Glob

31import System.FilePath.Glob

32+#if __GLASGOW_HASKELL__ <= 802

33+import Data.Monoid

34+#endif

35

36type LockFileHash = ByteString

37

src/lib/ProjectM36/TransactionInfo.hs+3−5

@@ -1,12 +1,10 @@

1module ProjectM36.TransactionInfo where

2import ProjectM36.Base

3import Data.Time.Clock

4−import qualified Data.List.NonEmpty as NE

4+import Data.List.NonEmpty

5

6-- | Create a TransactionInfo with just one parent transaction ID.

7singleParent :: TransactionId -> UTCTime -> TransactionInfo

8singleParent tid stamp' = TransactionInfo {

9− parents = tid NE.:| [],

9+ parents = tid :| [],

10− stamp = stamp',

10+ stamp = stamp' }

11− merkleHash = mempty }

12−

src/lib/ProjectM36/Tuple.hs+33−47

@@ -1,7 +1,7 @@

1module ProjectM36.Tuple where

2import ProjectM36.Base

3import ProjectM36.Error

4−import ProjectM36.Attribute as A

4+import ProjectM36.Attribute

5import ProjectM36.Atom

6import ProjectM36.AtomType

7import ProjectM36.DataTypes.Primitive

@@ -15,19 +15,19 @@ import Control.Arrow

15import Data.Maybe

16

17emptyTuple :: RelationTuple

18−emptyTuple = RelationTuple mempty mempty

18+emptyTuple = RelationTuple V.empty V.empty

19

20tupleSize :: RelationTuple -> Int

21−tupleSize (RelationTuple tupAttrs _) = arity tupAttrs

21+tupleSize (RelationTuple tupAttrs _) = V.length tupAttrs

22

23tupleAttributeNameSet :: RelationTuple -> S.Set AttributeName

24−tupleAttributeNameSet (RelationTuple tupAttrs _) = attributeNameSet tupAttrs

24+tupleAttributeNameSet (RelationTuple tupAttrs _) = S.fromList $ V.toList $ V.map attributeName tupAttrs

25

26tupleAttributes :: RelationTuple -> Attributes

27tupleAttributes (RelationTuple tupAttrs _) = tupAttrs

28

29tupleAssocs :: RelationTuple -> [(AttributeName, Atom)]

30−tupleAssocs (RelationTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)

30+tupleAssocs (RelationTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)

31

32orderedTupleAssocs :: RelationTuple -> [(AttributeName, Atom)]

33orderedTupleAssocs tup@(RelationTuple attrVec _) = map (\attr -> (attributeName attr, atomForAttr (attributeName attr))) oAttrs

@@ -42,7 +42,7 @@ tupleAtoms :: RelationTuple -> V.Vector Atom

42tupleAtoms (RelationTuple _ tupVec) = tupVec

43

44atomForAttributeName :: AttributeName -> RelationTuple -> Either RelationalError Atom

45−atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of

45+atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of

46 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

47 Just index -> case tupVec V.!? index of

48 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

@@ -59,7 +59,7 @@ vectorIndicesForAttributeNames attrNameVec attrs = if not $ V.null unknownAttrNa

59 Right $ V.map mapper attrNameVec

60 where

61 unknownAttrNames = V.filter (`V.notElem` attributeNames attrs) attrNameVec

62− mapper attrName = fromMaybe (error "logic failure in vectorIndicesForAttributeNames") (V.elemIndex attrName (attributeNames attrs))

62+ mapper attrName = fromMaybe (error "logic failure in vectorIndicesForAttributeNames") (V.elemIndex attrName (V.map attributeName attrs))

63

64

65relationForAttributeName :: AttributeName -> RelationTuple -> Either RelationalError Relation

@@ -86,10 +86,10 @@ mkRelationTuples attrs = map mapper

86 mapper = mkRelationTuple attrs

87

88mkRelationTupleFromMap :: M.Map AttributeName Atom -> RelationTuple

89−mkRelationTupleFromMap attrMap = RelationTuple (attributesFromList attrs) (V.map (attrMap M.!) (V.fromList attrNames))

89+mkRelationTupleFromMap attrMap = RelationTuple attrs (V.map (attrMap M.!) attrNames)

90 where

91− attrNames = M.keys attrMap

91+ attrNames = V.fromList (M.keys attrMap)

92− attrs = map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames

92+ attrs = V.map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames

93

94--return error if attribute names match but their types do not

95singleTupleSetJoin :: Attributes -> RelationTuple -> RelationTupleSet -> Either RelationalError [RelationTuple]

@@ -120,8 +120,8 @@ singleTupleJoin joinedAttrs tup1@(RelationTuple tupAttrs1 _) tup2@(RelationTuple

120 return $ Just $ RelationTuple joinedAttrs newVec

121 where

122 keysIntersection = V.map attributeName attrsIntersection

123− attrsIntersection = V.filter (`V.elem` attributesVec tupAttrs1) (attributesVec tupAttrs2)

123+ attrsIntersection = V.filter (`V.elem` tupAttrs1) tupAttrs2

124− newVec = V.map (findAtomForAttributeName . attributeName) (attributesVec joinedAttrs)

124+ newVec = V.map (findAtomForAttributeName . attributeName) joinedAttrs

125 --search both tuples for the attribute

126 findAtomForAttributeName attrName = head $ rights $ fmap (atomForAttributeName attrName) [tup1, tup2]

127

@@ -138,31 +138,23 @@ vectorUnion v1 v2 = V.foldr folder v1 v2

138tupleExtend :: RelationTuple -> RelationTuple -> RelationTuple

139tupleExtend (RelationTuple tupAttrs1 tupVec1) (RelationTuple tupAttrs2 tupVec2) = RelationTuple newAttrs newVec

140 where

141− newAttrs = tupAttrs1 <> tupAttrs2

141+ newAttrs = tupAttrs1 V.++ tupAttrs2

142− newVec = tupVec1 <> tupVec2

142+ newVec = tupVec1 V.++ tupVec2

143

144tupleAtomExtend :: AttributeName -> Atom -> RelationTuple -> RelationTuple

145tupleAtomExtend newAttrName atom tupIn = tupleExtend tupIn newTup

146 where

147− newTup = RelationTuple (A.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)

147+ newTup = RelationTuple (V.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)

148

149+--this could be cheaper- it may not be wortwhile to update all the tuples for projection, but then the attribute management must be slightly different- perhaps the attributes should be a vector of association tuples [(name, index)]

149−{-tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

150+tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

150tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec

151tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec

151 where

152 where

152− deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) (attributesVec attrs)

153+ deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) attrs

153 indexDeleter = V.ifilter (\index _ -> V.notElem index deleteIndices)

154 indexDeleter = V.ifilter (\index _ -> V.notElem index deleteIndices)

154− newAttrs = case A.projectionAttributesForNames projectAttrs attrs of

155+ newAttrs = indexDeleter attrs

155− Left err -> error (show (err, projectAttrs, attrs))

156− Right attrs' -> attrs'

157 newTupVec = indexDeleter tupVec

156 newTupVec = indexDeleter tupVec

158−-}

157+

159−-- remember that the attributes order matters

160−tupleProject :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

161−tupleProject projectAttrs tup = do

162− newTupVec <- foldM (\acc attr ->

163− V.snoc acc <$> atomForAttributeName (attributeName attr) tup

164− ) V.empty (attributesVec projectAttrs)

165− pure $ reorderTuple projectAttrs (RelationTuple projectAttrs newTupVec)

166--return the attributes and atoms which are equal in both vectors

158--return the attributes and atoms which are equal in both vectors

167--semi-join

159--semi-join

168tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple

160tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple

@@ -170,14 +162,12 @@ tupleIntersection tuple1 tuple2 = RelationTuple newAttrs newTupVec

170 where

162 where

171 attrs1 = tupleAttributes tuple1

163 attrs1 = tupleAttributes tuple1

172 attrs2 = tupleAttributes tuple2

164 attrs2 = tupleAttributes tuple2

173− intersectAttrs = A.intersection attrs1 attrs2

174− matchingIndices = V.findIndices (\attr -> A.member attr intersectAttrs &&

165+ matchingIndices = V.findIndices (\attr -> V.elem attr attrs2 &&

175− atomForAttributeName (attributeName attr) tuple1 ==

166+ atomForAttributeName (attributeName attr) tuple1 ==

176− atomForAttributeName (attributeName attr) tuple2) (attributesVec attrs1)

167+ atomForAttributeName (attributeName attr) tuple2

168+ ) attrs1

177 indexFilter = V.ifilter (\index _ -> V.elem index matchingIndices)

169 indexFilter = V.ifilter (\index _ -> V.elem index matchingIndices)

178− newAttrs = case A.projectionAttributesForNames (A.attributeNameSet intersectAttrs) attrs1 of

170+ newAttrs = indexFilter attrs1

179− Left _ -> mempty

180− Right attrs' -> attrs'

181 newTupVec = indexFilter (tupleAtoms tuple1)

171 newTupVec = indexFilter (tupleAtoms tuple1)

182

172

183-- | An optimized form of tuple update which updates vectors efficiently.

173-- | An optimized form of tuple update which updates vectors efficiently.

@@ -185,20 +175,19 @@ updateTupleWithAtoms :: M.Map AttributeName Atom -> RelationTuple -> RelationTup

185updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec

175updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec

186 where

176 where

187 updateKeysSet = M.keysSet updateMap

177 updateKeysSet = M.keysSet updateMap

188− updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed (attributesVec attrs))

178+ updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed attrs)

189 newVec = V.update tupVec updateVec

179 newVec = V.update tupVec updateVec

190 updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec

180 updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec

191

181

192tupleToMap :: RelationTuple -> M.Map AttributeName Atom

182tupleToMap :: RelationTuple -> M.Map AttributeName Atom

193tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList

183tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList

194 where

184 where

195− assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed (attributesVec attrs))

185+ assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed attrs)

196

186

197−-- | Validate that the tuple has the correct attributes in the correct order

198verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

187verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

199−verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs

188+verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs

200 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in

189 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in

201− if A.arity attrs /= V.length tupleTypes then

190+ if V.length attrs /= V.length tupleTypes then

202 Left $ TupleAttributeCountMismatchError 0

191 Left $ TupleAttributeCountMismatchError 0

203 else do

192 else do

204 mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)

193 mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)

@@ -207,18 +196,15 @@ verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs

207--two tuples can be equal but the vectors of attributes could be out-of-order

196--two tuples can be equal but the vectors of attributes could be out-of-order

208--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering

197--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering

209reorderTuple :: Attributes -> RelationTuple -> RelationTuple

198reorderTuple :: Attributes -> RelationTuple -> RelationTuple

210−reorderTuple attrs tupIn = if attributesAndOrderEqual (tupleAttributes tupIn) attrs then

199+reorderTuple attrs tupIn = if tupleAttributes tupIn == attrs then

211 tupIn

200 tupIn

212 else

201 else

213− RelationTuple attrs (V.map mapper (attributesVec attrs))

202+ RelationTuple attrs (V.map mapper attrs)

214 where

203 where

215 mapper attr = case atomForAttributeName (attributeName attr) tupIn of

204 mapper attr = case atomForAttributeName (attributeName attr) tupIn of

216− Left err -> error ("logic bug in reorderTuple: " ++ show err <> show tupIn)

205+ Left err -> error ("logic bug in reorderTuple: " ++ show err)

217 Right atom -> atom

206 Right atom -> atom

218

207

219--used in Generics derivation for ADTs without named attributes

208--used in Generics derivation for ADTs without named attributes

220trimTuple :: Int -> RelationTuple -> RelationTuple

209trimTuple :: Int -> RelationTuple -> RelationTuple

221−trimTuple index (RelationTuple attrs vals) =

210+trimTuple index (RelationTuple attrs vals) = RelationTuple (V.drop index attrs) (V.drop index vals)

222− RelationTuple newAttrs (V.drop index vals)

223− where

224− newAttrs = A.drop index attrs

src/lib/ProjectM36/TupleSet.hs−7

@@ -31,10 +31,3 @@ mkTupleSet attrs tuples = verifyTupleSet attrs (RelationTupleSet tuples)

31

32mkTupleSetFromList :: Attributes -> [[Atom]] -> Either RelationalError RelationTupleSet

33mkTupleSetFromList attrs atomMatrix = mkTupleSet attrs $ map (mkRelationTuple attrs . V.fromList) atomMatrix

34−

35−

36−-- | Union two tuplesets while reordering their attribute/atom mapping properly.

37−tupleSetUnion :: Attributes -> RelationTupleSet -> RelationTupleSet -> RelationTupleSet

38−tupleSetUnion targetAttrs tupSet1 tupSet2 = RelationTupleSet $ HS.toList . HS.fromList $ reorder (asList tupSet1) ++ reorder (asList tupSet2)

39− where

40− reorder = map (reorderTuple targetAttrs)

src/lib/ProjectM36/Tupleable.hs+36−113

@@ -4,47 +4,28 @@

4{-# LANGUAGE ScopedTypeVariables #-}

5{-# LANGUAGE TypeOperators #-}

6{-# LANGUAGE UndecidableInstances #-}

7−{-# LANGUAGE CPP #-}

7+

8−

9−module ProjectM36.Tupleable

8+module ProjectM36.Tupleable where

10− ( toInsertExpr

11− , toDefineExpr

12− , tupleAssocsEqualityPredicate

13− , partitionByAttributes

14− , toUpdateExpr

15− , toDeleteExpr

16− , validateAttributes

17− , Tupleable(..)

18−

19− -- * Generics

20− , genericToTuple

21− , genericFromTuple

22− , genericToAttributes

23− , TupleableG(..)

24− -- ** Options

25− , defaultTupleableOptions

26− , TupleableOptions()

27− , fieldModifier

28− ) where

29

9

30import Data.Foldable

10import Data.Foldable

31import Data.List (partition)

11import Data.List (partition)

32import qualified Data.Map as Map

12import qualified Data.Map as Map

33−#if __GLASGOW_HASKELL__ < 804

34−import Data.Monoid

13+--import Data.Monoid

35−#endif

36import Data.Proxy

14import Data.Proxy

37import qualified Data.Text as T

15import qualified Data.Text as T

38import qualified Data.Vector as V

16import qualified Data.Vector as V

39import GHC.Generics

17import GHC.Generics

40import ProjectM36.Atomable

18import ProjectM36.Atomable

41−import ProjectM36.Attribute as A hiding (null, toList)

19+import ProjectM36.Attribute hiding (null)

42import ProjectM36.Base

20import ProjectM36.Base

43import ProjectM36.DataTypes.Primitive

21import ProjectM36.DataTypes.Primitive

44import ProjectM36.Error

22import ProjectM36.Error

45import ProjectM36.Tuple

23import ProjectM36.Tuple

46import ProjectM36.TupleSet

24import ProjectM36.TupleSet

47import qualified Data.Set as S

25import qualified Data.Set as S

26+#if __GLASGOW_HASKELL__ <= 802

27+import Data.Monoid

28+#endif

48

29

49{-import Data.Binary

30{-import Data.Binary

50import Control.DeepSeq

31import Control.DeepSeq

@@ -89,7 +70,7 @@ toInsertExpr vals rvName = do

89

70

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'.

71-- | Convert a 'Tupleable' to a create a 'Define' expression which can be used to create an empty relation variable. Use 'toInsertExpr' to insert the actual tuple data. This function is typically used with 'Data.Proxy'.

91toDefineExpr :: forall a proxy. Tupleable a => proxy a -> RelVarName -> DatabaseContextExpr

72toDefineExpr :: forall a proxy. Tupleable a => proxy a -> RelVarName -> DatabaseContextExpr

92−toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList (attributesVec attrs)))

73+toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList attrs))

93 where

74 where

94 attrs = toAttributes (Proxy :: Proxy a)

75 attrs = toAttributes (Proxy :: Proxy a)

95

76

@@ -140,110 +121,56 @@ validateAttributes actualAttrs expectedAttrs val

140 where

121 where

141 nonMatchingAttrs = attributeNamesNotContained actualAttrs expectedAttrs

122 nonMatchingAttrs = attributeNamesNotContained actualAttrs expectedAttrs

142

123

143−-- | Types that can be converted to and from 'RelationTuple'.

124+

144−--

145−-- deriving without customization:

146−--

147−-- > data Example = Example

148−-- > { foo :: Integer

149−-- > , bar :: Text

150−-- > }

151−-- > deriving (Generic)

152−-- >

153−-- > instance Tupleable Example

154−--

155−-- deriving with customization using "ProjectM36.Tupleable.Deriving":

156−--

157−-- > data Example = Example

158−-- > { exampleFoo :: Integer

159−-- > , exampleBar :: Text

160−-- > }

161−-- > deriving stock (Generic)

162−-- > deriving (Tupleable)

163−-- > via Codec (Field (DropPrefix "example" >>> CamelCase)) Example

164class Tupleable a where

125class Tupleable a where

165 toTuple :: a -> RelationTuple

126 toTuple :: a -> RelationTuple

166

127

167 fromTuple :: RelationTuple -> Either RelationalError a

128 fromTuple :: RelationTuple -> Either RelationalError a

168

129

169− toAttributes :: Proxy a -> Attributes

130+ toAttributes :: proxy a -> Attributes

170

131

171 default toTuple :: (Generic a, TupleableG (Rep a)) => a -> RelationTuple

132 default toTuple :: (Generic a, TupleableG (Rep a)) => a -> RelationTuple

172− toTuple = genericToTuple defaultTupleableOptions

133+ toTuple v = toTupleG (from v)

173

134

174 default fromTuple :: (Generic a, TupleableG (Rep a)) => RelationTuple -> Either RelationalError a

135 default fromTuple :: (Generic a, TupleableG (Rep a)) => RelationTuple -> Either RelationalError a

175− fromTuple = genericFromTuple defaultTupleableOptions

176−

177− default toAttributes :: (Generic a, TupleableG (Rep a)) => Proxy a -> Attributes

178− toAttributes = genericToAttributes defaultTupleableOptions

179−

180−-- | Options that influence deriving behavior.

181−newtype TupleableOptions = TupleableOptions {

182− -- | A function that translates record field names into attribute names.

183− fieldModifier :: T.Text -> T.Text

184− }

185−

186−-- | The default options for deriving Tupleable instances.

187−--

188−-- These options can be customized by using record update syntax. For example,

189−--

190−-- > defaultTupleableOptions

191−-- > { fieldModifier = \fieldName ->

192−-- > case Data.Text.stripPrefix "example" fieldName of

193−-- > Nothing -> fieldName

194−-- > Just attributeName -> attributeName

195−-- > }

196−--

197−-- will result in record field names being translated into attribute names by

198−-- removing the prefix "example" from the field names.

199−defaultTupleableOptions :: TupleableOptions

200−defaultTupleableOptions = TupleableOptions {

201− fieldModifier = id

202− }

203−

204−genericToTuple :: (Generic a, TupleableG (Rep a)) => TupleableOptions -> a -> RelationTuple

205−genericToTuple opts v = toTupleG opts (from v)

206−

207−genericFromTuple :: (Generic a, TupleableG (Rep a)) => TupleableOptions -> RelationTuple -> Either RelationalError a

208−genericFromTuple opts tup = to <$> fromTupleG opts tup

136+ fromTuple tup = to <$> fromTupleG tup

209

137

210−genericToAttributes :: forall a. (Generic a, TupleableG (Rep a)) => TupleableOptions -> Proxy a -> Attributes

138+ default toAttributes :: (Generic a, TupleableG (Rep a)) => proxy a -> Attributes

211−genericToAttributes opts _ = toAttributesG opts (from (undefined :: a))

139+ toAttributes _ = toAttributesG (from (undefined :: a))

212

140

213class TupleableG g where

141class TupleableG g where

214− toTupleG :: TupleableOptions -> g a -> RelationTuple

142+ toTupleG :: g a -> RelationTuple

215− toAttributesG :: TupleableOptions -> g a -> Attributes

143+ toAttributesG :: g a -> Attributes

216− fromTupleG :: TupleableOptions -> RelationTuple -> Either RelationalError (g a)

144+ fromTupleG :: RelationTuple -> Either RelationalError (g a)

217 isRecordTypeG :: g a -> Bool

145 isRecordTypeG :: g a -> Bool

218

146

219--data type metadata

147--data type metadata

220instance (Datatype c, TupleableG a) => TupleableG (M1 D c a) where

148instance (Datatype c, TupleableG a) => TupleableG (M1 D c a) where

221− toTupleG opts (M1 v) = toTupleG opts v

149+ toTupleG (M1 v) = toTupleG v

222− toAttributesG opts (M1 v) = toAttributesG opts v

150+ toAttributesG (M1 v) = toAttributesG v

223− fromTupleG opts v = M1 <$> fromTupleG opts v

151+ fromTupleG v = M1 <$> fromTupleG v

224 isRecordTypeG (M1 v) = isRecordTypeG v

152 isRecordTypeG (M1 v) = isRecordTypeG v

225

153

226--constructor metadata

154--constructor metadata

227instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) where

155instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) where

228− toTupleG opts (M1 v) = RelationTuple attrs atoms

156+ toTupleG (M1 v) = RelationTuple attrs atoms

229 where

157 where

230− attrsToCheck = toAttributesG opts v

158+ attrsToCheck = toAttributesG v

231− counter = V.generate (arity attrsToCheck) id

159+ counter = V.generate (V.length attrsToCheck) id

232− attrs = attributesFromList (V.toList attrsV)

233− attrsV = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

160+ attrs = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

234 Attribute ("attr" <> T.pack (show (num + 1))) typ

161 Attribute ("attr" <> T.pack (show (num + 1))) typ

235 else

162 else

236− attr) counter (attributesVec attrsToCheck)

163+ attr) counter attrsToCheck

237 atoms = V.fromList (toAtomsG v)

164 atoms = V.fromList (toAtomsG v)

238− toAttributesG opts (M1 v) = toAttributesG opts v

165+ toAttributesG (M1 v) = toAttributesG v

239− fromTupleG opts tup = M1 <$> fromTupleG opts tup

166+ fromTupleG tup = M1 <$> fromTupleG tup

240 isRecordTypeG (M1 v) = isRecordTypeG v

167 isRecordTypeG (M1 v) = isRecordTypeG v

241

168

242-- product types

169-- product types

243instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

170instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

244 toTupleG = error "toTupleG"

171 toTupleG = error "toTupleG"

245− toAttributesG opts ~(x :*: y) = toAttributesG opts x <> toAttributesG opts y --a bit of extra laziness prevents whnf so that we can use toAttributes (undefined :: Test2T Int Int) without throwing an exception

172+ toAttributesG ~(x :*: y) = toAttributesG x V.++ toAttributesG y --a bit of extra laziness prevents whnf so that we can use toAttributes (undefined :: Test2T Int Int) without throwing an exception

246− fromTupleG opts tup = (:*:) <$> fromTupleG opts tup <*> fromTupleG opts processedTuple

173+ fromTupleG tup = (:*:) <$> fromTupleG tup <*> fromTupleG processedTuple

247 where

174 where

248 processedTuple = if isRecordTypeG (undefined :: a x) then

175 processedTuple = if isRecordTypeG (undefined :: a x) then

249 tup

176 tup

@@ -254,22 +181,18 @@ instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

254--selector/record

181--selector/record

255instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

182instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

256 toTupleG = error "toTupleG"

183 toTupleG = error "toTupleG"

257− toAttributesG opts m@(M1 v) = A.singleton (Attribute modifiedName aType)

184+ toAttributesG m@(M1 v) = V.singleton (Attribute name aType)

258 where

185 where

259 name = T.pack (selName m)

186 name = T.pack (selName m)

260− modifiedName = if T.null name then

261− name

262− else

263− fieldModifier opts name

264 aType = toAtomTypeG v

187 aType = toAtomTypeG v

265− fromTupleG opts tup = if null name then -- non-record type, just pull off the first tuple item

188+ fromTupleG tup = if null name then -- non-record type, just pull off the first tuple item

266 M1 <$> atomv (V.head (tupleAtoms tup))

189 M1 <$> atomv (V.head (tupleAtoms tup))

267 else do

190 else do

268− atom <- atomForAttributeName (fieldModifier opts (T.pack name)) tup

191+ atom <- atomForAttributeName (T.pack name) tup

269 val <- atomv atom

192 val <- atomv atom

270 pure (M1 val)

193 pure (M1 val)

271 where

194 where

272− expectedAtomType = atomType (V.head (attributesVec (toAttributesG opts (undefined :: M1 S c a x))))

195+ expectedAtomType = atomType (V.head (toAttributesG (undefined :: M1 S c a x)))

273 atomv atom = maybe (Left (AtomTypeMismatchError

196 atomv atom = maybe (Left (AtomTypeMismatchError

274 expectedAtomType

197 expectedAtomType

275 (atomTypeForAtom atom)

198 (atomTypeForAtom atom)

@@ -280,8 +203,8 @@ instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

280--constructors with no arguments

203--constructors with no arguments

281--basically useless but orthoganal to relationTrue

204--basically useless but orthoganal to relationTrue

282instance TupleableG U1 where

205instance TupleableG U1 where

283− toTupleG _ _ = emptyTuple

206+ toTupleG _= emptyTuple

284− toAttributesG _ _ = emptyAttributes

207+ toAttributesG _ = emptyAttributes

285− fromTupleG _ _ = pure U1

208+ fromTupleG _ = pure U1

286 isRecordTypeG _ = False

209 isRecordTypeG _ = False

287

210

src/lib/ProjectM36/Tupleable/Deriving.hsdeleted−229

@@ -1,229 +0,0 @@

1−{-# LANGUAGE ScopedTypeVariables #-}

2−{-# LANGUAGE TypeOperators #-}

3−{-# LANGUAGE KindSignatures #-}

4−{-# LANGUAGE DataKinds #-}

5−{-# LANGUAGE FlexibleContexts #-}

6−{-# LANGUAGE UndecidableInstances #-}

7−

8−-- | Newtypes for deriving Tupleable instances with customization using

9−-- @DerivingVia@.

10−--

11−-- Inspired by

12−-- [Dhall.Deriving](https://hackage.haskell.org/package/dhall-1.33.1/docs/Dhall-Deriving.html)

13−-- which in turn was inspired by Matt Parson's blog post

14−-- [Mirror Mirror: Reflection and Encoding Via](https://www.parsonsmatt.org/2020/02/04/mirror_mirror.html).

15−--

16−-- required extensions:

17−--

18−-- * DerivingVia

19−-- * DeriveGenerics

20−-- * TypeOperators (for @('<<<')@ and @('>>>')@)

21−-- * DataKinds (for types that take a string argument)

22−

23−module ProjectM36.Tupleable.Deriving

24− ( -- * DerivingVia Newtype

25− Codec(..)

26−

27− -- * Type-level Options

28− , ModifyOptions(..)

29− , Field

30−

31− -- * Type-level 'T.Text' -> 'T.Text' Functions

32− , ModifyText(..)

33− , AddPrefix

34− , DropPrefix

35− , AddSuffix

36− , DropSuffix

37− , UpperCase

38− , LowerCase

39− , TitleCase

40− , CamelCase

41− , PascalCase

42− , SnakeCase

43− , SpinalCase

44− , TrainCase

45−

46− -- * Composition

47− , AsIs

48− , type (<<<)

49− , type (>>>)

50−

51− -- * Re-Exports

52− , Generic

53− , module ProjectM36.Tupleable

54− ) where

55−import Data.Maybe (fromMaybe)

56−import Data.Proxy

57−import qualified Data.Text as T

58−import Data.Text.Manipulate

59−import GHC.TypeLits

60−import GHC.Generics (Generic, Rep)

61−import ProjectM36.Tupleable

62−

63−

64−-- | A newtype wrapper to allow for easier deriving of 'Tupleable' instances

65−-- with customization.

66−--

67−-- The @tag@ type variable can be used to specify options for converting the

68−-- datatype to and from a 'RelationTuple'. For example,

69−--

70−-- > data Example = Example

71−-- > { exampleFoo :: Int

72−-- > , exampleBar :: Int

73−-- > }

74−-- > deriving stock (Generic)

75−-- > deriving (Tupleable)

76−-- > via Codec (Field (DropPrefix "example" >>> CamelCase)) Example

77−--

78−-- will derive an instance of 'Tupleable' where field names are translated into

79−-- attribute names by dropping the prefix @"example"@ and then converting the

80−-- result to camelCase. So @"exampleFoo"@ becomes @"foo"@ and @"exampleBar"@

81−-- becomes @"bar"@.

82−--

83−-- Requires the @DerivingGeneric@ and @DerivingVia@ extensions to be enabled.

84−newtype Codec tag a = Codec { unCodec :: a }

85−

86−instance (ModifyOptions tag, Generic a, TupleableG (Rep a)) => Tupleable (Codec tag a) where

87− toTuple v = genericToTuple opts (unCodec v)

88− where

89− opts = modifyOptions (Proxy :: Proxy tag) defaultTupleableOptions

90−

91− fromTuple tup = Codec <$> genericFromTuple opts tup

92− where

93− opts = modifyOptions (Proxy :: Proxy tag) defaultTupleableOptions

94−

95− toAttributes _ = genericToAttributes opts (Proxy :: Proxy a)

96− where

97− opts = modifyOptions (Proxy :: Proxy tag) defaultTupleableOptions

98−

99−-- | Types that can be used as tags for 'Codec'.

100−class ModifyOptions a where

101− modifyOptions :: proxy a -> TupleableOptions -> TupleableOptions

102−

103−-- | Change how record field names are translated into attribute names. For

104−-- example,

105−--

106−-- > Field SnakeCase

107−--

108−-- will translate the field name @fooBar@ into the attribute name @foo_bar@.

109−data Field a

110−

111−instance ModifyText a => ModifyOptions (Field a) where

112− modifyOptions _ opts = opts { fieldModifier = newFieldModifier }

113− where

114− newFieldModifier = modifyText (Proxy :: Proxy a) . fieldModifier opts

115−

116−-- | Types that can be used in options that modify 'T.Text' such as in 'Field'.

117−class ModifyText a where

118− modifyText :: proxy a -> T.Text -> T.Text

119−

120−-- | Add a prefix. @AddPrefix "foo"@ will transform @"bar"@ into @"foobar"@.

121−data AddPrefix (prefix :: Symbol)

122−

123−instance KnownSymbol prefix => ModifyText (AddPrefix prefix) where

124− modifyText _ oldText = prefixText <> oldText

125− where

126− prefixText = T.pack (symbolVal (Proxy :: Proxy prefix))

127−

128−-- | Drop a prefix. @DropPrefix "bar"@ will transform @"foobar"@ into @"foo"@.

129−data DropPrefix (prefix :: Symbol)

130−

131−instance KnownSymbol prefix => ModifyText (DropPrefix prefix) where

132− modifyText _ oldText = fromMaybe oldText (T.stripPrefix prefixText oldText)

133− where

134− prefixText = T.pack (symbolVal (Proxy :: Proxy prefix))

135−

136−-- | Add a suffix. @AddSuffix "bar"@ will transform @"foo"@ into @"foobar"@.

137−data AddSuffix (suffix :: Symbol)

138−

139−instance KnownSymbol suffix => ModifyText (AddSuffix suffix) where

140− modifyText _ oldText = oldText <> suffixText

141− where

142− suffixText = T.pack (symbolVal (Proxy :: Proxy suffix))

143−

144−-- | Drop a suffix. @DropSuffix "bar"@ will transform @"foobar"@ into @"foo"@.

145−data DropSuffix (suffix :: Symbol)

146−

147−instance KnownSymbol suffix => ModifyText (DropSuffix suffix) where

148− modifyText _ oldText = fromMaybe oldText (T.stripSuffix suffixText oldText)

149− where

150− suffixText = T.pack (symbolVal (Proxy :: Proxy suffix))

151−

152−-- | Convert to UPPERCASE. Will transform @"foobar"@ into @\"FOOBAR\"@.

153−data UpperCase

154−

155−instance ModifyText UpperCase where

156− modifyText _ = T.toUpper

157−

158−-- | Convert to lowercase. Will transform @\"FOOBAR\"@ into @"foobar"@.

159−data LowerCase

160−

161−instance ModifyText LowerCase where

162− modifyText _ = T.toLower

163−

164−-- | Convert to Title Case. Will transform @"fooBar"@ into @\"Foo Bar\"@.

165−data TitleCase

166−

167−instance ModifyText TitleCase where

168− modifyText _ = toTitle

169−

170−-- | Convert to camelCase. Will transform @"foo_bar"@ into @"fooBar"@.

171−data CamelCase

172−

173−instance ModifyText CamelCase where

174− modifyText _ = toCamel

175−

176−-- | Convert to PascalCase. Will transform @"foo_bar"@ into @\"FooBar\"@.

177−data PascalCase

178−

179−instance ModifyText PascalCase where

180− modifyText _ = toPascal

181−

182−-- | Convert to snake_case. Will transform @"fooBar"@ into @"foo_bar"@.

183−data SnakeCase

184−

185−instance ModifyText SnakeCase where

186− modifyText _ = toSnake

187−

188−-- | Convert to spinal-case. will transform @"fooBar"@ into @"foo-bar"@.

189−data SpinalCase

190−

191−instance ModifyText SpinalCase where

192− modifyText _ = toSpinal

193−

194−-- | Convert to Train-Case. Will transform @"fooBar"@ into @\"Foo-Bar\"@.

195−data TrainCase

196−

197−instance ModifyText TrainCase where

198− modifyText _ = toTrain

199−

200−-- | Identity option.

201−type AsIs = ()

202−

203−instance ModifyOptions () where

204− modifyOptions _ = id

205−

206−instance ModifyText () where

207− modifyText _ = id

208−

209−-- | Right to left composition.

210−--

211−-- Requires the @TypeOperators@ extension to be enabled.

212−data a <<< b

213−

214−instance (ModifyOptions a, ModifyOptions b) => ModifyOptions (a <<< b) where

215− modifyOptions _ = modifyOptions (Proxy :: Proxy a) . modifyOptions (Proxy :: Proxy b)

216−

217−instance (ModifyText a, ModifyText b) => ModifyText (a <<< b) where

218− modifyText _ = modifyText (Proxy :: Proxy a) . modifyText (Proxy :: Proxy b)

219−

220−-- | Left to right composition.

221−--

222−-- Requires the @TypeOperators@ extension to be enabled.

223−data a >>> b

224−

225−instance (ModifyOptions a, ModifyOptions b) => ModifyOptions (a >>> b) where

226− modifyOptions _ = modifyOptions (Proxy :: Proxy b) . modifyOptions (Proxy :: Proxy a)

227−

228−instance (ModifyText a, ModifyText b) => ModifyText (a >>> b) where

229− modifyText _ = modifyText (Proxy :: Proxy b) . modifyText (Proxy :: Proxy a)

src/lib/ProjectM36/WithNameExpr.hs+3−5

@@ -17,7 +17,7 @@ substituteWithNameMacros macros e@(RelationVariable rvname tid) =

17 macroFilt (WithNameExpr macroName macroTid, _) = rvname == macroName && tid== macroTid in

18 case filter macroFilt macros of

19 [] -> e

20− [(_,replacement)] -> replacement

20+ (_,replacement):[] -> replacement

21 _ -> error "more than one macro matched!"

22substituteWithNameMacros macros (Project attrs expr) =

23 Project attrs (substituteWithNameMacros macros expr)

@@ -42,11 +42,9 @@ substituteWithNameMacros macros (NotEquals exprA exprB) =

42substituteWithNameMacros macros (Extend extendTup expr) =

43 Extend (substituteWitNameMacrosExtendTupleExpr macros extendTup) (substituteWithNameMacros macros expr)

44substituteWithNameMacros macros (With moreMacros expr) =

45− --collect and update nested with exprs

45+ --collect and override existing macros and recurse

46 let newMacros = foldr macroFolder macros moreMacros

47− macroFolder (wnexpr, mexpr) acc =

47+ macroFolder (wnexpr, mexpr) acc = filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, mexpr)] in

48− let subExpr = substituteWithNameMacros macros mexpr in

49− filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, subExpr)] in

50 --scan for a match- if it exists, replace it (representing a with clause at a lower level

48 --scan for a match- if it exists, replace it (representing a with clause at a lower level

51 substituteWithNameMacros newMacros expr

49 substituteWithNameMacros newMacros expr

52

50

stack.ghc8.0.yamlnew file+50

@@ -0,0 +1,50 @@

1+# This file was automatically generated by stack init

2+# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

3+

4+# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5+resolver: lts-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.yamldeleted−19

@@ -1,19 +0,0 @@

1−resolver: lts-17.13

2−packages:

3− - "."

4−

5−extra-deps:

6− - git: https://github.com/agentm/curryer.git

7− commit: 74ecaac619ad1165a4517d5c0f4e530493bda130

8− - git: https://github.com/composewell/streamly.git

9− commit: ac3af8749194f1788704dda8667d0b3807075cc2

10− - fast-builder-0.1.2.1

11− - rset-1.0.0

12− - winery-1.3.2

13− - barbies-th-0.1.8

14− - base16-bytestring-1.0.1.0

15−

16−flags:

17− project-m36:

18− stack: true

19−# allow-newer: true

stack.ghc8.8.yaml → stack.ghc8.2.yamlrenamed+15−26

@@ -2,39 +2,27 @@

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-16.4

5+resolver: lts-11.20

6

7# Local packages, usually specified by relative directory name

8packages:

9− - "."

9+- '.'

10# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11extra-deps:

12− - git: https://github.com/agentm/curryer.git

12+- data-accessor-transformers-0.2.1.7

13− commit: 74ecaac619ad1165a4517d5c0f4e530493bda130

13+- data-interval-1.2.0

14− - git: https://github.com/composewell/streamly.git

15− commit: ac3af8749194f1788704dda8667d0b3807075cc2

16− - fast-builder-0.1.2.1

17− - winery-1.3.2

18− - barbies-2.0.2.0

19− - barbies-th-0.1.7

20− - extended-reals-0.2.3.0

14+- extended-reals-0.2.1.0

21− - data-interval-2.0.1

15+- gnuplot-0.5.4.1

22− - stm-containers-1.1.0.4

16+- text-1.2.2.1

23− - stm-hamt-1.2.0.4

17+- aeson-1.2.1.00

24− - rset-1.0.0

18+- distributed-process-0.7.3

25− - hashable-time-0.2.0.2

19+- distributed-process-async-0.2.4.1

26− - network-transport-tcp-0.7.0

20+- distributed-process-client-server-0.2.3

27− - megaparsec-7.0.5

21+- distributed-process-extras-0.3.2

28− - network-2.8.0.1

22+- rset-1.0.0

29− - primitive-extras-0.8

30− - primitive-unlifted-0.1.3.0

31− - prettyprinter-1.7.0

32− - prettyprinter-ansi-terminal-1.1.2

33− - base16-bytestring-1.0.1.0

34− - modern-uri-0.3.4.0

35

23

36# Override default flag values for local packages and extra-deps

24# Override default flag values for local packages and extra-deps

37−flags:

25+flags:

38 project-m36:

26 project-m36:

39 stack: true

27 stack: true

40

28

@@ -60,3 +48,4 @@ extra-package-dbs: []

60# compiler-check: newer-minor

48# compiler-check: newer-minor

61

49

62allow-newer: true

50allow-newer: true

51+

stack.ghc8.6.yaml → stack.ghc8.4.yamlrenamed+17−26

@@ -2,39 +2,29 @@

2# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

3

4# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5−resolver: lts-14.27

5+resolver: lts-12.11

6

7# Local packages, usually specified by relative directory name

8packages:

9− - "."

9+- '.'

10# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11extra-deps:

12− - git: https://github.com/agentm/curryer.git

12+- data-accessor-transformers-0.2.1.7

13− commit: 74ecaac619ad1165a4517d5c0f4e530493bda130

13+- data-interval-1.2.0

14− - git: https://github.com/composewell/streamly.git

15− commit: ac3af8749194f1788704dda8667d0b3807075cc2

16− - fast-builder-0.1.2.1

17− - winery-1.3.2

18− - barbies-2.0.2.0

19− - barbies-th-0.1.7

20− - extended-reals-0.2.3.0

14+- extended-reals-0.2.1.0

21− - data-interval-2.0.1

15+- gnuplot-0.5.5.3

22− - stm-containers-1.1.0.4

16+- aeson-1.2.1.00

23− - stm-hamt-1.2.0.4

17+- distributed-process-0.7.4

18+- distributed-process-async-0.2.4.1

19+- distributed-process-client-server-0.2.3

20+- distributed-process-extras-0.3.2

21+#- deferred-folds-0.9.7.1

24− - rset-1.0.0

22+- rset-1.0.0

25− - hashable-time-0.2.0.2

23+- hashable-time-0.2.0.2

26− - network-transport-tcp-0.6.0

24+- network-transport-tcp-0.6.0

27− - megaparsec-7.0.5

28− - prettyprinter-1.7.0

29− - prettyprinter-ansi-terminal-1.1.2

30− - fusion-plugin-types-0.1.0

31− - base16-bytestring-1.0.1.0

32− - modern-uri-0.3.4.0

33− - cryptohash-sha256-0.11.102.0

34− - http-types-0.12.3

35

25

36# Override default flag values for local packages and extra-deps

26# Override default flag values for local packages and extra-deps

37−flags:

27+flags:

38 project-m36:

28 project-m36:

39 stack: true

29 stack: true

40

30

@@ -60,3 +50,4 @@ extra-package-dbs: []

60# compiler-check: newer-minor

50# compiler-check: newer-minor

61

51

62allow-newer: true

52allow-newer: true

53+

test/Client/Simple.hs+2−1

@@ -9,6 +9,7 @@ import System.IO.Temp

9import System.FilePath

10import ProjectM36.TupleSet

11import ProjectM36.Attribute

12+import qualified Data.Vector as V

12import qualified Data.Map as M

13import qualified Data.Map as M

13

14

14main :: IO ()

15main :: IO ()

@@ -58,7 +59,7 @@ testSimpleCommitFailure = TestCase $ do

58 execute $ Assign "x" (ExistingRelation relationTrue)

59 execute $ Assign "x" (ExistingRelation relationTrue)

59 --cause error

60 --cause error

60 execute $ Assign "x" (MakeStaticRelation failAttrs emptyTupleSet)

61 execute $ Assign "x" (MakeStaticRelation failAttrs emptyTupleSet)

61− let expectedErr = Left (RelError (RelationTypeMismatchError mempty failAttrs))

62+ let expectedErr = Left (RelError (RelationTypeMismatchError V.empty failAttrs))

62 assertEqual "dbc error" expectedErr err

63 assertEqual "dbc error" expectedErr err

63

64

64-- #176 default merge couldn't handle Update

65-- #176 default merge couldn't handle Update

test/IsomorphicSchema.hs+27−37

@@ -4,13 +4,13 @@ import ProjectM36.Error

4import ProjectM36.IsomorphicSchema

5import ProjectM36.Relation

6import ProjectM36.RelationalExpression

7−import ProjectM36.TransactionGraph

8−import ProjectM36.StaticOptimizer

9import qualified ProjectM36.DatabaseContext as DBC

7import qualified ProjectM36.DatabaseContext as DBC

10import qualified ProjectM36.Attribute as A

8import qualified ProjectM36.Attribute as A

11import System.Exit

9import System.Exit

12import qualified Data.Map as M

10import qualified Data.Map as M

13import qualified Data.Set as S

11import qualified Data.Set as S

12+import Control.Monad.State

13+import Control.Monad.Trans.Reader

14

15testList :: Test

16testList = TestList [testIsoRename, testIsoRestrict, testIsoUnion, testSchemaValidation]

@@ -36,7 +36,7 @@ assertMaybe x msg = case x of

36testSchemaValidation :: Test

37testSchemaValidation = TestCase $ do

38 let potentialSchema = DBC.basicDatabaseContext {

39− relationVariables = M.singleton "anotherRel" (ExistingRelation relationTrue)

39+ relationVariables = M.singleton "anotherRel" relationTrue

40 }

41 -- missing relvars failure

42 morphs = [IsoRename "true" "true", IsoRename "false" "false"]

@@ -50,17 +50,15 @@ testSchemaValidation = TestCase $ do

50testIsoRename :: Test

51testIsoRename = TestCase $ do

52 -- create a schema with two relvars and rename one while the other remains the same in the isomorphic schema

53− let ctx = DBC.empty {

53+ let schemaA = mkRelationalExprState DBC.empty {

54− relationVariables = M.fromList [("employee", ExistingRelation relationTrue),

54+ relationVariables = M.fromList [("employee", relationTrue),

55− ("department", ExistingRelation relationFalse)]

55+ ("department", relationFalse)]

56 }

57− (graph, _) <- freshTransactionGraph ctx

58− let isomorphsAtoB = [IsoRename "emp" "employee",

57+ isomorphsAtoB = [IsoRename "emp" "employee",

59 IsoRename "department" "department"]

58 IsoRename "department" "department"]

60− unionExpr = Union (RelationVariable "emp" ()) (RelationVariable "department" ())

59+ unionExpr = Union (RelationVariable "emp" ()) (RelationVariable "department" ())

61− env = mkRelationalExprEnv ctx graph

62 relExpr <- assertEither (applyRelationalExprSchemaIsomorphs isomorphsAtoB unionExpr)

60 relExpr <- assertEither (applyRelationalExprSchemaIsomorphs isomorphsAtoB unionExpr)

63− let relResult = optimizeAndEvalRelationalExpr env relExpr

61+ let relResult = runReader (evalRelationalExpr relExpr) schemaA

64 assertEqual "employee relation morph" (Right relationTrue) relResult

62 assertEqual "employee relation morph" (Right relationTrue) relResult

65

63

66testIsoRestrict :: Test

64testIsoRestrict :: Test

@@ -69,70 +67,62 @@ testIsoRestrict = TestCase $ do

69 -- the virtual schema has an employee

67 -- the virtual schema has an employee

70 let empattrs = A.attributesFromList [Attribute "name" TextAtomType,

68 let empattrs = A.attributesFromList [Attribute "name" TextAtomType,

71 Attribute "boss" TextAtomType]

69 Attribute "boss" TextAtomType]

72− (graph, transId) <- freshTransactionGraph DBC.empty

73 emprel <- assertEither $ mkRelationFromList empattrs

70 emprel <- assertEither $ mkRelationFromList empattrs

74 [[TextAtom "Steve", TextAtom ""],

71 [[TextAtom "Steve", TextAtom ""],

75 [TextAtom "Cindy", TextAtom "Steve"],

72 [TextAtom "Cindy", TextAtom "Steve"],

76 [TextAtom "Sam", TextAtom "Steve"]]

73 [TextAtom "Sam", TextAtom "Steve"]]

77 let predicate = AttributeEqualityPredicate "boss" (NakedAtomExpr (TextAtom ""))

74 let predicate = AttributeEqualityPredicate "boss" (NakedAtomExpr (TextAtom ""))

78− reenv = mkRelationalExprEnv DBC.empty graph

79− bossRel <- assertEither $ runRelationalExprM reenv (evalRelationalExpr (Restrict predicate (ExistingRelation emprel)))

75+ bossRel <- assertEither $ runReader (evalRelationalExpr (Restrict predicate (ExistingRelation emprel))) (mkRelationalExprState DBC.empty)

80− nonBossRel <- assertEither $ runRelationalExprM reenv (evalRelationalExpr (Restrict (NotPredicate predicate) (ExistingRelation emprel)))

76+ nonBossRel <- assertEither $ runReader (evalRelationalExpr (Restrict (NotPredicate predicate) (ExistingRelation emprel))) (mkRelationalExprState DBC.empty)

81

77

82− let schemaA = mkRelationalExprEnv baseContext graph

78+ let schemaA = mkRelationalExprState DBC.empty {

83− baseContext = DBC.empty {

84− relationVariables = M.fromList [("nonboss", ExistingRelation nonBossRel),

79+ relationVariables = M.fromList [("nonboss", nonBossRel),

85− ("boss", ExistingRelation bossRel)]

80+ ("boss", bossRel)]

86 }

81 }

82+

87 isomorphsAtoB = [IsoRestrict "employee" predicate ("boss", "nonboss")]

83 isomorphsAtoB = [IsoRestrict "employee" predicate ("boss", "nonboss")]

88 bossq = RelationVariable "boss" ()

84 bossq = RelationVariable "boss" ()

89 nonbossq = RelationVariable "nonboss" ()

85 nonbossq = RelationVariable "nonboss" ()

90 employeeq = RelationVariable "employee" ()

86 employeeq = RelationVariable "employee" ()

91 unionq = Union bossq nonbossq

87 unionq = Union bossq nonbossq

92 empExpr <- assertEither (applyRelationalExprSchemaIsomorphs isomorphsAtoB employeeq)

88 empExpr <- assertEither (applyRelationalExprSchemaIsomorphs isomorphsAtoB employeeq)

93− let empResult = evalRelExpr (evalRelationalExpr empExpr)

89+ let empResult = runReader (evalRelationalExpr empExpr) schemaA

94− unionResult = evalRelExpr (evalRelationalExpr unionq)

90+ unionResult = runReader (evalRelationalExpr unionq) schemaA

95− evalRelExpr = runRelationalExprM schemaA

96 assertEqual "boss/nonboss isorestrict" unionResult empResult

91 assertEqual "boss/nonboss isorestrict" unionResult empResult

97 --execute database context expr

92 --execute database context expr

98 bobRel <- assertEither (mkRelationFromList empattrs [[TextAtom "Bob", TextAtom ""]])

93 bobRel <- assertEither (mkRelationFromList empattrs [[TextAtom "Bob", TextAtom ""]])

99 let schemaBInsertExpr = Insert "employee" (ExistingRelation bobRel)

94 let schemaBInsertExpr = Insert "employee" (ExistingRelation bobRel)

100 schemaBInsertExpr' <- assertEither (processDatabaseContextExprInSchema (Schema isomorphsAtoB) schemaBInsertExpr)

95 schemaBInsertExpr' <- assertEither (processDatabaseContextExprInSchema (Schema isomorphsAtoB) schemaBInsertExpr)

101− let Right dbcState = evalDBCExpr schemaBInsertExpr'

96+ let (postInsertContext,_,_) = execState (evalDatabaseContextExpr schemaBInsertExpr') (freshDatabaseState (stateElemsContext schemaA))

102− postInsertContext = dbc_context dbcState

103− evalDBCExpr expr' = runDatabaseContextEvalMonad baseContext dbcenv (optimizeAndEvalDatabaseContextExpr False expr')

104− dbcenv = mkDatabaseContextEvalEnv transId graph

105− expectedRel = runRelationalExprM postInsertEnv (evalRelationalExpr (Union (RelationVariable "boss" ()) (RelationVariable "nonboss" ())))

97+ expectedRel = runReader (evalRelationalExpr (Union (RelationVariable "boss" ()) (RelationVariable "nonboss" ()))) (mkRelationalExprState postInsertContext)

106− postInsertEnv = mkRelationalExprEnv postInsertContext graph

107 --execute the expression against the schema and compare against the base context

98 --execute the expression against the schema and compare against the base context

108 processedExpr <- assertEither (processRelationalExprInSchema (Schema isomorphsAtoB) (RelationVariable "employee" ()))

99 processedExpr <- assertEither (processRelationalExprInSchema (Schema isomorphsAtoB) (RelationVariable "employee" ()))

109− let processedRel = runRelationalExprM postInsertEnv (evalRelationalExpr processedExpr)

100+ let processedRel = runReader (evalRelationalExpr processedExpr) (mkRelationalExprState postInsertContext)

110 assertEqual "insert bob boss" expectedRel processedRel

101 assertEqual "insert bob boss" expectedRel processedRel

111

102

112testIsoUnion :: Test

103testIsoUnion :: Test

113testIsoUnion = TestCase $ do

104testIsoUnion = TestCase $ do

114 --create motors relation which is split into low-power (<50 horsepower) and high-power (>=50 horsepower) motors

105 --create motors relation which is split into low-power (<50 horsepower) and high-power (>=50 horsepower) motors

115 --the schema is contains the split relvars

106 --the schema is contains the split relvars

116− (graph, _) <- freshTransactionGraph DBC.empty

117 motorsRel <- assertEither $ mkRelationFromList (A.attributesFromList [Attribute "name" TextAtomType,

107 motorsRel <- assertEither $ mkRelationFromList (A.attributesFromList [Attribute "name" TextAtomType,

118 Attribute "power" IntegerAtomType])

108 Attribute "power" IntegerAtomType])

119 [[TextAtom "Puny", IntegerAtom 10],

109 [[TextAtom "Puny", IntegerAtom 10],

120 [TextAtom "Scooter", IntegerAtom 49],

110 [TextAtom "Scooter", IntegerAtom 49],

121 [TextAtom "Auto", IntegerAtom 200],

111 [TextAtom "Auto", IntegerAtom 200],

122 [TextAtom "Tractor", IntegerAtom 500]]

112 [TextAtom "Tractor", IntegerAtom 500]]

123− let env = mkRelationalExprEnv DBC.basicDatabaseContext {

113+ let baseSchema = mkRelationalExprState DBC.basicDatabaseContext {

124− relationVariables = M.singleton "motor" (ExistingRelation motorsRel)

114+ relationVariables = M.singleton "motor" motorsRel

125− } graph

115+ }

126 splitPredicate = AtomExprPredicate (FunctionAtomExpr "lt" [AttributeAtomExpr "power", NakedAtomExpr (IntegerAtom 50)] ())

116 splitPredicate = AtomExprPredicate (FunctionAtomExpr "lt" [AttributeAtomExpr "power", NakedAtomExpr (IntegerAtom 50)] ())

127 splitIsomorphs = [IsoUnion ("lowpower", "highpower") splitPredicate "motor",

117 splitIsomorphs = [IsoUnion ("lowpower", "highpower") splitPredicate "motor",

128 IsoRename "true" "true",

118 IsoRename "true" "true",

129 IsoRename "false" "false"]

119 IsoRename "false" "false"]

130− lowmotors = runRelationalExprM env (evalRelationalExpr (Restrict splitPredicate (RelationVariable "motor" ())))

120+ lowmotors = runReader (evalRelationalExpr (Restrict splitPredicate (RelationVariable "motor" ()))) baseSchema

131− highmotors = runRelationalExprM env (evalRelationalExpr (Restrict (NotPredicate splitPredicate) (RelationVariable "motor" ())))

121+ highmotors = runReader (evalRelationalExpr (Restrict (NotPredicate splitPredicate) (RelationVariable "motor" ()))) baseSchema

132− relResult expr = runRelationalExprM env (evalRelationalExpr expr)

122+ relResult expr = runReader (evalRelationalExpr expr) baseSchema

133 lowpowerExpr <- assertEither (processRelationalExprInSchema (Schema splitIsomorphs) (RelationVariable "lowpower" ()))

123 lowpowerExpr <- assertEither (processRelationalExprInSchema (Schema splitIsomorphs) (RelationVariable "lowpower" ()))

134 lowpowerRel <- assertEither (relResult lowpowerExpr)

124 lowpowerRel <- assertEither (relResult lowpowerExpr)

135 highpowerExpr <- assertEither (processRelationalExprInSchema (Schema splitIsomorphs) (RelationVariable "highpower" ()))

125 highpowerExpr <- assertEither (processRelationalExprInSchema (Schema splitIsomorphs) (RelationVariable "highpower" ()))

136 highpowerRel <- assertEither (relResult highpowerExpr)

126 highpowerRel <- assertEither (relResult highpowerExpr)

137 assertEqual "lowpower relation difference" (Right lowpowerRel) lowmotors

127 assertEqual "lowpower relation difference" (Right lowpowerRel) lowmotors

138− assertEqual "highpower relation difference" (Right highpowerRel) highmotors

128+ assertEqual "highpower relation difference" (Right highpowerRel) highmotors

test/Relation/Atomable.hs+20−52

@@ -1,7 +1,8 @@

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, DerivingVia #-}

2+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings #-}

3import Test.HUnit

4import ProjectM36.Client

5+import Data.Binary

5import Control.DeepSeq

6import Control.DeepSeq

6import System.Exit

7import System.Exit

7import TutorialD.Interpreter.TestBase

8import TutorialD.Interpreter.TestBase

@@ -12,65 +13,47 @@ import Data.Time.Calendar (fromGregorian)

12import Data.Text

13import Data.Text

13import qualified Data.Map as M

14import qualified Data.Map as M

14import Data.Proxy

15import Data.Proxy

15−import Codec.Winery

16

17{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

18data Test1T = Test1C Integer

19− deriving (Generic, Show, Eq, NFData, Atomable)

19+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)

20− deriving Serialise via WineryVariant Test1T

21

20

22data Test2T x = Test2C x

21data Test2T x = Test2C x

23− deriving (Show, Generic, Eq, NFData, Atomable)

22+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

24− deriving Serialise via WineryVariant (Test2T x)

25

23

26data Test3T = Test3C Integer Integer

24data Test3T = Test3C Integer Integer

27− deriving (Show, Generic, Eq, NFData, Atomable)

25+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

28− deriving Serialise via WineryVariant Test3T

29

26

30data Test4T = Test4Ca Integer |

27data Test4T = Test4Ca Integer |

31 Test4Cb Integer

28 Test4Cb Integer

32− deriving (Show, Generic, Eq, NFData, Atomable)

29+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

33− deriving Serialise via WineryVariant Test4T

34

30

35data TestListT = TestListC [Integer]

31data TestListT = TestListC [Integer]

36− deriving (Show, Generic, Eq, NFData, Atomable)

32+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

37− deriving Serialise via WineryVariant TestListT

38

33

39data TestNonEmptyT = TestNonEmptyC [Integer]

34data TestNonEmptyT = TestNonEmptyC [Integer]

40− deriving (Show, Generic, Eq, NFData, Atomable)

35+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

41− deriving Serialise via WineryVariant TestNonEmptyT

42

36

43data Test5T = Test5C {

37data Test5T = Test5C {

44 con1 :: Integer,

38 con1 :: Integer,

45 con2 :: Integer

39 con2 :: Integer

46− } deriving (Show, Generic, Eq, NFData, Atomable)

40+ } deriving (Show, Generic, Eq, Binary, NFData, Atomable)

47− deriving Serialise via WineryRecord Test5T

48

41

49data Test6T = Test6C (Maybe Integer)

42data Test6T = Test6C (Maybe Integer)

50− deriving (Show, Generic, Eq, NFData, Atomable)

43+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

51− deriving Serialise via WineryVariant Test6T

52

44

53data Test7T = Test7C (Either Integer Integer)

45data Test7T = Test7C (Either Integer Integer)

54− deriving (Show, Generic, Eq, NFData, Atomable)

46+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

55− deriving Serialise via WineryVariant Test7T

56

47

57data Test8T = Test8C Test1T

48data Test8T = Test8C Test1T

58− deriving (Show, Generic, Eq, NFData, Atomable)

49+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

59− deriving Serialise via WineryVariant Test8T

60−

61−data User = User

62− { userFirstName :: Text

63− , userLastName :: Text

64− } deriving (Eq, Ord, Show, Generic, NFData, Atomable)

65− deriving Serialise via WineryRecord User

66

50

67data Test9_4T = Test9_4C {

51data Test9_4T = Test9_4C {

68 f9_41 :: Int,

52 f9_41 :: Int,

69 f9_42 :: Int,

53 f9_42 :: Int,

70 f9_43 :: Int,

54 f9_43 :: Int,

71 f9_44 :: Int }

55 f9_44 :: Int }

72− deriving (Show, Generic, Eq, NFData, Atomable)

56+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

73− deriving Serialise via WineryRecord Test9_4T

74

57

75data Test9_5T = Test9_5C {

58data Test9_5T = Test9_5C {

76 f9_51 :: Int,

59 f9_51 :: Int,

@@ -79,16 +62,17 @@ data Test9_5T = Test9_5C {

79 f9_54 :: Int,

62 f9_54 :: Int,

80 f9_55 :: Int

63 f9_55 :: Int

81 }

64 }

82− deriving (Show, Generic, Eq, NFData, Atomable)

65+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

83− deriving Serialise via WineryRecord Test9_5T

84

66

67+

85main :: IO ()

68main :: IO ()

86main = do

69main = do

87 tcounts <- runTestTT testList

70 tcounts <- runTestTT testList

88 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

71 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

89

72

90testList :: Test

73testList :: Test

91−testList = TestList [testHaskell2DB, testADT1, testADT2, testADT3, testADT4, testADT5, testBasicMarshaling, testSimpleList, testListInstance, testNonEmptyInstance, testADT6Maybe, testADT7Either, testNonPrimitiveValues, testRecordType, testManyFields]

74+testList = TestList [testHaskell2DB, testADT1, testADT2, testADT3, testADT4, testADT5, testBasicMarshaling, testListInstance, testNonEmptyInstance, testADT6Maybe, testADT7Either, testNonPrimitiveValues]

75+

92

76

93-- test some basic data types like int, day, etc.

77-- test some basic data types like int, day, etc.

94testBasicMarshaling :: Test

78testBasicMarshaling :: Test

@@ -117,7 +101,7 @@ testHaskell2DB = TestCase $ do

117 let createRelExpr = Assign "x" rel

101 let createRelExpr = Assign "x" rel

118

102

119 rel = MakeRelationFromExprs Nothing

103 rel = MakeRelationFromExprs Nothing

120− (TupleExprs () [TupleExpr (M.singleton "a1" (NakedAtomExpr atomVal))])

104+ [TupleExpr (M.singleton "a1" (NakedAtomExpr atomVal))]

121 atomVal = toAtom exampleVal

105 atomVal = toAtom exampleVal

122 exampleVal = Test1C 10

106 exampleVal = Test1C 10

123 checkExecuteDatabaseContextExpr sessionId dbconn createRelExpr

107 checkExecuteDatabaseContextExpr sessionId dbconn createRelExpr

@@ -173,12 +157,6 @@ testListInstance = TestCase $ do

173 let example = TestListC [3,4,5]

157 let example = TestListC [3,4,5]

174 assertEqual "List instance" example (fromAtom (toAtom example))

158 assertEqual "List instance" example (fromAtom (toAtom example))

175

159

176−testSimpleList :: Test

177−testSimpleList = TestCase $ do

178− let example = toAtom @[Integer] [1,2,3]

179− expected = ConstructedAtom "Cons" (ConstructedAtomType "List" (M.fromList [("a",IntegerAtomType)])) [IntegerAtom 1,ConstructedAtom "Cons" (ConstructedAtomType "List" (M.fromList [("a",IntegerAtomType)])) [IntegerAtom 2,ConstructedAtom "Cons" (ConstructedAtomType "List" (M.fromList [("a",IntegerAtomType)])) [IntegerAtom 3,ConstructedAtom "Empty" (ConstructedAtomType "List" (M.fromList [("a",IntegerAtomType)])) []]]]

180− assertEqual "simple list" expected example

181−

182testNonEmptyInstance :: Test

160testNonEmptyInstance :: Test

183testNonEmptyInstance = TestCase $ do

161testNonEmptyInstance = TestCase $ do

184 let example = TestNonEmptyC [3,4,5]

162 let example = TestNonEmptyC [3,4,5]

@@ -189,21 +167,11 @@ testNonPrimitiveValues = TestCase $ do

189 let example = Test8C (Test1C 3)

167 let example = Test8C (Test1C 3)

190 assertEqual "non-primitive values" example (fromAtom (toAtom example))

168 assertEqual "non-primitive values" example (fromAtom (toAtom example))

191

169

192−testRecordType :: Test

193−testRecordType = TestCase $ do

194− let example = User { userFirstName = "Bob"

195− ,userLastName = "Smith"

196− }

197− assertEqual "User record" example (fromAtom (toAtom example))

198− let expected = AddTypeConstructor (ADTypeConstructorDef "User" []) [DataConstructorDef "User" [DataConstructorDefTypeConstructorArg (PrimitiveTypeConstructor "Text" TextAtomType),DataConstructorDefTypeConstructorArg (PrimitiveTypeConstructor "Text" TextAtomType)]]

199−

200− assertEqual "User record to database context expr" expected (toAddTypeExpr (Proxy :: Proxy User))

201−

202--test both odd and even product types with more than 2 fields

170--test both odd and even product types with more than 2 fields

203testManyFields :: Test

171testManyFields :: Test

204testManyFields = TestCase $ do

172testManyFields = TestCase $ do

205− let example4 = Test9_4C 1 2 3 4

173+ let example4 = Test9_4T 1 2 3 4

206 assertEqual "four fields product type" example4 (fromAtom (toAtom example4))

174 assertEqual "four fields product type" example4 (fromAtom (toAtom example4))

207

175

208− let example5 = Test9_5C 1 2 3 4 5

176+ let example5 = Test9_5T 1 2 3 4 5

209 assertEqual "five fields product type" example5 (fromAtom (toAtom example5))

177 assertEqual "five fields product type" example5 (fromAtom (toAtom example5))

test/Relation/Basic.hs+17−24

@@ -3,11 +3,13 @@ import ProjectM36.Base

3import ProjectM36.Relation

4import ProjectM36.Error

5import ProjectM36.DateExamples

6+import ProjectM36.TupleSet

7+import ProjectM36.Attribute hiding (null, attributeNames)

6import ProjectM36.DataTypes.Primitive

8import ProjectM36.DataTypes.Primitive

7import ProjectM36.RelationalExpression

9import ProjectM36.RelationalExpression

8−import ProjectM36.TransactionGraph

9import ProjectM36.Tuple

10import ProjectM36.Tuple

10import qualified ProjectM36.DatabaseContext as DBC

11import qualified ProjectM36.DatabaseContext as DBC

12+import Control.Monad.Trans.Reader

11import qualified ProjectM36.Attribute as A

13import qualified ProjectM36.Attribute as A

12import qualified Data.Map as M

14import qualified Data.Map as M

13import qualified Data.Vector as V

15import qualified Data.Vector as V

@@ -23,8 +25,8 @@ testList = TestList [testRelation "relationTrue" relationTrue, testRelation "rel

23 testRelation "products" productsRel,

25 testRelation "products" productsRel,

24 testRelation "supplierProducts" supplierProductsRel,

26 testRelation "supplierProducts" supplierProductsRel,

25 testMkRelationFromExprsBadAttrs,

27 testMkRelationFromExprsBadAttrs,

26− testExistingRelationType,

28+ testDuplicateAttributes,

27− testReorderTuple

29+ testExistingRelationType

28 ]

30 ]

29

31

30main :: IO ()

32main :: IO ()

@@ -62,8 +64,8 @@ validateAttrTypesMatchTupleAttrTypes rel@(Relation attrs tupSet) = foldr (\tuple

62 tupleAtomCheck tuple = V.all (== True) (attrChecks tuple)

64 tupleAtomCheck tuple = V.all (== True) (attrChecks tuple)

63 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of

65 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of

64 Left _ -> False

66 Left _ -> False

65− Right atom -> Right (atomTypeForAtom atom) ==

67+ Right atom -> (Right $ atomTypeForAtom atom) ==

66− A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributesVec (attributes rel))

68+ A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributes rel)

67

69

68simpleRel :: Relation

70simpleRel :: Relation

69simpleRel = case mkRelation attrs tupleSet of

71simpleRel = case mkRelation attrs tupleSet of

@@ -92,28 +94,19 @@ testMkRelation1 = TestCase $ assertEqual "key mismatch" expectedError (mkRelatio

92

94

93testMkRelationFromExprsBadAttrs :: Test

95testMkRelationFromExprsBadAttrs :: Test

94testMkRelationFromExprsBadAttrs = TestCase $ do

96testMkRelationFromExprsBadAttrs = TestCase $ do

95− let context = DBC.empty

97+ let context = DBC.empty

96− (graph,_) <- freshTransactionGraph context

97− let reenv = mkRelationalExprEnv context graph

98− reExpr = MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "badAttr1" (PrimitiveTypeConstructor "Int" IntAtomType) ()]) (TupleExprs () [TupleExpr (M.singleton "badAttr2" (NakedAtomExpr (IntAtom 1)))])

98+ case runReader (evalRelationalExpr (MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "badAttr1" (PrimitiveTypeConstructor "Int" IntAtomType) ()]) [TupleExpr (M.singleton "badAttr2" (NakedAtomExpr (IntAtom 1)))])) (mkRelationalExprState context) of

99− evald = runRelationalExprM reenv (evalRelationalExpr reExpr)

100− case evald of

101 Left err -> assertEqual "tuple type mismatch" (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "badAttr2" IntAtomType])) err

99 Left err -> assertEqual "tuple type mismatch" (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "badAttr2" IntAtomType])) err

102 Right _ -> assertFailure "expected tuple type mismatch"

100 Right _ -> assertFailure "expected tuple type mismatch"

103

101

102+--creating an empty relation with duplicate attribute names should fail

103+testDuplicateAttributes :: Test

104+testDuplicateAttributes = TestCase $ do

105+ let eRel = mkRelation attrs emptyTupleSet

106+ attrs = attributesFromList [Attribute "a" IntAtomType, Attribute "a" TextAtomType]

107+ assertEqual "duplicate attribute names" (Left (DuplicateAttributeNamesError (S.singleton "a"))) eRel

108+

104testExistingRelationType :: Test

109testExistingRelationType :: Test

105testExistingRelationType = TestCase $ do

110testExistingRelationType = TestCase $ do

106− (graph, _) <- freshTransactionGraph dateExamples

107− let typeResult = runRelationalExprM reenv (typeForRelationalExpr (ExistingRelation relationTrue))

111+ let typeResult = runReader (typeForRelationalExpr (ExistingRelation relationTrue)) (RelationalExprStateElems DBC.empty)

108− reenv = mkRelationalExprEnv dateExamples graph

109 assertEqual "ExistingRelation with tuples type" (Right relationFalse) typeResult

112 assertEqual "ExistingRelation with tuples type" (Right relationFalse) typeResult

110−

111−-- | Ensure that tuple reordering honors the

112−testReorderTuple :: Test

113−testReorderTuple = TestCase $ do

114− let tup1 = mkRelationTuple attrs1 (V.fromList [IntAtom 4, TextAtom "test"])

115− attrs1 = A.attributesFromList [Attribute "a" IntAtomType, Attribute "b" TextAtomType]

116− attrs2 = A.attributesFromList [Attribute "b" TextAtomType, Attribute "a" IntAtomType]

117− actual = reorderTuple attrs2 tup1

118− expected = mkRelationTuple attrs2 (V.fromList [TextAtom "test", IntAtom 4])

119− assertEqual "reorderTuple" expected actual

test/Relation/Export/CSV.hs+18−23

@@ -1,5 +1,3 @@

1−{-# LANGUAGE CPP #-}

2−

3import ProjectM36.Base

1import ProjectM36.Base

4import ProjectM36.Relation.Show.CSV

2import ProjectM36.Relation.Show.CSV

5import ProjectM36.Relation.Parse.CSV

3import ProjectM36.Relation.Parse.CSV

@@ -13,11 +11,7 @@ import System.Exit

13import Test.HUnit

11import Test.HUnit

14import Data.Time.Calendar

12import Data.Time.Calendar

15import Data.Time.Clock

13import Data.Time.Clock

16−

17−#if __GLASGOW_HASKELL__ < 804

18import Data.Monoid

14import Data.Monoid

19−#endif

20−

21{-

15{-

22import qualified Data.Text.Lazy as TL

16import qualified Data.Text.Lazy as TL

23import qualified Data.Text.Lazy.Encoding as TE

17import qualified Data.Text.Lazy.Encoding as TE

@@ -25,9 +19,9 @@ import ProjectM36.Relation.Show.Term

25import qualified Data.ByteString.Lazy as BS

19import qualified Data.ByteString.Lazy as BS

26-}

20-}

27

21

28−main :: IO ()

22+main :: IO ()

29−main = do

23+main = do

30− tcounts <- runTestTT $ TestList [testCSVExport,

24+ tcounts <- runTestTT $ TestList [testCSVExport,

31 testADTExport]

25 testADTExport]

32 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

26 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

33

27

@@ -37,8 +31,8 @@ assertEither x = do

37 case res of

31 case res of

38 Left err -> assertFailure (show err) >> undefined

32 Left err -> assertFailure (show err) >> undefined

39 Right val -> pure val

33 Right val -> pure val

40−

34+

41−testADTExport :: Test

35+testADTExport :: Test

42testADTExport = TestCase $ do

36testADTExport = TestCase $ do

43 let adtCSV = "a\nCons 4 (Cons 5 Empty)\n"

37 let adtCSV = "a\nCons 4 (Cons 5 Empty)\n"

44 attrs = A.attributesFromList [Attribute "a" (listAtomType IntegerAtomType)]

38 attrs = A.attributesFromList [Attribute "a" (listAtomType IntegerAtomType)]

@@ -46,17 +40,17 @@ testADTExport = TestCase $ do

46 case csvAsRelation attrs basicTypeConstructorMapping adtCSV of

40 case csvAsRelation attrs basicTypeConstructorMapping adtCSV of

47 Left err -> assertFailure ("import failure: " <> show err)

41 Left err -> assertFailure ("import failure: " <> show err)

48 Right rel -> assertEqual "import cons list" expectedRel (Right rel)

42 Right rel -> assertEqual "import cons list" expectedRel (Right rel)

49−

43+

50--round-trip various atom types through CSV export/import

44--round-trip various atom types through CSV export/import

51testCSVExport :: Test

45testCSVExport :: Test

52testCSVExport = TestCase $ do

46testCSVExport = TestCase $ do

53 now <- getCurrentTime

47 now <- getCurrentTime

54− testInterval <- assertEither $ pure (createInterval

48+ testInterval <- assertEither $ pure (createInterval

55− (DateTimeAtom now)

49+ (DateTimeAtom now)

56 (DateTimeAtom (addUTCTime 86400 now))

50 (DateTimeAtom (addUTCTime 86400 now))

57 True

51 True

58 False)

52 False)

59− let attrs = A.attributesFromList [Attribute "textattr" TextAtomType,

53+ let attrs = A.attributesFromList [Attribute "textattr" TextAtomType,

60 Attribute "integerattr" IntegerAtomType,

54 Attribute "integerattr" IntegerAtomType,

61 Attribute "dayattr" DayAtomType,

55 Attribute "dayattr" DayAtomType,

62 Attribute "datetimeattr" DateTimeAtomType,

56 Attribute "datetimeattr" DateTimeAtomType,

@@ -67,8 +61,8 @@ testCSVExport = TestCase $ do

67 ]

61 ]

68 sampleByteString = "\1\0\244\34\150"

62 sampleByteString = "\1\0\244\34\150"

69 relOrErr = mkRelationFromList attrs [

63 relOrErr = mkRelationFromList attrs [

70− [TextAtom "text atom with \"quote\"",

64+ [TextAtom "text atom with \"quote\"",

71− IntegerAtom 123,

65+ IntegerAtom 123,

72 DayAtom (fromGregorian 2017 4 10),

66 DayAtom (fromGregorian 2017 4 10),

73 DateTimeAtom now,

67 DateTimeAtom now,

74 ByteStringAtom sampleByteString,

68 ByteStringAtom sampleByteString,

@@ -76,19 +70,19 @@ testCSVExport = TestCase $ do

76 listCons TextAtomType [TextAtom "text1", TextAtom "text2"],

70 listCons TextAtomType [TextAtom "text1", TextAtom "text2"],

77 testInterval

71 testInterval

78 ],

72 ],

79− [TextAtom "second text atom with 漢字",

73+ [TextAtom "second text atom with 漢字",

80− IntegerAtom 314,

74+ IntegerAtom 314,

81 DayAtom (fromGregorian 1001 6 28),

75 DayAtom (fromGregorian 1001 6 28),

82 DateTimeAtom (addUTCTime 360 now),

76 DateTimeAtom (addUTCTime 360 now),

83− ByteStringAtom sampleByteString,

77+ ByteStringAtom sampleByteString,

84 listCons IntegerAtomType [IntegerAtom 10, IntegerAtom 11, IntegerAtom 12],

78 listCons IntegerAtomType [IntegerAtom 10, IntegerAtom 11, IntegerAtom 12],

85 listCons TextAtomType [TextAtom "text5\"", TextAtom "text6\r\n"],

79 listCons TextAtomType [TextAtom "text5\"", TextAtom "text6\r\n"],

86 testInterval

80 testInterval

87 ]]

81 ]]

88−

82+

89− case relOrErr of

83+ case relOrErr of

90 Left err -> assertFailure $ "export relation creation failure: " ++ show err

84 Left err -> assertFailure $ "export relation creation failure: " ++ show err

91− Right rel ->

85+ Right rel ->

92 case relationAsCSV rel of

86 case relationAsCSV rel of

93 Left err -> assertFailure $ "export failed: " ++ show err

87 Left err -> assertFailure $ "export failed: " ++ show err

94 Right csvData ->

88 Right csvData ->

@@ -97,3 +91,4 @@ testCSVExport = TestCase $ do

97 case csvAsRelation attrs basicTypeConstructorMapping csvData of -- import csv data back to relation

91 case csvAsRelation attrs basicTypeConstructorMapping csvData of -- import csv data back to relation

98 Left err -> assertFailure $ "re-import failed: " ++ show err

92 Left err -> assertFailure $ "re-import failed: " ++ show err

99 Right rel' -> assertEqual "relation CSV comparison" rel rel'

93 Right rel' -> assertEqual "relation CSV comparison" rel rel'

94+

test/Relation/StaticOptimizer.hs+51−76

@@ -1,12 +1,13 @@

1import ProjectM36.Base

2import ProjectM36.Relation

3−import ProjectM36.TransactionGraph

3+import ProjectM36.RelationalExpression

4import ProjectM36.DateExamples

5+import ProjectM36.Error

5import ProjectM36.TupleSet

6import ProjectM36.TupleSet

6import ProjectM36.StaticOptimizer

7import ProjectM36.StaticOptimizer

7−import ProjectM36.DatabaseContext as DBC

8import System.Exit

9import Control.Monad.State

10+import Control.Monad.Trans.Reader

10import Test.HUnit

11import Test.HUnit

11import qualified Data.Set as S

12import qualified Data.Set as S

12

13

@@ -15,126 +16,100 @@ main = do

15 tcounts <- runTestTT (TestList tests)

16 tcounts <- runTestTT (TestList tests)

16 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

17 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

17 where

18 where

18− tests = [testTransitiveOptimization,

19+ tests = relationOptTests ++ databaseOptTests ++ [testTransitiveOptimization,

19− testImpossiblePredicates,

20+ testImpossiblePredicates,

20− testJoinElimination,

21+ testJoinElimination,

21− testRestrictionPredicateCollapse,

22+ testRestrictionPredicateCollapse,

22− testPushDownRestrictionPredicate,

23+ testPushDownRestrictionPredicate]

23− testOptimizeRelationalExpr,

24+ optDBCTest = map (\(name, expr, unopt) -> TestCase $ assertEqual name expr (evalState (applyStaticDatabaseOptimization unopt) (freshDatabaseState dateExamples)))

24− testOptimizeDatabaseContextExpr]

25+ relvar nam = RelationVariable nam ()

25−

26+ startState = mkRelationalExprState dateExamples

26−testOptimizeDatabaseContextExpr :: Test

27+ optRelTest = map (\(name, expr, unopt) -> TestCase $ assertEqual name expr (runReader (applyStaticRelationalOptimization unopt) startState))

27−testOptimizeDatabaseContextExpr = TestCase $ do

28+ relationOptTests = optRelTest [

28− (graph, transId) <- freshTransactionGraph DBC.empty

29+ ("StaticProject", Right $ relvar "s", Project (AttributeNames (attributeNames suppliersRel)) (relvar "s")),

29− let relvar nam = RelationVariable nam ()

30+ ("StaticUnion", Right $ relvar "s", Union (relvar "s") (relvar "s")),

30− relvarId nam = RelationVariable nam UncommittedContextMarker

31+ ("StaticJoin", Right $ relvar "s", Join (relvar "s") (relvar "s"))

31− testInfos = [

32+ ]

33+ databaseOptTests = optDBCTest [

32− ("StaticAssign",

34+ ("StaticAssign",

33− Right $ Assign "z" (relvarId "s"),

35+ Right $ Assign "z" (relvar "s"),

34− Assign "z" (Restrict TruePredicate (relvar "s"))

36+ Assign "z" (Restrict TruePredicate (relvar "s"))

35− ),

37+ ),

36− ("StaticMultipleExpr",

38+ ("StaticMultipleExpr",

37− Right $ MultipleExpr [Assign "z" (relvarId "s"),

39+ Right $ MultipleExpr [Assign "z" (relvar "s"),

38− Assign "z" (relvarId "s")],

40+ Assign "z" (relvar "s")],

39− MultipleExpr [Assign "z" (Restrict TruePredicate (relvar "s")),

41+ MultipleExpr [Assign "z" (Restrict TruePredicate (relvar "s")),

40− Assign "z" (Restrict TruePredicate (relvar "s"))])

42+ Assign "z" (Restrict TruePredicate (relvar "s"))])

41− ]

43+ ]

42− forM_ testInfos $ \(name, expectedExpr, unoptExpr) -> do

43− let optExpr = runGraphRefSOptDatabaseContextExprM transId dateExamples graph (optimizeDatabaseContextExpr unoptExpr)

44− assertEqual name expectedExpr optExpr

45

44

46testTransitiveOptimization :: Test

45testTransitiveOptimization :: Test

47testTransitiveOptimization = TestCase $ do

46testTransitiveOptimization = TestCase $ do

48− (graph, _) <- freshTransactionGraph dateExamples

49 let expr atomexpr = AndPredicate (AttributeEqualityPredicate "a" (NakedAtomExpr (IntegerAtom 300))) (AttributeEqualityPredicate "b" atomexpr)

47 let expr atomexpr = AndPredicate (AttributeEqualityPredicate "a" (NakedAtomExpr (IntegerAtom 300))) (AttributeEqualityPredicate "b" atomexpr)

50 exprIn = expr (AttributeAtomExpr "a")

48 exprIn = expr (AttributeAtomExpr "a")

51 exprOut = expr (NakedAtomExpr (IntegerAtom 300))

49 exprOut = expr (NakedAtomExpr (IntegerAtom 300))

52− optExpr = runGraphRefSOptRelationalExprM Nothing graph (applyStaticPredicateOptimization exprIn)

53− assertEqual "transitive property" (Right exprOut) optExpr

50+ assertEqual "transitive property" (Right exprOut) (runReader (applyStaticPredicateOptimization exprIn) (RelationalExprStateElems dateExamples))

54−

51+

55−

52+optRelExpr :: RelationalExpr -> Either RelationalError RelationalExpr

56−testOptimizeRelationalExpr :: Test

53+optRelExpr expr = runReader (applyStaticRelationalOptimization expr) (RelationalExprStateElems dateExamples)

57−testOptimizeRelationalExpr = TestCase $ do

58− (graph, _) <- freshTransactionGraph dateExamples

59− let relvarId nam = RelationVariable nam UncommittedContextMarker

60− relationOptTests = [

61− ("StaticProject",

62− Right $ relvarId "s",

63− Project (AttributeNames (attributeNames suppliersRel)) (relvarId "s")),

64− ("StaticUnion",

65− Right $ relvarId "s",

66− Union (relvarId "s") (relvarId "s")),

67− ("StaticJoin",

68− Right $ relvarId "s",

69− Join (relvarId "s") (relvarId "s"))

70− ]

71− forM_ relationOptTests $ \(name, expr, unoptExpr) -> do

72− let optExpr = runGraphRefSOptRelationalExprM (Just dateExamples) graph (optimizeGraphRefRelationalExpr unoptExpr)

73− assertEqual name expr optExpr

74

54

75testImpossiblePredicates :: Test

55testImpossiblePredicates :: Test

76testImpossiblePredicates = TestCase $ do

56testImpossiblePredicates = TestCase $ do

77− (graph, _) <- freshTransactionGraph dateExamples

78 let tautTrue = Restrict (AtomExprPredicate (NakedAtomExpr (BoolAtom True))) rel

57 let tautTrue = Restrict (AtomExprPredicate (NakedAtomExpr (BoolAtom True))) rel

79 tautTrue2 = Restrict TruePredicate rel

58 tautTrue2 = Restrict TruePredicate rel

80 tautFalse = Restrict (AtomExprPredicate (NakedAtomExpr (BoolAtom False))) rel

59 tautFalse = Restrict (AtomExprPredicate (NakedAtomExpr (BoolAtom False))) rel

81 tautFalse2 = Restrict (NotPredicate TruePredicate) rel

60 tautFalse2 = Restrict (NotPredicate TruePredicate) rel

82 emptyRel = MakeStaticRelation (attributes suppliersRel) emptyTupleSet

61 emptyRel = MakeStaticRelation (attributes suppliersRel) emptyTupleSet

83− rel = RelationVariable "s" UncommittedContextMarker

62+ rel = RelationVariable "s" ()

84− optRelExpr expr = optimizeGraphRefRelationalExpr' (Just dateExamples) graph expr

85 assertEqual "remove tautology where true" (Right rel) (optRelExpr tautTrue)

63 assertEqual "remove tautology where true" (Right rel) (optRelExpr tautTrue)

86 assertEqual "remove tautology where true2" (Right rel) (optRelExpr tautTrue2)

64 assertEqual "remove tautology where true2" (Right rel) (optRelExpr tautTrue2)

87 assertEqual "remove tautology where false" (Right emptyRel) (optRelExpr tautFalse)

65 assertEqual "remove tautology where false" (Right emptyRel) (optRelExpr tautFalse)

88 assertEqual "remove tautology where false2" (Right emptyRel) (optRelExpr tautFalse2)

66 assertEqual "remove tautology where false2" (Right emptyRel) (optRelExpr tautFalse2)

67+

68+optJoinExpr :: RelationalExpr -> Either RelationalError RelationalExpr

69+optJoinExpr expr = runReader (applyStaticJoinElimination expr) (RelationalExprStateElems dateExamples)

89

70

90testJoinElimination :: Test

71testJoinElimination :: Test

91testJoinElimination = TestCase $ do

72testJoinElimination = TestCase $ do

92− (graph, _) <- freshTransactionGraph dateExamples

93− let marker = UncommittedContextMarker

94− optJoinExpr expr = runGraphRefSOptRelationalExprM (Just dateExamples) graph (applyStaticJoinElimination expr)

95− relvar rv = RelationVariable rv marker

96−

97 -- (s join sp){s#,qty,p#} == sp

73 -- (s join sp){s#,qty,p#} == sp

98− let unoptExpr = Project (AttributeNames (S.fromList ["p#", "qty", "s#"])) (Join (relvar "sp") (relvar "s"))

74+ let unoptExpr = Project (AttributeNames (S.fromList ["p#", "qty", "s#"])) (Join (RelationVariable "sp" ()) (RelationVariable "s" ()))

99− assertEqual "remove extraneous join" (Right (relvar "sp")) (optJoinExpr unoptExpr)

75+ assertEqual "remove extraneous join" (Right (RelationVariable "sp" ())) (optJoinExpr unoptExpr)

100

76

101-- (sp join s){s#,qty,p#} == sp --flip relvar names

77-- (sp join s){s#,qty,p#} == sp --flip relvar names

102− let unoptExpr2 = Project (AttributeNames (S.fromList ["p#", "qty", "s#"])) (Join (relvar "s") (relvar "sp"))

78+ let unoptExpr2 = Project (AttributeNames (S.fromList ["p#", "qty", "s#"])) (Join (RelationVariable "s" ()) (RelationVariable "sp" ()))

103− assertEqual "remove extraneous join2" (Right (relvar "sp")) (optJoinExpr unoptExpr2)

79+ assertEqual "remove extraneous join2" (Right (RelationVariable "sp" ())) (optJoinExpr unoptExpr2)

104

80

105-- (sp join s){s#,qty,sname} != sp - attribute from s included

81-- (sp join s){s#,qty,sname} != sp - attribute from s included

106− let expr3 = Project (AttributeNames (S.fromList ["p#", "qty", "sname"])) (Join (relvar "sp") (relvar "s"))

82+ let expr3 = Project (AttributeNames (S.fromList ["p#", "qty", "sname"])) (Join (RelationVariable "sp" ()) (RelationVariable "s" ()))

107 assertEqual "retain join" (Right expr3) (optJoinExpr expr3)

83 assertEqual "retain join" (Right expr3) (optJoinExpr expr3)

108

84

109 -- (sp join s){qty} != sp --projection does not include foreign key attribute

85 -- (sp join s){qty} != sp --projection does not include foreign key attribute

110− let expr4 = Project (AttributeNames (S.singleton "qty")) (Join (relvar "sp") (relvar "s"))

86+ let expr4 = Project (AttributeNames (S.singleton "qty")) (Join (RelationVariable "sp" ()) (RelationVariable "s" ()))

111 assertEqual "retain join2" (Right expr4) (optJoinExpr expr4)

87 assertEqual "retain join2" (Right expr4) (optJoinExpr expr4)

112

88

113 -- (sp join s){s#,qty} == sp - a subset of attributes in the projection are in the foreign key

89 -- (sp join s){s#,qty} == sp - a subset of attributes in the projection are in the foreign key

114− let expr5 = Project (AttributeNames (S.fromList ["s#", "qty"])) (Join (relvar "sp") (relvar "s"))

90+ let expr5 = Project (AttributeNames (S.fromList ["s#", "qty"])) (Join (RelationVariable "sp" ()) (RelationVariable "s" ()))

115− let expect5 = Project (AttributeNames (S.fromList ["s#", "qty"])) (relvar "sp")

91+ let expect5 = Project (AttributeNames (S.fromList ["s#", "qty"])) (RelationVariable "sp" ())

116 assertEqual "remove extraneous join (attribute subset)" (Right expect5) (optJoinExpr expr5)

92 assertEqual "remove extraneous join (attribute subset)" (Right expect5) (optJoinExpr expr5)

117

93

118 -- (s join p){s#,p#} != sp -- no foreign key

94 -- (s join p){s#,p#} != sp -- no foreign key

119− let expr6 = Project (AttributeNames (S.fromList ["s#", "p#"])) (Join (relvar "s") (relvar "p"))

95+ let expr6 = Project (AttributeNames (S.fromList ["s#", "p#"])) (Join (RelationVariable "s" ()) (RelationVariable "p" ()))

120 assertEqual "retain join- no foreign key" (Right expr6) (optJoinExpr expr6)

96 assertEqual "retain join- no foreign key" (Right expr6) (optJoinExpr expr6)

121

97

122 -- (s join p){s#,qty,p#,sname} != sp -- all sp attributes plus one s attributes

98 -- (s join p){s#,qty,p#,sname} != sp -- all sp attributes plus one s attributes

123− let expr7 = Project (AttributeNames (S.fromList ["s#", "p#", "qty", "sname"])) (Join (relvar "s") (relvar "sp"))

99+ let expr7 = Project (AttributeNames (S.fromList ["s#", "p#", "qty", "sname"])) (Join (RelationVariable "s" ()) (RelationVariable "sp" ()))

124 assertEqual "retain join- attributes from both relvars" (Right expr7) (optJoinExpr expr7)

100 assertEqual "retain join- attributes from both relvars" (Right expr7) (optJoinExpr expr7)

125

101

126testRestrictionPredicateCollapse :: Test

102testRestrictionPredicateCollapse :: Test

127testRestrictionPredicateCollapse = TestCase $ do

103testRestrictionPredicateCollapse = TestCase $ do

128 let expr1 = Restrict (NotPredicate TruePredicate) rv

104 let expr1 = Restrict (NotPredicate TruePredicate) rv

129− rv = RelationVariable "a" UncommittedContextMarker

105+ rv = RelationVariable "a" ()

130− relvar name = RelationVariable name UncommittedContextMarker

131 assertEqual "one restriction" expr1 (applyStaticRestrictionCollapse expr1)

106 assertEqual "one restriction" expr1 (applyStaticRestrictionCollapse expr1)

132

107

133 let attrEqualsPred = AttributeEqualityPredicate "x" (NakedAtomExpr (IntAtom 3))

108 let attrEqualsPred = AttributeEqualityPredicate "x" (NakedAtomExpr (IntAtom 3))

134− expr2 = Restrict TruePredicate (Restrict attrEqualsPred (relvar "a"))

109+ expr2 = Restrict TruePredicate (Restrict attrEqualsPred (RelationVariable "a" ()))

135− assertEqual "two restrictions" (Restrict (AndPredicate TruePredicate attrEqualsPred) (relvar "a")) (applyStaticRestrictionCollapse expr2)

110+ assertEqual "two restrictions" (Restrict (AndPredicate TruePredicate attrEqualsPred) (RelationVariable "a" ())) (applyStaticRestrictionCollapse expr2)

136

111

137− let expr3 = Restrict pred1 (Restrict pred2 (Restrict pred3 (relvar "a")))

112+ let expr3 = Restrict pred1 (Restrict pred2 (Restrict pred3 (RelationVariable "a" ())))

138 pred1 = NotPredicate TruePredicate

113 pred1 = NotPredicate TruePredicate

139 pred2 = attrEqualsPred

114 pred2 = attrEqualsPred

140 pred3 = AtomExprPredicate (NakedAtomExpr (BoolAtom True))

115 pred3 = AtomExprPredicate (NakedAtomExpr (BoolAtom True))

@@ -148,7 +123,7 @@ testRestrictionPredicateCollapse = TestCase $ do

148testPushDownRestrictionPredicate :: Test

123testPushDownRestrictionPredicate :: Test

149testPushDownRestrictionPredicate = TestCase $ do

124testPushDownRestrictionPredicate = TestCase $ do

150 -- (s union relation{tuple{city "Boston", s# "S6", sname "Stevens", status 50}}) where status = 30 == (s where status=30) union (relation{tuple{city "Boston", s# "S6", sname "Stevens", status 50}} where status=30)

125 -- (s union relation{tuple{city "Boston", s# "S6", sname "Stevens", status 50}}) where status = 30 == (s where status=30) union (relation{tuple{city "Boston", s# "S6", sname "Stevens", status 50}} where status=30)

151− let rvs = RelationVariable "s" UncommittedContextMarker

126+ let rvs = RelationVariable "s" ()

152 let status30 = AttributeEqualityPredicate "status" (NakedAtomExpr (IntAtom 30))

127 let status30 = AttributeEqualityPredicate "status" (NakedAtomExpr (IntAtom 30))

153 relationsOrError = do

128 relationsOrError = do

154 stevens <- mkRelationFromList (attributes suppliersRel) [[TextAtom "S6", TextAtom "Stevens", IntegerAtom 50, TextAtom "Boston"]]

129 stevens <- mkRelationFromList (attributes suppliersRel) [[TextAtom "S6", TextAtom "Stevens", IntegerAtom 50, TextAtom "Boston"]]

test/Relation/Tupleable.hs+9−187

@@ -1,29 +1,19 @@

1−{-# LANGUAGE

1+{-# LANGUAGE DeriveGeneric, FlexibleInstances, FlexibleContexts, TypeOperators, DeriveAnyClass #-}

2− DeriveGeneric

3− , FlexibleInstances

4− , FlexibleContexts

5− , DeriveAnyClass

6− , ScopedTypeVariables

7− , TypeApplications

8− , DataKinds

9− , TypeOperators

10− , AllowAmbiguousTypes

11− , DerivingVia

12− #-}

13import Test.HUnit

2import Test.HUnit

14−import ProjectM36.Tupleable.Deriving

3+import ProjectM36.Tupleable

15import ProjectM36.Atomable

4import ProjectM36.Atomable

16−import ProjectM36.Attribute as A

5+import ProjectM36.Attribute

17import ProjectM36.Error

6import ProjectM36.Error

7+import Data.Binary

18import ProjectM36.Base

8import ProjectM36.Base

19import Control.DeepSeq (NFData)

9import Control.DeepSeq (NFData)

10+import GHC.Generics

20import qualified Data.Vector as V

11import qualified Data.Vector as V

21import qualified Data.Map as M

12import qualified Data.Map as M

22import qualified Data.Text as T

13import qualified Data.Text as T

23import qualified Data.Set as S

14import qualified Data.Set as S

24import System.Exit

15import System.Exit

25import Data.Proxy

16import Data.Proxy

26−import Codec.Winery

27

17

28{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

18{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

29

19

@@ -31,43 +21,35 @@ data Test1T = Test1C {

31 attrA :: Integer

21 attrA :: Integer

32 }

22 }

33 deriving (Generic, Eq, Show)

23 deriving (Generic, Eq, Show)

34− deriving Serialise via WineryRecord Test1T

35

24

36data Test2T = Test2C {

25data Test2T = Test2C {

37 attrB :: Integer,

26 attrB :: Integer,

38 attrC :: Integer

27 attrC :: Integer

39 }

28 }

40 deriving (Generic, Eq, Show)

29 deriving (Generic, Eq, Show)

41− deriving Serialise via WineryRecord Test2T

42

30

43data Test3T = Test3C Integer

31data Test3T = Test3C Integer

44 deriving (Generic, Eq, Show)

32 deriving (Generic, Eq, Show)

45− deriving Serialise via WineryVariant Test3T

46

33

47data Test4T = Test4C

34data Test4T = Test4C

48 deriving (Generic, Eq, Show)

35 deriving (Generic, Eq, Show)

49− deriving Serialise via WineryVariant Test4T

50

36

51data Test5T = Test5C1 Integer |

37data Test5T = Test5C1 Integer |

52 Test5C2 Integer

38 Test5C2 Integer

53 deriving (Generic, Eq, Show)

39 deriving (Generic, Eq, Show)

54− deriving Serialise via WineryVariant Test5T

55

40

56data Test6T = Test6C T.Text Integer Double

41data Test6T = Test6C T.Text Integer Double

57 deriving (Generic, Eq, Show)

42 deriving (Generic, Eq, Show)

58

43

59data Test7A = Test7AC Integer

44data Test7A = Test7AC Integer

60− deriving (Generic, Show, Eq, NFData, Atomable)

45+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)

61− deriving Serialise via WineryVariant Test7A

62

46

63

47

64data Test7T = Test7C Test7A

48data Test7T = Test7C Test7A

65 deriving (Generic, Show, Eq)

49 deriving (Generic, Show, Eq)

66− deriving Serialise via WineryVariant Test7T

67

50

68data Test8T = Test8C

51data Test8T = Test8C

69 deriving (Generic, Show, Eq)

52 deriving (Generic, Show, Eq)

70− deriving Serialise via WineryVariant Test8T

71

53

72data Test9T = Test9C

54data Test9T = Test9C

73 {

55 {

@@ -76,15 +58,6 @@ data Test9T = Test9C

76 attr9C :: Double

58 attr9C :: Double

77 }

59 }

78 deriving (Generic, Show, Eq)

60 deriving (Generic, Show, Eq)

79− deriving Serialise via WineryRecord Test9T

80−

81−data Test10T = Test10C {

82− longAttrNameA10 :: Integer,

83− long_attr_name_b10 :: Integer,

84− longMixed_attr_NameC10 :: Integer

85− }

86− deriving (Generic, Show, Eq)

87− deriving Serialise via WineryRecord Test10T

88

61

89instance Tupleable Test1T

62instance Tupleable Test1T

90

63

@@ -110,7 +83,7 @@ main = do

110 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

83 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

111

84

112testList :: Test

85testList :: Test

113−testList = TestList [testADT1, testADT2, testADT3, testADT4, testADT6, testADT7, testADT8 ,testInsertExpr, testDefineExpr, testUpdateExpr, testUpdateExprEmptyAttrs, testDeleteExpr, testUpdateExprWrongAttr, testReorderedTuple, testAddPrefixField, testDropPrefixField, testAddSuffixField, testDropSuffixField, testUpperCaseField, testLowerCaseField, testTitleCaseField, testCamelCaseField, testPascalCaseField, testSnakeCaseField, testSpinalCaseField, testTrainCaseField, testAsIsCodec, testAsIsField, testComposeRLCodec, testComposeRLField, testComposeLRCodec, testComposeLRField]

86+testList = TestList [testADT1, testADT2, testADT3, testADT4, testADT6, testADT7, testADT8, testInsertExpr, testDefineExpr, testUpdateExpr, testUpdateExprEmptyAttrs, testDeleteExpr, testUpdateExprWrongAttr, testReorderedTuple]

114

87

115testADT1 :: Test

88testADT1 :: Test

116testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))

89testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))

@@ -148,7 +121,7 @@ testADT7 :: Test

148testADT7 = TestCase $ do

121testADT7 = TestCase $ do

149 let example = Test7C (Test7AC 3)

122 let example = Test7C (Test7AC 3)

150 assertEqual "atom type" (Right example) (fromTuple (toTuple example))

123 assertEqual "atom type" (Right example) (fromTuple (toTuple example))

151− let expectedAttrs = A.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))

124+ let expectedAttrs = V.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))

152 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))

125 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))

153

126

154testADT8 :: Test

127testADT8 :: Test

@@ -222,159 +195,8 @@ testDeleteExpr = TestCase $ do

222testReorderedTuple :: Test

195testReorderedTuple :: Test

223testReorderedTuple = TestCase $ do

196testReorderedTuple = TestCase $ do

224 let tupleRev :: RelationTuple -> RelationTuple

197 let tupleRev :: RelationTuple -> RelationTuple

225− tupleRev (RelationTuple v1 v2) = RelationTuple (revAttrs v1) (V.reverse v2)

198+ tupleRev (RelationTuple v1 v2) = RelationTuple (V.reverse v1) (V.reverse v2)

226− revAttrs attrs = A.attributesFromList (reverse (A.toList attrs))

227 expected = Test2C {attrB = 3,

199 expected = Test2C {attrB = 3,

228 attrC = 4}

200 attrC = 4}

229 actual = fromTuple . tupleRev . toTuple $ expected

201 actual = fromTuple . tupleRev . toTuple $ expected

230 assertEqual "reordered tuple" (Right expected) actual

202 assertEqual "reordered tuple" (Right expected) actual

231−

232−testCodec :: forall tag. ModifyOptions tag => String -> [AttributeName] -> Test

233−testCodec msg expected = TestCase $

234− assertEqual msg (S.fromList expected) actual

235− where

236− actual = attributeNameSet $ toAttributes (Proxy :: Proxy (Codec tag Test10T))

237−

238−testAddPrefixField :: Test

239−testAddPrefixField = testCodec

240− @(Field (AddPrefix "prefix_"))

241− "codec field add prefix attributes"

242− ["prefix_longAttrNameA10",

243− "prefix_long_attr_name_b10",

244− "prefix_longMixed_attr_NameC10"]

245−

246−testDropPrefixField :: Test

247−testDropPrefixField = testCodec

248− @(Field (DropPrefix "long"))

249− "codec field drop prefix"

250− ["AttrNameA10",

251− "_attr_name_b10",

252− "Mixed_attr_NameC10"]

253−

254−testAddSuffixField :: Test

255−testAddSuffixField = testCodec

256− @(Field (AddSuffix "_suffix"))

257− "codec field add suffix"

258− ["longAttrNameA10_suffix",

259− "long_attr_name_b10_suffix",

260− "longMixed_attr_NameC10_suffix"]

261−

262−testDropSuffixField :: Test

263−testDropSuffixField = testCodec

264− @(Field (DropSuffix "10"))

265− "codec field drop suffix"

266− ["longAttrNameA",

267− "long_attr_name_b",

268− "longMixed_attr_NameC"]

269−

270−testUpperCaseField :: Test

271−testUpperCaseField = testCodec

272− @(Field UpperCase)

273− "codec field uppercase"

274− ["LONGATTRNAMEA10",

275− "LONG_ATTR_NAME_B10",

276− "LONGMIXED_ATTR_NAMEC10"]

277−

278−testLowerCaseField :: Test

279−testLowerCaseField = testCodec

280− @(Field LowerCase)

281− "codec field lowercase"

282− ["longattrnamea10",

283− "long_attr_name_b10",

284− "longmixed_attr_namec10"]

285−

286−testTitleCaseField :: Test

287−testTitleCaseField = testCodec

288− @(Field TitleCase)

289− "codec field title case"

290− ["Long Attr Name A10",

291− "Long Attr Name B10",

292− "Long Mixed Attr Name C10"]

293−

294−testCamelCaseField :: Test

295−testCamelCaseField = testCodec

296− @(Field CamelCase)

297− "codec field camel case"

298− ["longAttrNameA10",

299− "longAttrNameB10",

300− "longMixedAttrNameC10"]

301−

302−testPascalCaseField :: Test

303−testPascalCaseField = testCodec

304− @(Field PascalCase)

305− "codec field pascal case"

306− ["LongAttrNameA10",

307− "LongAttrNameB10",

308− "LongMixedAttrNameC10"]

309−

310−testSnakeCaseField :: Test

311−testSnakeCaseField = testCodec

312− @(Field SnakeCase)

313− "codec field snake case"

314− ["long_attr_name_a10",

315− "long_attr_name_b10",

316− "long_mixed_attr_name_c10"]

317−

318−testSpinalCaseField :: Test

319−testSpinalCaseField = testCodec

320− @(Field SpinalCase)

321− "codec field spinal case"

322− ["long-attr-name-a10",

323− "long-attr-name-b10",

324− "long-mixed-attr-name-c10"]

325−

326−testTrainCaseField :: Test

327−testTrainCaseField = testCodec

328− @(Field TrainCase)

329− "codec field train case"

330− ["Long-Attr-Name-A10",

331− "Long-Attr-Name-B10",

332− "Long-Mixed-Attr-Name-C10"]

333−

334−testAsIsCodec :: Test

335−testAsIsCodec = testCodec

336− @AsIs

337− "codec as is"

338− ["longAttrNameA10",

339− "long_attr_name_b10",

340− "longMixed_attr_NameC10"]

341−

342−testAsIsField :: Test

343−testAsIsField = testCodec

344− @(Field AsIs)

345− "codec field as is"

346− ["longAttrNameA10",

347− "long_attr_name_b10",

348− "longMixed_attr_NameC10"]

349−

350−testComposeRLCodec :: Test

351−testComposeRLCodec = testCodec

352− @(Field UpperCase <<< Field (DropPrefix "long"))

353− "codec (<<<)"

354− ["ATTRNAMEA10",

355− "_ATTR_NAME_B10",

356− "MIXED_ATTR_NAMEC10"]

357−

358−testComposeRLField :: Test

359−testComposeRLField = testCodec

360− @(Field (UpperCase <<< DropPrefix "long"))

361− "codec field (<<<)"

362− ["ATTRNAMEA10",

363− "_ATTR_NAME_B10",

364− "MIXED_ATTR_NAMEC10"]

365−

366−testComposeLRCodec :: Test

367−testComposeLRCodec = testCodec

368− @(Field (DropPrefix "long") >>> Field UpperCase)

369− "codec (>>>)"

370− ["ATTRNAMEA10",

371− "_ATTR_NAME_B10",

372− "MIXED_ATTR_NAMEC10"]

373−

374−testComposeLRField :: Test

375−testComposeLRField = testCodec

376− @(Field (DropPrefix "long" >>> UpperCase))

377− "codec field (>>>)"

378− ["ATTRNAMEA10",

379− "_ATTR_NAME_B10",

380− "MIXED_ATTR_NAMEC10"]

test/Server/Main.hs+23−24

@@ -5,6 +5,7 @@ test client/server interaction

5import Test.HUnit

6import ProjectM36.Client

7import qualified ProjectM36.Client as C

8+import ProjectM36.Server.EntryPoints

8import ProjectM36.Server

9import ProjectM36.Server

9import ProjectM36.Server.Config

10import ProjectM36.Server.Config

10import ProjectM36.Relation

11import ProjectM36.Relation

@@ -13,8 +14,16 @@ import ProjectM36.IsomorphicSchema

13import ProjectM36.Base

14import ProjectM36.Base

14

15

15import System.Exit

16import System.Exit

16−import Network.Socket (SockAddr(..))

17+

17import Control.Concurrent

18import Control.Concurrent

19+import Network.Transport (EndPointAddress)

20+

21+#if MIN_VERSION_network_transport_tcp(0,6,0)

22+import Network.Transport.TCP.Internal (encodeEndPointAddress, decodeEndPointAddress)

23+#else

24+import Network.Transport.TCP (encodeEndPointAddress, decodeEndPointAddress)

25+#endif

26+

18import Data.Either (isRight)

27import Data.Either (isRight)

19import Control.Exception

28import Control.Exception

20import System.IO.Temp

29import System.IO.Temp

@@ -23,8 +32,6 @@ import System.FilePath

23import System.Directory

32import System.Directory

24#endif

33#endif

25

34

26−type Timeout = Int

27−

28testList :: SessionId -> Connection -> MVar () -> Test

35testList :: SessionId -> Connection -> MVar () -> Test

29testList sessionId conn notificationTestMVar = TestList $ serverTests ++ sessionTests

36testList sessionId conn notificationTestMVar = TestList $ serverTests ++ sessionTests

30 where

37 where

@@ -42,7 +49,7 @@ testList sessionId conn notificationTestMVar = TestList $ serverTests ++ session

42 testRelationVariableSummary,

49 testRelationVariableSummary,

43 testNotification notificationTestMVar

50 testNotification notificationTestMVar

44 ]

51 ]

45− serverTests = [testRequestTimeout, testFileDescriptorCount, testClientConnectFail]

52+ serverTests = [testRequestTimeout, testFileDescriptorCount]

46

53

47main :: IO ()

54main :: IO ()

48main = do

55main = do

@@ -62,9 +69,11 @@ main = do

62testDatabaseName :: DatabaseName

69testDatabaseName :: DatabaseName

63testDatabaseName = "test"

70testDatabaseName = "test"

64

71

65−testConnection :: Port -> MVar () -> IO (Either ConnectionError (SessionId, Connection))

72+testConnection :: EndPointAddress -> MVar () -> IO (Either ConnectionError (SessionId, Connection))

66−testConnection serverPort mvar = do

73+testConnection serverAddress mvar = do

74+ let Just (host, service, _) = decodeEndPointAddress serverAddress

75+ serverAddress' = encodeEndPointAddress host service 1

67− let connInfo = RemoteConnectionInfo testDatabaseName "127.0.0.1" (show serverPort) (testNotificationCallback mvar)

76+ let connInfo = RemoteProcessConnectionInfo testDatabaseName (NodeId serverAddress') (testNotificationCallback mvar)

68 --putStrLn ("testConnection: " ++ show serverAddress)

77 --putStrLn ("testConnection: " ++ show serverAddress)

69 eConn <- connectProjectM36 connInfo

78 eConn <- connectProjectM36 connInfo

70 case eConn of

79 case eConn of

@@ -76,7 +85,7 @@ testConnection serverPort mvar = do

76 Right sessionId -> pure $ Right (sessionId, conn)

85 Right sessionId -> pure $ Right (sessionId, conn)

77

86

78-- | A version of 'launchServer' which returns the port on which the server is listening on a secondary thread

87-- | A version of 'launchServer' which returns the port on which the server is listening on a secondary thread

79−launchTestServer :: Timeout -> IO (Port, ThreadId)

88+launchTestServer :: Timeout -> IO (EndPointAddress, ThreadId)

80launchTestServer ti = do

89launchTestServer ti = do

81 addressMVar <- newEmptyMVar

90 addressMVar <- newEmptyMVar

82 tid <- forkIO $

91 tid <- forkIO $

@@ -85,14 +94,13 @@ launchTestServer ti = do

85 persistenceStrategy = CrashSafePersistence (tempdir </> "db"),

94 persistenceStrategy = CrashSafePersistence (tempdir </> "db"),

86 perRequestTimeout = ti,

95 perRequestTimeout = ti,

87 testMode = True,

96 testMode = True,

88− bindPort = 0,

97+ bindPort = 0

89− checkFS = False --not stricly needed for these tests

90 }

98 }

91

99

92 launchServer config (Just addressMVar) >> pure ()

100 launchServer config (Just addressMVar) >> pure ()

93− (SockAddrInet port _) <- takeMVar addressMVar

101+ endPointAddress <- takeMVar addressMVar

94 --liftIO $ putStrLn ("launched server on " ++ show endPointAddress)

102 --liftIO $ putStrLn ("launched server on " ++ show endPointAddress)

95− pure (fromIntegral port, tid)

103+ pure (endPointAddress, tid)

96

104

97testRelationalExpr :: SessionId -> Connection -> Test

105testRelationalExpr :: SessionId -> Connection -> Test

98testRelationalExpr sessionId conn = TestCase $ do

106testRelationalExpr sessionId conn = TestCase $ do

@@ -138,11 +146,10 @@ testPlanForDatabaseContextExpr sessionId conn = TestCase $ do

138 let attrExprs = [AttributeAndTypeNameExpr "x" (PrimitiveTypeConstructor "Int" IntAtomType) ()]

146 let attrExprs = [AttributeAndTypeNameExpr "x" (PrimitiveTypeConstructor "Int" IntAtomType) ()]

139 testrv = "testrv"

147 testrv = "testrv"

140 dbExpr = Define testrv attrExprs

148 dbExpr = Define testrv attrExprs

141− expected = Define testrv [AttributeAndTypeNameExpr "x" (PrimitiveTypeConstructor "Int" IntAtomType) UncommittedContextMarker]

142 planResult <- planForDatabaseContextExpr sessionId conn dbExpr

149 planResult <- planForDatabaseContextExpr sessionId conn dbExpr

143 case planResult of

150 case planResult of

144 Left err -> assertFailure (show err)

151 Left err -> assertFailure (show err)

145− Right plan -> assertEqual "planForDatabaseContextExpr failure" expected plan

152+ Right plan -> assertEqual "planForDatabaseContextExpr failure" dbExpr plan

146

153

147testTransactionGraphAsRelation :: SessionId -> Connection -> Test

154testTransactionGraphAsRelation :: SessionId -> Connection -> Test

148testTransactionGraphAsRelation sessionId conn = TestCase $ do

155testTransactionGraphAsRelation sessionId conn = TestCase $ do

@@ -208,7 +215,7 @@ testRequestTimeout = TestCase $ do

208 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure

215 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure

209 Right (session, testConn) -> do

216 Right (session, testConn) -> do

210 res <- catchJust (\exc -> if exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))

217 res <- catchJust (\exc -> if exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))

211− assertBool "timeout exception was not thrown" (not res)

218+ assertBool "exception was not thrown" (not res)

212 killThread serverTid

219 killThread serverTid

213

220

214testFileDescriptorCount :: Test

221testFileDescriptorCount :: Test

@@ -237,12 +244,4 @@ fdCount = do

237#else

244#else

238--pass on non-linux platforms

245--pass on non-linux platforms

239testFileDescriptorCount = TestCase (pure ())

246testFileDescriptorCount = TestCase (pure ())

240−#endif

247+#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+12−8

@@ -18,6 +18,12 @@ import Data.Aeson

18import qualified Data.Map as M

19import qualified Data.ByteString.Lazy as BS

20import ProjectM36.Relation

21+#if MIN_VERSION_network_transport_tcp(0,6,0)

22+import Network.Transport.TCP.Internal (decodeEndPointAddress)

23+#else

24+import Network.Transport.TCP (decodeEndPointAddress)

25+#endif

26+

21

27

22--start the websocket server

28--start the websocket server

23-- run some tutoriald against it

29-- run some tutoriald against it

@@ -26,17 +32,16 @@ launchTestServer :: IO (PortNumber, DatabaseName)

26launchTestServer = do

32launchTestServer = do

27 addressMVar <- newEmptyMVar

33 addressMVar <- newEmptyMVar

28 let config = defaultServerConfig { databaseName = testDatabaseName,

34 let config = defaultServerConfig { databaseName = testDatabaseName,

29− bindPort = 0,

35+ bindPort = 0 }

30− checkFS = False}

31 testDatabaseName = "test"

36 testDatabaseName = "test"

32 -- start normal server

37 -- start normal server

33 _ <- forkIO (launchServer config (Just addressMVar) >> pure ())

38 _ <- forkIO (launchServer config (Just addressMVar) >> pure ())

34− (SockAddrInet dbPort _) <- takeMVar addressMVar

39+ serverAddress <- takeMVar addressMVar

35 let wsServerHost = "127.0.0.1"

40 let wsServerHost = "127.0.0.1"

36 wsServerPort = 8889

41 wsServerPort = 8889

37− dbHost = "127.0.0.1"

42+ Just (dbHost, dbPort, _) = decodeEndPointAddress serverAddress

38 -- start websocket server proxy -- runServer doesn't support returning an arbitrary socket

43 -- start websocket server proxy -- runServer doesn't support returning an arbitrary socket

39− _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (fromIntegral dbPort) dbHost))

44+ _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (read dbPort) dbHost))

40 --wait for socket to be listening

45 --wait for socket to be listening

41 waitForListenSocket 5 (fromIntegral wsServerPort)

46 waitForListenSocket 5 (fromIntegral wsServerPort)

42 pure (fromIntegral wsServerPort, testDatabaseName)

47 pure (fromIntegral wsServerPort, testDatabaseName)

@@ -51,14 +56,13 @@ waitForListenSocket secondsToTry port =

51 if secondsToTry <= 0 then

56 if secondsToTry <= 0 then

52 throw WaitForSocketListenException

57 throw WaitForSocketListenException

53 else do

58 else do

54− --hostaddr <- inet_addr "127.0.0.1"

59+ hostaddr <- inet_addr "127.0.0.1"

55− hostaddr:_ <- getAddrInfo Nothing (Just "127.0.0.1") (Just (show port))

56 sock <- socket AF_INET Stream defaultProtocol

60 sock <- socket AF_INET Stream defaultProtocol

57 let handler :: IOException -> IO ()

61 let handler :: IOException -> IO ()

58 handler _ = do

62 handler _ = do

59 threadDelay 1000000

63 threadDelay 1000000

60 waitForListenSocket (secondsToTry - 1) port

64 waitForListenSocket (secondsToTry - 1) port

61− catch (connect sock (addrAddress hostaddr)) handler

65+ catch (connect sock (SockAddrInet port hostaddr)) handler

62

66

63main :: IO ()

67main :: IO ()

64main = do

68main = do

test/TransactionGraph/Merge.hs+39−70

@@ -4,28 +4,15 @@ import ProjectM36.Base

4import ProjectM36.Attribute

5import ProjectM36.Relation

6import ProjectM36.Transaction

7−import ProjectM36.TransactionInfo as TI

8import ProjectM36.TransactionGraph

7import ProjectM36.TransactionGraph

9import ProjectM36.Error

8import ProjectM36.Error

10import ProjectM36.Key

9import ProjectM36.Key

11import qualified ProjectM36.DisconnectedTransaction as Discon

10import qualified ProjectM36.DisconnectedTransaction as Discon

12import qualified ProjectM36.DatabaseContext as DBC

11import qualified ProjectM36.DatabaseContext as DBC

13import ProjectM36.RelationalExpression

12import ProjectM36.RelationalExpression

14−import ProjectM36.StaticOptimizer

15

13

16import qualified Data.ByteString.Lazy as BS

14import qualified Data.ByteString.Lazy as BS

17import System.Exit

15import System.Exit

18−

19−

20−

21−

22−

23−

24−

25−

26−

27−

28−

29import Data.Word

16import Data.Word

30import qualified Data.UUID as U

17import qualified Data.UUID as U

31import qualified Data.Set as S

18import qualified Data.Set as S

@@ -34,6 +21,8 @@ import Data.Maybe

34import Data.Time.Clock

21import Data.Time.Clock

35import Data.Time.Calendar

22import Data.Time.Calendar

36

23

24+import Control.Monad.State

25+

37{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}

26{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}

38

27

39testTime :: UTCTime

28testTime :: UTCTime

@@ -73,8 +62,8 @@ basicTransactionGraph = do

73 uuidB = fakeUUID 11

62 uuidB = fakeUUID 11

74 uuidRoot = fakeUUID 1

63 uuidRoot = fakeUUID 1

75 rootContext = concreteDatabaseContext rootTrans

64 rootContext = concreteDatabaseContext rootTrans

76− (_, bsGraph') <- addTransaction "branchA" (createTrans uuidA (TI.singleParent uuidRoot testTime) rootContext) bsGraph

65+ (_, bsGraph') <- addTransaction "branchA" (createTrans uuidA (TransactionInfo uuidRoot S.empty testTime) rootContext) bsGraph

77− (_, bsGraph'') <- addTransaction "branchB" (createTrans uuidB (TI.singleParent uuidRoot testTime) rootContext) bsGraph'

66+ (_, bsGraph'') <- addTransaction "branchB" (createTrans uuidB (TransactionInfo uuidRoot S.empty testTime) rootContext) bsGraph'

78 pure bsGraph''

67 pure bsGraph''

79

68

80addTransaction :: HeadName -> Transaction -> TransactionGraph -> IO (Transaction, TransactionGraph)

69addTransaction :: HeadName -> Transaction -> TransactionGraph -> IO (Transaction, TransactionGraph)

@@ -118,7 +107,7 @@ testSubGraphToFirstAncestorSnipBranch = TestCase $ do

118 baseGraph <- basicTransactionGraph

107 baseGraph <- basicTransactionGraph

119 transA <- assertMaybe (transactionForHead "branchA" baseGraph) "failed to get branchA"

108 transA <- assertMaybe (transactionForHead "branchA" baseGraph) "failed to get branchA"

120 transB <- assertMaybe (transactionForHead "branchB" baseGraph) "failed to get branchB"

109 transB <- assertMaybe (transactionForHead "branchB" baseGraph) "failed to get branchB"

121− (_, graph) <- addTransaction "branchC" (createTrans (fakeUUID 12) (TI.singleParent (fakeUUID 1) testTime) (concreteDatabaseContext transA)) baseGraph

110+ (_, graph) <- addTransaction "branchC" (createTrans (fakeUUID 12) (TransactionInfo (fakeUUID 1) S.empty testTime) (concreteDatabaseContext transA)) baseGraph

122 subgraph <- assertEither $ subGraphOfFirstCommonAncestor graph (transactionHeadsForGraph baseGraph) transA transB S.empty

111 subgraph <- assertEither $ subGraphOfFirstCommonAncestor graph (transactionHeadsForGraph baseGraph) transA transB S.empty

123 assertGraph subgraph

112 assertGraph subgraph

124 let graphEq graphArg = S.map transactionId (transactionsForGraph graphArg)

113 let graphEq graphArg = S.map transactionId (transactionsForGraph graphArg)

@@ -132,18 +121,16 @@ testSubGraphToFirstAncestorMoreTransactions = TestCase $ do

132

121

133-- add another relvar to branchB

122-- add another relvar to branchB

134 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "failed to get branchB head"

123 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "failed to get branchB head"

135− let env = mkDatabaseContextEvalEnv (transactionId branchBTrans) graph

124+ (updatedBranchBContext,_,_) <- case runState (evalDatabaseContextExpr (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) (freshDatabaseState (concreteDatabaseContext branchBTrans)) of

136− branchBContext = concreteDatabaseContext branchBTrans

137− updatedBranchBContext <- case runDatabaseContextEvalMonad branchBContext env (optimizeAndEvalDatabaseContextExpr True (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) of

138− Left err -> assertFailure (show err) >> undefined

125+ (Left err, _) -> assertFailure (show err) >> undefined

139− Right st -> pure $ dbc_context st

126+ (Right (), context) -> pure context

140− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) updatedBranchBContext) graph

127+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans) S.empty testTime) updatedBranchBContext) graph

141 branchBTrans' <- assertMaybe (transactionForHead "branchB" graph') "failed to get branchB head"

128 branchBTrans' <- assertMaybe (transactionForHead "branchB" graph') "failed to get branchB head"

142 assertEqual "branchB id 3" (fakeUUID 3) (transactionId branchBTrans')

129 assertEqual "branchB id 3" (fakeUUID 3) (transactionId branchBTrans')

143

130

144 -- add another transaction to branchA

131 -- add another transaction to branchA

145 branchATrans <- assertMaybe (transactionForHead "branchA" graph) "failed to get branchA head"

132 branchATrans <- assertMaybe (transactionForHead "branchA" graph) "failed to get branchA head"

146− (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchATrans) testTime) (concreteDatabaseContext branchATrans)) graph'

133+ (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchATrans) S.empty testTime) (concreteDatabaseContext branchATrans)) graph'

147 branchATrans' <- assertMaybe (transactionForHead "branchA" graph'') "failed to get branchA head"

134 branchATrans' <- assertMaybe (transactionForHead "branchA" graph'') "failed to get branchA head"

148 assertEqual "branchA id 4" (fakeUUID 4) (transactionId branchATrans')

135 assertEqual "branchA id 4" (fakeUUID 4) (transactionId branchATrans')

149

136

@@ -161,15 +148,12 @@ testSelectedBranchMerge = TestCase $ do

161

148

162 -- add another relvar to branchB

149 -- add another relvar to branchB

163 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "failed to get branchB head"

150 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "failed to get branchB head"

164− let env = mkDatabaseContextEvalEnv (transactionId branchBTrans) graph

165− branchBContext = concreteDatabaseContext branchBTrans

166− updatedBranchBContext <- case runDatabaseContextEvalMonad branchBContext env (optimizeAndEvalDatabaseContextExpr True (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) of

151+ (updatedBranchBContext,_,_) <- case runState (evalDatabaseContextExpr (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) (freshDatabaseState (concreteDatabaseContext branchBTrans)) of

167− Left err -> assertFailure (show err) >> undefined

152+ (Left err, _) -> assertFailure (show err) >> undefined

168− Right st -> pure (dbc_context st)

153+ (Right (), context) -> pure context

169− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) updatedBranchBContext) graph

154+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans) S.empty testTime) updatedBranchBContext) graph

170 --create the merge transaction in the graph

155 --create the merge transaction in the graph

171− let eGraph' = runGraphRefRelationalExprM gfEnv $ mergeTransactions testTime (fakeUUID 4) (fakeUUID 10) (SelectedBranchMergeStrategy "branchA") ("branchA", "branchB")

156+ let eGraph' = mergeTransactions testTime (fakeUUID 4) (fakeUUID 10) (SelectedBranchMergeStrategy "branchA") ("branchA", "branchB") graph'

172− gfEnv = freshGraphRefRelationalExprEnv Nothing graph'

173

157

174 (_, graph'') <- assertEither eGraph'

158 (_, graph'') <- assertEither eGraph'

175

159

@@ -191,22 +175,18 @@ testUnionPreferMergeStrategy = TestCase $ do

191 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "branchBTrans"

175 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "branchBTrans"

192 branchBRelVar <- assertEither $ mkRelationFromList (attributesFromList [Attribute "conflict" IntAtomType]) []

176 branchBRelVar <- assertEither $ mkRelationFromList (attributesFromList [Attribute "conflict" IntAtomType]) []

193 let branchAContext = (concreteDatabaseContext branchATrans) {relationVariables = M.insert conflictRelVarName branchARelVar (relationVariables (concreteDatabaseContext branchATrans))}

177 let branchAContext = (concreteDatabaseContext branchATrans) {relationVariables = M.insert conflictRelVarName branchARelVar (relationVariables (concreteDatabaseContext branchATrans))}

194− branchARelVar = ExistingRelation relationTrue

178+ branchARelVar = relationTrue

195− branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.insert conflictRelVarName (ExistingRelation branchBRelVar) (relationVariables (concreteDatabaseContext branchBTrans))}

179+ branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.insert conflictRelVarName branchBRelVar (relationVariables (concreteDatabaseContext branchBTrans))}

196− conflictRelVarName = "conflictRelVar"

180+ conflictRelVarName = "conflictRelVar"

197

181

198− (_, graph') <- addTransaction "branchA" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchATrans) testTime) branchAContext) graph

182+ (_, graph') <- addTransaction "branchA" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchATrans) S.empty testTime) branchAContext) graph

199− (_, graph'') <- addTransaction "branchB" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchBTrans) testTime) branchBContext) graph'

183+ (_, graph'') <- addTransaction "branchB" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchBTrans) S.empty testTime) branchBContext) graph'

200 -- validate that the conflict is hidden because we preferred a branch

184 -- validate that the conflict is hidden because we preferred a branch

201− let merged = runGraphRefRelationalExprM env $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) (UnionPreferMergeStrategy "branchB") ("branchA", "branchB")

185+ let merged = mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) (UnionPreferMergeStrategy "branchB") ("branchA", "branchB") graph''

202− env = freshGraphRefRelationalExprEnv Nothing graph''

203 case merged of

186 case merged of

204 Left err -> assertFailure ("expected merge success: " ++ show err)

187 Left err -> assertFailure ("expected merge success: " ++ show err)

205− Right (discon, _) -> do

188+ Right (discon, _) ->

206− let Just rvExpr = M.lookup conflictRelVarName (relationVariables (Discon.concreteDatabaseContext discon))

207− reEnv = freshGraphRefRelationalExprEnv (Just (Discon.concreteDatabaseContext discon)) graph

208− let eRvRel = runGraphRefRelationalExprM reEnv (evalGraphRefRelationalExpr rvExpr)

209− assertEqual "branchB relvar preferred in conflict" (Right branchBRelVar) eRvRel

189+ assertEqual "branchB relvar preferred in conflict" (Just branchBRelVar) (M.lookup conflictRelVarName (relationVariables (Discon.concreteDatabaseContext discon)))

210

190

211-- try various individual component conflicts and check for merge failure

191-- try various individual component conflicts and check for merge failure

212testUnionMergeStrategy :: Test

192testUnionMergeStrategy :: Test

@@ -221,41 +201,31 @@ testUnionMergeStrategy = TestCase $ do

221

201

222 let updatedBranchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.insert branchBOnlyRelVarName branchBOnlyRelVar (relationVariables (concreteDatabaseContext branchBTrans)) }

202 let updatedBranchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.insert branchBOnlyRelVarName branchBOnlyRelVar (relationVariables (concreteDatabaseContext branchBTrans)) }

223 updatedBranchAContext = (concreteDatabaseContext branchATrans) {inclusionDependencies = M.insert branchAOnlyIncDepName branchAOnlyIncDep (inclusionDependencies (concreteDatabaseContext branchATrans)) }

203 updatedBranchAContext = (concreteDatabaseContext branchATrans) {inclusionDependencies = M.insert branchAOnlyIncDepName branchAOnlyIncDep (inclusionDependencies (concreteDatabaseContext branchATrans)) }

224− branchBOnlyRelVar = ExistingRelation relationTrue

204+ branchBOnlyRelVar = relationTrue

225 branchAOnlyIncDepName = "branchAOnlyIncDep"

205 branchAOnlyIncDepName = "branchAOnlyIncDep"

226 branchBOnlyRelVarName = "branchBOnlyRelVar"

206 branchBOnlyRelVarName = "branchBOnlyRelVar"

227 branchAOnlyIncDep = InclusionDependency (ExistingRelation relationTrue) (ExistingRelation relationTrue)

207 branchAOnlyIncDep = InclusionDependency (ExistingRelation relationTrue) (ExistingRelation relationTrue)

228− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) updatedBranchBContext) graph

208+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans) S.empty testTime) updatedBranchBContext) graph

229− let env = freshGraphRefRelationalExprEnv Nothing graph'

230− (discon, _) <- assertEither $ runGraphRefRelationalExprM env $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 10) UnionMergeStrategy ("branchA", "branchB")

209+ (discon, _) <- assertEither $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 10) UnionMergeStrategy ("branchA", "branchB") graph'

231− let Just rvExpr = M.lookup branchBOnlyRelVarName (relationVariables (Discon.concreteDatabaseContext discon))

232− Right rvRel = runGraphRefRelationalExprM reEnv (evalGraphRefRelationalExpr rvExpr)

233− reEnv = freshGraphRefRelationalExprEnv (Just (Discon.concreteDatabaseContext discon)) graph

234−

235− assertEqual "branchBOnlyRelVar should appear in the merge" relationTrue rvRel

210+ assertEqual "branchBOnlyRelVar should appear in the merge" (M.lookup branchBOnlyRelVarName (relationVariables (Discon.concreteDatabaseContext discon))) (Just relationTrue)

236− (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchATrans) testTime) updatedBranchAContext) graph'

211+ (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchATrans) S.empty testTime) updatedBranchAContext) graph'

237− let eMergeGraph = runGraphRefRelationalExprM gfEnv $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB")

212+ let eMergeGraph = mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB") graph''

238− gfEnv = freshGraphRefRelationalExprEnv Nothing graph''

239 case eMergeGraph of

213 case eMergeGraph of

240 Left err -> assertFailure ("expected merge success: " ++ show err)

214 Left err -> assertFailure ("expected merge success: " ++ show err)

241 Right (_, mergeGraph) -> do

215 Right (_, mergeGraph) -> do

242 -- check that the new merge transaction has the correct parents

216 -- check that the new merge transaction has the correct parents

243 mergeTrans <- assertEither $ transactionForId (fakeUUID 5) mergeGraph

217 mergeTrans <- assertEither $ transactionForId (fakeUUID 5) mergeGraph

244 let mergeContext = concreteDatabaseContext mergeTrans

218 let mergeContext = concreteDatabaseContext mergeTrans

245− assertEqual "merge transaction parents" (parentIds mergeTrans) (S.fromList [fakeUUID 3, fakeUUID 4])

219+ assertEqual "merge transaction parents" (transactionParentIds mergeTrans) (S.fromList [fakeUUID 3, fakeUUID 4])

246 -- check that the new merge tranasction has elements from both A and B branches

220 -- check that the new merge tranasction has elements from both A and B branches

247− let Just rvExpr' = M.lookup branchBOnlyRelVarName (relationVariables mergeContext)

248− Right rvRel' = runGraphRefRelationalExprM reEnv' (evalGraphRefRelationalExpr rvExpr')

249− reEnv' = freshGraphRefRelationalExprEnv (Just mergeContext) graph

250− assertEqual "merge transaction relvars" relationTrue rvRel'

221+ assertEqual "merge transaction relvars" (Just relationTrue) (M.lookup branchBOnlyRelVarName (relationVariables mergeContext))

251 assertEqual "merge transaction incdeps" (Just branchAOnlyIncDep) (M.lookup branchAOnlyIncDepName (inclusionDependencies mergeContext))

222 assertEqual "merge transaction incdeps" (Just branchAOnlyIncDep) (M.lookup branchAOnlyIncDepName (inclusionDependencies mergeContext))

252 -- test an expected conflict- add branchBOnlyRelVar with same name but different attributes

223 -- test an expected conflict- add branchBOnlyRelVar with same name but different attributes

253 conflictRelVar <- assertEither $ mkRelationFromList (attributesFromList [Attribute "conflict" IntAtomType]) []

224 conflictRelVar <- assertEither $ mkRelationFromList (attributesFromList [Attribute "conflict" IntAtomType]) []

254− let conflictContextA = updatedBranchAContext {relationVariables = M.insert branchBOnlyRelVarName (ExistingRelation conflictRelVar) (relationVariables updatedBranchAContext) }

225+ let conflictContextA = updatedBranchAContext {relationVariables = M.insert branchBOnlyRelVarName conflictRelVar (relationVariables updatedBranchAContext) }

255 conflictBranchATrans <- assertMaybe (transactionForHead "branchA" graph'') "retrieving head transaction for expected conflict"

226 conflictBranchATrans <- assertMaybe (transactionForHead "branchA" graph'') "retrieving head transaction for expected conflict"

256− (_, graph''') <- addTransaction "branchA" (createTrans (fakeUUID 6) (TI.singleParent (transactionId conflictBranchATrans) testTime) conflictContextA) graph''

227+ (_, graph''') <- addTransaction "branchA" (createTrans (fakeUUID 6) (TransactionInfo (transactionId conflictBranchATrans) S.empty testTime) conflictContextA) graph''

257− let failingMerge = runGraphRefRelationalExprM gfEnv' $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB")

228+ let failingMerge = mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB") graph'''

258− gfEnv' = freshGraphRefRelationalExprEnv Nothing graph'''

259 case failingMerge of

229 case failingMerge of

260 Right _ -> assertFailure "expected merge failure"

230 Right _ -> assertFailure "expected merge failure"

261 Left err -> assertEqual "merge failure" err (MergeTransactionError StrategyViolatesRelationVariableMergeError)

231 Left err -> assertEqual "merge failure" err (MergeTransactionError StrategyViolatesRelationVariableMergeError)

@@ -274,21 +244,20 @@ testUnionMergeIncDepViolation = TestCase $ do

274 rvName = "x"

244 rvName = "x"

275 Right branchArv = eRel 2

245 Right branchArv = eRel 2

276 Right branchBrv = eRel 3

246 Right branchBrv = eRel 3

277− branchAContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.singleton rvName (ExistingRelation branchArv)}

247+ branchAContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.singleton rvName branchArv}

278− branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.singleton rvName (ExistingRelation branchBrv),

248+ branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.singleton rvName branchBrv,

279 inclusionDependencies = M.singleton incDepName incDep}

249 inclusionDependencies = M.singleton incDepName incDep}

280 incDepName = "x_key"

250 incDepName = "x_key"

281 incDep = inclusionDependencyForKey (AttributeNames (S.singleton "x")) (RelationVariable "x" ())

251 incDep = inclusionDependencyForKey (AttributeNames (S.singleton "x")) (RelationVariable "x" ())

282

252

283

253

284 --add the rv in new commits to both branches

254 --add the rv in new commits to both branches

285− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) branchBContext) graph

255+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans) S.empty testTime) branchBContext) graph

286

256

287− (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchATrans) testTime) branchAContext) graph'

257+ (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchATrans) S.empty testTime) branchAContext) graph'

288

258

289 --check that the union merge fails due to a violated constraint

259 --check that the union merge fails due to a violated constraint

290− let eMerge = runGraphRefRelationalExprM env $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB")

260+ let eMerge = mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB") graph''

291− env = freshGraphRefRelationalExprEnv Nothing graph''

292 case eMerge of

261 case eMerge of

293 Left (InclusionDependencyCheckError incDepName') -> assertEqual "incdep violation name" incDepName incDepName'

262 Left (InclusionDependencyCheckError incDepName') -> assertEqual "incdep violation name" incDepName incDepName'

294 Left err -> assertFailure ("other error: " ++ show err)

263 Left err -> assertFailure ("other error: " ++ show err)

test/TransactionGraph/Persist.hs+15−79

@@ -1,14 +1,14 @@

1−{-# LANGUAGE CPP #-}

2import Test.HUnit

1import Test.HUnit

3import ProjectM36.Base

2import ProjectM36.Base

4import ProjectM36.Persist (DiskSync(NoDiskSync))

3import ProjectM36.Persist (DiskSync(NoDiskSync))

5import ProjectM36.TransactionGraph.Persist

4import ProjectM36.TransactionGraph.Persist

6−import ProjectM36.TransactionGraph as TG

5+import ProjectM36.TransactionGraph

7import ProjectM36.Transaction

6import ProjectM36.Transaction

8import ProjectM36.DateExamples

7import ProjectM36.DateExamples

8+import ProjectM36.Client

9+import ProjectM36.Relation

9import System.IO.Temp

10import System.IO.Temp

10import System.Exit

11import System.Exit

11−import System.Directory

12import Data.Either

13import Data.UUID.V4 (nextRandom)

14import System.FilePath

@@ -17,9 +17,6 @@ import qualified Data.Map as M

17import qualified Data.Set as S

18import Data.Time.Clock

19import Data.Time.Calendar

20−import ProjectM36.Client as C

21−import ProjectM36.Relation

22−import ProjectM36.Transaction.Persist

23

20

24main :: IO ()

21main :: IO ()

25main = do

22main = do

@@ -29,12 +26,11 @@ main = do

29testList :: Test

26testList :: Test

30testList = TestList [testBootstrapDB,

27testList = TestList [testBootstrapDB,

31 testDBSimplePersistence,

28 testDBSimplePersistence,

32− testFunctionPersistence,

29+ testFunctionPersistence]

33− testMerkleHashValidation]

34

30

35

31

36−stamp' :: UTCTime

32+stamp :: UTCTime

37−stamp' = UTCTime (fromGregorian 1980 01 01) (secondsToDiffTime 1000)

33+stamp = UTCTime (fromGregorian 1980 01 01) (secondsToDiffTime 1000)

38

34

39{- bootstrap a database, ensure that it can be read -}

35{- bootstrap a database, ensure that it can be read -}

40testBootstrapDB :: Test

36testBootstrapDB :: Test

@@ -42,7 +38,7 @@ testBootstrapDB = TestCase $ withSystemTempDirectory "m36testdb" $ \tempdir -> d

42 let dbdir = tempdir </> "dbdir"

38 let dbdir = tempdir </> "dbdir"

43 freshId <- nextRandom

39 freshId <- nextRandom

44

40

45− _ <- bootstrapDatabaseDir NoDiskSync dbdir (bootstrapTransactionGraph stamp' freshId dateExamples)

41+ _ <- bootstrapDatabaseDir NoDiskSync dbdir (bootstrapTransactionGraph stamp freshId dateExamples)

46 loadedGraph <- transactionGraphLoad dbdir emptyTransactionGraph Nothing

42 loadedGraph <- transactionGraphLoad dbdir emptyTransactionGraph Nothing

47 assertBool "transactionGraphLoad" $ isRight loadedGraph

43 assertBool "transactionGraphLoad" $ isRight loadedGraph

48

44

@@ -52,17 +48,17 @@ testDBSimplePersistence = TestCase $ withSystemTempDirectory "m36testdb" $ \temp

52 let dbdir = tempdir </> "dbdir"

48 let dbdir = tempdir </> "dbdir"

53 freshId <- nextRandom

49 freshId <- nextRandom

54

50

55− let graph = bootstrapTransactionGraph stamp' freshId dateExamples

51+ let graph = bootstrapTransactionGraph stamp freshId dateExamples

56 _ <- bootstrapDatabaseDir NoDiskSync dbdir graph

52 _ <- bootstrapDatabaseDir NoDiskSync dbdir graph

57 case transactionForHead "master" graph of

53 case transactionForHead "master" graph of

58 Nothing -> assertFailure "Failed to retrieve head transaction for master branch."

54 Nothing -> assertFailure "Failed to retrieve head transaction for master branch."

59 Just headTrans ->

55 Just headTrans ->

60− case interpretDatabaseContextExpr (concreteDatabaseContext headTrans) (transactionId headTrans) graph "x:=s" of

56+ case interpretDatabaseContextExpr (concreteDatabaseContext headTrans) "x:=s" of

61 Left err -> assertFailure (show err)

57 Left err -> assertFailure (show err)

62 Right context' -> do

58 Right context' -> do

63 freshId' <- nextRandom

59 freshId' <- nextRandom

64− let newdiscon = DisconnectedTransaction (transactionId headTrans) (Schemas context' M.empty) False

60+ let newdiscon = DisconnectedTransaction (transactionId headTrans) (Schemas context' M.empty) True

65− addTrans = addDisconnectedTransaction stamp' freshId' "master" newdiscon graph

61+ addTrans = addDisconnectedTransaction stamp freshId' "master" newdiscon graph

66 --add a transaction to the graph

62 --add a transaction to the graph

67 case addTrans of

63 case addTrans of

68 Left err -> assertFailure (show err)

64 Left err -> assertFailure (show err)

@@ -75,69 +71,11 @@ testDBSimplePersistence = TestCase $ withSystemTempDirectory "m36testdb" $ \temp

75 case graphErr of

71 case graphErr of

76 Left err -> assertFailure (show err)

72 Left err -> assertFailure (show err)

77 Right graph'' -> assertBool "graph equality" (mapEq graph'' == mapEq graph')

73 Right graph'' -> assertBool "graph equality" (mapEq graph'' == mapEq graph')

78−

74+

79−testMerkleHashValidation :: Test

80−testMerkleHashValidation = TestCase $

81− -- add a commit and validate the hashes successfully

82− withSystemTempDirectory "m36testdb" $ \tempdir -> do

83− let dbdir = tempdir </> "dbdir"

84− connInfo = InProcessConnectionInfo (MinimalPersistence dbdir) emptyNotificationCallback []

85− conn <- assertIOEither $ connectProjectM36 connInfo

86− sess <- assertIOEither $ createSessionAtHead conn "master"

87− Right _ <- executeDatabaseContextExpr sess conn (Assign "x" (ExistingRelation relationTrue))

88− Right _ <- commit sess conn

89− val <- C.validateMerkleHashes sess conn

90− assertEqual "merkle success" (Right ()) val

91−

92− --read graph from disk

93− conn' <- assertIOEither $ connectProjectM36 connInfo

94− sess' <- assertIOEither $ createSessionAtHead conn' "master"

95−

96− val' <- C.validateMerkleHashes sess' conn'

97− assertEqual "merkle read again success" (Right ()) val'

98−

99− --alter the on-disk representation and check that the hash validation fails

100− eGraph <- transactionGraphLoad dbdir emptyTransactionGraph Nothing

101− case eGraph of

102− Left err -> assertFailure $ "failed to load graph" ++ show err

103− Right graph -> do

104− let trans = transactionHeadsForGraph graph M.! "master"

105− updatedTrans = Transaction (transactionId trans) (transactionInfo trans) updatedSchemas

106− transactionDir' = dbdir </> show (transactionId trans)

107− updatedSchemas =

108− case schemas trans of

109− Schemas ctx sschemas ->

110− let updatedContext = ctx {

111− relationVariables = M.insert "malicious" (ExistingRelation relationFalse) (relationVariables ctx)

112− } in

113− Schemas updatedContext sschemas

114− maliciousGraph = TransactionGraph malHeads malTransSet

115− malHeads = M.insert "master" updatedTrans (transactionHeadsForGraph graph)

116− malTransSet = S.insert updatedTrans (transactionsForGraph graph)

117− malMerkleHash = calculateMerkleHash updatedTrans maliciousGraph

118− regMerkleHash = merkleHash (transactionInfo trans)

119− --validate and fail

120− let val'' = TG.validateMerkleHashes maliciousGraph

121− assertEqual "loaded graph merkle hashes" (Left [MerkleValidationError (transactionId trans) regMerkleHash malMerkleHash]) val''

122− --delete existing transaction directory

123− removeDirectoryRecursive transactionDir'

124− writeTransaction NoDiskSync dbdir updatedTrans

125−

126− --read graph from disk

127− eConnFail <- connectProjectM36 connInfo

128− case eConnFail of

129− Left err ->

130− assertEqual "open connection merkle validation" (DatabaseValidationError [MerkleValidationError (transactionId trans) regMerkleHash malMerkleHash]) err

131− Right _ -> assertFailure "open connection validation"

132−

133−

134

75

135--only Haskell-scripted dbc and atom functions can be serialized

76--only Haskell-scripted dbc and atom functions can be serialized

136testFunctionPersistence :: Test

77testFunctionPersistence :: Test

137−#if !defined(PM36_HASKELL_SCRIPTING)

138−testFunctionPersistence = TestCase $ pure ()

78+testFunctionPersistence = TestCase $

139−#else

140−testFunctionPersistence = TestCase $

141 withSystemTempDirectory "m36testdb" $ \tempdir -> do

79 withSystemTempDirectory "m36testdb" $ \tempdir -> do

142 let dbdir = tempdir </> "dbdir"

80 let dbdir = tempdir </> "dbdir"

143 connInfo = InProcessConnectionInfo (MinimalPersistence dbdir) emptyNotificationCallback []

81 connInfo = InProcessConnectionInfo (MinimalPersistence dbdir) emptyNotificationCallback []

@@ -155,12 +93,10 @@ testFunctionPersistence = TestCase $

155 conn2 <- assertIOEither $ connectProjectM36 connInfo

93 conn2 <- assertIOEither $ connectProjectM36 connInfo

156 sess2 <- assertIOEither $ createSessionAtHead conn2 "master"

94 sess2 <- assertIOEither $ createSessionAtHead conn2 "master"

157

95

158− res <- executeRelationalExpr sess2 conn2 (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (M.singleton "a" (FunctionAtomExpr "testdisk" [NakedAtomExpr (IntAtom 3)] ()))]))

96+ res <- executeRelationalExpr sess2 conn2 (MakeRelationFromExprs Nothing [TupleExpr (M.singleton "a" (FunctionAtomExpr "testdisk" [NakedAtomExpr (IntAtom 3)] ()))])

159 let expectedRel = mkRelationFromList (attributesFromList [Attribute "a" IntAtomType]) [[IntAtom 3]]

97 let expectedRel = mkRelationFromList (attributesFromList [Attribute "a" IntAtomType]) [[IntAtom 3]]

160 assertEqual "testdisk dbc function run" expectedRel res

98 assertEqual "testdisk dbc function run" expectedRel res

161−

99+

162−#endif

163−

164assertIOEither :: (Show a) => IO (Either a b) -> IO b

100assertIOEither :: (Show a) => IO (Either a b) -> IO b

165assertIOEither x = do

101assertIOEither x = do

166 ret <- x

102 ret <- x

test/TutorialD/InterpreterTest.hs → test/TutorialD/Interpreter.hsrenamed+27−115

@@ -9,7 +9,6 @@ import ProjectM36.TupleSet

9import ProjectM36.Error

10import ProjectM36.DatabaseContext

11import ProjectM36.AtomFunctions.Primitive

12−import ProjectM36.RelationalExpression

13import ProjectM36.DataTypes.Either

12import ProjectM36.DataTypes.Either

14import ProjectM36.DataTypes.Interval

13import ProjectM36.DataTypes.Interval

15import ProjectM36.DataTypes.NonEmptyList

14import ProjectM36.DataTypes.NonEmptyList

@@ -40,9 +39,8 @@ main = do

40 tcounts <- runTestTT (TestList tests)

39 tcounts <- runTestTT (TestList tests)

41 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

40 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

42 where

41 where

43− tests = [

42+ tests = map (\(tutd, expected) -> TestCase $ assertTutdEqual basicDatabaseContext expected tutd) simpleRelTests ++

44− simpleRelTests,

43+ map (\(tutd, expected) -> TestCase $ assertTutdEqual dateExamples expected tutd) dateExampleRelTests ++ [

45− dateExampleRelTests,

46 transactionGraphBasicTest,

44 transactionGraphBasicTest,

47 transactionGraphAddCommitTest,

45 transactionGraphAddCommitTest,

48 transactionRollbackTest,

46 transactionRollbackTest,

@@ -75,22 +73,9 @@ main = do

75 testNonEmptyListType,

73 testNonEmptyListType,

76 testUnresolvedAtomTypes,

74 testUnresolvedAtomTypes,

77 testWithClause,

75 testWithClause,

78− testAtomFunctionArgumentMismatch,

76+ testAtomFunctionArgumentMismatch

79− testInvalidDataConstructor,

80− testBasicList,

81− testRelationDeclarationMismatch,

82− testInvalidTuples,

83− testSelfReferencingUncommittedContext,

84− testUnionAndIntersectionAttributeExprs

85 ]

77 ]

86−

87−simpleRelTests :: Test

88−simpleRelTests = TestCase $ do

89− (graph, transId) <- freshTransactionGraph dateExamples

90− mapM_ (\(tutd, expected) ->

91− assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups

92− where

93− testTups = [("x:=true", Right relationTrue),

78+ simpleRelTests = [("x:=true", Right relationTrue),

94 ("x:=false", Right relationFalse),

79 ("x:=false", Right relationFalse),

95 ("x:=true union false", Right relationTrue),

80 ("x:=true union false", Right relationTrue),

96 ("x:=true minus false", Right relationTrue),

81 ("x:=true minus false", Right relationTrue),

@@ -123,39 +108,31 @@ simpleRelTests = TestCase $ do

123 ("x:=relation{tuple{a 5}} : {b:=6}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 6])]),

108 ("x:=relation{tuple{a 5}} : {b:=6}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 6])]),

124 ("x:=relation{tuple{a 5}} : {b:=add(@a,5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 10])]),

109 ("x:=relation{tuple{a 5}} : {b:=add(@a,5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 10])]),

125 ("x:=relation{tuple{a 5}} : {b:=add(@a,\"spam\")}", Left (AtomFunctionTypeError "add" 2 IntegerAtomType TextAtomType)),

110 ("x:=relation{tuple{a 5}} : {b:=add(@a,\"spam\")}", Left (AtomFunctionTypeError "add" 2 IntegerAtomType TextAtomType)),

126− ("x:=relation{tuple{a 5}} : {b:=add(add(@a,2),5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 12])]),

111+ ("x:=relation{tuple{a 5}} : {b:=add(add(@a,2),5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 12])])

127− ("x:=false:{a:=1,b:=2}", mkRelationFromTuples simpleDAttributes [])

128 ]

112 ]

129 simpleAAttributes = A.attributesFromList [Attribute "a" IntegerAtomType]

113 simpleAAttributes = A.attributesFromList [Attribute "a" IntegerAtomType]

130 simpleBAttributes = A.attributesFromList [Attribute "d" IntegerAtomType]

114 simpleBAttributes = A.attributesFromList [Attribute "d" IntegerAtomType]

131 simpleCAttributes = A.attributesFromList [Attribute "a" TextAtomType, Attribute "b" IntegerAtomType]

115 simpleCAttributes = A.attributesFromList [Attribute "a" TextAtomType, Attribute "b" IntegerAtomType]

132 simpleDAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" IntegerAtomType]

116 simpleDAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" IntegerAtomType]

133− simpleProjectionAttributes = A.attributesFromList [Attribute "c" IntegerAtomType]

134− nestedRelationAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" (RelationAtomType $ A.attributesFromList [Attribute "a" IntegerAtomType])]

135−

136−dateExampleRelTests :: Test

137−dateExampleRelTests = TestCase $ do

138− (graph, transId) <- freshTransactionGraph dateExamples

139− mapM_ (\(tutd, expected) ->

140− assertTutdEqual dateExamples transId graph expected tutd) testTups

141− where

142− simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]

143− maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)

144 maybeTextAtomType = ConstructedAtomType "Maybe" (M.singleton "a" TextAtomType)

117 maybeTextAtomType = ConstructedAtomType "Maybe" (M.singleton "a" TextAtomType)

118+ maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)

145 simpleMaybeTextAttributes = A.attributesFromList [Attribute "a" maybeTextAtomType]

119 simpleMaybeTextAttributes = A.attributesFromList [Attribute "a" maybeTextAtomType]

146 simpleMaybeIntAttributes = A.attributesFromList [Attribute "a" maybeIntegerAtomType]

120 simpleMaybeIntAttributes = A.attributesFromList [Attribute "a" maybeIntegerAtomType]

121+ simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]

122+ simpleProjectionAttributes = A.attributesFromList [Attribute "c" IntegerAtomType]

123+ nestedRelationAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" (RelationAtomType $ A.attributesFromList [Attribute "a" IntegerAtomType])]

124+ extendTestAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" $ RelationAtomType (R.attributes suppliersRel)]

147 byteStringAttributes = A.attributesFromList [Attribute "y" ByteStringAtomType]

125 byteStringAttributes = A.attributesFromList [Attribute "y" ByteStringAtomType]

148− minMaxAttrs = A.attributesFromList [Attribute "s#" TextAtomType, Attribute "z" IntegerAtomType]

149 groupCountAttrs = A.attributesFromList [Attribute "z" IntegerAtomType]

126 groupCountAttrs = A.attributesFromList [Attribute "z" IntegerAtomType]

127+ minMaxAttrs = A.attributesFromList [Attribute "s#" TextAtomType, Attribute "z" IntegerAtomType]

150 updateParisPlus10 = relMap (\tuple -> do

128 updateParisPlus10 = relMap (\tuple -> do

151 statusAtom <- atomForAttributeName "status" tuple

129 statusAtom <- atomForAttributeName "status" tuple

152 cityAtom <- atomForAttributeName "city" tuple

130 cityAtom <- atomForAttributeName "city" tuple

153 if cityAtom == TextAtom "Paris" then

131 if cityAtom == TextAtom "Paris" then

154 Right $ updateTupleWithAtoms (M.singleton "status" (IntegerAtom (castInteger statusAtom + 10))) tuple

132 Right $ updateTupleWithAtoms (M.singleton "status" (IntegerAtom (castInteger statusAtom + 10))) tuple

155 else Right tuple) suppliersRel

133 else Right tuple) suppliersRel

156− extendTestAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" $ RelationAtomType (R.attributes suppliersRel)]

157− testTups = [("x:=s where true", Right suppliersRel),

134+ dateExampleRelTests = [("x:=s where true", Right suppliersRel),

158− ("x:=s where city = \"London\"", restrict (\tuple -> pure $ atomForAttributeName "city" tuple == Right (TextAtom "London")) suppliersRel),

135+ ("x:=s where city = \"London\"", restrict (\tuple -> pure $ atomForAttributeName "city" tuple == (Right $ TextAtom "London")) suppliersRel),

159 ("x:=s where false", Right $ Relation (R.attributes suppliersRel) emptyTupleSet),

136 ("x:=s where false", Right $ Relation (R.attributes suppliersRel) emptyTupleSet),

160 ("x:=p where color=\"Blue\" and city=\"Paris\"", mkRelationFromList (R.attributes productsRel) [[TextAtom "P5", TextAtom "Cam", TextAtom "Blue", IntegerAtom 12, TextAtom "Paris"]]),

137 ("x:=p where color=\"Blue\" and city=\"Paris\"", mkRelationFromList (R.attributes productsRel) [[TextAtom "P5", TextAtom "Cam", TextAtom "Blue", IntegerAtom 12, TextAtom "Paris"]]),

161 ("a:=s; update a (status:=50); x:=a{status}", mkRelation (A.attributesFromList [Attribute "status" IntegerAtomType]) (RelationTupleSet [mkRelationTuple (A.attributesFromList [Attribute "status" IntegerAtomType]) (V.fromList [IntegerAtom 50])])),

138 ("a:=s; update a (status:=50); x:=a{status}", mkRelation (A.attributesFromList [Attribute "status" IntegerAtomType]) (RelationTupleSet [mkRelationTuple (A.attributesFromList [Attribute "status" IntegerAtomType]) (V.fromList [IntegerAtom 50])])),

@@ -163,7 +140,7 @@ dateExampleRelTests = TestCase $ do

163 --atom function tests

140 --atom function tests

164 ("x:=((s : {status2 := add(10,@status)}) where status2=add(10,@status)){city,s#,sname,status}", Right suppliersRel),

141 ("x:=((s : {status2 := add(10,@status)}) where status2=add(10,@status)){city,s#,sname,status}", Right suppliersRel),

165 ("x:=relation{tuple{a 5}} : {b:=s}", mkRelation extendTestAttributes (RelationTupleSet [mkRelationTuple extendTestAttributes (V.fromList [IntegerAtom 5, RelationAtom suppliersRel])])),

142 ("x:=relation{tuple{a 5}} : {b:=s}", mkRelation extendTestAttributes (RelationTupleSet [mkRelationTuple extendTestAttributes (V.fromList [IntegerAtom 5, RelationAtom suppliersRel])])),

166− ("x:=s; update x where sname=\"Blake\" (city:=\"Boston\")", relMap (\tuple -> if atomForAttributeName "sname" tuple == Right (TextAtom "Blake") then Right $ updateTupleWithAtoms (M.singleton "city" (TextAtom "Boston")) tuple else Right tuple) suppliersRel),

143+ ("x:=s; update x where sname=\"Blake\" (city:=\"Boston\")", relMap (\tuple -> if atomForAttributeName "sname" tuple == (Right $ TextAtom "Blake") then Right $ updateTupleWithAtoms (M.singleton "city" (TextAtom "Boston")) tuple else Right tuple) suppliersRel),

167 ("x:=s; update x where city=\"Paris\" (status:=add(@status,10))", updateParisPlus10),

144 ("x:=s; update x where city=\"Paris\" (status:=add(@status,10))", updateParisPlus10),

168 --relatom function tests

145 --relatom function tests

169 ("x:=((s group ({city} as y)):{z:=count(@y)}){z}", mkRelation groupCountAttrs (RelationTupleSet [mkRelationTuple groupCountAttrs (V.singleton $ IntegerAtom 1)])),

146 ("x:=((s group ({city} as y)):{z:=count(@y)}){z}", mkRelation groupCountAttrs (RelationTupleSet [mkRelationTuple groupCountAttrs (V.singleton $ IntegerAtom 1)])),

@@ -197,17 +174,14 @@ dateExampleRelTests = TestCase $ do

197 ("x:=relation{tuple{a fromGregorian(2017,05,30)}}", mkRelationFromList (A.attributesFromList [Attribute "a" DayAtomType]) [[DayAtom (fromGregorian 2017 05 30)]])

174 ("x:=relation{tuple{a fromGregorian(2017,05,30)}}", mkRelationFromList (A.attributesFromList [Attribute "a" DayAtomType]) [[DayAtom (fromGregorian 2017 05 30)]])

198 ]

175 ]

199

176

200−assertTutdEqual :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError Relation -> Text -> Assertion

177+assertTutdEqual :: DatabaseContext -> Either RelationalError Relation -> Text -> Assertion

201−assertTutdEqual databaseContext transId graph expected tutd = assertEqual (unpack tutd) expected interpreted

178+assertTutdEqual databaseContext expected tutd = assertEqual (unpack tutd) expected interpreted

202 where

179 where

203− interpreted = case interpretDatabaseContextExpr databaseContext transId graph tutd of

180+ interpreted = case interpretDatabaseContextExpr databaseContext tutd of

204 Left err -> Left err

181 Left err -> Left err

205 Right context -> case M.lookup "x" (relationVariables context) of

182 Right context -> case M.lookup "x" (relationVariables context) of

206 Nothing -> Left $ RelVarNotDefinedError "x"

183 Nothing -> Left $ RelVarNotDefinedError "x"

207− Just relExpr -> do

184+ Just rel -> Right rel

208− let env = freshGraphRefRelationalExprEnv (Just context) graph

209− runGraphRefRelationalExprM env (evalGraphRefRelationalExpr relExpr)

210−

211

185

212transactionGraphBasicTest :: Test

186transactionGraphBasicTest :: Test

213transactionGraphBasicTest = TestCase $ do

187transactionGraphBasicTest = TestCase $ do

@@ -235,7 +209,7 @@ transactionGraphAddCommitTest = TestCase $ do

235 commit sessionId dbconn >>= eitherFail

209 commit sessionId dbconn >>= eitherFail

236 discon <- disconnectedTransaction_ sessionId dbconn

210 discon <- disconnectedTransaction_ sessionId dbconn

237 let context = Discon.concreteDatabaseContext discon

211 let context = Discon.concreteDatabaseContext discon

238− assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just (ExistingRelation suppliersRel))

212+ assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just suppliersRel)

239

213

240transactionRollbackTest :: Test

214transactionRollbackTest :: Test

241transactionRollbackTest = TestCase $ do

215transactionRollbackTest = TestCase $ do

@@ -277,16 +251,12 @@ transactionBranchTest = TestCase $ do

277

251

278-- test that overlapping attribute names with different types fail with an error

252-- test that overlapping attribute names with different types fail with an error

279failJoinTest :: Test

253failJoinTest :: Test

280−failJoinTest = TestCase $ do

281− (graph, transId) <- freshTransactionGraph dateExamples

282− assertTutdEqual basicDatabaseContext transId graph err "x:=relation{tuple{test 4}} join relation{tuple{test \"test\"}}"

254+failJoinTest = TestCase $ assertTutdEqual basicDatabaseContext err "x:=relation{tuple{test 4}} join relation{tuple{test \"test\"}}"

283 where

255 where

284 err = Left (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "test" IntegerAtomType]))

256 err = Left (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "test" IntegerAtomType]))

285

257

286simpleJoinTest :: Test

258simpleJoinTest :: Test

287−simpleJoinTest = TestCase $ do

288− (graph, transId) <- freshTransactionGraph dateExamples

289− assertTutdEqual dateExamples transId graph joinedRel "x:=s join sp"

259+simpleJoinTest = TestCase $ assertTutdEqual dateExamples joinedRel "x:=s join sp"

290 where

260 where

291 attrs = A.attributesFromList [Attribute "city" TextAtomType,

261 attrs = A.attributesFromList [Attribute "city" TextAtomType,

292 Attribute "qty" IntegerAtomType,

262 Attribute "qty" IntegerAtomType,

@@ -362,7 +332,7 @@ testComments :: Test

362testComments = TestCase $ do

332testComments = TestCase $ do

363 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

333 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

364 mapM_ (executeTutorialD sessionId dbconn) [

334 mapM_ (executeTutorialD sessionId dbconn) [

365− ":branch testbranch --test comment",

335+ ":branch testbranch --test comment\n",

366 ":jumphead {- test comment -} master"]

336 ":jumphead {- test comment -} master"]

367

337

368-- create a graph and query from two disparate contexts

338-- create a graph and query from two disparate contexts

@@ -413,9 +383,7 @@ testTransGraphRelationalExpr = TestCase $ do

413 _ -> assertFailure "failed to delete branch"

383 _ -> assertFailure "failed to delete branch"

414

384

415testMultiAttributeRename :: Test

385testMultiAttributeRename :: Test

416−testMultiAttributeRename = TestCase $ do

417− (graph, transId) <- freshTransactionGraph dateExamples

418− assertTutdEqual dateExamples transId graph renamedRel "x:=s rename {city as town, status as price} where false"

386+testMultiAttributeRename = TestCase $ assertTutdEqual dateExamples renamedRel "x:=s rename {city as town, status as price} where false"

419 where

387 where

420 sattrs = attributesFromList [Attribute "town" TextAtomType,

388 sattrs = attributesFromList [Attribute "town" TextAtomType,

421 Attribute "sname" TextAtomType,

389 Attribute "sname" TextAtomType,

@@ -500,22 +468,16 @@ testEmptyCommits = TestCase $ do

500 assertEqual "empty insert empty commit" (Right False) dirty'

468 assertEqual "empty insert empty commit" (Right False) dirty'

501 Right () <- commit sessionId dbconn

469 Right () <- commit sessionId dbconn

502

470

503− --update no tuples- since we defer the restriction, we can only assume the context is dirty, perhaps the constraint checker could offer an optimization here

471+ --update no tuples

504 Right () <- executeDatabaseContextExpr sessionId dbconn (Update "s" (M.singleton "sname" (NakedAtomExpr (TextAtom "Bob"))) (AttributeEqualityPredicate "sname" (NakedAtomExpr (TextAtom "Mike"))))

472 Right () <- executeDatabaseContextExpr sessionId dbconn (Update "s" (M.singleton "sname" (NakedAtomExpr (TextAtom "Bob"))) (AttributeEqualityPredicate "sname" (NakedAtomExpr (TextAtom "Mike"))))

505 dirty'' <- disconnectedTransactionIsDirty sessionId dbconn

473 dirty'' <- disconnectedTransactionIsDirty sessionId dbconn

506− assertEqual "empty update empty commit" (Right True) dirty''

474+ assertEqual "empty update empty commit" (Right False) dirty''

507− Right () <- commit sessionId dbconn

508−

509− --assign the same rel expr

510− Right () <- executeDatabaseContextExpr sessionId dbconn (Assign "true" (ExistingRelation relationTrue))

511− sameREdirty <- disconnectedTransactionIsDirty sessionId dbconn

512− assertEqual "same relexpr assigned" (Right False) sameREdirty

513 Right () <- commit sessionId dbconn

475 Right () <- commit sessionId dbconn

514

476

515 --delete no tuples

477 --delete no tuples

516 Right () <- executeDatabaseContextExpr sessionId dbconn (Delete "s" (AttributeEqualityPredicate "sname" (NakedAtomExpr (TextAtom "Mike"))))

478 Right () <- executeDatabaseContextExpr sessionId dbconn (Delete "s" (AttributeEqualityPredicate "sname" (NakedAtomExpr (TextAtom "Mike"))))

517 dirty''' <- disconnectedTransactionIsDirty sessionId dbconn

479 dirty''' <- disconnectedTransactionIsDirty sessionId dbconn

518− assertEqual "empty delete empty commit" (Right True) dirty'''

480+ assertEqual "empty delete empty commit" (Right False) dirty'''

519

481

520testIntervalAtom :: Test

482testIntervalAtom :: Test

521testIntervalAtom = TestCase $ do

483testIntervalAtom = TestCase $ do

@@ -545,7 +507,7 @@ testListConstructedAtom = TestCase $ do

545testTypeChecker :: Test

507testTypeChecker :: Test

546testTypeChecker = TestCase $ do

508testTypeChecker = TestCase $ do

547 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

509 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

548− let err1 = "AtomFunctionTypeError \"max\" 1"

510+ let err1 = "AtomFunctionTypeError \"max\" 1 (RelationAtomType [Attribute \"_\" IntegerAtomType]) IntegerAtomType"

549 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"

511 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"

550

512

551--exercise expression parser

513--exercise expression parser

@@ -665,10 +627,6 @@ testWithClause = TestCase $ do

665 executeTutorialD sessionId dbconn "x:=with (x as s) x"

627 executeTutorialD sessionId dbconn "x:=with (x as s) x"

666 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

628 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

667 assertEqual "with x as s" (Right suppliersRel) eX

629 assertEqual "with x as s" (Right suppliersRel) eX

668−

669− executeTutorialD sessionId dbconn "y:=with(a as true) (with (b as a) b)"

670− eY <- executeRelationalExpr sessionId dbconn (RelationVariable "y" ())

671− assertEqual "nested with" (Right relationTrue) eY

672

630

673 let err1 = "RelVarAlreadyDefinedError"

631 let err1 = "RelVarAlreadyDefinedError"

674 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"

632 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"

@@ -684,49 +642,3 @@ testAtomFunctionArgumentMismatch = TestCase $ do

684 --wrong argument count

642 --wrong argument count

685 let err2 = "FunctionArgumentCountMismatchError"

643 let err2 = "FunctionArgumentCountMismatchError"

686 expectTutorialDErr sessionId dbconn (T.isPrefixOf err2) "x:=relation{tuple{a 5}} where ^gt(@a,1,3)"

644 expectTutorialDErr sessionId dbconn (T.isPrefixOf err2) "x:=relation{tuple{a 5}} where ^gt(@a,1,3)"

687−

688−testInvalidDataConstructor :: Test

689−testInvalidDataConstructor = TestCase $ do

690− --test that a referenced TypeConstructor in a DataConstructor definition matches the expected count of arguments

691− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

692− let err1 = "ConstructedAtomArgumentCountMismatchError"

693− expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "data TestT = TestT Maybe Int"

694−

695−testBasicList :: Test

696−testBasicList = TestCase $ do

697− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

698− executeTutorialD sessionId dbconn "x := relation{tuple{ a (Cons 1 (Cons 2 Empty)) }}"

699−

700−testRelationDeclarationMismatch :: Test

701−testRelationDeclarationMismatch = TestCase $ do

702− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

703− expectTutorialDErr sessionId dbconn (T.isPrefixOf "AtomTypeMismatchError") "data A a = A a | B | C; a := relation{a A Integer}{tuple{a A \"1\"}}"

704−

705−--generate errors when the tuples in a new relation don't match

706−testInvalidTuples :: Test

707−testInvalidTuples = TestCase $ do

708− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

709− expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{b 2}}"

710− expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{a 2, b 3}}"

711−-- expectTutorialDErr sessionId dbconn (T.isPrefixOf "ParseErrorBundle") ":showexpr relation{tuple{a 2, a 3}}" --parse failure can't be validated with this function

712−

713−testSelfReferencingUncommittedContext :: Test

714−testSelfReferencingUncommittedContext = TestCase $ do

715− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

716− executeTutorialD sessionId dbconn "s:=s union s"

717− eS <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())

718− _ <- rollback sessionId dbconn

719− eSorig <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())

720− assertEqual "s=s'" eSorig eS

721−

722−testUnionAndIntersectionAttributeExprs :: Test

723−testUnionAndIntersectionAttributeExprs = TestCase $ do

724− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

725− executeTutorialD sessionId dbconn "x:=s{intersection of {all but sname} {sname}}"

726− xRel <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

727− assertEqual "intersection attrs" (Right relationTrue) xRel

728−

729− executeTutorialD sessionId dbconn "y:=s{union of {all but sname} {sname}}"

730− yRel <- executeRelationalExpr sessionId dbconn (RelationVariable "y" ())

731− assertEqual "union attrs" (Right suppliersRel) yRel

732−

test/TutorialD/Interpreter/AtomFunctionScript.hs+17−25

@@ -1,32 +1,25 @@

1−{-# LANGUAGE CPP #-}

1+import TutorialD.Interpreter.TestBase

2import System.Exit

3import Test.HUnit

4−#ifdef PM36_HASKELL_SCRIPTING

5−import TutorialD.Interpreter.TestBase

6import ProjectM36.Client

4import ProjectM36.Client

7import ProjectM36.Relation

5import ProjectM36.Relation

8import ProjectM36.DataTypes.Maybe

6import ProjectM36.DataTypes.Maybe

9import qualified Data.Vector as V

7import qualified Data.Vector as V

10import qualified Data.Map as M

8import qualified Data.Map as M

11−#endif

12

9

13{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}

10{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}

14main :: IO ()

11main :: IO ()

15main = do

12main = do

16− tcounts <- runTestTT (TestList [

13+ tcounts <- runTestTT (TestList [testBasicAtomFunction,

17−#ifdef PM36_HASKELL_SCRIPTING

18− testBasicAtomFunction,

19− testExceptionAtomFunction,

14+ testExceptionAtomFunction,

20− testErrorAtomFunction,

15+ testErrorAtomFunction,

21− testNoArgumentAtomFunction,

16+ testNoArgumentAtomFunction,

22− testArgumentTypeMismatch,

17+ testArgumentTypeMismatch,

23− testPolymorphicReturnType,

18+ testPolymorphicReturnType,

24− testScriptedTypeVariable

19+ testScriptedTypeVariable

25−#endif

26− ])

20+ ])

27 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

21 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

28

22

29−#ifdef PM36_HASKELL_SCRIPTING

30--add an atom function and run it

23--add an atom function and run it

31testBasicAtomFunction :: Test

24testBasicAtomFunction :: Test

32testBasicAtomFunction = TestCase $ do

25testBasicAtomFunction = TestCase $ do

@@ -36,7 +29,7 @@ testBasicAtomFunction = TestCase $ do

36 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()

29 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()

37 tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]

30 tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]

38 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 3]]

31 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 3]]

39− result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) (TupleExprs () tupleExprs))

32+ result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

40

33

41 assertEqual "simple atom function equality" expectedResult result

34 assertEqual "simple atom function equality" expectedResult result

42

35

@@ -47,7 +40,7 @@ testExceptionAtomFunction = TestCase $ do

47 executeTutorialD sess conn "addatomfunction \"mkTest\" Integer -> Either AtomFunctionError Integer \"\"\"(\\(IntegerAtom x:xs) -> (error (show 1))) :: [Atom] -> Either AtomFunctionError Atom\"\"\""

40 executeTutorialD sess conn "addatomfunction \"mkTest\" Integer -> Either AtomFunctionError Integer \"\"\"(\\(IntegerAtom x:xs) -> (error (show 1))) :: [Atom] -> Either AtomFunctionError Atom\"\"\""

48 let attrs = [Attribute "x" IntegerAtomType]

41 let attrs = [Attribute "x" IntegerAtomType]

49 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()

42 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()

50− tupleExprs = TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)]

43+ tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]

51 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

44 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

52 assertBool "catch error exception from script" (case result of

45 assertBool "catch error exception from script" (case result of

53 Left (UnhandledExceptionError _) -> True

46 Left (UnhandledExceptionError _) -> True

@@ -64,7 +57,7 @@ testNoArgumentAtomFunction = TestCase $ do

64 executeTutorialD sess conn "addatomfunction \"mkTest\" Either AtomFunctionError Integer \"\"\"(\\x -> pure (IntegerAtom 5)) :: [Atom] -> Either AtomFunctionError Atom\"\"\""

57 executeTutorialD sess conn "addatomfunction \"mkTest\" Either AtomFunctionError Integer \"\"\"(\\x -> pure (IntegerAtom 5)) :: [Atom] -> Either AtomFunctionError Atom\"\"\""

65 let attrs = [Attribute "x" IntegerAtomType]

58 let attrs = [Attribute "x" IntegerAtomType]

66 funcAtomExpr = FunctionAtomExpr "mkTest" [] ()

59 funcAtomExpr = FunctionAtomExpr "mkTest" [] ()

67− tupleExprs = TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)]

60+ tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]

68 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 5]]

61 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 5]]

69 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

62 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

70 assertEqual "no argument scripted function" expectedResult result

63 assertEqual "no argument scripted function" expectedResult result

@@ -73,7 +66,7 @@ testArgumentTypeMismatch :: Test

73testArgumentTypeMismatch = TestCase $ do

66testArgumentTypeMismatch = TestCase $ do

74 (sess, conn) <- dateExamplesConnection emptyNotificationCallback

67 (sess, conn) <- dateExamplesConnection emptyNotificationCallback

75 executeTutorialD sess conn "addatomfunction \"mkTest\" Integer -> Either AtomFunctionError Integer \"\"\"(\\(IntegerAtom x:_) -> pure $ TextAtom \"wrong type\") :: [Atom] -> Either AtomFunctionError Atom\"\"\""

68 executeTutorialD sess conn "addatomfunction \"mkTest\" Integer -> Either AtomFunctionError Integer \"\"\"(\\(IntegerAtom x:_) -> pure $ TextAtom \"wrong type\") :: [Atom] -> Either AtomFunctionError Atom\"\"\""

76− let tupleExprs = TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)]

69+ let tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]

77 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()

70 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()

78 attrs = [Attribute "x" IntegerAtomType]

71 attrs = [Attribute "x" IntegerAtomType]

79 expectedResult = Left (AtomTypeMismatchError IntegerAtomType TextAtomType)

72 expectedResult = Left (AtomTypeMismatchError IntegerAtomType TextAtomType)

@@ -87,7 +80,7 @@ testPolymorphicReturnType = TestCase $ do

87 let funcAtomExpr = FunctionAtomExpr "fromMaybe" [NakedAtomExpr (IntegerAtom 5),

80 let funcAtomExpr = FunctionAtomExpr "fromMaybe" [NakedAtomExpr (IntegerAtom 5),

88 NakedAtomExpr maybeAtom] ()

81 NakedAtomExpr maybeAtom] ()

89 maybeAtom = ConstructedAtom "Just" (maybeAtomType IntegerAtomType) [IntegerAtom 3]

82 maybeAtom = ConstructedAtom "Just" (maybeAtomType IntegerAtomType) [IntegerAtom 3]

90− relExpr = MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)])

83+ relExpr = MakeRelationFromExprs Nothing [TupleExpr (M.singleton "x" funcAtomExpr)]

91 mRelType <- typeForRelationalExpr sess conn relExpr

84 mRelType <- typeForRelationalExpr sess conn relExpr

92 case mRelType of

85 case mRelType of

93 Left err -> assertFailure (show err)

86 Left err -> assertFailure (show err)

@@ -101,7 +94,7 @@ testPolymorphicReturnType = TestCase $ do

101 let failFuncAtomExpr = FunctionAtomExpr "fromMaybe" [NakedAtomExpr (IntegerAtom 5),

94 let failFuncAtomExpr = FunctionAtomExpr "fromMaybe" [NakedAtomExpr (IntegerAtom 5),

102 NakedAtomExpr mismatchAtom] ()

95 NakedAtomExpr mismatchAtom] ()

103 mismatchAtom = ConstructedAtom "Just" (maybeAtomType TextAtomType) [TextAtom "fail"]

96 mismatchAtom = ConstructedAtom "Just" (maybeAtomType TextAtomType) [TextAtom "fail"]

104− failRelExpr = MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (M.singleton "x" failFuncAtomExpr)])

97+ failRelExpr = MakeRelationFromExprs Nothing [TupleExpr (M.singleton "x" failFuncAtomExpr)]

105 mFailRes <- executeRelationalExpr sess conn failRelExpr

98 mFailRes <- executeRelationalExpr sess conn failRelExpr

106 let expectedErr = Left (AtomFunctionTypeVariableMismatch "a" IntegerAtomType TextAtomType)

99 let expectedErr = Left (AtomFunctionTypeVariableMismatch "a" IntegerAtomType TextAtomType)

107 assertEqual "expected type variable mismatch" expectedErr mFailRes

100 assertEqual "expected type variable mismatch" expectedErr mFailRes

@@ -113,10 +106,9 @@ testScriptedTypeVariable = TestCase $ do

113 executeTutorialD sess conn "addatomfunction \"idTest\" a -> Either AtomFunctionError a \"(\\\\(x:_) -> pure x) :: [Atom] -> Either AtomFunctionError Atom\""

106 executeTutorialD sess conn "addatomfunction \"idTest\" a -> Either AtomFunctionError a \"(\\\\(x:_) -> pure x) :: [Atom] -> Either AtomFunctionError Atom\""

114 let attrs = [Attribute "x" IntegerAtomType]

107 let attrs = [Attribute "x" IntegerAtomType]

115 funcAtomExpr = FunctionAtomExpr "idTest" [NakedAtomExpr (IntegerAtom 3)] ()

108 funcAtomExpr = FunctionAtomExpr "idTest" [NakedAtomExpr (IntegerAtom 3)] ()

116− tupleExprs = TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)]

109+ tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]

117 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 3]]

110 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 3]]

118 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

111 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

119

112

120 assertEqual "id function equality" expectedResult result

113 assertEqual "id function equality" expectedResult result

121−

114+

122−#endif

test/TutorialD/Interpreter/DatabaseContextFunctionScript.hs+6−13

@@ -1,26 +1,19 @@

1−{-# LANGUAGE CPP #-}

1+import TutorialD.Interpreter.TestBase

2import System.Exit

3import Test.HUnit

4−#ifdef PM36_HASKELL_SCRIPTING

5−import TutorialD.Interpreter.TestBase

6import ProjectM36.Client

4import ProjectM36.Client

7import ProjectM36.Relation

5import ProjectM36.Relation

8import qualified Data.Text as T

6import qualified Data.Text as T

9−#endif

10

7

11main :: IO ()

8main :: IO ()

12main = do

9main = do

13− tcounts <- runTestTT (TestList [

10+ tcounts <- runTestTT (TestList [testBasicDBCFunction,

14−#ifdef PM36_HASKELL_SCRIPTING

15− testBasicDBCFunction,

16− testErrorDBCFunction,

11+ testErrorDBCFunction,

17− testExceptionDBCFunction,

12+ testExceptionDBCFunction,

18− testDBCFunctionWithAtomArguments

13+ testDBCFunctionWithAtomArguments

19−#endif

20 ])

14 ])

21 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

15 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

22

16

23−#ifdef PM36_HASKELL_SCRIPTING

24testBasicDBCFunction :: Test

17testBasicDBCFunction :: Test

25testBasicDBCFunction = TestCase $ do

18testBasicDBCFunction = TestCase $ do

26 (sess, conn) <- dateExamplesConnection emptyNotificationCallback

19 (sess, conn) <- dateExamplesConnection emptyNotificationCallback

@@ -62,4 +55,4 @@ testDBCFunctionWithAtomArguments = TestCase $ do

62 assertEqual "person relation" expectedPerson result

55 assertEqual "person relation" expectedPerson result

63 expectTutorialDErr sess conn (T.isPrefixOf "AtomTypeMismatchError") "execute multiArgFunc(\"fail\", \"fail\")"

56 expectTutorialDErr sess conn (T.isPrefixOf "AtomTypeMismatchError") "execute multiArgFunc(\"fail\", \"fail\")"

64

57

65−#endif

58+

test/TutorialD/Interpreter/Import/ImportTest.hsdeleted−47

@@ -1,47 +0,0 @@

1−import Test.HUnit

2−import ProjectM36.Base

3−import TutorialD.Interpreter.Import.TutorialD

4−import System.Exit

5−import qualified Data.Text as T

6−import System.IO.Temp

7−import System.FilePath

8−import qualified Data.Map as M

9−import System.IO

10−import System.Directory

11−import qualified Data.ByteString as BS

12−import qualified Data.Text.Encoding as TE

13−import Text.URI hiding (makeAbsolute)

14−

15−main :: IO ()

16−main = do

17− tcounts <- runTestTT $ TestList [testTutdFileImport

18− ,testTutdHTTPSImport

19− ]

20− if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

21−

22−testTutdFileImport :: Test

23−testTutdFileImport = TestCase $

24− withSystemTempFile "m.tutd" $ \tempPath handle -> do

25− BS.hPut handle (TE.encodeUtf8 "x:=relation{tuple{a 5,b \"spam\"}}; y:=relation{tuple{b \"漢字\"}}")

26− hClose handle

27− let expectedExpr = MultipleExpr [

28− Assign "x" (MakeRelationFromExprs Nothing

29− $ TupleExprs () [TupleExpr (M.fromList [("a", NakedAtomExpr $ IntegerAtom 5),

30− ("b", NakedAtomExpr $ TextAtom "spam")])]),

31− Assign "y" (MakeRelationFromExprs Nothing

32− $ TupleExprs () [TupleExpr (M.fromList [("b", NakedAtomExpr (TextAtom "漢字"))])])]

33− --on Windows, the file URI should not include the drive letter "/c/Users..." -> "/Users"

34− let uri = "file://" <> map (\c -> if c == '\\' then '/' else c) ( joinDrive "/" (dropDrive tempPath))

35− fileURI <- mkURI (T.pack uri)

36− imported <- importTutorialDFromFile fileURI Nothing

37− assertEqual "import tutd" (Right expectedExpr) imported

38−

39−testTutdHTTPSImport :: Test

40−testTutdHTTPSImport = TestCase $ do

41− uri <- mkURI "https://raw.githubusercontent.com/agentm/project-m36/master/test/TutorialD/Interpreter/Import/httpimporttest.tutd"

42− let hash = "effe32b247586dc3ac0079fc241b9618d41d189afcaeb7907edbe5a8b45992a4"

43− expected = Right (MultipleExpr [Assign "x" (RelationVariable "true" ()),Assign "y" (RelationVariable "false" ())])

44− actual <- importTutorialDViaHTTP uri (Just hash)

45− assertEqual "github https" expected actual

46−

47−

test/TutorialD/Interpreter/Import/TutorialD.hsnew file+29

@@ -0,0 +1,29 @@

1+import Test.HUnit

2+import ProjectM36.Base

3+import TutorialD.Interpreter.Import.TutorialD

4+import System.Exit

5+import System.IO.Temp

6+import qualified Data.Map as M

7+import System.IO

8+import qualified Data.ByteString as BS

9+import qualified Data.Text.Encoding as TE

10+

11+main :: IO ()

12+main = do

13+ tcounts <- runTestTT $ TestList [testTutdImport]

14+ if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

15+

16+testTutdImport :: Test

17+testTutdImport = TestCase $

18+ withSystemTempFile "m.tutd" $ \tempPath handle -> do

19+ BS.hPut handle (TE.encodeUtf8 "x:=relation{tuple{a 5,b \"spam\"}}; y:=relation{tuple{b \"漢字\"}}")

20+ hClose handle

21+ let expectedExpr = MultipleExpr [

22+ Assign "x" (MakeRelationFromExprs Nothing

23+ [TupleExpr (M.fromList [("a", NakedAtomExpr $ IntegerAtom 5),

24+ ("b", NakedAtomExpr $ TextAtom "spam")])]),

25+ Assign "y" (MakeRelationFromExprs Nothing

26+ [TupleExpr (M.fromList [("b", NakedAtomExpr (TextAtom "漢字"))])])]

27+ imported <- importTutorialD tempPath

28+ assertEqual "import tutd" (Right expectedExpr) imported

29+

test/TutorialD/Interpreter/Import/httpimporttest.tutddeleted−2

@@ -1,2 +0,0 @@

1−x:=true;

2−y:=false;

test/TutorialD/Interpreter/TestBase.hs+12−10

@@ -2,14 +2,16 @@ module TutorialD.Interpreter.TestBase where

2import ProjectM36.Client

3import TutorialD.Interpreter

4import TutorialD.Interpreter.Base

5+import qualified ProjectM36.Base as Base

5import ProjectM36.DateExamples

6import ProjectM36.DateExamples

6−import ProjectM36.DatabaseContext

7import Test.HUnit

8+import qualified Data.Map as M

8import Data.Text

9import Data.Text

9

10

10dateExamplesConnection :: NotificationCallback -> IO (SessionId, Connection)

11dateExamplesConnection :: NotificationCallback -> IO (SessionId, Connection)

11dateExamplesConnection callback = do

12dateExamplesConnection callback = do

12 dbconn <- connectProjectM36 (InProcessConnectionInfo NoPersistence callback [])

13 dbconn <- connectProjectM36 (InProcessConnectionInfo NoPersistence callback [])

14+ let incDeps = Base.inclusionDependencies dateExamples

13 case dbconn of

15 case dbconn of

14 Left err -> error (show err)

16 Left err -> error (show err)

15 Right conn -> do

17 Right conn -> do

@@ -17,7 +19,7 @@ dateExamplesConnection callback = do

17 case eSessionId of

19 case eSessionId of

18 Left err -> error (show err)

20 Left err -> error (show err)

19 Right sessionId -> do

21 Right sessionId -> do

20− executeDatabaseContextExpr sessionId conn (databaseContextAsDatabaseContextExpr dateExamples) >>= eitherFail

22+ executeDatabaseContextExpr sessionId conn (databaseContextAsDatabaseContextExpr dateExamples

21 --skipping atom functions for now- there are no atom function manipulation operators yet

23 --skipping atom functions for now- there are no atom function manipulation operators yet

22 commit sessionId conn >>= eitherFail

24 commit sessionId conn >>= eitherFail

23 pure (sessionId, conn)

25 pure (sessionId, conn)

@@ -28,13 +30,13 @@ executeTutorialD sessionId conn tutd = case parseTutorialD tutd of

28 Right parsed -> do

30 Right parsed -> do

29 result <- evalTutorialD sessionId conn UnsafeEvaluation parsed

31 result <- evalTutorialD sessionId conn UnsafeEvaluation parsed

30 case result of

32 case result of

31− QuitResult -> assertFailure "quit?"

33+ QuitResult -> putStrLn "yyy" >> assertFailure "quit?"

32− DisplayResult _ -> assertFailure "display?"

34+ DisplayResult _ -> putStrLn "xxx" >> assertFailure "display?"

33− DisplayIOResult _ -> assertFailure "displayIO?"

35+ DisplayIOResult _ -> putStrLn "z" >> assertFailure "displayIO?"

34− DisplayRelationResult _ -> assertFailure "displayrelation?"

36+ DisplayRelationResult _ -> putStrLn "Y" >> assertFailure "displayrelation?"

35− DisplayDataFrameResult _ -> assertFailure "displaydataframe?"

37+ DisplayDataFrameResult _ -> putStrLn "DF" >> assertFailure "displaydataframe?"

36− DisplayParseErrorResult _ _ -> assertFailure "displayparseerrorresult?"

38+ DisplayParseErrorResult _ _ -> putStrLn "X" >> assertFailure "displayparseerrorresult?"

37− DisplayErrorResult err -> assertFailure (show tutd ++ ": " ++ show err)

39+ DisplayErrorResult err -> putStrLn "asd" >> assertFailure (show tutd ++ ": " ++ show err)

38 QuietSuccessResult -> pure ()

40 QuietSuccessResult -> pure ()

39

41

40expectTutorialDErr :: SessionId -> Connection -> (Text -> Bool) -> Text -> IO ()

42expectTutorialDErr :: SessionId -> Connection -> (Text -> Bool) -> Text -> IO ()

@@ -49,7 +51,7 @@ expectTutorialDErr sessionId conn matchFunc tutd = case parseTutorialD tutd of

49 DisplayRelationResult _ -> assertFailure "displayrelation?"

51 DisplayRelationResult _ -> assertFailure "displayrelation?"

50 DisplayDataFrameResult _ -> assertFailure "displaydataframe?"

52 DisplayDataFrameResult _ -> assertFailure "displaydataframe?"

51 DisplayParseErrorResult _ _ -> assertFailure "displayparseerrorresult?"

53 DisplayParseErrorResult _ _ -> assertFailure "displayparseerrorresult?"

52− DisplayErrorResult err -> assertBool (unpack tutd ++ " match error on: " ++ unpack err) (matchFunc err)

54+ DisplayErrorResult err -> assertBool ("match error on: " ++ unpack err) (matchFunc err)

53 QuietSuccessResult -> pure ()

55 QuietSuccessResult -> pure ()

54

56

55eitherFail :: Either RelationalError a -> IO ()

57eitherFail :: Either RelationalError a -> IO ()

test/TutorialD/PrinterTest.hsdeleted−47

@@ -1,47 +0,0 @@

1−{-# LANGUAGE OverloadedStrings #-}

2−import Test.HUnit

3−import ProjectM36.Base

4−import System.Exit

5−import Data.Text.Prettyprint.Doc

6−import Data.Map (fromList)

7−import TutorialD.Printer ()

8−import TutorialD.Interpreter.RelationalExpr

9−import Text.Megaparsec

10−import Data.Text (pack)

11−

12−testList :: Test

13−testList = TestList [

14− testPretty "true" (RelationVariable "true" ()),

15− testPretty "relation{tuple{a 3, b \"x\"}, tuple{a 4, b \"y\"}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",NakedAtomExpr (IntegerAtom 3)),("b",NakedAtomExpr (TextAtom "x"))]),TupleExpr (fromList [("a",NakedAtomExpr (IntegerAtom 4)),("b",NakedAtomExpr (TextAtom "y"))])])),

16− testPretty "true:{a:=1, b:=1}" (Extend (AttributeExtendTupleExpr "b" (NakedAtomExpr (IntegerAtom 1))) (Extend (AttributeExtendTupleExpr "a" (NakedAtomExpr (IntegerAtom 1))) (RelationVariable "true" ()))),

17− testPretty "relation{tuple{a fromGregorian(2014, 2, 4)}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",FunctionAtomExpr "fromGregorian" [NakedAtomExpr (IntegerAtom 2014),NakedAtomExpr (IntegerAtom 2),NakedAtomExpr (IntegerAtom 4)] ())])])),

18− testPretty "relation{tuple{a bytestring(\"dGVzdGRhdGE=\")}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",FunctionAtomExpr "bytestring" [NakedAtomExpr (TextAtom "dGVzdGRhdGE=")] ())])])),

19− testPretty "relation{tuple{a t}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",NakedAtomExpr (BoolAtom True))])])),

20− testPretty "relation{tuple{a Cons 4 (Cons 5 Empty)}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",ConstructedAtomExpr "Cons" [NakedAtomExpr (IntegerAtom 4),ConstructedAtomExpr "Cons" [NakedAtomExpr (IntegerAtom 5),ConstructedAtomExpr "Empty" [] ()] ()] ())])])),

21− testPretty "relation{a Int, b Text, c Bool}{}" (MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "a" (ADTypeConstructor "Int" []) (),AttributeAndTypeNameExpr "b" (ADTypeConstructor "Text" []) (),AttributeAndTypeNameExpr "c" (ADTypeConstructor "Bool" []) ()]) (TupleExprs () [])),

22− testPretty "relation{a relation{b Int}}{}" (MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "a" (RelationAtomTypeConstructor [AttributeAndTypeNameExpr "b" (ADTypeConstructor "Int" []) ()]) ()]) (TupleExprs () []))

23− ]

24−

25−main :: IO ()

26−main = do

27− tcounts <- runTestTT testList

28− if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

29−

30−testPretty :: String -> RelationalExpr -> Test

31−testPretty tutdStr relExprADT =

32− TestCase $ do

33− let relExprStr = show (pretty relExprADT)

34− print relExprStr

35− roundTrip <- parseRelExpr relExprStr

36− {-tutdIn <- parseRelExpr tutdStr

37− print ("tutd parsed", tutdIn)-}

38− assertEqual ("pretty ADT " <> tutdStr) tutdStr relExprStr

39− assertEqual ("round-trip " <> tutdStr) relExprADT roundTrip

40−

41−--round trip tutoriald

42−parseRelExpr :: String -> IO RelationalExpr

43−parseRelExpr tutdStr =

44− case parse relExprP "test" (pack tutdStr) of

45− Left err ->

46− assertFailure (show err)

47− Right parsed -> pure parsed

test/scripts.hs+2−5

@@ -4,8 +4,6 @@ import TutorialD.Interpreter.Import.TutorialD

4import System.Directory

5import Data.List (isSuffixOf)

6import System.Exit

7−import qualified Data.Text as T

8−import Text.URI

9

7

10testList :: IO Test

8testList :: IO Test

11testList = do

9testList = do

@@ -22,8 +20,7 @@ main = do

22

20

23testScript :: FilePath -> Test

21testScript :: FilePath -> Test

24testScript tutdFile = TestCase $ do

22testScript tutdFile = TestCase $ do

25− fileURI <- mkURI (T.pack ("file://" <> tutdFile))

23+ eImport <- importTutorialD tutdFile

26− eImport <- importTutorialDFromFile fileURI Nothing

27 case eImport of

24 case eImport of

28 Left err -> assertFailure ("tutd import failure in " ++ tutdFile ++ ": " ++ show err)

25 Left err -> assertFailure ("tutd import failure in " ++ tutdFile ++ ": " ++ show err)

29− Right _ -> pure ()

26+ Right _ -> pure ()