git.iko.soy/project-m36
on master help sign in
swap
44feeff85 ahead, 0 behind
96 files changed+2644−1511
since splitsnapshots
unifiedsplit
.github/workflows/ci.yaml+61−21 .gitignore+3−1 .travis.yml−60 .travis/attach-binary.sh−25 .travis/install-dependencies.sh−22 .travis/install-ghc.sh−16 .travis/install-ghr.sh−21 .travis/install-stack.sh−27 Changelog.markdown+17 README.markdown+2−3 cabal.project+2−5 docker.nix+16−11 docs/15_minute_tutorial.markdown+64−67 docs/import_export_csv.markdown+2−2 docs/introduction_to_projectm36.markdown+2−2 docs/introduction_to_the_relational_algebra.markdown+1−1 docs/reaching_out_of_the_tarpit.markdown+1−1 docs/tutd_cheatsheet.markdown+3−1 docs/tutd_tutorial.markdown+56−2 examples/Plantfarm.hs+446 examples/out_of_the_tarpit.tutd+4−4 jupyter/TutorialD Notebook Walkthrough.ipynb+1−1 nix/sources.json+50 nix/sources.nix+171 pkgs.nix−7 project-m36.cabal+105−118 release.nix+17−58 scripts/DateExamples.tutd+2−2 scripts/multiline.tutd+2 src/bin/ProjectM36/Server/RemoteCallTypes/Json.hs+20−2 src/bin/ProjectM36/Server/WebSocket.hs+2−1 src/bin/ProjectM36/Server/WebSocket/websocket-client.html+1−1 src/bin/ProjectM36/Server/WebSocket/websocket-server.hs+42−9 src/bin/TutorialD/Interpreter.hs+3−1 src/bin/TutorialD/Interpreter/Base.hs+29−8 src/bin/TutorialD/Interpreter/DatabaseContextExpr.hs+3−2 src/bin/TutorialD/Interpreter/Import/Base.hs+8−3 src/bin/TutorialD/Interpreter/Import/BasicExamples.hs+2−2 src/bin/TutorialD/Interpreter/Import/CSV.hs+3−3 src/bin/TutorialD/Interpreter/Import/TutorialD.hs+70−17 src/bin/TutorialD/Interpreter/RODatabaseContextOperator.hs+33−16 src/bin/TutorialD/Interpreter/RelationalExpr.hs+27−8 src/bin/TutorialD/Printer.hs+165 src/lib/ProjectM36/Arbitrary.hs+6−1 src/lib/ProjectM36/Atom.hs+1 src/lib/ProjectM36/AtomType.hs+8−7 src/lib/ProjectM36/Atomable.hs+2−1 src/lib/ProjectM36/Attribute.hs+148−29 src/lib/ProjectM36/Base.hs+94−47 src/lib/ProjectM36/Client.hs+84−135 src/lib/ProjectM36/DataFrame.hs+7−7 src/lib/ProjectM36/DataTypes/Interval.hs+2 src/lib/ProjectM36/DataTypes/Primitive.hs+1 src/lib/ProjectM36/DataTypes/Sorting.hs+1 src/lib/ProjectM36/Error.hs+10−2 src/lib/ProjectM36/InclusionDependency.hs+5−6 src/lib/ProjectM36/IsomorphicSchema.hs+1−1 src/lib/ProjectM36/Relation.hs+17−22 src/lib/ProjectM36/Relation/Parse/CSV.hs+7−3 src/lib/ProjectM36/Relation/Show/CSV.hs+5−5 src/lib/ProjectM36/Relation/Show/HTML.hs+2−2 src/lib/ProjectM36/RelationalExpression.hs+148−302 src/lib/ProjectM36/ScriptSession.hs−2 src/lib/ProjectM36/Serialise/Base.hs+11−2 src/lib/ProjectM36/Serialise/Error.hs+1 src/lib/ProjectM36/Serialise/IsomorphicSchema.hs+1−1 src/lib/ProjectM36/Server.hs+2−2 src/lib/ProjectM36/Server/Config.hs+6 src/lib/ProjectM36/Server/EntryPoints.hs+26−24 src/lib/ProjectM36/Server/ParseArgs.hs+31−14 src/lib/ProjectM36/Server/RemoteCallTypes.hs+1−2 src/lib/ProjectM36/Server/Types.hs−38 src/lib/ProjectM36/Shortcuts.hs+247 src/lib/ProjectM36/StaticOptimizer.hs+4−3 src/lib/ProjectM36/TransactionGraph.hs+2−2 src/lib/ProjectM36/Tuple.hs+47−33 src/lib/ProjectM36/TupleSet.hs+7 src/lib/ProjectM36/Tupleable.hs+9−8 src/lib/ProjectM36/WithNameExpr.hs+4−2 stack.ghc8.0.yaml−48 stack.ghc8.10.yaml+19 stack.ghc8.2.yaml−50 stack.ghc8.4.yaml−46 stack.ghc8.6.yaml+25−12 stack.ghc8.8.yaml+24−14 test/Client/Simple.hs+1−2 test/Relation/Basic.hs+13−12 test/Relation/Tupleable.hs+18−6 test/Server/Main.hs+19−20 test/Server/WebSocket.hs+3−9 test/TutorialD/Interpreter/Import/ImportTest.hs+47 test/TutorialD/Interpreter/Import/TutorialD.hs−29 test/TutorialD/Interpreter/Import/httpimporttest.tutd+2 test/TutorialD/Interpreter.hs → test/TutorialD/InterpreterTest.hs+37−7 test/TutorialD/PrinterTest.hs+47 test/scripts.hs+5−2
.github/workflows/ci.yaml+61−21
@@ -6,24 +6,64 @@ jobs:
66 dockerimage:
77 runs-on: ubuntu-latest
88 steps:
9− - uses: actions/checkout@v2.3.1
10− - uses: cachix/install-nix-action@v10
11− with:
12− skip_adding_nixpkgs_channel: true
13− - uses: cachix/cachix-action@v6
14− with:
15− name: project-m36
16− signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}'
17− - run: cachix use iohk
18− - name: docker load
19− run: docker load < $(nix-build docker.nix)
20− - name: docker login
21− run: echo ${{secrets.DOCKERHUB_PASSWORD}} | docker login --username ${{secrets.DOCKERHUB_USER}} --password-stdin
22− - name: docker tag with version
23− run: docker tag project-m36:latest projectm36/project-m36:$(awk '/^Version:/ {print $2}' project-m36.cabal)
24− if: ${{ github.ref == 'refs/heads/master' }}
25− - name: docker tag latest
26− run: docker tag project-m36:latest projectm36/project-m36:latest
27− if: ${{ github.ref == 'refs/heads/master' }}
28− - run: docker push projectm36/project-m36
29− if: ${{ github.ref == 'refs/heads/master' }}
9+ - uses: actions/checkout@v2.3.1
10+ - uses: cachix/install-nix-action@v12
11+ with:
12+ nix_path: nixpkgs=channel:nixos-unstable
13+ - uses: cachix/cachix-action@v8
14+ with:
15+ name: project-m36
16+ signingKey: "${{ secrets.CACHIX_SIGNING_KEY }}"
17+ - run: cachix use iohk
18+ - name: docker load
19+ run: docker load < $(nix-build docker.nix)
20+ - name: docker login
21+ if: ${{ github.ref == 'refs/heads/master' }}
22+ run: echo ${{secrets.DOCKERHUB_PASSWORD}} | docker login --username ${{secrets.DOCKERHUB_USER}} --password-stdin
23+ - name: docker tag with version
24+ run: docker tag project-m36:latest projectm36/project-m36:$(awk '/^Version:/ {print $2}' project-m36.cabal)
25+ if: ${{ github.ref == 'refs/heads/master' }}
26+ - name: docker tag latest
27+ run: docker tag project-m36:latest projectm36/project-m36:latest
28+ if: ${{ github.ref == 'refs/heads/master' }}
29+ - run: docker push projectm36/project-m36
30+ if: ${{ github.ref == 'refs/heads/master' }}
31+
32+ stack-build:
33+ runs-on: ${{ matrix.os }}
34+ strategy:
35+ matrix:
36+ os: [ubuntu-latest]
37+ ghc:
38+ - ghc8.10
39+ - ghc8.8
40+ - ghc8.6
41+ include:
42+ - os: macos-latest
43+ ghc: ghc8.10
44+ env:
45+ STACK_YAML: stack.${{ matrix.ghc }}.yaml
46+ steps:
47+ - uses: actions/checkout@v2
48+ - name: Cache
49+ uses: actions/cache@v1
50+ with:
51+ path: ~/.stack
52+ key: ${{ runner.os }}-build-stack-${{ matrix.ghc }}-${{ hashFiles(env.STACK_YAML) }}-${{ hashFiles('**/*.cabal') }}
53+ restore-keys: |
54+ ${{ runner.os }}-build-stack-${{ matrix.ghc }}-${{ hashFiles(env.STACK_YAML) }}
55+ ${{ runner.os }}-build-stack-${{ matrix.ghc }}
56+ - name: Fix macOS cache bug
57+ run: rm -rf ~/.stack/setup-exe-cache
58+ - name: Build
59+ run: stack build --ghc-options -O2 --local-bin-path out --copy-bins
60+ - name: Test
61+ run: stack test --stack-yaml=${{ env.STACK_YAML }}
62+ - name: HLint
63+ run: curl -sSL https://raw.github.com/ndmitchell/hlint/master/misc/run.sh | sh -s .
64+ - name: Haddock
65+ run: stack --no-install-ghc --system-ghc --no-haddock-deps haddock
66+ - uses: actions/upload-artifact@v2
67+ with:
68+ name: project-m36-${{ matrix.os }}-${{ matrix.ghc }}
69+ path: out/
.gitignore+3−1
@@ -18,4 +18,6 @@ persistence-notes
1818jupyter/itutd.egg-info
1919jupyter/build
2020juyter/dist
21−.ipynb_checkpoints
21+.ipynb_checkpoints
22+project-m36.nix
23+stack.yaml
.travis.ymldeleted−60
@@ -1,60 +0,0 @@
1−# For more information, see https://github.com/ChrisPenner/haskell-stack-travis-ci
2−language: c
3−sudo: false
4−
5−git:
6− submodules: false # whether to recursively clone submodules
7−
8−cache:
9− directories:
10− - $HOME/.ghc
11− - $HOME/.cabal
12− - $HOME/.stack
13− - .stack-work
14− timeout: 1000
15−
16−matrix:
17− fast_finish: true
18− include:
19− - env: CACHE_NAME=8.4.4 STACK_YAML=stack.ghc8.4.yaml
20− compiler: ": #stack 8.4.4"
21−
22− - env: CACHE_NAME=8.6.5 STACK_YAML=stack.ghc8.6.yaml
23− compiler: ": #stack 8.6.5"
24−
25− - env: CACHE_NAME=osx-8.6.5 STACK_YAML=stack.ghc8.6.yaml
26− os: osx
27− osx_image: xcode11
28− compiler: ": #stack 8.6.5"
29−
30−before_script:
31− - unset CC
32− - export PATH=$HOME/.local/bin:/opt/ghc/$GHC_VERSION/bin:$PATH
33− - ./.travis/install-ghr.sh
34− - ./.travis/install-stack.sh
35−
36−# Here starts the actual work to be performed for the package under test;
37−# any command which exits with a non-zero exit code causes the build to fail.
38−script:
39− - |
40− # Run tests
41− set -e
42− ./.travis/install-dependencies.sh
43− stack --no-terminal --jobs=2 --system-ghc test
44− - |
45− #Run HLint
46− if [[ "$(uname)" = "Linux" ]]; then
47− curl -sL https://raw.github.com/ndmitchell/hlint/master/misc/travis.sh | sh -s lint src test examples --cpp-define VERSION_project_m36=HLINT
48− fi
49− - |
50− #Run Haddock
51− if [[ "$(uname)" = "Linux" ]]; then
52− stack --no-install-ghc --system-ghc --no-haddock-deps haddock
53− fi
54−
55−after_success:
56− - |
57− # Build and ship binary
58− #./.travis/attach-binary.sh
59−
60−# EOF
.travis/attach-binary.shdeleted−25
@@ -1,25 +0,0 @@
1−#!/bin/sh
2−set -o errexit -o verbose
3−
4−if test ! "$BUILD_BINARY" || test ! "$TRAVIS_TAG"
5−then
6− echo 'This is not a release build.'
7−elif test ! "$GITHUB_TOKEN"
8−then
9− echo 'The GITHUB_TOKEN environment variable is not set!'
10− exit 1
11−else
12− echo "Building binary for $TRAVIS_OS_NAME to $TRAVIS_TAG..."
13− stack build --ghc-options -O2 --pedantic
14− echo "Attaching binary for $TRAVIS_OS_NAME to $TRAVIS_TAG..."
15− OWNER="$(echo "$TRAVIS_REPO_SLUG" | cut -f1 -d/)"
16− REPO="$(echo "$TRAVIS_REPO_SLUG" | cut -f2 -d/)"
17− BIN="$(stack path --local-install-root)/bin/$REPO"
18− BUNDLE_NAME="$REPO-$TRAVIS_TAG-$TRAVIS_OS_NAME.tar.gz"
19− cp "$BIN" "./$REPO"
20− chmod +x "./$REPO"
21− tar -czf "$BUNDLE_NAME" "$REPO"
22− echo "SHA256:"
23− shasum -a 256 "$BUNDLE_NAME"
24− ghr -t "$GITHUB_TOKEN" -u "$OWNER" -r "$REPO" --replace "$(git describe --tags)" "$BUNDLE_NAME"
25−fi
.travis/install-dependencies.shdeleted−22
@@ -1,22 +0,0 @@
1−# Run tests
2−if [[ "$(uname)" = "Darwin" ]]; then
3− timeout_cmd="gtimeout"
4−else
5− timeout_cmd="timeout"
6−fi
7−$timeout_cmd 40m stack --no-terminal --jobs=2 --install-ghc --system-ghc build --only-dependencies --fast
8−ret=$?
9−case "$ret" in
10− 0)
11− # continue
12− ;;
13− 124)
14− echo "Timed out while installing dependencies."
15− echo "Try building again by pushing a new commit."
16− exit 1
17− ;;
18− *)
19− echo "Failed to install dependencies; stack exited with $ret"
20− exit "$ret"
21− ;;
22−esac
.travis/install-ghc.shdeleted−16
@@ -1,16 +0,0 @@
1−#!/bin/sh
2−set -eux
3−#assume stack is installed
4−STACK=~/.local/bin/stack
5−
6−fetch_ghc_osx() {
7− echo "Using stack to install GHC $GHC_VERSION"
8− $STACK setup $GHC_VERSION
9−}
10−
11−if [ "$(uname)" = "Darwin" ]; then
12− fetch_ghc_osx
13−else
14− #installed by apt
15− echo "Linux GHC $GHC_VERSION via APT already installed."
16−fi
.travis/install-ghr.shdeleted−21
@@ -1,21 +0,0 @@
1−#!/bin/sh
2−set -o errexit -o verbose
3−
4−if test ! "$BUILD_BINARY" || test ! "$TRAVIS_TAG"
5−then
6− echo 'This is not a release build.'
7−else
8− if [ "$TRAVIS_OS_NAME" = "linux" ]
9− then
10− ARCH="linux"
11− else
12− ARCH="darwin"
13− fi
14− echo "Installing ghr"
15− URL="https://github.com/tcnksm/ghr/releases/download/v0.5.4/ghr_v0.5.4_${ARCH}_386.zip"
16− curl -L ${URL} > ghr.zip
17− mkdir -p "$HOME/bin"
18− export PATH="$HOME/bin:$PATH"
19− unzip ghr.zip -d "$HOME/bin"
20− rm ghr.zip
21−fi
.travis/install-stack.shdeleted−27
@@ -1,27 +0,0 @@
1−#!/bin/sh
2−
3−# Adapted from https://github.com/commercialhaskell/stack
4−
5−set -eux
6−
7−travis_retry() {
8− cmd=$*
9− $cmd || (sleep 2 && $cmd) || (sleep 10 && $cmd)
10−}
11−
12−fetch_stack_osx() {
13− curl -skL https://get.haskellstack.org/stable/osx-x86_64.tar.gz | tar xz --strip-components=1 --include '*/stack' -C ~/.local/bin;
14−}
15−
16−fetch_stack_linux() {
17− curl -sL https://get.haskellstack.org/stable/linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C ~/.local/bin '*/stack';
18−}
19−
20−# We need stack to generate cabal files with precise bounds, even for cabal
21−# builds.
22−mkdir -p ~/.local/bin;
23−if [ "$(uname)" = "Darwin" ]; then
24− travis_retry fetch_stack_osx
25−else
26− travis_retry fetch_stack_linux
27−fi
Changelog.markdown+17
@@ -1,3 +1,20 @@
1+# 2021-04-01 (v0.9.3)
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+
118# 2020-10-05 (v0.8.1)
219
320* support GHC 8.10
README.markdown+2−3
@@ -4,7 +4,6 @@
44[![Public Domain](https://img.shields.io/badge/license-Public%20Domain-brightgreen.svg)](http://unlicense.org)
55[![Hackage](https://img.shields.io/hackage/v/project-m36.svg)](http://hackage.haskell.org/package/project-m36)
66[![Hackage dependency status](https://img.shields.io/hackage-deps/v/project-m36.svg)](http://packdeps.haskellers.com/feed?needle=project-m36)
7−[![Build status](https://travis-ci.org/agentm/project-m36.svg?branch=master)](https://travis-ci.org/agentm/project-m36)
87[![Windows Build status](https://ci.appveyor.com/api/projects/status/q7jyddd6dy1ibqdo/branch/master?svg=true)](https://ci.appveyor.com/project/agentm/project-m36)
98[![Github Workflow status](https://github.com/agentm/project-m36/workflows/CI/badge.svg)](https://github.com/agentm/project-m36/actions?query=workflow%3ACI)
109
@@ -45,7 +44,7 @@ Project:M36 supports multiple frontends which target different audiences.
4544
4645* [Developer's Blog](https://agentm.github.io/project-m36/)
4746* [Mailing List/Discussion Group](https://groups.google.com/d/forum/project-m36)
48−* IRC Channel: chat.freenode.net #project-m36
47+* IRC Channel: irc.libera.chat #project-m36 -- [Chat via Web Client](http://kiwiirc.com/nextclient/irc.libera.chat:+6697/#project-m36)
4948* [Hackage](https://hackage.haskell.org/package/project-m36)
5049* [Diogo Biazus' Project:M36 Video Tutorial](https://www.youtube.com/watch?v=_GC_lxlVEnE)
5150
@@ -95,7 +94,7 @@ Project:M36 supports multiple frontends which target different audiences.
9594
9695## Development
9796
98−Project:M36 is developed in Haskell and compiled with GHC 8.2.2 or later.
97+Project:M36 is developed in Haskell and compiled with GHC 8.6 or later.
9998
10099## Related Projects
101100
cabal.project+2−5
@@ -1,10 +1,7 @@
11packages: project-m36.cabal
22
3−--RPC library
4−source-repository-package
5− type: git
6− location: https://github.com/agentm/curryer.git
7− tag: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c
3+package *
4+ split-sections: True
85
96--high-performance streaming library
107source-repository-package
docker.nix+16−11
@@ -1,13 +1,18 @@
1−{ pkgs ? import ./pkgs.nix }:
1+{ compiler ? "ghc8104"
2+, sources ? import ./nix/sources.nix
3+, pkgs ? import sources.nixpkgs { }
4+}:
25let
3− release = import ./release.nix { inherit pkgs; };
4− static-project-m36 = pkgs.haskell.lib.justStaticExecutables release.project;
6+ release = import ./release.nix { inherit pkgs compiler sources; };
7+ static-project-m36 = pkgs.haskell.lib.dontCheck (pkgs.haskell.lib.justStaticExecutables release.project);
58in
6− pkgs.dockerTools.buildImage {
7− name = "project-m36";
8− tag = "latest";
9− contents = [static-project-m36];
10− #expose default project-m36 and websocket server ports
11− config = { Env = ["LC_ALL=en_US.UTF-8"];
12− ExposedPorts = { "6543/tcp" = {}; "8000/tcp" = {}; }; };
13− }
9+pkgs.dockerTools.buildImage {
10+ name = "project-m36";
11+ tag = "latest";
12+ contents = [ static-project-m36 ];
13+ # expose default project-m36 and websocket server ports
14+ config = {
15+ Env = [ "LC_ALL=en_US.UTF-8" ];
16+ ExposedPorts = { "6543/tcp" = { }; "8000/tcp" = { }; };
17+ };
18+}
docs/15_minute_tutorial.markdown+64−67
@@ -4,17 +4,19 @@ Thank you for evaluating Project:M36, a new relational algebra engine written in
44
55## Prerequisites
66
7−* any Linux
8−* GHC 8.2 or later version (Haskell compiler)
9−* cabal (package downloader) installed
7+* any Linux, MacOS, or Windows computer with Docker installed
108
119## Download and Install
1210
11+Run a pre-built docker image:
12+
13+```docker run -it projectm36/project-m36 tutd```
14+
15+or build it yourself with GHC >= 8.6:
16+
1317```bash
1418git clone https://github.com/agentm/project-m36.git
15−cabal sandbox init
16−cabal install --dependencies-only
17−cabal run tutd
19+cabal new-run tutd
1820```
1921
2022## Some Basic TutorialD
@@ -26,18 +28,10 @@ Note that TutorialD is strongly-typed- no type coercions take place automaticall
2628### Load the Canonical Chris Date Example
2729
2830```
29−TutorialD (master/main): :importexample date
30−```
31−
32−or
33−
34−```
35−TutorialD (master/main): :importtud "scripts/DateExamples.tutd"
31+TutorialD (master/main): :importexample cjdate
3632```
3733
38−```:importtutd``` (do not skip typing the preceding colon), loads a file which contains a script written in the TutorialD dialect used by Project:M36 and executes it to change the state of the database. In this case, the relations "s" (supplier), "p" (product), and "sp" (suppliers-products) are now loaded.
39−
40−```:importexample date``` loads the date example directly without any file I/O, so it is safe to use with the websocket server.
34+```:importexample``` (do not skip typing the preceding colon), loads a built-in example schema and executes it to change the state of the database. In this case, the relations "s" (supplier), "p" (product), and "sp" (suppliers-products) are now loaded.
4135
4236### Execute Relational Expressions
4337
@@ -164,7 +158,7 @@ Database context expressions change the state of the database, much like "CREATE
164158#### Create a Relation Variable
165159
166160```
167−TutorialD (master/main): x:=relation{name Text, age Int}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}
161+TutorialD (master/main): x:=relation{name Text, age Integer}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}
168162TutorialD (master/main): :showexpr x
169163┌────────┬──────────┐
170164│age::Int│name::Text│
@@ -179,23 +173,25 @@ This is similar to SQL's "CREATE TABLE" operator.
179173#### Insert Additional Tuples
180174
181175```
182−TutorialD (master/main): x:=relation{name Text, age Int}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}
176+TutorialD (master/main): x:=relation{name Text, age Integer}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}
183177TutorialD (master/main): :showexpr x
184−┌────────┬──────────┐
185−│age::Int│name::Text│
186−├────────┼──────────┤
187−│40 │"Steve" │
188−│31 │"Mike" │
189−└────────┴──────────┘
178+┌────────────┬──────────┐
179+│age::Integer│name::Text│
180+├────────────┼──────────┤
181+│31 │"Mike" │
182+│40 │"Steve" │
183+└────────────┴──────────┘
184+
190185TutorialD (master/main): insert x relation{tuple{name "Bob", age 24}}
191186TutorialD (master/main): :showexpr x
192−┌────────┬──────────┐
193−│age::Int│name::Text│
194−├────────┼──────────┤
195−│40 │"Steve" │
196−│24 │"Bob" │
197−│31 │"Mike" │
198−└────────┴──────────┘
187+┌────────────┬──────────┐
188+│age::Integer│name::Text│
189+├────────────┼──────────┤
190+│31 │"Mike" │
191+│40 │"Steve" │
192+│24 │"Bob" │
193+└────────────┴──────────┘
194+
199195```
200196
201197Note that the relational insertion is identical to "x:=x union relation{...}".
@@ -204,50 +200,51 @@ Note that the relational insertion is identical to "x:=x union relation{...}".
204200
205201```
206202TutorialD (master/main): :showexpr s
207−┌──────────┬────────┬───────────┬───────────┐
208−│city::Text│s#::Text│sname::Text│status::Int│
209−├──────────┼────────┼───────────┼───────────┤
210−│"Paris" │"S2" │"Jones" │10 │
211−│"Paris" │"S3" │"Blake" │30 │
212−│"London" │"S1" │"Smith" │20 │
213−│"London" │"S4" │"Clark" │20 │
214−│"Athens" │"S5" │"Adams" │30 │
215−└──────────┴────────┴───────────┴───────────┘
203+┌──────────┬────────┬───────────┬───────────────┐
204+│city::Text│s#::Text│sname::Text│status::Integer│
205+├──────────┼────────┼───────────┼───────────────┤
206+│"London" │"S1" │"Smith" │20 │
207+│"Athens" │"S5" │"Adams" │30 │
208+│"Paris" │"S3" │"Blake" │30 │
209+│"London" │"S4" │"Clark" │20 │
210+│"Paris" │"S2" │"Jones" │10 │
211+└──────────┴────────┴───────────┴───────────────┘
216212TutorialD (master/main): update s where city="London" (status:=35)
217213TutorialD (master/main): :showexpr s
218−┌──────────┬────────┬───────────┬───────────┐
219−│city::Text│s#::Text│sname::Text│status::Int│
220−├──────────┼────────┼───────────┼───────────┤
221−│"London" │"S4" │"Clark" │35 │
222−│"London" │"S1" │"Smith" │35 │
223−│"Paris" │"S2" │"Jones" │10 │
224−│"Paris" │"S3" │"Blake" │30 │
225−│"Athens" │"S5" │"Adams" │30 │
226−└──────────┴────────┴───────────┴───────────┘
214+┌──────────┬────────┬───────────┬───────────────┐
215+│city::Text│s#::Text│sname::Text│status::Integer│
216+├──────────┼────────┼───────────┼───────────────┤
217+│"Athens" │"S5" │"Adams" │30 │
218+│"London" │"S1" │"Smith" │35 │
219+│"London" │"S4" │"Clark" │35 │
220+│"Paris" │"S3" │"Blake" │30 │
221+│"Paris" │"S2" │"Jones" │10 │
222+└──────────┴────────┴───────────┴───────────────┘
223+
227224```
228225#### Deleting Tuples from a Relation Variable
229226
230227```
231228TutorialD (master/main): :showexpr s
232−┌──────────┬────────┬───────────┬───────────┐
233−│city::Text│s#::Text│sname::Text│status::Int│
234−├──────────┼────────┼───────────┼───────────┤
235−│"Paris" │"S2" │"Jones" │10 │
236−│"Paris" │"S3" │"Blake" │30 │
237−│"London" │"S1" │"Smith" │20 │
238−│"London" │"S4" │"Clark" │20 │
239−│"Athens" │"S5" │"Adams" │30 │
240−└──────────┴────────┴───────────┴───────────┘
229+┌──────────┬────────┬───────────┬───────────────┐
230+│city::Text│s#::Text│sname::Text│status::Integer│
231+├──────────┼────────┼───────────┼───────────────┤
232+│"Paris" │"S2" │"Jones" │10 │
233+│"Paris" │"S3" │"Blake" │30 │
234+│"London" │"S1" │"Smith" │20 │
235+│"Athens" │"S5" │"Adams" │30 │
236+│"London" │"S4" │"Clark" │20 │
237+└──────────┴────────┴───────────┴───────────────┘
241238TutorialD (master/main): delete s where sname="Adams"
242239TutorialD (master/main): :showexpr s
243−┌──────────┬────────┬───────────┬───────────┐
244−│city::Text│s#::Text│sname::Text│status::Int│
245−├──────────┼────────┼───────────┼───────────┤
246−│"Paris" │"S2" │"Jones" │10 │
247−│"Paris" │"S3" │"Blake" │30 │
248−│"London" │"S1" │"Smith" │20 │
249−│"London" │"S4" │"Clark" │20 │
250−└──────────┴────────┴───────────┴───────────┘
240+┌──────────┬────────┬───────────┬───────────────┐
241+│city::Text│s#::Text│sname::Text│status::Integer│
242+├──────────┼────────┼───────────┼───────────────┤
243+│"Paris" │"S2" │"Jones" │10 │
244+│"London" │"S4" │"Clark" │20 │
245+│"Paris" │"S3" │"Blake" │30 │
246+│"London" │"S1" │"Smith" │20 │
247+└──────────┴────────┴───────────┴───────────────┘
251248```
252249
253250### Execute Transaction Graph Expressions
@@ -270,7 +267,7 @@ TutorialD (master/main): :rollback
270267
271268```
272269TutorialD (master/main): :branch experimental
273−TutorialD (experimental): employee:=relation{name Text, salary Int}
270+TutorialD (experimental): employee:=relation{name Text, salary Integer}
274271TutorialD (experimental): :commit
275272```
276273
docs/import_export_csv.markdown+2−2
@@ -9,7 +9,7 @@ If a relation variable cannot be exported due to data types which are not suppor
99### Example Export
1010
1111```
12−TutorialD (master/main): :importexample date
12+TutorialD (master/main): :importexample cjdate
1313TutorialD (master/main): :exportcsv s "/tmp/csv"
1414```
1515```
@@ -37,7 +37,7 @@ s#,sname,status,city
3737S6,Samson,100,New York
3838```
3939```
40−TutorialD (master/main): :importexample date
40+TutorialD (master/main): :importexample cjdate
4141TutorialD (master/main): :showexpr s
4242┌──────────┬────────┬───────────┬───────────────┐
4343│city::Text│s#::Text│sname::Text│status::Integer│
docs/introduction_to_projectm36.markdown+2−2
@@ -51,7 +51,7 @@ Requirements:
5151
5252To build with stack:
5353
54−* [GHC 8.4.4 or greater](https://www.haskell.org/downloads)
54+* [GHC 8.6.5 or greater](https://www.haskell.org/downloads)
5555* [Haskell stack](https://docs.haskellstack.org/en/stable/README/)
5656* Linux, macOS, or Microsoft Windows
5757
@@ -63,7 +63,7 @@ Compilation steps:
6363
6464At this point, the TutorialD interactive interpreter can be run using ```stack exec tutd```.
6565
66−Alternative building with GHC 8.4.4 or greater:
66+Alternative building with GHC 8.6.5 or greater:
6767
6868* ```cabal new-build```
6969
docs/introduction_to_the_relational_algebra.markdown+1−1
@@ -202,7 +202,7 @@ Join (Instructor relation)
202202
203203(Course Relation)
204204
205−|(Course Name, Course Name Type)|(Instructor, Instructor Name Type)|(Course Room Number, Room Number Type)|
205+|(Course Name, Course Name Type)|(Instructor Name, Instructor Name Type)|(Course Room Number, Room Number Type)|
206206|-------------------------------|----------------------------------|--------------------------------------|
207207|English 1|Steve|Room 104|
208208|French 2|Bob|Room 103|
docs/reaching_out_of_the_tarpit.markdown+1−1
@@ -57,7 +57,7 @@ Project:M36 implements multiple interfaces:
5757To understand how Project:M36 stacks up against the fictional programming language shown in the paper, we have implemented the [example from the paper](/examples/out_of_the_tarpit.tutd). The language used in the script is a dialect of Chris Date's TutorialD language. It can be loaded into an interactive ```tutd``` session like so:
5858
5959```
60−TutorialD (master/main): :importexample date
60+TutorialD (master/main): :importexample cjdate
6161TutorialD (master/main): :showexpr p
6262┌───────────────────┬────────────┬───────────────────┬────────────┬────────────┐
6363│address::Address │agent::Agent│dateRegistered::Day│photo::Text │price::Price│
docs/tutd_cheatsheet.markdown+3−1
@@ -47,7 +47,9 @@ Database context expressions take the current database context as input and alte
4747
4848|Database Context Expression |Description |
4949|------------------------------------------------------|---------------------------------------|
50−|`:importexample date`|Imports a precooked schema from Chris Date's books resulting in relvars `s`, `sp`, and `p`|
50+|`:importexample cjdate`|Imports a precooked schema from Chris Date's books resulting in relvars `s`, `sp`, and `p`|
51+|`:importtutd "file:///home/agentm/project-m36/scripts/emp.tutd"`|Imports TutorialD from file URI|
52+|`:importtutd "https://raw.githubusercontent.com/agentm/project-m36/master/scripts/emp.tutd" "effe32b247586dc3ac0079fc241b9618d41d189afcaeb7907edbe5a8b45992a4"`| Imports TutorialD from HTTP or HTTPS URI|
5153|`newrelvar:=relation{tuple{age 3}}`|Assign a new relation variable named `newrelvar`|
5254|`undefine s`|Remove a relation variable|
5355|`insert s relation{tuple{city "Boston",s# "S10",sname "Gonzalez",status 10}}`| Append to an existing relation variable with another relational expression|
docs/tutd_tutorial.markdown+56−2
@@ -19,7 +19,7 @@ TutorialD (master/main):
1919The examples in this tutorial can be executed after loading Chris Date's sample relations using:
2020
2121```
22−:importexample date
22+:importexample cjdate
2323```
2424
2525Each section assumes a fresh instance of the Date examples. The relation variables created in the script are:
@@ -30,6 +30,24 @@ Each section assumes a fresh instance of the Date examples. The relation variabl
3030|p|parts|
3131|sp|contains mapping of which suppliers supply which parts|
3232
33+### Importing TutorialD from Other Sources
34+
35+The `tutd` console can also run TutorialD from a local file or from a web server.
36+
37+To import TutorialD from a file:
38+
39+```
40+:importtutd "file:///home/agentm/project-m36/scripts/emp.tutd"
41+```
42+
43+or from a web server:
44+
45+```
46+:importtutd "https://raw.githubusercontent.com/agentm/project-m36/master/scripts/DateExamples.tutd" "db9f3d9fe06d0a29b8355e045b89ec94d6428e3a3de93def7ca77bf0298b7010"
47+```
48+
49+The second argument is an optional SHA256 hash in hexadecimal form. This can be used to validate that the script has not changed since the last import. Importing TutorialD from the web is in general safe because it is effectively sandboxed with "Safe Haskell" for functions, so the script is contained security-wise, however, nothing prevents the script from running forever. Downloading a schema from the web is a great way to share schemas and to kick start your project without starting from scratch.
50+
3351### Types
3452
3553TutorialD is strongly-typed. The basic built-in types are:
@@ -197,7 +215,7 @@ TutorialD (master/main): :showexpr s{all but city}
197215└────────┴───────────┴───────────────┘
198216```
199217
200−Projection attributes can also be derived from a relational expression using `all from`:
218+Projection attributes can be derived from a relational expression using `all from`:
201219
202220```
203221TutorialD (master/main): :showexpr (s join sp){all from s}
@@ -213,6 +231,42 @@ TutorialD (master/main): :showexpr (s join sp){all from s}
213231
214232Above, we join `s` and `sp` but project the result back onto the attributes of `s`.
215233
234+Projection attributes can be unioned from multiple sources using `union of`:
235+
236+```
237+TutorialD (master/main): :showexpr (s join sp){union of {all from s} {all but p#}}
238+┌──────────┬────────────┬────────┬───────────┬───────────────┐
239+│city::Text│qty::Integer│s#::Text│sname::Text│status::Integer│
240+├──────────┼────────────┼────────┼───────────┼───────────────┤
241+│"Paris" │400 │"S2" │"Jones" │10 │
242+│"London" │400 │"S1" │"Smith" │20 │
243+│"Paris" │200 │"S3" │"Blake" │30 │
244+│"London" │200 │"S4" │"Clark" │20 │
245+│"London" │200 │"S1" │"Smith" │20 │
246+│"Paris" │300 │"S2" │"Jones" │10 │
247+│"London" │100 │"S1" │"Smith" │20 │
248+│"London" │300 │"S4" │"Clark" │20 │
249+│"London" │300 │"S1" │"Smith" │20 │
250+│"London" │400 │"S4" │"Clark" │20 │
251+└──────────┴────────────┴────────┴───────────┴───────────────┘
252+```
253+
254+Here, after joining `s` and `p`, the union of all attributes from `s` and all attributes from `p` except for `p#` are returned.all
255+
256+Finally, projection attributes can be intersected using `intersection of`:
257+
258+```
259+TutorialD (master/main): :showexpr (s join sp){intersection of {all from s} {all from p}}
260+┌──────────┐
261+│city::Text│
262+├──────────┤
263+│"London" │
264+│"Paris" │
265+└──────────┘
266+```
267+
268+Here, after joining `s` and `p`, we project on the intersection of attributes from `s` and `p` which happens to be `city`.
269+
216270#### Restriction
217271
218272Restriction is applied using a "where" clause, much like in SQL.
examples/Plantfarm.hsnew file+446
@@ -0,0 +1,446 @@
1+{-# LANGUAGE DeriveGeneric #-}
2+
3+{-# LANGUAGE OverloadedStrings #-}
4+
5+{-# LANGUAGE DeriveAnyClass #-}
6+
7+{-# LANGUAGE DerivingVia #-}
8+
9+
10+import Codec.Winery (Serialise, WineryVariant(WineryVariant))
11+import Control.DeepSeq (NFData)
12+import Data.Aeson (FromJSON, ToJSON(toEncoding, toJSON))
13+import Data.Data (Proxy(Proxy))
14+import Data.Either (lefts, rights)
15+import Data.Functor (($>))
16+import Data.Text as T (Text)
17+import qualified Data.Text.Lazy as TL (pack)
18+import GHC.Generics (Generic)
19+import qualified ProjectM36.Base as Base
20+import ProjectM36.Client
21+ ( AtomExprBase(NakedAtomExpr)
22+ , Atomable(toAddTypeExpr, toAtom)
23+ , AttributeName
24+ , Connection
25+ , ConnectionInfo(InProcessConnectionInfo)
26+ , DatabaseContextExpr
27+ , DatabaseContextExprBase(Delete)
28+ , PersistenceStrategy(NoPersistence)
29+ , RelationalError
30+ , RelationalExprBase(RelationVariable, Restrict)
31+ , RestrictionPredicateExprBase(AttributeEqualityPredicate)
32+ , SessionId
33+ , close
34+ , commit
35+ , connectProjectM36
36+ , createSessionAtHead
37+ , databaseContextExprForUniqueKey
38+ , defaultHeadName
39+ , emptyNotificationCallback
40+ , executeDatabaseContextExpr
41+ , executeRelationalExpr
42+ , withTransaction
43+ )
44+import qualified ProjectM36.Relation as Relation
45+import ProjectM36.Tupleable
46+ ( Tupleable(fromTuple)
47+ , toDefineExpr
48+ , toDeleteExpr
49+ , toInsertExpr
50+ , toUpdateExpr
51+ )
52+import qualified System.Random as R
53+
54+
55+import Control.Monad.IO.Class (MonadIO(liftIO))
56+import qualified Web.Scotty as S
57+
58+-- | This is an example showcasing the updating of data
59+-- with the help of plants. \\
60+-- This is a very simple example and of course not how
61+-- plants grow in nature. \\
62+-- The main goal of this example is to showcase the updating
63+-- of data and the different options of persistence.
64+-- You can just pipe the output from curl into jq:
65+--
66+-- curl -X POST -H 'Accept: application/json' http://localhost:8001/plant/water/angu | jq -r '.stage'
67+
68+
69+data Stage = Seed | Sprout | Seedling | Adult | Dead
70+ deriving (Show, Eq, Ord, Generic, NFData, Atomable)
71+ deriving Serialise via WineryVariant Stage
72+
73+
74+instance ToJSON Stage where -- The where can be removed and the implementation commented out
75+ -- if the ascii values are not wanted
76+ toJSON s = toJSON $ show s <> "\nascii only provided for visualisation:\n" <> stagetoAscii s
77+
78+ toEncoding s = toEncoding $ show s <> "\nascii only provided for visualisation:\n" <> stagetoAscii s
79+
80+instance FromJSON Stage
81+
82+instance S.Parsable Stage where
83+ parseParam t
84+ | t == "seed" || t == "Seed" = Right Seed
85+ | t == "sprout" || t == "Sprout" = Right Sprout
86+ | t == "seedling" || t == "Seedling" = Right Seedling
87+ | t == "adult" || t == "Adult" = Right Adult
88+ | t == "dead" || t == "Dead" = Right Dead
89+ | otherwise = Left t
90+
91+
92+-- Just for ToJSON for ilustration of stage
93+type ASCIIStage = String
94+
95+seedStr :: ASCIIStage
96+seedStr = "<>\n\
97+ \'''\n"
98+sproutStr :: ASCIIStage
99+sproutStr = " ..\n\
100+ \<|>\n\
101+ \''''\n"
102+seedlingStr :: ASCIIStage
103+seedlingStr = " `\\⁄o \n\
104+ \ v|/\n\
105+ \'´;'''\n"
106+adultStr :: ASCIIStage
107+adultStr = "*~(#)~\n\
108+ \ \\,Y,e\n\
109+ \ \\|/\n\
110+ \''+'\\''\n"
111+deadStr :: ASCIIStage
112+deadStr = " ,__:<\n\
113+ \'/'''''\n"
114+
115+-- Just used for ToJSON illustration of stages
116+stagetoAscii :: Stage -> ASCIIStage
117+stagetoAscii Seed = seedStr
118+stagetoAscii Sprout = sproutStr
119+stagetoAscii Seedling = seedlingStr
120+stagetoAscii Adult = adultStr
121+stagetoAscii Dead = deadStr
122+
123+-- used for update stage
124+next :: Stage -> Stage
125+next Seed = Sprout
126+next Sprout = Seedling
127+next Seedling = Adult
128+next s = s
129+
130+data Plant = Plant { name :: Text, species :: Text, stage :: Stage, waterings:: Integer } deriving (Show, Generic)
131+instance Tupleable Plant
132+instance ToJSON Plant
133+instance FromJSON Plant
134+
135+
136+main :: IO ()
137+main = do
138+ putStrLn "Connecting to plant farm"
139+ c <- dbConnection
140+ _ <- createSchema c
141+ putStrLn "Planting some plants"
142+ _ <- insertSampleData c
143+ let port = 8001
144+ putStrLn $ "Started Plant farm at " <> show port
145+ S.scotty port $ do
146+
147+ -- retrieve a plant by name
148+ S.get "/plant/:name" $ do
149+ n <- S.param "name"
150+ e <- liftIO $ getPlant c n
151+ p <- handleWebError e
152+ S.json p
153+
154+
155+ -- save a plant providing it as json data
156+ S.post "/plant" $ do
157+ pl <- S.jsonData :: S.ActionM Plant
158+ e <- liftIO $ savePlant c [pl]
159+ p <- handleWebError e
160+ S.json p
161+
162+ -- updating a plant providing it as json data
163+ S.put "/plant" $ do
164+ pl <- S.jsonData :: S.ActionM Plant
165+ e <- liftIO $ updatePlantFst c pl
166+ p <- handleWebError e
167+ S.json p
168+
169+ -- watering the plant having the provided name.
170+ -- This will water the plant and might let it progress to the next stage. It might also die.
171+ S.post "/plant/water/:name" $ do
172+ n <- S.param "name"
173+ e <- liftIO $ waterPlant c n
174+ p <- handleWebError e
175+ S.json p
176+
177+ -- retriving all the plants as json data
178+ S.get "/plants" $ do
179+ e <- liftIO $ getAllPlants c
180+ ps <- handleWebErrors e
181+ S.json ps
182+
183+ -- saving many plants at the same time
184+ S.post "/plants" $ do
185+ pl <- S.jsonData :: S.ActionM [Plant]
186+ e <- liftIO $ savePlant c pl
187+ p <- handleWebError e
188+ S.json p
189+
190+ -- deleting all plants at a specific stage
191+ S.delete "/plants?stage=:stage" $ do
192+ s <- S.param "stage"
193+ e <- liftIO $ deletePlantsByStage c s
194+ p <- handleWebError e
195+ S.json p
196+
197+ -- deleting all plants at a specific stage
198+ S.delete "/plants" $ do
199+ s <- S.param "name"
200+ e <- liftIO $ deletePlantByName c s
201+ p <- handleWebError e
202+ S.json p
203+
204+ -- deleting all dead plants
205+ S.delete "/plants/clear" $ do
206+ e <- liftIO $ clearDeadPlants c
207+ ps <- handleWebErrors e
208+ S.json ps
209+
210+handleWebError :: Either Err b -> S.ActionM b
211+handleWebError (Left e) = S.raise (TL.pack $ "An error occurred:\n" <> show e)
212+handleWebError (Right v) = pure v
213+
214+handleWebErrors :: [Either Err b] -> S.ActionM [b]
215+handleWebErrors e = do
216+ case lefts e of
217+ [] -> pure (rights e)
218+ l -> S.raise (TL.pack $ "Errors occurred:\n" <> concatMap ((<>"\n") . show) l)
219+
220+
221+-- | watering a plant and thereby possibly updating its stage
222+waterPlant :: DBConnection -> Text -> IO (Either Err Plant)
223+waterPlant db n = do
224+ p <- getPlant db n
225+ case p of
226+ Left e -> pure $ Left e
227+ Right v -> updateStage db $ v { waterings = waterings v + 1 }
228+
229+-- | used by 'waterPlant' updates the stage depending on random numbers
230+updateStage :: DBConnection -> Plant -> IO (Either Err Plant)
231+updateStage db p@(Plant _ _ Dead _ ) = do
232+ tmp <- updatePlantFst db p
233+ case tmp of
234+ Left e -> pure $ Left e
235+ Right _ -> pure $ Right p
236+updateStage db p = do
237+ res <- calculateStage p
238+ tmp <- updatePlantFst db res
239+ case tmp of
240+ Left e -> pure $ Left e
241+ Right _ -> pure $ Right res
242+ where calculateStage p' = do
243+ r1 <- R.randomRIO (1, 10) :: IO Integer
244+ let np = if r1 < waterings p' then p' { stage = next $ stage p', waterings = 0 } else p'
245+ r2 <- R.randomRIO (1, 20)
246+ pure $ if r2 < waterings np then np { stage = Dead, waterings = 0 } else np
247+
248+-- | deletes all plants with Stage = Dead
249+clearDeadPlants :: DBConnection -> IO [Either Err Plant]
250+clearDeadPlants db = do
251+ _ <- deletePlantsByStage db Dead
252+ getAllPlants db
253+
254+
255+-- ****************************
256+-- | *Database functions* :
257+-- ****************************
258+
259+
260+-- | Error type for passing. It is not very specific.
261+-- Just minimal and non optimal for this example.
262+data Err = NotSpecified | NotFound deriving (Show ,Generic)
263+
264+instance ToJSON Err
265+
266+-- | Just for convinience for passing around the SessionId
267+-- and the Connection
268+data DBConnection = DB SessionId Connection
269+
270+
271+-- | Getting plants by their name.\
272+-- Because plant has name as primary key \
273+-- we can assume will get at most one result. \
274+-- Alternatively we could return a list.
275+getPlant :: DBConnection -> Text -> IO (Either Err Plant)
276+getPlant db n = defaultHead (Left NotFound) <$> (
277+ get db
278+ ( Restrict -- Restrict can be thought of as similar to "WITH" in SQL
279+ (AttributeEqualityPredicate "name" (NakedAtomExpr (toAtom n))) -- This is the Predicate we are "restricting" our RelationalExprBase with
280+ (RelationVariable "plants" ())
281+ )
282+ :: IO [Either Err Plant] -- this is needed because our 'get' function is
283+ )
284+
285+defaultHead :: a -> [a] -> a
286+defaultHead d [] = d
287+defaultHead _ (x:_) = x
288+
289+-- | Getting all the plants
290+getAllPlants :: DBConnection -> IO [Either Err Plant]
291+getAllPlants db = get db (RelationVariable "plants" ())
292+
293+-- | Getting all the plants that satisfy the restrictions
294+getAllPlantsWith :: DBConnection -> Base.RestrictionPredicateExpr -> IO [Either Err Plant]
295+getAllPlantsWith db ex = get db (Restrict ex (RelationVariable "plants" ()))
296+
297+
298+-- | Saving a plant
299+savePlant :: (Traversable t) => DBConnection -> t Plant -> IO (Either Err ())
300+savePlant db sps = insert db sps "plants"
301+
302+-- | An alternative to update alone because due to updates
303+-- not being cached yet \
304+-- they have to be calculated every update. \
305+-- This seems like an alternative until caching is implemented.
306+updatePlantFst :: DBConnection -> Plant -> IO (Either Err ())
307+updatePlantFst db pln = do
308+ _ <- delete db pln ["name"] "plants"
309+ savePlant db [pln]
310+
311+-- | Updating a plant. Due to the way project 36 works, \
312+-- updates have to be executed every time.\
313+-- This is slow but won't be an issue soon because they will
314+-- be cached.\
315+-- But because of this project 36 can provide O(1) commits.
316+updatePlant :: DBConnection -> Plant -> IO (Either Err ())
317+updatePlant db sps = update
318+ db -- db connection
319+ sps -- plant value
320+ ["name"] -- the attributes to be updated by (in case of unique key)
321+ "plants" -- the relation we want to update on
322+
323+
324+-- | deleting all plants that have given name.
325+deletePlantByName :: DBConnection -> Text -> IO (Either Err ())
326+deletePlantByName db s = executeWithTransaction db $ Right $ Delete "plants" $ AttributeEqualityPredicate "name" (NakedAtomExpr (toAtom s))
327+
328+-- | deleting all plants that have given stage.
329+deletePlantsByStage :: DBConnection -> Stage -> IO (Either Err ())
330+deletePlantsByStage db s = executeWithTransaction db $ Right $ Delete "plants" $ AttributeEqualityPredicate "stage" (NakedAtomExpr (toAtom s))
331+
332+
333+-- | Inserting the schema into the DB
334+createSchema :: DBConnection -> IO ()
335+createSchema (DB sessionId conn) = do
336+ _ <- handleIOErrorsAndQuit $ mapM (executeDatabaseContextExpr sessionId conn) [
337+ toAddTypeExpr (Proxy :: Proxy Stage) -- Adds the Type Stage as data to the DB
338+ , toDefineExpr (Proxy :: Proxy Plant) "plants" -- Creates the plants relation
339+ , databaseContextExprForUniqueKey "plants" ["name"] -- Makes name of the plants relation a uniqe Key,
340+ -- Foreign Key restrictions are available too
341+ ]
342+ pure ()
343+
344+
345+-- | inserting some sample data
346+insertSampleData :: DBConnection -> IO (Either Err ())
347+insertSampleData (DB sid conn) = do
348+ insert (DB sid conn) [
349+ Plant "angu" "Caladenia angustata" Seed 0
350+ , Plant "thely" "Thelymitra alcockiae" Seed 0
351+ , Plant "monstera" "Araceae" Seed 0
352+ ] "plants"
353+
354+dbConnection :: IO DBConnection
355+dbConnection = do
356+ -- connect to the database
357+ let connInfo = InProcessConnectionInfo NoPersistence emptyNotificationCallback []
358+ -- The code below persists the data in a DB with the name "base". \\
359+-- let connInfo = InProcessConnectionInfo (CrashSafePersistence "base") emptyNotificationCallback [] \\
360+ -- In addition minimal persistance is available. \\
361+-- let connInfo = InProcessConnectionInfo (MinimalPersistence "base") emptyNotificationCallback []
362+ conn <- handleIOErrorAndQuit $ connectProjectM36 connInfo
363+ --create a database session at the default branch of the database
364+ sessionId <- handleIOErrorAndQuit $ createSessionAtHead conn defaultHeadName
365+ pure (DB sessionId conn)
366+
367+
368+-- | A polymorphic function to insert data (a traversable of data) into the DB
369+insert :: (Tupleable a, Traversable t) => DBConnection -> t a -> Base.RelVarName -> IO (Either Err ())
370+insert db rlv rlvName = executeWithTransaction db $ toInsertExpr rlv rlvName
371+
372+-- | A polymorphic function to update data in the DB.
373+-- An update in one funtion would take:
374+--
375+-- - SessionId
376+-- - Connection
377+-- - Tuplable a -- the Tuplable you want to update
378+-- - [AttributeName] -- the Attributes of the Tuplable you want to update those are of StringType
379+-- - RelVarName -- the name of the relation
380+--
381+-- With that you can via 'toUpdateExpr' create a 'DatabaseContextExpr' to be executed. \\
382+-- For inserting its very similarly done with 'toInsertExpr'.
383+update :: (Tupleable a) => DBConnection -> a -> [AttributeName]-> Base.RelVarName -> IO (Either Err ())
384+update db rlv attr rlvName = executeWithTransaction db $ toUpdateExpr rlvName attr rlv
385+
386+-- | A polymorphic function to delete data in the DB
387+delete :: (Tupleable a) => DBConnection -> a -> [AttributeName]-> Base.RelVarName -> IO (Either Err ())
388+delete db rlv attr rlvName = executeWithTransaction db $ toDeleteExpr rlvName attr rlv
389+
390+-- | A convenience function to make executing DBContextExpr with commiting simpler. \\
391+-- In particular for expr that just insert, delete and update.
392+-- Therefor ultimately return Either _ ()
393+executeWithTransaction :: DBConnection -> Either RelationalError DatabaseContextExpr -> IO (Either Err ())
394+executeWithTransaction (DB sid conn) expr = do
395+ iEx <- handleError expr
396+ case iEx of
397+ Left e -> pure $ Left e
398+ Right v -> handleIOError $ withTransaction sid conn (executeDatabaseContextExpr sid conn v) (commit sid conn)
399+
400+-- | A polymorphic function to get data (a list of data and possibly errors) from the DB
401+get :: Tupleable b => DBConnection -> Base.RelationalExpr -> IO [Either Err b]
402+get (DB sessionId conn) q = do
403+ eRel <- executeRelationalExpr sessionId conn q
404+ e <- handleError eRel
405+ case e of
406+ Left err -> pure [Left err]
407+ Right pRel -> do
408+ ws <- Relation.toList pRel
409+ mapM (handleError . fromTuple) ws
410+
411+-- | for closing the DB connection.
412+-- Not really needed when using in-memory DB
413+closeConn :: DBConnection -> IO ()
414+closeConn (DB _ conn) = close conn
415+
416+
417+-- | Error handling is heavily inspired by 'blog.hs' the blog example \\
418+-- by (agentm)[https://github.com/agentm] (https://github.com/agentm/project-m36, commit: f8432522adaafeae7c32bc2b8b6cb09c00396fc6). \\
419+-- As stated there, your application should have proper error handling.
420+handleIOErrorAndQuit :: Show e => IO (Either e a) -> IO a
421+handleIOErrorAndQuit m = do
422+ v <- m
423+ handleErrorAndQuit v
424+
425+handleError :: Show e => Either e a -> IO (Either Err a)
426+handleError eErr = case eErr of
427+ Left err -> print err $> Left NotSpecified
428+ Right v -> pure $ Right v
429+
430+handleIOError :: Show e => IO (Either e a) -> IO (Either Err a)
431+handleIOError m = do
432+ v <- m
433+ handleError v
434+
435+handleErrorAndQuit :: Show e => Either e a -> IO a
436+handleErrorAndQuit eErr = case eErr of
437+ Left err -> print err >> error "Quit."
438+ Right v -> pure v
439+
440+handleIOErrorsAndQuit :: Show e => IO [Either e a] -> IO [a]
441+handleIOErrorsAndQuit m = do
442+ eErrs <- m
443+ case lefts eErrs of
444+ [] -> pure (rights eErrs)
445+ err:_ -> handleErrorAndQuit (Left err)
446+
examples/out_of_the_tarpit.tutd+4−4
@@ -3,9 +3,9 @@
33data Address = Address Text
44data Agent = Agent Text
55data Name = Name Text
6−data Price = Price Double
6+data Price = Price Integer --dollars
77data RoomType = Kitchen | Bathroom | LivingRoom
8−data PriceBand = Low | Medium | High | Premium
8+data PriceBand = Low | Med | High | Premium
99data AreaCode = City | Suburban | Rural
1010data SpeedBand = VeryFast | Fast | Medium | Slow
1111
@@ -57,9 +57,9 @@ constraint noOffersAfterSale (offer join decision where ^dayEarlierThan(@offerDa
5757--1. identify offerPrices > 2000 (arbitrarily-chosen high price band which is not specified in the paper)
5858--2. remove the properties which have been sold
5959--3. group and count sub-relation and restrict by greater than 50
60−constraint noMoreThan50PremiumProperties ((((property where ^gt(offerPrice,2000.0)) minus ((property join decision){address,agent,dateRegistered,photo,price})) group ({} as x) : {z:=gt(count(@x),50)}) {z}){} equals false
60+constraint noMoreThan50PremiumProperties ((((property where ^gt(@price,Price 2000)) minus ((property join decision){address,agent,dateRegistered,photo,price})) group ({} as x) : {z:=gt(count(@x),50)}) {z}){} equals false
6161
62−constraint noBidderCanMakeMoreThan10BidsOnAProperty (((offer group ({all but bidderAddress} as bidder)) : {bidCount:=gt(count(@bidder),10)}) where ^gt(bidCount,10)) {} equals false
62+constraint noBidderCanMakeMoreThan10BidsOnAProperty (((offer group ({all but bidderAddress} as bidder)) : {bidCount:=gt(count(@bidder),10)}) where ^gt(@bidCount,10)) {} equals false
6363
6464-- sample data
6565
jupyter/TutorialD Notebook Walkthrough.ipynb+1−1
@@ -38,7 +38,7 @@
3838 }
3939 ],
4040 "source": [
41− ":importexample date"
41+ ":importexample cjdate"
4242 ]
4343 },
4444 {
nix/sources.jsonnew file+50
@@ -0,0 +1,50 @@
1+{
2+ "curryer": {
3+ "branch": "master",
4+ "description": "Fast Haskell RPC",
5+ "homepage": null,
6+ "owner": "agentm",
7+ "repo": "curryer",
8+ "rev": "74ecaac619ad1165a4517d5c0f4e530493bda130",
9+ "sha256": "1izdvzj00k0y76ixm7dfgvq2fzphb8h4nzqgwkl3p0bg0806rsn1",
10+ "type": "tarball",
11+ "url": "https://github.com/agentm/curryer/archive/74ecaac619ad1165a4517d5c0f4e530493bda130.tar.gz",
12+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
13+ },
14+ "niv": {
15+ "branch": "master",
16+ "description": "Easy dependency management for Nix projects",
17+ "homepage": "https://github.com/nmattia/niv",
18+ "owner": "nmattia",
19+ "repo": "niv",
20+ "rev": "1819632b5823e0527da28ad82fecd6be5136c1e9",
21+ "sha256": "08jz17756qchq0zrqmapcm33nr4ms9f630mycc06i6zkfwl5yh5i",
22+ "type": "tarball",
23+ "url": "https://github.com/nmattia/niv/archive/1819632b5823e0527da28ad82fecd6be5136c1e9.tar.gz",
24+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
25+ },
26+ "nixpkgs": {
27+ "branch": "master",
28+ "description": "Nix Packages collection",
29+ "homepage": "",
30+ "owner": "NixOS",
31+ "repo": "nixpkgs",
32+ "rev": "429c23aad0fce9ef38b0e60d55d7459c19d53ddc",
33+ "sha256": "1nj8sh1fnxp07jdlvjkijwfd1pnsi2zj0ivy7a0dhx02g63byhg3",
34+ "type": "tarball",
35+ "url": "https://github.com/NixOS/nixpkgs/archive/429c23aad0fce9ef38b0e60d55d7459c19d53ddc.tar.gz",
36+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
37+ },
38+ "streamly": {
39+ "branch": "ac3af8749194f1788704dda8667d0b3807075cc2",
40+ "description": "Beautiful Streaming, Concurrent and Reactive Composition (Haskell)",
41+ "homepage": "https://hackage.haskell.org/package/streamly",
42+ "owner": "composewell",
43+ "repo": "streamly",
44+ "rev": "ac3af8749194f1788704dda8667d0b3807075cc2",
45+ "sha256": "04d8fk654vawdfs0dfidmq2awwgwi8x44iv8r7vqz70zkcsd5fij",
46+ "type": "tarball",
47+ "url": "https://github.com/composewell/streamly/archive/ac3af8749194f1788704dda8667d0b3807075cc2.tar.gz",
48+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
49+ }
50+}
nix/sources.nixnew file+171
@@ -0,0 +1,171 @@
1+# This file has been generated by Niv.
2+
3+let
4+
5+ #
6+ # The fetchers. fetch_<type> fetches specs of type <type>.
7+ #
8+
9+ fetch_file = pkgs: name: spec:
10+ let
11+ name' = sanitizeName name + "-src";
12+ in
13+ if spec.builtin or true then
14+ builtins_fetchurl { inherit (spec) url sha256; name = name'; }
15+ else
16+ pkgs.fetchurl { inherit (spec) url sha256; name = name'; };
17+
18+ fetch_tarball = pkgs: name: spec:
19+ let
20+ name' = sanitizeName name + "-src";
21+ in
22+ if spec.builtin or true then
23+ builtins_fetchTarball { name = name'; inherit (spec) url sha256; }
24+ else
25+ pkgs.fetchzip { name = name'; inherit (spec) url sha256; };
26+
27+ fetch_git = name: spec:
28+ let
29+ ref =
30+ if spec ? ref then spec.ref else
31+ if spec ? branch then "refs/heads/${spec.branch}" else
32+ if spec ? tag then "refs/tags/${spec.tag}" else
33+ abort "In git source '${name}': Please specify `ref`, `tag` or `branch`!";
34+ in
35+ builtins.fetchGit { url = spec.repo; inherit (spec) rev; inherit ref; };
36+
37+ fetch_local = spec: spec.path;
38+
39+ fetch_builtin-tarball = name: throw
40+ ''[${name}] The niv type "builtin-tarball" is deprecated. You should instead use `builtin = true`.
41+ $ niv modify ${name} -a type=tarball -a builtin=true'';
42+
43+ fetch_builtin-url = name: throw
44+ ''[${name}] The niv type "builtin-url" will soon be deprecated. You should instead use `builtin = true`.
45+ $ niv modify ${name} -a type=file -a builtin=true'';
46+
47+ #
48+ # Various helpers
49+ #
50+
51+ # https://github.com/NixOS/nixpkgs/pull/83241/files#diff-c6f540a4f3bfa4b0e8b6bafd4cd54e8bR695
52+ sanitizeName = name:
53+ (
54+ concatMapStrings (s: if builtins.isList s then "-" else s)
55+ (
56+ builtins.split "[^[:alnum:]+._?=-]+"
57+ ((x: builtins.elemAt (builtins.match "\\.*(.*)" x) 0) name)
58+ )
59+ );
60+
61+ # The set of packages used when specs are fetched using non-builtins.
62+ mkPkgs = sources: system:
63+ let
64+ sourcesNixpkgs =
65+ import (builtins_fetchTarball { inherit (sources.nixpkgs) url sha256; }) { inherit system; };
66+ hasNixpkgsPath = builtins.any (x: x.prefix == "nixpkgs") builtins.nixPath;
67+ hasThisAsNixpkgsPath = <nixpkgs> == ./.;
68+ in
69+ if builtins.hasAttr "nixpkgs" sources
70+ then sourcesNixpkgs
71+ else if hasNixpkgsPath && ! hasThisAsNixpkgsPath then
72+ import <nixpkgs> {}
73+ else
74+ abort
75+ ''
76+ Please specify either <nixpkgs> (through -I or NIX_PATH=nixpkgs=...) or
77+ add a package called "nixpkgs" to your sources.json.
78+ '';
79+
80+ # The actual fetching function.
81+ fetch = pkgs: name: spec:
82+
83+ if ! builtins.hasAttr "type" spec then
84+ abort "ERROR: niv spec ${name} does not have a 'type' attribute"
85+ else if spec.type == "file" then fetch_file pkgs name spec
86+ else if spec.type == "tarball" then fetch_tarball pkgs name spec
87+ else if spec.type == "git" then fetch_git name spec
88+ else if spec.type == "local" then fetch_local spec
89+ else if spec.type == "builtin-tarball" then fetch_builtin-tarball name
90+ else if spec.type == "builtin-url" then fetch_builtin-url name
91+ else
92+ abort "ERROR: niv spec ${name} has unknown type ${builtins.toJSON spec.type}";
93+
94+ # If the environment variable NIV_OVERRIDE_${name} is set, then use
95+ # the path directly as opposed to the fetched source.
96+ replace = name: drv:
97+ let
98+ saneName = stringAsChars (c: if isNull (builtins.match "[a-zA-Z0-9]" c) then "_" else c) name;
99+ ersatz = builtins.getEnv "NIV_OVERRIDE_${saneName}";
100+ in
101+ if ersatz == "" then drv else ersatz;
102+
103+ # Ports of functions for older nix versions
104+
105+ # a Nix version of mapAttrs if the built-in doesn't exist
106+ mapAttrs = builtins.mapAttrs or (
107+ f: set: with builtins;
108+ listToAttrs (map (attr: { name = attr; value = f attr set.${attr}; }) (attrNames set))
109+ );
110+
111+ # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/lists.nix#L295
112+ range = first: last: if first > last then [] else builtins.genList (n: first + n) (last - first + 1);
113+
114+ # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L257
115+ stringToCharacters = s: map (p: builtins.substring p 1 s) (range 0 (builtins.stringLength s - 1));
116+
117+ # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L269
118+ stringAsChars = f: s: concatStrings (map f (stringToCharacters s));
119+ concatMapStrings = f: list: concatStrings (map f list);
120+ concatStrings = builtins.concatStringsSep "";
121+
122+ # https://github.com/NixOS/nixpkgs/blob/8a9f58a375c401b96da862d969f66429def1d118/lib/attrsets.nix#L331
123+ optionalAttrs = cond: as: if cond then as else {};
124+
125+ # fetchTarball version that is compatible between all the versions of Nix
126+ builtins_fetchTarball = { url, name ? null, sha256 }@attrs:
127+ let
128+ inherit (builtins) lessThan nixVersion fetchTarball;
129+ in
130+ if lessThan nixVersion "1.12" then
131+ fetchTarball ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))
132+ else
133+ fetchTarball attrs;
134+
135+ # fetchurl version that is compatible between all the versions of Nix
136+ builtins_fetchurl = { url, name ? null, sha256 }@attrs:
137+ let
138+ inherit (builtins) lessThan nixVersion fetchurl;
139+ in
140+ if lessThan nixVersion "1.12" then
141+ fetchurl ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))
142+ else
143+ fetchurl attrs;
144+
145+ # Create the final "sources" from the config
146+ mkSources = config:
147+ mapAttrs (
148+ name: spec:
149+ if builtins.hasAttr "outPath" spec
150+ then abort
151+ "The values in sources.json should not have an 'outPath' attribute"
152+ else
153+ spec // { outPath = replace name (fetch config.pkgs name spec); }
154+ ) config.sources;
155+
156+ # The "config" used by the fetchers
157+ mkConfig =
158+ { sourcesFile ? if builtins.pathExists ./sources.json then ./sources.json else null
159+ , sources ? if isNull sourcesFile then {} else builtins.fromJSON (builtins.readFile sourcesFile)
160+ , system ? builtins.currentSystem
161+ , pkgs ? mkPkgs sources system
162+ }: rec {
163+ # The sources, i.e. the attribute set of spec name to spec
164+ inherit sources;
165+
166+ # The "pkgs" (evaluated nixpkgs) to use for e.g. non-builtin fetchers
167+ inherit pkgs;
168+ };
169+
170+in
171+mkSources (mkConfig {}) // { __functor = _: settings: mkSources (mkConfig settings); }
pkgs.nixdeleted−7
@@ -1,7 +0,0 @@
1−let
2−nixpkgs = builtins.fetchGit {
3− url = "https://github.com/NixOS/nixpkgs";
4− rev = "f58482658eabf7d695f45904ecbc5f49c19fef98";
5−};
6−in
7−import nixpkgs { config.allowBroken = true; }
project-m36.cabal+105−118
@@ -1,7 +1,8 @@
11Cabal-Version: 2.2
22Name: project-m36
3−Version: 0.9.0
4−License: Unlicense
3+Version: 0.9.3
4+License: MIT
5+--note that this license specification is erroneous and only labeled MIT to appease hackage which does not recognize public domain packages in cabal >2.2- Project:M36 is dedicated to the public domain
56Build-Type: Simple
67Homepage: https://github.com/agentm/project-m36
78Bug-Reports: https://github.com/agentm/project-m36/issues
@@ -34,7 +35,7 @@ Flag haskell-scripting
3435 Default: True
3536
3637Library
37− Build-Depends: base>=4.8 && < 4.15, ghc-paths, mtl, containers, unordered-containers, hashable, haskeline, directory, MonadRandom, random-shuffle, uuid >= 1.3.12, cassava >= 0.4.5.1 && < 0.6, text, bytestring, deepseq, deepseq-generics, vector, parallel, monad-parallel, exceptions, transformers, gnuplot, filepath, zlib, directory, temporary, stm, time, hashable-time, old-locale, rset, attoparsec, either, base64-bytestring, data-interval, extended-reals, network-transport, aeson >= 1.1, path-pieces, conduit, resourcet, http-api-data, semigroups, QuickCheck, quickcheck-instances, list-t, stm-containers >= 0.2.15, foldl, optparse-applicative, Glob, cryptohash-sha256, text-manipulate >= 0.2.0.1 && < 0.3, winery, curryer, network
38+ Build-Depends: base>=4.8 && < 4.15, ghc-paths, mtl, containers, unordered-containers, hashable, haskeline, directory, MonadRandom, random-shuffle, uuid >= 1.3.12, cassava >= 0.4.5.1 && < 0.6, text, bytestring, deepseq, deepseq-generics, vector, parallel, monad-parallel, exceptions, transformers, gnuplot, filepath, zlib, directory, temporary, stm, time, hashable-time, old-locale, rset, attoparsec, either, base64-bytestring, data-interval, extended-reals, aeson >= 1.1, path-pieces, conduit, resourcet, http-api-data, semigroups, QuickCheck, quickcheck-instances, list-t, stm-containers >= 0.2.15, foldl, optparse-applicative, Glob, cryptohash-sha256, text-manipulate >= 0.2.0.1 && < 0.4, winery, curryer-rpc, network, async, vector-instances, recursion-schemes, streamly >= 0.7.2, convertible
3839 if flag(haskell-scripting)
3940 Build-Depends: ghc >= 8.2 && < 8.11
4041 CPP-Options: -DPM36_HASKELL_SCRIPTING
@@ -62,6 +63,7 @@ Library
6263 ProjectM36.AtomFunction,
6364 ProjectM36.AtomFunctionError,
6465 ProjectM36.ScriptSession,
66+ ProjectM36.Shortcuts,
6567 ProjectM36.DatabaseContextFunction,
6668 ProjectM36.DatabaseContextFunctionError,
6769 ProjectM36.DatabaseContextFunctionUtils,
@@ -116,7 +118,6 @@ Library
116118 ProjectM36.Serialise.DataFrame,
117119 ProjectM36.Serialise.DatabaseContextFunctionError,
118120 ProjectM36.Serialise.IsomorphicSchema,
119− ProjectM36.Server.Types,
120121 ProjectM36.Session,
121122 ProjectM36.Sessions,
122123 ProjectM36.Transaction.Persist,
@@ -135,14 +136,14 @@ Library
135136 Other-Modules: ProjectM36.Win32Handle
136137 else
137138 --219- too many exported symbols under Windows and GHC 8.4
138− GHC-Options: -rdynamic
139+ GHC-Options: -rdynamic -fexternal-interpreter
139140 C-sources: cbits/DirectoryFsync.c, cbits/darwin_statfs.c
140141 Build-Depends: unix
141142 CC-Options: -fPIC
142143 Hs-Source-Dirs: ./src/lib
143144 Default-Language: Haskell2010
144145 Default-Extensions: OverloadedStrings, CPP
145− if !flag(stack)
146+ if !flag(stack)
146147 Build-Depends: deferred-folds
147148
148149Executable tutd
@@ -174,7 +175,7 @@ Executable tutd
174175 directory,
175176 filepath,
176177 temporary,
177− megaparsec >= 5.2.0 && < 9,
178+ megaparsec >= 5.2.0 && < 10,
178179 haskeline,
179180 random, MonadRandom,
180181 base64-bytestring,
@@ -183,7 +184,14 @@ Executable tutd
183184 stm-containers >= 1.0.0,
184185 list-t,
185186 parser-combinators,
186− curryer
187+ curryer-rpc,
188+ prettyprinter,
189+ cryptohash-sha256,
190+ --due to decode signature change
191+ base16-bytestring >= 1.0.0.0,
192+ http-conduit,
193+ modern-uri,
194+ http-types
187195 Other-Modules: TutorialD.Interpreter,
188196 TutorialD.Interpreter.Base,
189197 TutorialD.Interpreter.DatabaseContextExpr,
@@ -202,6 +210,7 @@ Executable tutd
202210 TutorialD.Interpreter.SchemaOperator,
203211 TutorialD.Interpreter.TransGraphRelationalOperator,
204212 TutorialD.Interpreter.SchemaOperator
213+ TutorialD.Printer
205214 main-is: TutorialD/tutd.hs
206215 CC-Options: -fPIC
207216 GHC-Options: -Wall -threaded
@@ -214,8 +223,8 @@ Executable project-m36-server
214223 Build-Depends: ghc >= 8.2 && < 8.11
215224 Build-Depends: base,
216225 ghc-paths,
217− project-m36,
218226 transformers,
227+ project-m36,
219228 temporary,
220229 data-interval,
221230 deepseq,
@@ -228,7 +237,6 @@ Executable project-m36-server
228237 optparse-applicative,
229238 hashable-time,
230239 time,
231− vector-binary-instances,
232240 text,
233241 deepseq-generics,
234242 mtl,
@@ -250,7 +258,7 @@ Executable project-m36-server
250258Executable bigrel
251259 Default-Language: Haskell2010
252260 Default-Extensions: OverloadedStrings
253− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups, parser-combinators
261+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups, parser-combinators
254262 Other-Modules: TutorialD.Interpreter.Base,
255263 TutorialD.Interpreter.DatabaseContextExpr,
256264 TutorialD.Interpreter.RelationalExpr,
@@ -262,11 +270,11 @@ Executable bigrel
262270 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
263271
264272Common commontest
265− Default-Language: Haskell2010
266− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators
273+ Default-Language: Haskell2010
274+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators, winery, curryer-rpc, prettyprinter, base64-bytestring, modern-uri, http-types, http-conduit, base16-bytestring,cryptohash-sha256
267275 Default-Extensions: OverloadedStrings
268276 GHC-Options: -Wall -threaded
269− Hs-Source-Dirs: ./src/bin, ., test/
277+ Hs-Source-Dirs: test, src/bin
270278
271279Benchmark basic-benchmark
272280 Default-Language: Haskell2010
@@ -279,121 +287,131 @@ Benchmark basic-benchmark
279287 if flag(profiler)
280288 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
281289
290+--benchmark inserts, updates, deletes for a basic use-case to shake out any space leaks
291+Benchmark update-exprs
292+ Default-Language: Haskell2010
293+ Default-Extensions: OverloadedStrings
294+ Build-Depends: base, criterion, project-m36, text, winery
295+ Main-Is: benchmark/Server.hs
296+ Type: exitcode-stdio-1.0
297+ GHC-Options: -Wall -threaded -rtsopts
298+ HS-Source-Dirs: ./src/bin
299+ if flag(profiler)
300+ GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall -fexternal-interpreter
301+
282302Test-Suite test-tutoriald
283303 import: commontest
284304 type: exitcode-stdio-1.0
285− main-is: test/TutorialD/Interpreter.hs
286− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator
305+ main-is: TutorialD/InterpreterTest.hs
306+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer
307+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, list-t, project-m36, random, MonadRandom, semigroups, parser-combinators, prettyprinter
287308
288309Test-Suite test-tutoriald-atomfunctionscript
289310 import: commontest
290311 type: exitcode-stdio-1.0
291− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator
292− main-is: test/TutorialD/Interpreter/AtomFunctionScript.hs
312+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer
313+ main-is: TutorialD/Interpreter/AtomFunctionScript.hs
293314
294315Test-Suite test-tutoriald-databasecontextfunctionscript
295316 import: commontest
296317 type: exitcode-stdio-1.0
297− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator
298− main-is: test/TutorialD/Interpreter/DatabaseContextFunctionScript.hs
318+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer
319+ main-is: TutorialD/Interpreter/DatabaseContextFunctionScript.hs
299320
300321Test-Suite test-relation
301322 import: commontest
302323 type: exitcode-stdio-1.0
303− main-is: test/Relation/Basic.hs
324+ main-is: Relation/Basic.hs
304325
305326Test-Suite test-static-optimizer
306327 import: commontest
307328 type: exitcode-stdio-1.0
308− main-is: test/Relation/StaticOptimizer.hs
329+ main-is: Relation/StaticOptimizer.hs
309330
310331Test-Suite test-transactiongraph-persist
311332 import: commontest
312333 type: exitcode-stdio-1.0
313− main-is: test/TransactionGraph/Persist.hs
314− Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples
334+ main-is: TransactionGraph/Persist.hs
335+ Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Printer
315336
316337Test-Suite test-relation-import-csv
317338 import: commontest
318339 type: exitcode-stdio-1.0
319− main-is: test/Relation/Import/CSV.hs
340+ main-is: Relation/Import/CSV.hs
320341
321342Test-Suite test-tutoriald-import-tutoriald
322− Default-Language: Haskell2010
323− Default-Extensions: OverloadedStrings
343+ import: commontest
324344 type: exitcode-stdio-1.0
325− main-is: test/TutorialD/Interpreter/Import/TutorialD.hs
326− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, random, MonadRandom, semigroups, parser-combinators
327− Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples
328− GHC-Options: -Wall -threaded
329− Hs-Source-Dirs: ., ./src/bin
345+ main-is: TutorialD/Interpreter/Import/ImportTest.hs
346+ Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Printer
330347
331348Test-Suite test-relation-export-csv
332− Default-Language: Haskell2010
333− Default-Extensions: OverloadedStrings
349+ import: commontest
334350 type: exitcode-stdio-1.0
335− main-is: test/Relation/Export/CSV.hs
336− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36
337− GHC-Options: -Wall -threaded
351+ main-is: Relation/Export/CSV.hs
338352
339353Test-Suite test-transactiongraph-merge
340− Default-Language: Haskell2010
341− Default-Extensions: OverloadedStrings
354+ import: commontest
342355 type: exitcode-stdio-1.0
343− main-is: test/TransactionGraph/Merge.hs
344− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, template-haskell, transformers, aeson, conduit, either, path-pieces, http-api-data, stm-containers, list-t, project-m36
345− GHC-Options: -Wall -threaded
356+ main-is: TransactionGraph/Merge.hs
357+
358+
359+Test-Suite test-prettyprinter
360+ import: commontest
361+ type: exitcode-stdio-1.0
362+ main-is: TutorialD/PrinterTest.hs
363+ Other-Modules: TutorialD.Printer, TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types
346364
347365benchmark bench
348− Default-Language: Haskell2010
349− Default-Extensions: OverloadedStrings
366+ import: commontest
350367 type: exitcode-stdio-1.0
351368 main-is: benchmark/Relation.hs
352− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, criterion, stm-containers, project-m36
353− GHC-Options: -Wall -rtsopts -threaded
354− Hs-Source-Dirs: ./src/bin
355369
356370Test-Suite test-server
357− Default-Language: Haskell2010
358− Default-Extensions: OverloadedStrings
371+ import: commontest
359372 type: exitcode-stdio-1.0
360− main-is: test/Server/Main.hs
361− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, project-m36, network-transport, semigroups
362− HS-Source-Dirs: ., ./src/bin
363− GHC-Options: -Wall -threaded
373+ main-is: Server/Main.hs
374+
364375
365376Executable Example-SimpleClient
366377 Default-Language: Haskell2010
367378 Default-Extensions: OverloadedStrings
368− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, ghc, ghc-paths, project-m36, random, MonadRandom
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
369380 Main-Is: examples/SimpleClient.hs
370381 GHC-Options: -Wall -threaded
371382
372383Executable Example-OutOfTheTarpit
373384 Default-Language: Haskell2010
374385 Default-Extensions: OverloadedStrings
375− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery
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
376387 Main-Is: examples/out_of_the_tarpit.hs
377388 GHC-Options: -Wall -threaded
378389
379390Executable Example-Blog
380391 Default-Language: Haskell2010
381392 Default-Extensions: OverloadedStrings
382− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, scotty, blaze-html, http-types, winery
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
383394 Main-Is: examples/blog.hs
384395 GHC-Options: -Wall -threaded
385396
386397Executable Example-Hair
387398 Default-Language: Haskell2010
388399 Default-Extensions: OverloadedStrings
389− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery
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
390401 Main-Is: examples/hair.hs
391402 GHC-Options: -Wall -threaded
392403
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+
393411Executable Example-CustomTupleable
394412 Default-Language: Haskell2010
395413 Default-Extensions: OverloadedStrings
396− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery
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
397415 Main-Is: examples/CustomTupleable.hs
398416 GHC-Options: -Wall -threaded
399417
@@ -408,95 +426,63 @@ Executable Example-DerivingCustomTupleable
408426 GHC-Options: -Wall -threaded
409427
410428Test-Suite test-scripts
411− Default-Language: Haskell2010
412− Default-Extensions: OverloadedStrings
429+ import: commontest
413430 type: exitcode-stdio-1.0
414− main-is: test/scripts.hs
415− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, project-m36, random, MonadRandom, semigroups, parser-combinators
416− Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.Import.BasicExamples
417− GHC-Options: -Wall -threaded
418− Hs-Source-Dirs: ., ./src/bin
431+ main-is: scripts.hs
432+ Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Printer
419433
420434Executable project-m36-websocket-server
421435 Default-Language: Haskell2010
422− Build-Depends: base, aeson, path-pieces, either, conduit, http-api-data, template-haskell, websockets, aeson, optparse-applicative, project-m36, containers, bytestring, text, vector, uuid, megaparsec, haskeline, mtl, directory, base64-bytestring, random, MonadRandom, time, network-transport-tcp, semigroups, attoparsec, parser-combinators, network
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
423437 Main-Is: ProjectM36/Server/WebSocket/websocket-server.hs
424− Other-Modules: ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator
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
425439 GHC-Options: -Wall -threaded
426440 Hs-Source-Dirs: ./src/bin
427441 Default-Extensions: OverloadedStrings
428442
429443Test-Suite test-websocket-server
430− Default-Language: Haskell2010
444+ import: commontest
431445 type: exitcode-stdio-1.0
432− main-is: test/Server/WebSocket.hs
433− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, network-transport-tcp, semigroups, parser-combinators
434− Other-Modules: TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.TransactionGraphOperator, ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator
435− Default-Extensions: OverloadedStrings
436− GHC-Options: -Wall -threaded
437− Hs-Source-Dirs: ./src/bin, .
446+ main-is: Server/WebSocket.hs
447+ Other-Modules: TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.TransactionGraphOperator, ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer
438448
439449Test-Suite test-isomorphic-schemas
440− Default-Language: Haskell2010
450+ import: commontest
441451 type: exitcode-stdio-1.0
442− main-is: test/IsomorphicSchema.hs
443− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36
444− Default-Extensions: OverloadedStrings
445− GHC-Options: -Wall -threaded
446− Hs-Source-Dirs: ./src/bin, .
452+ main-is: IsomorphicSchema.hs
447453
448454Test-Suite test-atomable
449− Default-Language: Haskell2010
455+ import: commontest
450456 type: exitcode-stdio-1.0
451− main-is: test/Relation/Atomable.hs
452− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators, winery
453− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types
454− Default-Extensions: OverloadedStrings
455− GHC-Options: -Wall -threaded
456− Hs-Source-Dirs: ./src/bin, ., test/
457+ main-is: Relation/Atomable.hs
458+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Printer
457459
458460Test-Suite test-multiprocess-access
459− Default-Language: Haskell2010
461+ import: commontest
460462 type: exitcode-stdio-1.0
461− main-is: test/MultiProcessDatabaseAccess.hs
462− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom
463− Default-Extensions: OverloadedStrings
464− GHC-Options: -Wall -threaded
465− Hs-Source-Dirs: ./src/bin, ., test/
463+ main-is: MultiProcessDatabaseAccess.hs
466464
467465Test-Suite test-transactiongraph-automerge
468− Default-Language: Haskell2010
466+ import: commontest
469467 type: exitcode-stdio-1.0
470− main-is: test/TransactionGraph/Automerge.hs
471− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators
472− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types
473− Default-Extensions: OverloadedStrings
474− GHC-Options: -Wall -threaded
475− Hs-Source-Dirs: ./src/bin, ., test/
468+ main-is: TransactionGraph/Automerge.hs
469+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Printer
476470
477471Test-Suite test-tupleable
478− Default-Language: Haskell2010
472+ import: commontest
479473 type: exitcode-stdio-1.0
480− main-is: test/Relation/Tupleable.hs
481− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups
482− Default-Extensions: OverloadedStrings
483− GHC-Options: -Wall -threaded
484− Hs-Source-Dirs: ./src/bin, ., test/
474+ main-is: Relation/Tupleable.hs
485475
486476Test-Suite test-client-simple
487− Default-Language: Haskell2010
488− Main-Is: test/Client/Simple.hs
477+ import: commontest
478+ Main-Is: Client/Simple.hs
489479 type: exitcode-stdio-1.0
490− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups
491− Default-Extensions: OverloadedStrings
492− GHC-Options: -Wall -threaded
493− Hs-Source-Dirs: ./src/bin, ., test/
494480
495481-- test for file handle leaks
496482Executable handles
497483 Default-Language: Haskell2010
498484 Default-Extensions: OverloadedStrings
499− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups, parser-combinators
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
500486 main-is: benchmark/Handles.hs
501487 Other-Modules: TutorialD.Interpreter,
502488 TutorialD.Interpreter.Base,
@@ -515,13 +501,14 @@ Executable handles
515501 TutorialD.Interpreter.TransGraphRelationalOperator,
516502 TutorialD.Interpreter.TransactionGraphOperator,
517503 TutorialD.Interpreter.Types
504+ TutorialD.Printer
518505 GHC-Options: -Wall -threaded -rtsopts
519506 HS-Source-Dirs: ./src/bin
520507 if flag(profiler)
521508 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
522−
523−Test-Suite test-dataframe
524− import: commontest
525− Main-Is: test/DataFrame.hs
526− type: exitcode-stdio-1.0
527509
510+Test-Suite test-dataframe
511+ import: commontest
512+ type: exitcode-stdio-1.0
513+ Main-Is: DataFrame.hs
514+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Printer
release.nix+17−58
@@ -1,71 +1,30 @@
1−{ compiler ? "ghc865"
2−, pkgs ? import ./pkgs.nix
1+{ compiler ? "ghc8104"
2+, sources ? import ./nix/sources.nix
3+, pkgs ? import sources.nixpkgs { }
34}:
4−
55let
6− inherit (pkgs.lib.trivial) flip pipe;
7− inherit (pkgs.haskell.lib) appendPatch appendConfigureFlags;
86 doJailbreak = pkgs.haskell.lib.doJailbreak;
9− dontHaddock = pkgs.haskell.lib.dontHaddock;
10− dontCheck = pkgs.haskell.lib.dontCheck;
11− distProcessPkg = pkg : dontHaddock (doJailbreak (dontCheck pkg));
12− callHackageDirectWithOptions = {pkg,ver, sha256, options}:
13− let pkgver = "${pkg}-${ver}";
14− in
15− haskellPackages.callCabal2nixWithOptions pkg (pkgs.fetchzip {
16− url = "mirror://hackage/${pkgver}/${pkgver}.tar.gz";
17− inherit sha256;
18− }) options;
19−
7+ needsCocoa = drv:
8+ if pkgs.stdenv.isDarwin
9+ then drv.overrideDerivation (old:
10+ { buildInputs = [ pkgs.darwin.apple_sdk.frameworks.Cocoa ] ++ old.buildInputs; }
11+ )
12+ else drv;
13+
2014 haskellPackages = pkgs.haskell.packages.${compiler}.override {
2115 overrides = self: super: {
22− rank1dynamic =
23− distProcessPkg (self.callHackageDirect {
24− pkg = "rank1dynamic";
25− ver = "0.4.0";
26− sha256 = "1x6p9z53s7xwp93jp4n1lq6m5xspcn6w62p461v8vqnp9600328b";
27−}{});
28− stm-hamt =
29− self.callHackageDirect {
30− pkg = "stm-hamt";
31− ver = "1.2.0.3";
32− sha256 = "1i8j7q8nhx3l7gydrjlsyhkvllr6bppgrjf0hp38zpm7p6xcv2bb";
33− }{};
34−
35− stm-containers =
36− self.callHackageDirect {
37− pkg = "stm-containers";
38− ver = "1.1.0.4";
39− sha256 = "0h9z6lawdm44minx9spvdb7sp645l36ri5cnxvhrcxwzr64s7qb5";
40− }{};
41−
42− data-interval =
43− self.callHackageDirect {
44− pkg = "data-interval";
45− ver = "2.0.1";
46− sha256 = "085j4yjr8wimxampxqdrg47p577whwg2mjxgfdl44yfck52fb6an";
47− }{};
48−
49− curryer =
50− self.callHackageDirect {
51− pkg = "curryer";
52− ver = "0.1";
53− sha256 = "085j4yjr8wimxampxqdrg47p577whwg2mjxgfdl44yfck52fb6ac";
54− }{};
55−
56− project-m36 = dontCheck (self.callCabal2nixWithOptions "project-m36" ./. "-f-haskell-scripting" { });
57−
16+ curryer-rpc = self.callCabal2nix "curryer-rpc" sources.curryer { };
17+ streamly = doJailbreak (needsCocoa (self.callCabal2nix "streamly" sources.streamly { }));
18+ project-m36 = ((self.callCabal2nixWithOptions "project-m36" ./. "-f-haskell-scripting" { }));
5819 };
5920 };
60−
61− project = haskellPackages.project-m36;
6221in
6322{
64− project = project;
23+ project = haskellPackages.project-m36;
6524
6625 shell = haskellPackages.shellFor {
67− packages = p: with p; [
68− project
26+ packages = p: [
27+ p.project-m36
6928 ];
7029 buildInputs = [
7130 haskellPackages.ghcid
@@ -74,4 +33,4 @@ in
7433 ];
7534 withHoogle = true;
7635 };
77−}
36+}
scripts/DateExamples.tutd+2−2
@@ -20,7 +20,7 @@ sp := relation{tuple{s# "S1",p# "P1",qty 300},
2020 tuple{s# "S3",p# "P2",qty 200},
2121 tuple{s# "S4",p# "P4",qty 300},
2222 tuple{s# "S4",p# "P5",qty 400}};
23−key s_pkey {s#} s
24−key p_key {p#} p
23+key s_pkey {s#} s;
24+key p_key {p#} p;
2525foreign key s_sp_fk sp{s#} in s{s#};
2626foreign key p_sp_fk sp{p#} in p{p#};
scripts/multiline.tutdnew file+2
@@ -0,0 +1,2 @@
1+x:=relation{
2+tuple{ x 2}} -- nice
src/bin/ProjectM36/Server/RemoteCallTypes/Json.hs+20−2
@@ -11,6 +11,7 @@ import ProjectM36.Error
1111import ProjectM36.IsomorphicSchema
1212import ProjectM36.Server.RemoteCallTypes
1313import ProjectM36.MerkleHash
14+import ProjectM36.Attribute as A
1415
1516import Data.Aeson
1617import Data.ByteString.Base64 as B64
@@ -44,8 +45,11 @@ instance FromJSON ExecuteRelationalExpr
4445instance ToJSON Relation
4546instance FromJSON Relation
4647
47−instance ToJSON Attribute
48−instance FromJSON Attribute
48+instance ToJSON Attribute where
49+ toJSON (Attribute attrName aType) = object [ "name" .= attrName
50+ , "type" .= toJSON aType ]
51+instance FromJSON Attribute where
52+ parseJSON = withObject "Attribute" $ \v -> Attribute <$> v .: "name" <*> v .: "type"
4953
5054instance ToJSON ExtendTupleExpr
5155instance FromJSON ExtendTupleExpr
@@ -99,6 +103,8 @@ instance ToJSON Atom where
99103 "val" .= i ]
100104 toJSON atom@(RelationAtom i) = object [ "type" .= atomTypeForAtom atom,
101105 "val" .= i ]
106+ toJSON atom@(RelationalExprAtom i) = object [ "type" .= atomTypeForAtom atom,
107+ "val" .= i ]
102108 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [
103109 "dataconstructorname" .= dConsName,
104110 "type" .= toJSON atomtype,
@@ -126,6 +132,7 @@ instance FromJSON Atom where
126132 Left err -> fail ("Failed to parse base64-encoded ByteString: " ++ err)
127133 Right bs -> pure (ByteStringAtom bs)
128134 BoolAtomType -> BoolAtom <$> o .: "val"
135+ RelationalExprAtomType -> RelationalExprAtom <$> o .: "val"
129136
130137instance ToJSON Notification
131138instance FromJSON Notification
@@ -142,6 +149,12 @@ instance FromJSON MerkleHash where
142149 Left err -> fail ("Failed to parse merkle hash: " ++ err)
143150 Right bs -> pure (MerkleHash bs)
144151
152+instance ToJSON Attributes where
153+ toJSON attrs = object ["attributes" .= map toJSON (A.toList attrs)]
154+instance FromJSON Attributes where
155+ parseJSON = withObject "Attributes" $ \o ->
156+ A.attributesFromList <$> o .: "attributes"
157+
145158instance ToJSON RelationalError
146159instance FromJSON RelationalError
147160
@@ -151,6 +164,9 @@ instance FromJSON SchemaError
151164instance ToJSON MergeError
152165instance FromJSON MergeError
153166
167+instance ToJSON ImportError'
168+instance FromJSON ImportError'
169+
154170instance ToJSON DatabaseContextFunctionError
155171instance FromJSON DatabaseContextFunctionError
156172
@@ -165,3 +181,5 @@ instance FromJSON AtomFunctionError
165181
166182instance ToJSON WithNameExpr
167183instance FromJSON WithNameExpr
184+
185+
src/bin/ProjectM36/Server/WebSocket.hs+2−1
@@ -22,6 +22,7 @@ import Data.Attoparsec.Text
2222import Control.Applicative
2323import Text.Megaparsec.Error
2424import Data.Functor
25+import Data.Either (fromRight)
2526
2627#if MIN_VERSION_megaparsec(7,0,0)
2728import Data.List.NonEmpty as NE
@@ -117,7 +118,7 @@ promptInfo :: SessionId -> Connection -> IO (HeadName, SchemaName)
117118promptInfo sessionId conn = do
118119 eHeadName <- headName sessionId conn
119120 eSchemaName <- currentSchemaName sessionId conn
120− pure (either (const "<unknown>") id eHeadName, either (const "<no schema>") id eSchemaName)
121+ pure (fromRight "<unknown>" eHeadName, fromRight "<no schema>" eSchemaName)
121122
122123sendPromptInfo :: (HeadName, SchemaName) -> WS.Connection -> IO ()
123124sendPromptInfo (hName, sName) conn = WS.sendTextData conn (encode (object ["promptInfo" .= object ["headname" .= hName, "schemaname" .= sName]]))
src/bin/ProjectM36/Server/WebSocket/websocket-client.html+1−1
@@ -126,7 +126,7 @@ margin-bottom: 5pt;
126126 <li>:showrelvars</li>
127127 <li>:showexpr true</li>
128128 <li>:showexpr false</li>
129− <li>:importexample date</li>
129+ <li>:importexample cjdate</li>
130130 <li>:showexpr s join sp</li>
131131 <li>update s where city=&quot;Paris&quot; (status:=10)</li>
132132 <li>:showexpr s</li>
src/bin/ProjectM36/Server/WebSocket/websocket-server.hs+42−9
@@ -1,23 +1,40 @@
11{-# LANGUAGE CPP #-}
2−import ProjectM36.Server.WebSocket
3−import ProjectM36.Server.Config
4−import ProjectM36.Server.ParseArgs
5−import ProjectM36.Server
2+
63import Control.Concurrent
7−import qualified Network.WebSockets as WS
84import Control.Exception
5+import Control.Monad (when)
6+import Data.Maybe (isJust)
7+import Data.String (fromString)
8+import Network.HTTP.Types (status400)
99import Network.Socket
10+import Network.Wai (Application, responseLBS)
11+import Network.Wai.Handler.Warp
12+import Network.Wai.Handler.WarpTLS (runTLS, tlsSettings)
13+import qualified Network.Wai.Handler.WebSockets as WS
14+import Network.WebSockets (defaultConnectionOptions)
15+import ProjectM36.Server
16+import ProjectM36.Server.Config
17+import ProjectM36.Server.ParseArgs
18+import ProjectM36.Server.WebSocket
1019
1120main :: IO ()
1221main = do
1322 -- launch normal project-m36-server
1423 addressMVar <- newEmptyMVar
15− serverConfig <- parseConfigWithDefaults (defaultServerConfig { bindPort = 8000, bindHost = "127.0.0.1" })
24+ wsConfig <- parseWSConfigWithDefaults (defaultServerConfig {bindPort = 8000, bindHost = "127.0.0.1"})
25+
1626 --usurp the serverConfig for our websocket server and make the proxied server run locally
17− let wsHost = bindHost serverConfig
27+ let serverConfig = wsServerConfig wsConfig
28+ wsHost = bindHost serverConfig
1829 wsPort = bindPort serverConfig
1930 serverHost = "127.0.0.1"
2031 serverConfig' = serverConfig {bindPort = 0, bindHost = serverHost}
32+ configCertificateFile = tlsCertificatePath wsConfig
33+ configKeyFile = tlsKeyPath wsConfig
34+
35+ when (isJust configCertificateFile /= isJust configKeyFile) $
36+ throwIO $ ErrorCall "TLS_CERTIFICATE_PATH and TLS_KEY_PATH must be set in tandem"
37+
2138 _ <- forkFinally (launchServer serverConfig' (Just addressMVar) >> pure ()) (either throwIO pure)
2239 --wait for server to be listening
2340 addr <- takeMVar addressMVar
@@ -25,6 +42,22 @@ main = do
2542 case addr of
2643 SockAddrInet port' _ -> fromIntegral port'
2744 _ -> error "unsupported socket address (IPv4 only currently)"
28− --this built-in server is apparently not meant for production use, but it's easier to test than starting up the wai or snap interfaces
29− WS.runServer wsHost (fromIntegral wsPort) (websocketProxyServer port serverHost)
45+ wsApp = websocketProxyServer port serverHost
46+ waiApp = WS.websocketsOr defaultConnectionOptions wsApp backupApp
47+ settings = warpSettings wsHost (fromIntegral wsPort)
48+
49+ case (configCertificateFile, configKeyFile) of
50+ (Just certificate, Just key) -> runTLS (tlsSettings certificate key) settings waiApp
51+ _ -> runSettings settings waiApp
52+
53+backupApp :: Application
54+backupApp _ respond = respond $ responseLBS status400 [] "Not a WebSocket request"
3055
56+warpSettings :: HostName -> Port -> Settings
57+warpSettings host port =
58+ setHost (fromString host)
59+ . setPort port
60+ . setServerName "project-m36"
61+ . setTimeout 3600
62+ . setGracefulShutdownTimeout (Just 5)
63+ $ defaultSettings
src/bin/TutorialD/Interpreter.hs+3−1
@@ -34,6 +34,7 @@ import Data.Monoid
3434import Data.List (isPrefixOf)
3535import Control.Exception
3636import System.Exit
37+import Data.Either (fromRight)
3738
3839{-
3940context ops are read-only operations which only operate on the database context (relvars and constraints)
@@ -77,7 +78,7 @@ safeInterpreterParserP = fmap RODatabaseContextOp (roDatabaseContextOperatorP <*
7778promptText :: Either RelationalError HeadName -> Either RelationalError SchemaName -> StringType
7879promptText eHeadName eSchemaName = "TutorialD (" <> transInfo <> "): "
7980 where
80− transInfo = either (const "<unknown>") id eHeadName <> "/" <> either (const "<no schema>") id eSchemaName
81+ transInfo = fromRight "<unknown>" eHeadName <> "/" <> fromRight "<no schema>" eSchemaName
8182
8283parseTutorialD :: T.Text -> Either ParserError ParsedOperation
8384parseTutorialD = parse interpreterParserP ""
@@ -215,6 +216,7 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of
215216 unsafeError = pure $ DisplayErrorResult "File I/O operation prohibited."
216217 barf :: RelationalError -> IO TutorialDOperatorResult
217218 barf (ScriptError (OtherScriptCompilationError errStr)) = pure (DisplayErrorResult (T.pack errStr))
219+ barf (ParseError err) = pure (DisplayErrorResult err)
218220 barf err = return $ DisplayErrorResult (T.pack (show err))
219221 eHandler io = do
220222 eErr <- io
src/bin/TutorialD/Interpreter/Base.hs+29−8
@@ -12,11 +12,12 @@ module TutorialD.Interpreter.Base (
1212 where
1313import ProjectM36.Base
1414import ProjectM36.AtomType
15+import ProjectM36.Attribute as A
1516import ProjectM36.Relation
1617import ProjectM36.DataFrame
1718
1819#if MIN_VERSION_megaparsec(6,0,0)
19−import Text.Megaparsec.Char
20+import Text.Megaparsec.Char
2021import qualified Text.Megaparsec.Char.Lexer as Lex
2122import Text.Megaparsec
2223import Data.Void
@@ -30,7 +31,6 @@ import Data.Text hiding (count)
3031import System.Random
3132import qualified Data.Text as T
3233import qualified Data.List as L
33−import qualified Data.Vector as V
3434import qualified Data.Text.IO as TIO
3535import System.IO
3636import ProjectM36.Relation.Show.Term
@@ -44,6 +44,7 @@ import Data.List.NonEmpty as NE
4444import Data.Time.Clock
4545import Data.Time.Format
4646import Control.Monad (void)
47+import Data.Char
4748
4849#if !MIN_VERSION_megaparsec(7,0,0)
4950anySingle :: Parsec Void Text (Token Text)
@@ -81,8 +82,9 @@ type ParseStr = Text
8182type ParseStr = String
8283#endif
8384
85+-- consumes only horizontal spaces
8486spaceConsumer :: Parser ()
85−spaceConsumer = Lex.space (void spaceChar) (Lex.skipLineComment "--") (Lex.skipBlockComment "{-" "-}")
87+spaceConsumer = Lex.space space1 (Lex.skipLineComment "--") (Lex.skipBlockComment "{-" "-}")
8688
8789opChar :: Parser Char
8890opChar = oneOf (":!#$%&*+./<=>?\\^|-~" :: String)-- remove "@" so it can be used as attribute marker without spaces
@@ -135,11 +137,14 @@ arrow = symbol "->"
135137semi :: Parser Text
136138semi = symbol ";"
137139
140+nline :: Parser Text
141+nline = (T.singleton <$> newline) <|> crlf
142+
138143integer :: Parser Integer
139144#if MIN_VERSION_megaparsec(6,0,0)
140−integer = Lex.signed spaceConsumer Lex.decimal
145+integer = Lex.signed (pure ()) Lex.decimal <* spaceConsumer
141146#else
142−integer = Lex.signed spaceConsumer Lex.integer
147+integer = Lex.signed (pure ()) Lex.integer <* spaceConsumer
143148#endif
144149
145150natural :: Parser Integer
@@ -150,7 +155,7 @@ natural = Lex.integer <* spaceConsumer
150155#endif
151156
152157float :: Parser Double
153−float = Lex.float
158+float = Lex.float <* spaceConsumer
154159
155160capitalizedIdentifier :: Parser Text
156161capitalizedIdentifier =
@@ -163,8 +168,8 @@ uncapitalizedIdentifier =
163168showRelationAttributes :: Attributes -> Text
164169showRelationAttributes attrs = "{" <> T.concat (L.intersperse ", " $ L.map showAttribute attrsL) <> "}"
165170 where
166− showAttribute (Attribute name atomType) = name <> " " <> prettyAtomType atomType
167− attrsL = V.toList attrs
171+ showAttribute (Attribute name atomType') = name <> " " <> prettyAtomType atomType'
172+ attrsL = A.toList attrs
168173
169174type PromptLength = Int
170175
@@ -200,6 +205,9 @@ normalQuotedString = quote *> (T.pack <$> manyTill Lex.charLiteral quote)
200205quotedString :: Parser Text
201206quotedString = try tripleQuotedString <|> normalQuotedString
202207
208+quoted :: Parser a -> Parser a
209+quoted = between quote quote
210+
203211uuidP :: Parser U.UUID
204212uuidP = do
205213 uuidStart <- count 8 hexDigitChar
@@ -222,3 +230,16 @@ utcTimeP = do
222230 case parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" (T.unpack timeStr) of
223231 Nothing -> fail "invalid datetime input, use \"YYYY-MM-DD HH:MM:SS\""
224232 Just stamp' -> pure stamp'
233+
234+
235+colonOp :: Text -> Parser ()
236+colonOp opStr = do
237+ _ <- string opStr <* (void spaceChar <|> eof) <* spaceConsumer
238+ pure ()
239+
240+hex :: Parser Text
241+hex = takeWhileP (Just "hexadecimal")
242+ (\c ->
243+ isDigit c
244+ || (c >= 'a' && c <= 'f'))
245+
src/bin/TutorialD/Interpreter/DatabaseContextExpr.hs+3−2
@@ -53,8 +53,9 @@ multilineSep :: Parser T.Text
5353multilineSep = newline >> pure "\n"
5454
5555multipleDatabaseContextExprP :: Parser DatabaseContextExpr
56−multipleDatabaseContextExprP =
57− MultipleExpr <$> sepBy1 databaseContextExprP semi
56+multipleDatabaseContextExprP = do
57+ exprs <- filter (/= NoOperation) <$> sepBy1 databaseContextExprP semi
58+ pure (MultipleExpr exprs)
5859
5960insertP :: Parser DatabaseContextExpr
6061insertP = do
src/bin/TutorialD/Interpreter/Import/Base.hs+8−3
@@ -2,6 +2,8 @@
22module TutorialD.Interpreter.Import.Base where
33import ProjectM36.Base
44import ProjectM36.Error
5+import Text.URI (URI)
6+import Data.Text (Text)
57#if __GLASGOW_HASKELL__ < 804
68import Data.Monoid
79#endif
@@ -12,11 +14,14 @@ data RelVarDataImportOperator = RelVarDataImportOperator RelVarName FilePath (Re
1214instance Show RelVarDataImportOperator where
1315 show (RelVarDataImportOperator rv path _) = "RelVarDataImportOperator " <> show rv <> " " <> path
1416
17+type HashVerification = Maybe Text
18+
1519-- | import data into a database context
16−data DatabaseContextDataImportOperator = DatabaseContextDataImportOperator FilePath (FilePath -> IO (Either RelationalError DatabaseContextExpr))
20+data DatabaseContextDataImportOperator = DatabaseContextDataImportOperator URI HashVerification (URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr))
1721
1822instance Show DatabaseContextDataImportOperator where
19− show (DatabaseContextDataImportOperator path _) = "DatabaseContextDataImportOperator " <> path
23+ show (DatabaseContextDataImportOperator uri hash _) =
24+ "DatabaseContextDataImportOperator " <> show uri <> " " <> show hash
2025
2126-- perhaps create a structure to import a whole transaction graph section in the future
2227
@@ -24,4 +29,4 @@ evalRelVarDataImportOperator :: RelVarDataImportOperator -> TypeConstructorMappi
2429evalRelVarDataImportOperator (RelVarDataImportOperator relVarName path importFunc) tConsMap attrs = importFunc relVarName tConsMap attrs path
2530
2631evalDatabaseContextDataImportOperator :: DatabaseContextDataImportOperator -> IO (Either RelationalError DatabaseContextExpr)
27−evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator path importFunc) = importFunc path
32+evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator uri hash importFunc) = importFunc uri hash
src/bin/TutorialD/Interpreter/Import/BasicExamples.hs+2−2
@@ -20,8 +20,8 @@ importBasicExampleOperatorP :: Parser ImportBasicExampleOperator
2020importBasicExampleOperatorP = do
2121 reservedOp ":importexample"
2222 example <- identifier
23− if example == "date" then
23+ if example == "cjdate" then
2424 pure ImportBasicDateExampleOperator
2525 else
2626 fail "Unknown example name"
27−
27+
src/bin/TutorialD/Interpreter/Import/CSV.hs+3−3
@@ -14,10 +14,10 @@ importCSVRelation relVarName tConsMap attrs pathIn = do
1414 --TODO: handle filesystem errors
1515 csvData <- try (BS.readFile pathIn) :: IO (Either IOError BS.ByteString)
1616 case csvData of
17− Left err -> return $ Left (ImportError $ T.pack (show err))
17+ Left err -> pure $ Left (ImportError (ImportFileError (T.pack (show err))))
1818 Right csvData' -> case csvAsRelation attrs tConsMap csvData' of
19− Left err -> return $ Left (ParseError $ T.pack (show err))
20− Right csvRel -> return $ Right (Insert relVarName (ExistingRelation csvRel))
19+ Left err -> pure $ Left (ParseError $ T.pack (show err))
20+ Right csvRel -> pure $ Right (Insert relVarName (ExistingRelation csvRel))
2121
2222importCSVP :: Parser RelVarDataImportOperator
2323importCSVP = do
src/bin/TutorialD/Interpreter/Import/TutorialD.hs+70−17
@@ -9,25 +9,78 @@ import qualified Data.Text as T
99import Control.Exception
1010import qualified Data.ByteString as BS
1111import qualified Data.Text.Encoding as TE
12−--import a file containing TutorialD database context expressions
12+import qualified Text.URI as URI
13+import Text.URI (URI)
14+import Crypto.Hash.SHA256
15+import Data.ByteString.Base16 as B16
16+import Network.HTTP.Simple
17+import Network.HTTP.Types
18+--import a file containing TutorialD database context expressions via local files or HTTP/HTTPS
1319
14−importTutorialD :: FilePath -> IO (Either RelationalError DatabaseContextExpr)
15−importTutorialD pathIn = do
16− eTutdBytes <- try (BS.readFile pathIn) :: IO (Either IOError BS.ByteString)
17− case eTutdBytes of
18− Left err -> return $ Left (ImportError $ T.pack (show err))
19− Right tutdBytes ->
20− case TE.decodeUtf8' tutdBytes of
21− Left err -> pure (Left (ImportError $ T.pack (show err)))
22− Right tutdUtf8 ->
23− case parse multipleDatabaseContextExprP "import" tutdUtf8 of
24− --parseErrorPretty is new in megaparsec 5
25− Left err -> pure (Left (PM36E.ParseError (T.pack (show err))))
26− Right expr -> pure (Right expr)
27−
20+importTutorialDFromFile :: URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr)
21+importTutorialDFromFile fileURI mHash = do
22+ case URI.uriPath fileURI of
23+ Just (False, _) -> do
24+ eTutdBytes <- try (BS.readFile filePath) :: IO (Either IOError BS.ByteString)
25+ case eTutdBytes of
26+ Left err -> pure $ Left (ImportError (ImportFileError (T.pack (show err))))
27+ Right tutdBytes ->
28+ case validateBytes tutdBytes mHash of
29+ Left err -> pure (Left err)
30+ Right tutdBytes' -> importTutorialDBytes tutdBytes'
31+ _ -> pure (Left (ImportError (InvalidFileURIError (URI.render fileURI))))
32+ where
33+ filePath = drop (length ("file://" :: String)) (URI.renderStr fileURI)
34+
35+
36+importTutorialDBytes :: BS.ByteString -> IO (Either RelationalError DatabaseContextExpr)
37+importTutorialDBytes tutdBytes =
38+ case TE.decodeUtf8' tutdBytes of
39+ Left err -> pure (Left (ImportError (ImportFileDecodeError (T.pack (show err)))))
40+ Right tutdUtf8 ->
41+ case parse (multipleDatabaseContextExprP <* eof) "import" tutdUtf8 of
42+ --parseErrorPretty is new in megaparsec 5
43+ Left err -> pure (Left (PM36E.ParseError (T.pack (errorBundlePretty err))))
44+ Right expr -> pure (Right expr)
45+
46+importTutorialDViaHTTP :: URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr)
47+importTutorialDViaHTTP uri mHash = do
48+ reqURI <- parseRequest (URI.renderStr uri)
49+ response <- httpBS reqURI
50+ let scode = getResponseStatus response
51+ if scode == ok200 then
52+ let byteBody = getResponseBody response in
53+ case validateBytes byteBody mHash of
54+ Right byteBody' -> do
55+ importTutorialDBytes byteBody'
56+ Left err -> pure (Left err)
57+ else
58+ pure (Left (ImportError (ImportDownloadError (T.pack ("download failed: " <> show scode)))))
59+
60+validateBytes :: BS.ByteString -> HashVerification -> Either RelationalError BS.ByteString
61+validateBytes tutdBytes mHash =
62+ case mHash of
63+ Nothing -> pure tutdBytes
64+ Just expectedHashText ->
65+ case B16.decode (TE.encodeUtf8 expectedHashText) of
66+ Left _ -> Left (ImportError (InvalidSHA256Error expectedHashText))
67+ Right expectedHash | hashBytes == expectedHash -> pure tutdBytes
68+ | otherwise ->
69+ let p = TE.decodeUtf8 . B16.encode in
70+ Left (ImportError (SHA256MismatchError (p expectedHash) (p hashBytes)))
71+ where
72+ hashBytes = hash tutdBytes
73+
74+
2875tutdImportP :: Parser DatabaseContextDataImportOperator
2976tutdImportP = do
3077 reserved ":importtutd"
31− path <- quotedString
78+ uri <- quoted URI.parser
3279 spaceConsumer
33− return $ DatabaseContextDataImportOperator (T.unpack path) importTutorialD
80+ mhash <- optional (quoted hex)
81+ handler <- case URI.unRText <$> URI.uriScheme uri of
82+ Nothing -> fail "URI scheme missing"
83+ Just "file" -> pure importTutorialDFromFile
84+ Just scheme | scheme `elem` ["http", "https"] -> pure importTutorialDViaHTTP
85+ | otherwise -> fail ( "unsupported URI scheme: " <> show scheme)
86+ pure $ DatabaseContextDataImportOperator uri mhash handler
src/bin/TutorialD/Interpreter/RODatabaseContextOperator.hs+33−16
@@ -1,13 +1,16 @@
11{-# LANGUAGE GADTs #-}
22module TutorialD.Interpreter.RODatabaseContextOperator where
33import ProjectM36.Base
4+import ProjectM36.Relation
45import qualified ProjectM36.DataFrame as DF
56import ProjectM36.Error
7+import ProjectM36.Tuple
68import ProjectM36.InclusionDependency
79import qualified ProjectM36.Client as C
810import TutorialD.Interpreter.Base
911import TutorialD.Interpreter.RelationalExpr
1012import TutorialD.Interpreter.DatabaseContextExpr
13+import TutorialD.Printer
1114import Control.Monad.State
1215import qualified Data.Text as T
1316import ProjectM36.Relation.Show.Gnuplot
@@ -19,7 +22,7 @@ data RODatabaseContextOperator where
1922 ShowRelation :: RelationalExpr -> RODatabaseContextOperator
2023 PlotRelation :: RelationalExpr -> RODatabaseContextOperator
2124 ShowRelationType :: RelationalExpr -> RODatabaseContextOperator
22− ShowConstraint :: StringType -> RODatabaseContextOperator
25+ ShowConstraints :: StringType -> RODatabaseContextOperator
2326 ShowPlan :: DatabaseContextExpr -> RODatabaseContextOperator
2427 ShowTypes :: RODatabaseContextOperator
2528 ShowRelationVariables :: RODatabaseContextOperator
@@ -31,44 +34,44 @@ data RODatabaseContextOperator where
3134
3235typeP :: Parser RODatabaseContextOperator
3336typeP = do
34− reservedOp ":type"
37+ colonOp ":type"
3538 ShowRelationType <$> relExprP
3639
3740showRelP :: Parser RODatabaseContextOperator
3841showRelP = do
39− reservedOp ":showexpr"
42+ colonOp ":showexpr"
4043 ShowRelation <$> relExprP
4144
4245showPlanP :: Parser RODatabaseContextOperator
4346showPlanP = do
44− reservedOp ":showplan"
47+ colonOp ":showplan"
4548 ShowPlan <$> databaseContextExprP
4649
4750showTypesP :: Parser RODatabaseContextOperator
48−showTypesP = reserved ":showtypes" >> pure ShowTypes
51+showTypesP = colonOp ":showtypes" >> pure ShowTypes
4952
5053showRelationVariables :: Parser RODatabaseContextOperator
51−showRelationVariables = reserved ":showrelvars" >> pure ShowRelationVariables
54+showRelationVariables = colonOp ":showrelvars" >> pure ShowRelationVariables
5255
5356showAtomFunctionsP :: Parser RODatabaseContextOperator
54−showAtomFunctionsP = reserved ":showatomfunctions" >> pure ShowAtomFunctions
57+showAtomFunctionsP = colonOp ":showatomfunctions" >> pure ShowAtomFunctions
5558
5659showDatabaseContextFunctionsP :: Parser RODatabaseContextOperator
57−showDatabaseContextFunctionsP = reserved ":showdatabasecontextfunctions" >> pure ShowDatabaseContextFunctions
60+showDatabaseContextFunctionsP = colonOp ":showdatabasecontextfunctions" >> pure ShowDatabaseContextFunctions
5861
5962quitP :: Parser RODatabaseContextOperator
6063quitP = do
61− reservedOp ":quit"
64+ colonOp ":quit"
6265 return Quit
6366
6467showConstraintsP :: Parser RODatabaseContextOperator
6568showConstraintsP = do
66− reservedOp ":constraints"
67− ShowConstraint <$> option "" identifier
69+ colonOp ":constraints"
70+ ShowConstraints <$> option "" identifier
6871
6972plotRelExprP :: Parser RODatabaseContextOperator
7073plotRelExprP = do
71− reserved ":plotexpr"
74+ colonOp ":plotexpr"
7275 PlotRelation <$> relExprP
7376
7477roDatabaseContextOperatorP :: Parser RODatabaseContextOperator
@@ -106,15 +109,16 @@ evalRODatabaseContextOp sessionId conn (PlotRelation expr) = do
106109 err <- plotRelation rel
107110 when (isJust err) $ print err
108111
109−evalRODatabaseContextOp sessionId conn (ShowConstraint name) = do
112+evalRODatabaseContextOp sessionId conn (ShowConstraints name) = do
110113 eIncDeps <- C.inclusionDependencies sessionId conn
111114 let val = case eIncDeps of
112115 Left err -> Left err
113116 Right incDeps -> case name of
114− "" -> inclusionDependenciesAsRelation incDeps
117+ "" -> inclusionDependenciesAsRelation incDeps >>= renderRelExprsInIncDeps
115118 depName -> case M.lookup depName incDeps of
116119 Nothing -> Left (InclusionDependencyNameNotInUseError depName)
117− Just dep -> inclusionDependenciesAsRelation (M.singleton depName dep)
120+ Just dep ->
121+ inclusionDependenciesAsRelation (M.singleton depName dep) >>= renderRelExprsInIncDeps
118122 pure $ case val of
119123 Left err -> DisplayErrorResult (T.pack (show err))
120124 Right rel -> DisplayRelationResult rel
@@ -164,7 +168,7 @@ interpretRODatabaseContextOp sessionId conn tutdstring = case parse roDatabaseCo
164168
165169showDataFrameP :: Parser RODatabaseContextOperator
166170showDataFrameP = do
167− reservedOp ":showdataframe"
171+ colonOp ":showdataframe"
168172 relExpr <- relExprP
169173 reservedOp "orderby"
170174 attrOrdersExpr <- attrOrdersExprP
@@ -191,3 +195,16 @@ attrOrderExprP = DF.AttributeOrderExpr <$> identifier <*> orderP
191195
192196orderP :: Parser DF.Order
193197orderP = try (reservedOp "ascending" >> pure DF.AscendingOrder) <|> try (reservedOp "descending" >> pure DF.DescendingOrder) <|> pure DF.AscendingOrder
198+
199+-- render RelationalExprAtoms as TutorialD
200+renderRelExprsInIncDeps :: Relation -> Either RelationalError Relation
201+renderRelExprsInIncDeps = relMogrify tupMapper attrs
202+ where
203+ tupMapper tup = pure $ mkRelationTupleFromMap (M.map mapper (tupleToMap tup))
204+ mapper (RelationalExprAtom expr) = TextAtom (T.pack (show (prettyRelationalExpr expr)))
205+ mapper atom = atom
206+ attrs = C.attributesFromList [Attribute "name" TextAtomType,
207+ Attribute "sub" TextAtomType,
208+ Attribute "super" TextAtomType
209+ ]
210+
src/bin/TutorialD/Interpreter/RelationalExpr.hs+27−8
@@ -20,9 +20,18 @@ attributeListP :: RelationalMarkerExpr a => Parser (AttributeNamesBase a)
2020attributeListP =
2121 (reservedOp "all but" >>
2222 InvertedAttributeNames . S.fromList <$> sepBy attributeNameP comma) <|>
23+
2324 (reservedOp "all from" >>
2425 RelationalExprAttributeNames <$> relExprP) <|>
25− (AttributeNames . S.fromList <$> sepBy attributeNameP comma)
26+
27+ (reservedOp "union of" >>
28+ UnionAttributeNames <$> braces attributeListP <*> braces attributeListP) <|>
29+
30+ (reservedOp "intersection of" >>
31+ IntersectAttributeNames <$> braces attributeListP <*> braces attributeListP) <|>
32+
33+ (AttributeNames . S.fromList <$> sepBy attributeNameP comma)
34+
2635
2736makeRelationP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)
2837makeRelationP = do
@@ -102,7 +111,11 @@ ungroupP = do
102111extendP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)
103112extendP = do
104113 reservedOp ":"
105− Extend <$> braces extendTupleExpressionP
114+ extends <- braces (sepBy extendTupleExpressionP comma)
115+ case extends of
116+ [] -> pure (Restrict TruePredicate)
117+ extends' ->
118+ pure $ \expr -> foldl (flip Extend) expr extends'
106119
107120semijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)
108121semijoinP = do
@@ -129,7 +142,8 @@ relOperators = [
129142 [InfixL antijoinP],
130143 [InfixL (reservedOp "union" >> return Union)],
131144 [InfixL (reservedOp "minus" >> return Difference)],
132− [InfixN (reservedOp "=" >> return Equals)],
145+ [InfixN (reservedOp "=" >> return Equals),
146+ InfixN (reservedOp "/=" >> return NotEquals)],
133147 [Postfix extendP]
134148 ]
135149
@@ -200,8 +214,9 @@ consumeAtomExprP consume = try functionAtomExprP <|>
200214 try (parens (constructedAtomExprP True)) <|>
201215 constructedAtomExprP consume <|>
202216 attributeAtomExprP <|>
203− nakedAtomExprP <|>
217+ try nakedAtomExprP <|>
204218 relationalAtomExprP
219+
205220
206221attributeAtomExprP :: Parser (AtomExprBase a)
207222attributeAtomExprP = do
@@ -220,7 +235,7 @@ constructedAtomExprP consume = do
220235-- used only for primitive type parsing ?
221236atomP :: Parser Atom
222237atomP = stringAtomP <|>
223− doubleAtomP <|>
238+ try doubleAtomP <|>
224239 integerAtomP <|>
225240 boolAtomP
226241
@@ -235,15 +250,19 @@ stringAtomP :: Parser Atom
235250stringAtomP = TextAtom <$> quotedString
236251
237252doubleAtomP :: Parser Atom
238−doubleAtomP = DoubleAtom <$> try float
253+doubleAtomP = DoubleAtom <$> float
239254
240255integerAtomP :: Parser Atom
241256integerAtomP = IntegerAtom <$> integer
242257
243258boolAtomP :: Parser Atom
244259boolAtomP = do
245− val <- char 't' <|> char 'f'
246− return $ BoolAtom (val == 't')
260+ v <- identifier
261+ if v == "t" || v == "f" then
262+ pure $ BoolAtom (v == "t")
263+ else
264+ fail "invalid boolAtom"
265+
247266
248267relationAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)
249268relationAtomExprP = RelationAtomExpr <$> makeRelationP
src/bin/TutorialD/Printer.hsnew file+165
@@ -0,0 +1,165 @@
1+{-# OPTIONS_GHC -fno-warn-orphans #-}
2+{-# LANGUAGE FlexibleInstances #-}
3+{-# LANGUAGE OverloadedStrings #-}
4+{-# LANGUAGE ScopedTypeVariables #-}
5+{-# LANGUAGE TypeApplications #-}
6+module TutorialD.Printer where
7+import ProjectM36.Base
8+import ProjectM36.Attribute as A hiding (null)
9+import Data.Text.Prettyprint.Doc
10+import qualified Data.Set as S hiding (fromList)
11+import qualified Data.Vector as V
12+import qualified Data.Map.Strict as M
13+import Data.Time.Calendar
14+import Data.Time.Clock.POSIX
15+import qualified Data.ByteString.Base64 as B64
16+import qualified Data.Text.Encoding as TE
17+
18+instance Pretty Atom where
19+ pretty (IntegerAtom x) = pretty x
20+ pretty (IntAtom x) = "int" <> parensList [pretty x]
21+ pretty (DoubleAtom x) = pretty x
22+ pretty (TextAtom x) = dquotes (pretty x)
23+ pretty (DayAtom x) = "fromGregorian" <> parensList [pretty a, pretty b, pretty c]
24+ where
25+ (a,b,c) = toGregorian x
26+ pretty (DateTimeAtom time) = "dateTimeFromEpochSeconds" <> parensList [pretty @Integer (round (utcTimeToPOSIXSeconds time))]
27+ pretty (ByteStringAtom bs) = "bytestring" <> parensList [dquotes (pretty (TE.decodeUtf8 (B64.encode bs)))]
28+ pretty (BoolAtom x) = if x then "t" else "f"
29+ pretty (RelationAtom x) = pretty x
30+ pretty (RelationalExprAtom re) = pretty re
31+ pretty (ConstructedAtom n _ as) = pretty n <+> prettyList as
32+
33+instance Pretty AtomExpr where
34+ pretty (AttributeAtomExpr attrName) = pretty attrName
35+ pretty (NakedAtomExpr atom) = pretty atom
36+ pretty (FunctionAtomExpr atomFuncName' atomExprs _) = pretty atomFuncName' <> prettyAtomExprsAsArguments atomExprs
37+ pretty (RelationAtomExpr relExpr) = pretty relExpr
38+ pretty (ConstructedAtomExpr dName [] _) = pretty dName
39+ pretty (ConstructedAtomExpr dName atomExprs _) = pretty dName <+> hsep (map prettyAtomExpr atomExprs)
40+
41+prettyAtomExpr :: AtomExpr -> Doc ann
42+prettyAtomExpr atomExpr =
43+ case atomExpr of
44+ AttributeAtomExpr attrName -> "@" <> pretty attrName
45+ ConstructedAtomExpr dConsName [] () -> pretty dConsName
46+ ConstructedAtomExpr dConsName atomExprs () -> parens (pretty dConsName <+> hsep (map prettyAtomExpr atomExprs))
47+ _ -> pretty atomExpr
48+
49+prettyAtomExprsAsArguments :: [AtomExpr] -> Doc ann
50+prettyAtomExprsAsArguments = align . parensList . map addAt
51+ where addAt (atomExpr :: AtomExpr) =
52+ case atomExpr of
53+ AttributeAtomExpr attrName -> "@" <> pretty attrName
54+ _ -> pretty atomExpr
55+
56+instance Pretty TupleExpr where
57+ pretty (TupleExpr map') = "tuple" <> bracesList (Prelude.map (\(attrName,atom)-> pretty attrName <+> pretty atom) (M.toList map'))
58+
59+instance Pretty RelationTuple where
60+ pretty (RelationTuple attrs atoms) = "tuple" <> bracesList (zipWith (\x y-> pretty x <+> pretty y) (V.toList (attributeNames attrs)) (V.toList atoms))
61+
62+instance Pretty Relation where
63+ pretty (Relation attrs tupSet) | attrs == mempty && null (asList tupSet) = "false"
64+ pretty (Relation attrs tupSet) | attrs == mempty && asList tupSet == [RelationTuple mempty mempty] = "true"
65+ pretty (Relation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)
66+
67+instance Pretty Attribute where
68+ pretty (Attribute n aTy) = pretty n <+> pretty (show aTy) -- workaround
69+
70+instance Pretty RelationalExpr where
71+ pretty (RelationVariable n _) = pretty n
72+ pretty (ExistingRelation r) = pretty r
73+ pretty (NotEquals a b) = pretty' a <+> "!=" <+> pretty' b
74+ pretty (Equals a b) = pretty' a <+> "==" <+> pretty' b
75+ pretty (Project ns r) = pretty' (ignoreProjects r) <> pretty ns
76+ pretty (Extend ext r) = collectExtends r <> pretty ext <> "}"
77+ pretty (MakeRelationFromExprs Nothing (TupleExprs () tupExprs)) = "relation" <> prettyBracesList tupExprs
78+ pretty (MakeRelationFromExprs (Just attrExprs) (TupleExprs () tupExprs)) = "relation" <> prettyBracesList attrExprs <> prettyBracesList tupExprs
79+ pretty (MakeStaticRelation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)
80+ pretty (Union a b) = parens $ pretty' a <+> "union" <+> pretty' b
81+ pretty (Join a b) = parens $ pretty' a <+> "join" <+> pretty' b
82+ pretty (Rename n1 n2 relExpr) = parens $ pretty relExpr <+> "rename" <+> braces (pretty n1 <+> "as" <+> pretty n2)
83+ pretty (Difference a b) = parens $ pretty' a <+> "minus" <+> pretty' b
84+ pretty (Group attrNames attrName relExpr) = parens $ pretty relExpr <+> "group" <+> parens (pretty attrNames <+> "as" <+> pretty attrName)
85+ pretty (Ungroup attrName relExpr) = parens $ pretty' relExpr <+> "ungroup" <+> pretty attrName
86+ pretty (Restrict resPreExpr relExpr) = parens $ pretty' relExpr <+> "where" <+> pretty resPreExpr
87+ pretty (With pairs a) = "with" <+> parensList (map (\(name,expr)-> pretty name <+> "as" <+> pretty expr) pairs) <+> pretty' a
88+
89+-- relvar:{a:=?}:{b:=?}:... in ADTs => relvar:{a:=?, b:=?, ...} in Doc ann
90+collectExtends :: RelationalExpr -> Doc ann
91+collectExtends (Extend ext r) = collectExtends r <> pretty ext <> ", "
92+collectExtends r = pretty r <> ":{"
93+
94+--relvar{a,b,c,...}{a,b,...}..{a} => relvar{a}
95+ignoreProjects :: RelationalExpr -> RelationalExpr
96+ignoreProjects (Project _ r) = ignoreProjects r
97+ignoreProjects r = r
98+
99+prettyRelationalExpr :: RelationalExpr -> Doc n
100+prettyRelationalExpr (RelationVariable n _) = pretty n
101+prettyRelationalExpr r = parens (pretty r)
102+
103+pretty' :: RelationalExpr -> Doc n
104+pretty' = prettyRelationalExpr
105+
106+instance Pretty AttributeNames where
107+ pretty (AttributeNames attrNames) = prettyBracesList (S.toList attrNames)
108+ pretty (InvertedAttributeNames attrNames) = braces $ "all but" <+> concatWith (surround ", ") (map pretty (S.toList attrNames))
109+ pretty (RelationalExprAttributeNames relExpr) = braces $ "all from" <+> pretty relExpr
110+ pretty (UnionAttributeNames aAttrNames bAttrNames) = braces ("union of" <+> pretty aAttrNames <+> pretty bAttrNames)
111+ pretty (IntersectAttributeNames aAttrNames bAttrNames) = braces ("intersection of" <+> pretty aAttrNames <+> pretty bAttrNames)
112+
113+instance Pretty AttributeExpr where
114+ pretty (NakedAttributeExpr attr) = pretty attr
115+ pretty (AttributeAndTypeNameExpr name typeCons _) = pretty name <+> pretty typeCons
116+
117+instance Pretty TypeConstructor where
118+ pretty (ADTypeConstructor tcName []) = pretty tcName
119+ pretty (ADTypeConstructor tcName tConsArgs) = pretty tcName <+> hsep (map pretty tConsArgs)
120+ pretty (PrimitiveTypeConstructor tcName atomType') = pretty tcName <+> pretty atomType'
121+ pretty (RelationAtomTypeConstructor attrExprs) = "relation" <> prettyBracesList attrExprs
122+ pretty (TypeVariable x) = pretty x
123+
124+instance Pretty AtomType where
125+ pretty IntAtomType = "Int"
126+ pretty IntegerAtomType = "Integer"
127+ pretty DoubleAtomType = "Double"
128+ pretty TextAtomType = "Text"
129+ pretty DayAtomType = "Day"
130+ pretty DateTimeAtomType = "DateTime"
131+ pretty ByteStringAtomType = "ByteString"
132+ pretty BoolAtomType = "Bool"
133+ pretty (RelationAtomType attrs) = "relation " <+> prettyBracesList (A.toList attrs)
134+ pretty (ConstructedAtomType tcName tvMap) = pretty tcName <+> hsep (map pretty (M.toList tvMap)) --order matters
135+ pretty RelationalExprAtomType = "RelationalExpr"
136+ pretty (TypeVariableType x) = pretty x
137+
138+instance Pretty ExtendTupleExpr where
139+ pretty (AttributeExtendTupleExpr attrName atomExpr) = pretty attrName <> ":=" <> pretty atomExpr
140+
141+
142+instance Pretty RestrictionPredicateExpr where
143+ pretty TruePredicate = "true"
144+ pretty (AndPredicate a b) = pretty a <+> "and" <+> pretty b
145+ pretty (OrPredicate a b) = pretty a <+> "or" <+> pretty b
146+ pretty (NotPredicate a) = "not" <+> pretty a
147+ pretty (RelationalExprPredicate relExpr) = pretty relExpr
148+ pretty (AtomExprPredicate atomExpr) = pretty atomExpr
149+ pretty (AttributeEqualityPredicate attrName atomExpr) = pretty attrName <> "=" <> pretty atomExpr
150+
151+instance Pretty WithNameExpr where
152+ pretty (WithNameExpr name _) = pretty name
153+
154+bracesList :: [Doc ann] -> Doc ann
155+bracesList = group . encloseSep (flatAlt "{ " "{") (flatAlt " }" "}") ", "
156+
157+prettyBracesList :: Pretty a => [a] -> Doc ann
158+prettyBracesList = align . bracesList . map pretty
159+
160+parensList :: [Doc ann] -> Doc ann
161+parensList = group . encloseSep (flatAlt "( " "(") (flatAlt " )" ")") ", "
162+
163+prettyParensList :: Pretty a => [a] -> Doc ann
164+prettyParensList = align . parensList . map pretty
165+
src/lib/ProjectM36/Arbitrary.hs+6−1
@@ -9,6 +9,7 @@ import ProjectM36.AtomType
99import ProjectM36.Attribute (atomType)
1010import ProjectM36.DataConstructorDef as DCD
1111import ProjectM36.DataTypes.Interval
12+import ProjectM36.Relation
1213import qualified Data.Vector as V
1314import Data.Text (Text)
1415import Test.QuickCheck
@@ -48,6 +49,10 @@ arbitrary' ByteStringAtomType =
4849
4950arbitrary' BoolAtomType =
5051 Right . BoolAtom <$> lift (arbitrary :: Gen Bool)
52+
53+arbitrary' RelationalExprAtomType =
54+ pure (Right (RelationalExprAtom (ExistingRelation relationTrue))) -- don't bother with arbitrary relational expressions
55+
5156arbitrary' constructedAtomType@(ConstructedAtomType tcName tvMap)
5257 --special-casing for Interval type
5358 | isIntervalAtomType constructedAtomType = createArbitraryInterval (intervalSubType constructedAtomType)
@@ -79,7 +84,7 @@ maybeToRight y Nothing = Left y
7984arbitraryRelationTuple :: Attributes -> WithTCMap Gen (Either RelationalError RelationTuple)
8085arbitraryRelationTuple attris = do
8186 tcMap <- ask
82− listOfMaybeAType <- lift $ mapM ((\aTy -> runReaderT (arbitrary' aTy) tcMap) . atomType) (V.toList attris)
87+ listOfMaybeAType <- lift $ mapM ((\aTy -> runReaderT (arbitrary' aTy) tcMap) . atomType) (V.toList (attributesVec attris))
8388 case sequence listOfMaybeAType of
8489 Left err -> pure $ Left err
8590 Right listOfAttr -> do
src/lib/ProjectM36/Atom.hs+1
@@ -20,6 +20,7 @@ atomToText (DayAtom i) = (T.pack . show) i
2020atomToText (DateTimeAtom i) = (T.pack . show) i
2121atomToText (ByteStringAtom i) = (T.pack . show) i
2222atomToText (BoolAtom i) = (T.pack . show) i
23+atomToText (RelationalExprAtom re) = (T.pack . show) re
2324
2425atomToText (RelationAtom i) = (T.pack . show) i
2526atomToText (ConstructedAtom dConsName typ atoms)
src/lib/ProjectM36/AtomType.hs+8−7
@@ -211,7 +211,7 @@ isValidAtomTypeForTypeConstructor (ConstructedAtomType tConsName _) (ADTypeConst
211211
212212isValidAtomTypeForTypeConstructor (RelationAtomType attrs) (RelationAtomTypeConstructor attrExprs) tConsMap = do
213213 evaldAtomTypes <- mapM (\expr -> atomTypeForAttributeExpr expr tConsMap M.empty) attrExprs
214− mapM_ (uncurry resolveAtomType) (zip (map A.atomType (V.toList attrs)) evaldAtomTypes)
214+ mapM_ (uncurry resolveAtomType) (zip (A.atomTypesList attrs) evaldAtomTypes)
215215isValidAtomTypeForTypeConstructor aType tCons _ = Left (AtomTypeTypeConstructorReconciliationError aType (TC.name tCons))
216216
217217findTypeConstructor :: TypeConstructorName -> TypeConstructorMapping -> Maybe (TypeConstructorDef, [DataConstructorDef])
@@ -295,7 +295,7 @@ resolveTypeInAtom _ atom _ = Right atom
295295-- Example: "Nothing" does not specify the the argument in "Maybe a", so allow delayed resolution in the tuple before it is added to the relation. Note that this resolution could cause a type error. Hardly a Hindley-Milner system.
296296resolveTypesInTuple :: Attributes -> TypeConstructorMapping -> RelationTuple -> Either RelationalError RelationTuple
297297resolveTypesInTuple resolvedAttrs tConss (RelationTuple _ tupAtoms) = do
298− newAtoms <- mapM (\(atom, resolvedType) -> resolveTypeInAtom resolvedType atom tConss) (zip (V.toList tupAtoms) $ map A.atomType (V.toList resolvedAttrs))
298+ newAtoms <- mapM (\(atom, resolvedType) -> resolveTypeInAtom resolvedType atom tConss) (zip (V.toList tupAtoms) $ A.atomTypesList resolvedAttrs)
299299 Right (RelationTuple resolvedAttrs (V.fromList newAtoms))
300300
301301-- | Validate that the type is provided with complete type variables for type constructors.
@@ -314,7 +314,7 @@ validateAtomType typ@(ConstructedAtomType tConsName tVarMap) tConss =
314314 _ -> Right ()
315315validateAtomType (RelationAtomType attrs) tConss =
316316 mapM_ (\attr ->
317− validateAtomType (A.atomType attr) tConss) (V.toList attrs)
317+ validateAtomType (A.atomType attr) tConss) (attributesVec attrs)
318318validateAtomType (TypeVariableType x) _ = Left (TypeConstructorTypeVarMissing x)
319319validateAtomType _ _ = pure ()
320320
@@ -325,7 +325,7 @@ validateAttributes tConss attrs =
325325 else
326326 pure ()
327327 where
328− errs = lefts $ map ((`validateAtomType` tConss) . A.atomType) (V.toList attrs)
328+ errs = lefts $ map (`validateAtomType` tConss) (A.atomTypesList attrs)
329329
330330--ensure that all type vars are fully resolved
331331validateTypeVarMap :: TypeVarMap -> TypeConstructorMapping -> Either RelationalError ()
@@ -358,7 +358,7 @@ atomTypeVerify x@(RelationAtomType attrs1) y@(RelationAtomType attrs2) = do
358358 if notElem "_" [name1, name2] && name1 /= name2 then
359359 Left $ AtomTypeMismatchError x y
360360 else
361− atomTypeVerify (A.atomType attr1) (A.atomType attr2)) $ V.toList (V.zip attrs1 attrs2)
361+ atomTypeVerify (A.atomType attr1) (A.atomType attr2)) $ V.toList (V.zip (attributesVec attrs1) (attributesVec attrs2))
362362 return x
363363atomTypeVerify x y = if x == y then
364364 Right x
@@ -375,7 +375,7 @@ typeVarMapsVerify a b = M.keysSet a == M.keysSet b && (length . rights) zipped =
375375 (M.toAscList b)
376376
377377prettyAtomType :: AtomType -> T.Text
378−prettyAtomType (RelationAtomType attrs) = "relation {" `T.append` T.intercalate "," (map prettyAttribute (V.toList attrs)) `T.append` "}"
378+prettyAtomType (RelationAtomType attrs) = "relation {" `T.append` T.intercalate "," (map prettyAttribute (V.toList (attributesVec attrs))) `T.append` "}"
379379prettyAtomType (ConstructedAtomType tConsName typeVarMap) = tConsName `T.append` T.concat (map showTypeVars (M.toList typeVarMap))
380380 where
381381 showTypeVars (_, TypeVariableType x) = " " <> x
@@ -442,12 +442,13 @@ isResolvedType typ =
442442 DateTimeAtomType -> True
443443 ByteStringAtomType -> True
444444 BoolAtomType -> True
445+ RelationalExprAtomType -> True
445446 RelationAtomType attrs -> isResolvedAttributes attrs
446447 ConstructedAtomType _ tvMap -> all isResolvedType (M.elems tvMap)
447448 TypeVariableType _ -> False
448449
449450isResolvedAttributes :: Attributes -> Bool
450−isResolvedAttributes attrs = all isResolvedAttribute (V.toList attrs)
451+isResolvedAttributes attrs = all isResolvedAttribute (V.toList (attributesVec attrs))
451452
452453isResolvedAttribute :: Attribute -> Bool
453454isResolvedAttribute = isResolvedType . A.atomType
src/lib/ProjectM36/Atomable.hs+2−1
@@ -235,8 +235,9 @@ typeToTypeConstructor x@DayAtomType = PrimitiveTypeConstructor "Day" x
235235typeToTypeConstructor x@DateTimeAtomType = PrimitiveTypeConstructor "DateTime" x
236236typeToTypeConstructor x@ByteStringAtomType = PrimitiveTypeConstructor "ByteString" x
237237typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x
238+typeToTypeConstructor x@RelationalExprAtomType = PrimitiveTypeConstructor "RelationalExpr" x
238239typeToTypeConstructor (RelationAtomType attrs)
239− = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList attrs
240+ = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList (attributesVec attrs)
240241 where
241242 attrToAttrExpr (Attribute n t) = AttributeAndTypeNameExpr n (typeToTypeConstructor t) ()
242243typeToTypeConstructor (ConstructedAtomType tcName tvMap)
src/lib/ProjectM36/Attribute.hs+148−29
@@ -1,3 +1,4 @@
1+{-# OPTIONS_GHC -fno-warn-orphans #-}
12module ProjectM36.Attribute where
23import ProjectM36.Base
34import ProjectM36.Error
@@ -10,16 +11,54 @@ import qualified Data.Map as M
1011import Data.Either
1112
1213arity :: Attributes -> Int
13−arity = V.length
14+arity a = V.length (attributesVec a)
15+
16+instance Semigroup Attributes where
17+ attrsA <> attrsB =
18+ case joinAttributes attrsA attrsB of
19+ Left err -> error (show err)
20+ Right attrs' -> attrs'
21+
22+instance Monoid Attributes where
23+ mempty = Attributes {
24+ attributesVec = mempty
25+ --,attributeSet = mempty
26+ }
1427
1528emptyAttributes :: Attributes
16−emptyAttributes = V.empty
29+emptyAttributes = mempty
1730
1831null :: Attributes -> Bool
19−null = V.null
32+null a = V.null (attributesVec a)
33+
34+singleton :: Attribute -> Attributes
35+singleton attr = Attributes {
36+ attributesVec = V.singleton attr
37+ --,attributesSet = HS.singleton attr
38+ }
39+
40+toList :: Attributes -> [Attribute]
41+toList attrs = V.toList (attributesVec attrs)
2042
2143attributesFromList :: [Attribute] -> Attributes
22−attributesFromList = V.fromList -- . L.nub --too expensive
44+attributesFromList attrsL = Attributes {
45+ attributesVec = vec
46+ --,attributesSet = hset
47+ }
48+ where
49+ vec = if length attrsL == HS.size hset then
50+ --fast path- no duplicates
51+ V.fromList attrsL
52+ else
53+ --duplicate detected, uniqueify while maintaining original ordering
54+ V.fromList uniquedL
55+ hset = HS.fromList attrsL
56+ uniquedL = fst $ foldr (\attr acc@(l,s) ->
57+ if HS.member attr s then
58+ acc
59+ else
60+ (l ++ [attr], HS.insert attr s))
61+ ([],mempty) attrsL
2362
2463attributeName :: Attribute -> AttributeName
2564attributeName (Attribute name _) = name
@@ -28,17 +67,16 @@ atomType :: Attribute -> AtomType
2867atomType (Attribute _ atype) = atype
2968
3069atomTypes :: Attributes -> V.Vector AtomType
31−atomTypes = V.map atomType
70+atomTypes attrs = V.map atomType (attributesVec attrs)
3271
3372atomTypesList :: Attributes -> [AtomType]
3473atomTypesList = V.toList . atomTypes
3574
36−--hm- no error-checking here
3775addAttribute :: Attribute -> Attributes -> Attributes
38−addAttribute attr attrs = attrs `V.snoc` attr
76+addAttribute attr attrs = attrs <> singleton attr
3977
4078--if some attribute names overlap but the types do not, then spit back an error
41−joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes
79+{-joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes
4280joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length overlappingAttributes = Left (TupleAttributeTypeMismatchError overlappingAttributes)
4381 | V.length overlappingAttrsDifferentTypes > 0 = Left (TupleAttributeTypeMismatchError overlappingAttrsDifferentTypes)
4482 | otherwise = Right $ vectorUniqueify (attrs1 V.++ attrs2)
@@ -47,20 +85,52 @@ joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length
4785 attrNames2 = V.map attributeName attrs2
4886 uniqueOverlappingAttributes = vectorUniqueify overlappingAttributes
4987 overlappingAttributes = V.filter (`V.elem` attrs2) attrs1
88+-}
89+joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes
90+joinAttributes attrs1 attrs2
91+ | S.size overlappingNames == 0 = -- fast path, no overlapping names
92+ pure (concated id)
93+ | attributesForNames overlappingNames attrs1 == attributesForNames overlappingNames attrs2 = -- that atomtypes match
94+ pure (concated vectorUniqueify)
95+ | otherwise =
96+ --special handling to validate that overlapping names have the same atom types
97+ Left (TupleAttributeTypeMismatchError (attributesForNames overlappingNames attrs1))
98+ where
99+ nameSet1 = attributeNameSet attrs1
100+ nameSet2 = attributeNameSet attrs2
101+ overlappingNames = S.intersection nameSet1 nameSet2
102+ concated f = Attributes {
103+ attributesVec = f (attributesVec attrs1 <> attributesVec attrs2)
104+ --,attributesSet = attributesSet attrs1 <> attributesSet attrs2
105+ }
50106
51107addAttributes :: Attributes -> Attributes -> Attributes
52−addAttributes = (V.++)
108+addAttributes = (<>)
109+
110+member :: Attribute -> Attributes -> Bool
111+member attr attrs = HS.member attr (attributesSet attrs)
53112
54113deleteAttributeName :: AttributeName -> Attributes -> Attributes
55−deleteAttributeName attrName = V.filter (\attr -> attributeName attr /= attrName)
114+deleteAttributeName attrName = deleteAttributeNames (S.singleton attrName)
115+
116+deleteAttributeNames :: S.Set AttributeName -> Attributes -> Attributes
117+deleteAttributeNames attrNames attrs = Attributes {
118+ attributesVec = vec
119+ }
120+ where
121+ vec = V.filter attrFilter (attributesVec attrs)
122+ attrFilter attr = S.notMember (attributeName attr) attrNames
56123
57124renameAttribute :: AttributeName -> Attribute -> Attribute
58125renameAttribute newAttrName (Attribute _ typeo) = Attribute newAttrName typeo
59126
60127renameAttributes :: AttributeName -> AttributeName -> Attributes -> Attributes
61−renameAttributes oldAttrName newAttrName = V.map renamer
128+renameAttributes oldAttrName newAttrName attrs = Attributes {
129+ attributesVec = vec
130+ }
62131 where
63− renamer attr = if attributeName attr == oldAttrName then
132+ vec = V.map renamer (attributesVec attrs)
133+ renamer attr = if attributeName attr == oldAttrName then
64134 renameAttribute newAttrName attr
65135 else
66136 attr
@@ -71,7 +141,7 @@ atomTypeForAttributeName attrName attrs = do
71141 return atype
72142
73143attributeForName :: AttributeName -> Attributes -> Either RelationalError Attribute
74−attributeForName attrName attrs = case V.find (\attr -> attributeName attr == attrName) attrs of
144+attributeForName attrName attrs = case V.find (\attr -> attributeName attr == attrName) (attributesVec attrs) of
75145 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))
76146 Just attr -> Right attr
77147
@@ -89,15 +159,18 @@ projectionAttributesForNames names attrsIn =
89159 missingNames = attributeNamesNotContained names (S.fromList (V.toList (attributeNames attrsIn)))
90160
91161attributesForNames :: S.Set AttributeName -> Attributes -> Attributes
92−attributesForNames attrNameSet = V.filter filt
162+attributesForNames attrNameSet attrs = Attributes {
163+ attributesVec = vec
164+ }
93165 where
166+ vec = V.filter filt (attributesVec attrs)
94167 filt attr = S.member (attributeName attr) attrNameSet
95168
96169attributeNameSet :: Attributes -> S.Set AttributeName
97−attributeNameSet attrVec = S.fromList $ V.toList $ V.map (\(Attribute name _) -> name) attrVec
170+attributeNameSet attrs = S.fromList $ V.toList $ V.map (\(Attribute name _) -> name) (attributesVec attrs)
98171
99172attributeNames :: Attributes -> V.Vector AttributeName
100−attributeNames = V.map attributeName
173+attributeNames attrs = V.map attributeName (attributesVec attrs)
101174
102175--checks if set s1 is wholly contained in the set s2
103176attributesContained :: Attributes -> Attributes -> Bool
@@ -118,42 +191,88 @@ attributeNamesNotContained subset superset = S.filter (`S.notMember` superset) s
118191
119192-- useful for display
120193orderedAttributes :: Attributes -> [Attribute]
121−orderedAttributes attrs = L.sortBy (\a b -> attributeName a `compare` attributeName b) (V.toList attrs)
194+orderedAttributes attrs = L.sortBy (\a b -> attributeName a `compare` attributeName b) (V.toList (attributesVec attrs))
122195
123196orderedAttributeNames :: Attributes -> [AttributeName]
124197orderedAttributeNames attrs = map attributeName (orderedAttributes attrs)
125198
126199-- take two attribute sets and return an attribute set with the attributes which do not match
200+--this is the function which benefits the most from the HashSet representation- this turned up in the insert performance test
127201attributesDifference :: Attributes -> Attributes -> Attributes
128−attributesDifference attrsA attrsB = V.fromList $ diff (V.toList attrsA) (V.toList attrsB)
202+{-attributesDifference attrsA attrsB = V.fromList $ diff (V.toList attrsA) (V.toList attrsB)
129203 where
130204 diff a b = (a L.\\ b) ++ (b L.\\ a)
205+-}
206+attributesDifference attrsA attrsB =
207+ if attributesSet attrsA == attributesSet attrsB then
208+ mempty
209+ else
210+ Attributes {
211+ attributesVec = vec
212+ --,attributesSet = hset
213+ }
214+ where
215+ hset = HS.difference setA setB <> HS.difference setB setA
216+ setA = attributesSet attrsA
217+ setB = attributesSet attrsB
218+ vec = V.filter (`HS.member` hset) (attributesVec attrsA <> attributesVec attrsB)
131219
132220vectorUniqueify :: (Hash.Hashable a, Eq a) => V.Vector a -> V.Vector a
133221vectorUniqueify vecIn = V.fromList $ HS.toList $ HS.fromList $ V.toList vecIn
134222
135223--check that each attribute only appears once
136224verifyAttributes :: Attributes -> Either RelationalError Attributes
137−verifyAttributes attrs = if collapsedAttrs /= attrs then
138− Left (TupleAttributeTypeMismatchError (attributesDifference collapsedAttrs attrs))
139− else
140− Right attrs
225+verifyAttributes attrs =
226+ if vecSet == attributesSet attrs then
227+ pure attrs
228+ else
229+ Left (TupleAttributeTypeMismatchError diffAttrs)
141230 where
142− collapsedAttrs = vectorUniqueify attrs
231+ vecSet = V.foldr' HS.insert HS.empty (attributesVec attrs)
232+ diffSet = HS.difference vecSet (attributesSet attrs) <> HS.difference (attributesSet attrs) vecSet
233+ diffAttrs = Attributes {
234+ attributesVec = V.fromList (HS.toList diffSet)
235+ --,attributesSet = diffSet
236+ }
237+
238+--used in Generics derivation for ADTs without named attributes- not to be used elsewhere
239+--drop first n attributes from vector representation
240+drop :: Int -> Attributes -> Attributes
241+drop c attrs = Attributes { attributesVec = vec
242+ }
243+ where
244+ vec = V.drop c (attributesVec attrs)
245+
246+
247+-- use this in preference to attributesEqual when the attribute ordering matters such as during tuple unions
248+attributesAndOrderEqual :: Attributes -> Attributes -> Bool
249+attributesAndOrderEqual a b = attributesVec a == attributesVec b
143250
251+-- use to determine if the same attributes are contained (but ordering is irrelevant)
144252attributesEqual :: Attributes -> Attributes -> Bool
145−attributesEqual attrs1 attrs2 = V.null (attributesDifference attrs1 attrs2)
253+attributesEqual attrsA attrsB =
254+ attributesVec attrsA == attributesVec attrsB ||
255+ attributesSet attrsA == attributesSet attrsB
146256
147257attributesAsMap :: Attributes -> M.Map AttributeName Attribute
148−attributesAsMap attrs = (M.fromList . V.toList) (V.map (\attr -> (attributeName attr, attr)) attrs)
258+attributesAsMap attrs = V.foldr' (\attr acc -> M.insert (attributeName attr) attr acc) mempty (attributesVec attrs)
259+
149260
150261-- | Left-biased union of attributes.
151262union :: Attributes -> Attributes -> Attributes
152−union attrsA attrsB = V.fromList (M.elems unioned)
263+union attrsA attrsB = Attributes {
264+ attributesVec = vec
265+ --,attributesSet = hset
266+ }
153267 where
154− unioned = M.union (attributesAsMap attrsA) (attributesAsMap attrsB)
268+ hset = HS.union (attributesSet attrsA) (attributesSet attrsB)
269+ vec = HS.foldr (flip V.snoc) mempty hset
155270
156271intersection :: Attributes -> Attributes -> Attributes
157−intersection attrsA attrsB = V.fromList (M.elems intersected)
272+intersection attrsA attrsB = Attributes {
273+ attributesVec = vec
274+ --,attributesSet = hset
275+ }
158276 where
159− intersected = M.intersection (attributesAsMap attrsA) (attributesAsMap attrsB)
277+ hset = HS.intersection (attributesSet attrsA) (attributesSet attrsB)
278+ vec = HS.foldr (flip V.snoc) mempty hset
src/lib/ProjectM36/Base.hs+94−47
@@ -1,4 +1,4 @@
1−{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveTraversable, DerivingVia #-}
1+{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveTraversable, DerivingVia, TemplateHaskell, TypeFamilies #-}
22{-# OPTIONS_GHC -fno-warn-orphans #-}
33
44module ProjectM36.Base where
@@ -6,6 +6,7 @@ import ProjectM36.DatabaseContextFunctionError
66import ProjectM36.AtomFunctionError
77import ProjectM36.MerkleHash
88
9+import Data.Functor.Foldable.TH
910import qualified Data.Map as M
1011import qualified Data.HashSet as HS
1112import Data.Hashable (Hashable, hashWithSalt)
@@ -24,8 +25,11 @@ import Data.Time.Calendar (Day)
2425import Data.Typeable
2526import Data.ByteString (ByteString)
2627import qualified Data.List.NonEmpty as NE
28+import Data.Vector.Instances ()
2729
2830type StringType = Text
31+
32+type DatabaseName = String
2933
3034-- | Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.
3135data Atom = IntegerAtom Integer |
@@ -37,8 +41,9 @@ data Atom = IntegerAtom Integer |
3741 ByteStringAtom ByteString |
3842 BoolAtom Bool |
3943 RelationAtom Relation |
44+ RelationalExprAtom RelationalExpr | --used for returning inc deps
4045 ConstructedAtom DataConstructorName AtomType [Atom]
41− deriving (Eq, Show, Typeable, NFData, Generic)
46+ deriving (Eq, Show, Typeable, NFData, Generic, Read)
4247
4348instance Hashable Atom where
4449 hashWithSalt salt (ConstructedAtom dConsName _ atoms) = salt `hashWithSalt` atoms
@@ -52,6 +57,7 @@ instance Hashable Atom where
5257 hashWithSalt salt (ByteStringAtom bs) = salt `hashWithSalt` bs
5358 hashWithSalt salt (BoolAtom b) = salt `hashWithSalt` b
5459 hashWithSalt salt (RelationAtom r) = salt `hashWithSalt` r
60+ hashWithSalt salt (RelationalExprAtom re) = salt `hashWithSalt` re
5561
5662-- I suspect the definition of ConstructedAtomType with its name alone is insufficient to disambiguate the cases; for example, one could create a type named X, remove a type named X, and re-add it using different constructors. However, as long as requests are served from only one DatabaseContext at-a-time, the type name is unambiguous. This will become a problem for time-travel, however.
5763-- | The AtomType uniquely identifies the type of a atom.
@@ -65,13 +71,15 @@ data AtomType = IntAtomType |
6571 BoolAtomType |
6672 RelationAtomType Attributes |
6773 ConstructedAtomType TypeConstructorName TypeVarMap |
74+ RelationalExprAtomType |
6875 TypeVariableType TypeVarName
6976 --wildcard used in Atom Functions and tuples for data constructors which don't provide all arguments to the type constructor
70− deriving (Eq, NFData, Generic, Show)
77+ deriving (Eq, NFData, Generic, Show, Read, Hashable)
7178
7279instance Ord AtomType where
7380 compare = undefined
74−
81+
82+-- this should probably be an ordered dictionary in order to be able to round-trip these arguments
7583type TypeVarMap = M.Map TypeVarName AtomType
7684
7785instance Hashable TypeVarMap where
@@ -86,25 +94,40 @@ isRelationAtomType _ = False
8694type AttributeName = StringType
8795
8896-- | A relation's type is composed of attribute names and types.
89−data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Generic, NFData)
97+data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Read, Generic, NFData)
9098
9199instance Hashable Attribute where
92100 hashWithSalt salt (Attribute attrName _) = hashWithSalt salt attrName
93101
102+type AttributesHash = Int
103+
94104-- | 'Attributes' represent the head of a relation.
95−type Attributes = V.Vector Attribute
105+newtype Attributes = Attributes {
106+ attributesVec :: V.Vector Attribute
107+ --,attributesSet :: HS.HashSet Attribute --compare with this generated in heap profile and benchmarks
108+ }
109+ deriving (NFData, Read, Hashable, Generic)
110+
111+attributesSet :: Attributes -> HS.HashSet Attribute
112+attributesSet = HS.fromList . V.toList . attributesVec
113+
114+instance Show Attributes where
115+ show attrs = "attributesFromList [" <> L.intercalate ", " (map (\attr -> "(" <> show attr <> ")") (V.toList (attributesVec attrs))) <> "]"
116+
117+--when attribute ordering is irrelevant
118+instance Eq Attributes where
119+ attrsA == attrsB =
120+ attributesVec attrsA == attributesVec attrsB ||
121+ attributesSet attrsA == attributesSet attrsB
96122
97−-- | Equality function for a set of attributes.
98−attributesEqual :: Attributes -> Attributes -> Bool
99−attributesEqual attrs1 attrs2 = attrsAsSet attrs1 == attrsAsSet attrs2
100− where
101− attrsAsSet = HS.fromList . V.toList
102−
103123sortedAttributesIndices :: Attributes -> [(Int, Attribute)]
104−sortedAttributesIndices attrs = L.sortBy (\(_, Attribute name1 _) (_,Attribute name2 _) -> compare name1 name2) $ V.toList (V.indexed attrs)
124+sortedAttributesIndices attrs = L.sortBy (\(_, Attribute name1 _) (_,Attribute name2 _) -> compare name1 name2) $ V.toList (V.indexed (attributesVec attrs))
105125
106126-- | The relation's tuple set is the body of the relation.
107−newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic)
127+newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic, Read)
128+
129+instance Read Relation where
130+ readsPrec = error "relation read not supported"
108131
109132instance Eq RelationTupleSet where
110133 set1 == set2 = hset set1 == hset set2
@@ -117,8 +140,8 @@ instance NFData RelationTupleSet where rnf = genericRnf
117140instance Hashable RelationTuple where
118141 --sanity check the tuple for attribute and tuple counts
119142 --this bit me when tuples were being hashed before being verified
120− hashWithSalt salt (RelationTuple attrs tupVec) = if V.length attrs /= V.length tupVec then
121− error "invalid tuple: attributes and tuple count mismatch"
143+ hashWithSalt salt (RelationTuple attrs tupVec) = if V.length (attributesVec attrs) /= V.length tupVec then
144+ error ("invalid tuple: attributes and tuple count mismatch " <> show (attributesVec attrs, tupVec))
122145 else
123146 salt `hashWithSalt`
124147 sortedAttrs `hashWithSalt`
@@ -129,22 +152,23 @@ instance Hashable RelationTuple where
129152 sortedTupVec = V.map (\(index, _) -> tupVec V.! index) $ V.fromList sortedAttrsIndices
130153
131154-- | A tuple is a set of attributes mapped to their 'Atom' values.
132−data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Generic)
155+data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Read, Generic)
133156
134157instance Eq RelationTuple where
135− (==) tuple1@(RelationTuple attrs1 _) tuple2@(RelationTuple attrs2 _) = attributesEqual attrs1 attrs2 && atomsEqual
158+ tuple1@(RelationTuple attrs1 _) == tuple2@(RelationTuple attrs2 _) =
159+ attrs1 == attrs2 && atomsEqual
136160 where
137− atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) attrs of
161+ atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) (attributesVec attrs) of
138162 Nothing -> Nothing
139163 Just index -> tupVec V.!? index
140− atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) attrs1
164+ atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) (attributesVec attrs1)
141165
142166instance NFData RelationTuple where rnf = genericRnf
143167
144168data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)
145169
146170instance Eq Relation where
147− Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attributesEqual attrs1 attrs2 && tupSet1 == tupSet2
171+ Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attrs1 == attrs2 && tupSet1 == tupSet2
148172
149173instance NFData Relation where rnf = genericRnf
150174
@@ -199,10 +223,12 @@ data RelationalExprBase a =
199223 --Summarize :: AtomExpr -> AttributeName -> RelationalExpr -> RelationalExpr -> RelationalExpr -- a special case of Extend
200224 --Evaluate relationalExpr with scoped views
201225 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)
202− deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)
203−
226+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)
227+
228+instance Hashable RelationalExpr
229+
204230data WithNameExprBase a = WithNameExpr RelVarName a
205− deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)
231+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable, Hashable)
206232
207233type WithNameExpr = WithNameExprBase ()
208234
@@ -224,15 +250,15 @@ type TypeVarName = StringType
224250-- | Metadata definition for type constructors such as @data Either a b@.
225251data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |
226252 PrimitiveTypeConstructorDef TypeConstructorName AtomType
227− deriving (Show, Generic, Eq, NFData)
253+ deriving (Show, Generic, Eq, NFData, Hashable, Read)
228254
229255-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int
230256type TypeConstructor = TypeConstructorBase ()
231257data TypeConstructorBase a = ADTypeConstructor TypeConstructorName [TypeConstructor] |
232− PrimitiveTypeConstructor TypeConstructorName AtomType |
233− RelationAtomTypeConstructor [AttributeExprBase a] |
234− TypeVariable TypeVarName
235− deriving (Show, Generic, Eq, NFData)
258+ PrimitiveTypeConstructor TypeConstructorName AtomType |
259+ RelationAtomTypeConstructor [AttributeExprBase a] |
260+ TypeVariable TypeVarName
261+ deriving (Show, Generic, Eq, NFData, Hashable, Read)
236262
237263type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]
238264
@@ -242,13 +268,13 @@ type DataConstructorName = StringType
242268type AtomTypeName = StringType
243269
244270-- | Used to define a data constructor in a type constructor context such as @Left a | Right b@
245−data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Generic, NFData)
271+data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Generic, NFData, Hashable, Read)
246272
247273type DataConstructorDefs = [DataConstructorDef]
248274
249275data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |
250276 DataConstructorDefTypeVarNameArg TypeVarName
251− deriving (Show, Generic, Eq, NFData)
277+ deriving (Show, Generic, Eq, NFData, Hashable, Read)
252278
253279type InclusionDependencies = M.Map IncDepName InclusionDependency
254280type RelationVariables = M.Map RelVarName GraphRefRelationalExpr
@@ -293,7 +319,7 @@ data DatabaseContext = DatabaseContext {
293319type IncDepName = StringType
294320
295321-- | Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.
296−data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData)
322+data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData, Hashable, Read)
297323
298324type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr
299325
@@ -302,6 +328,8 @@ type DatabaseContextExprName = StringType
302328
303329type DatabaseContextExpr = DatabaseContextExprBase ()
304330
331+instance Hashable DatabaseContextExpr
332+
305333type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker
306334
307335-- | Database context expressions modify the database context.
@@ -331,7 +359,10 @@ data DatabaseContextExprBase a =
331359 ExecuteDatabaseContextFunction DatabaseContextFunctionName [AtomExprBase a] |
332360
333361 MultipleExpr [DatabaseContextExprBase a]
334− deriving (Show, Eq, Generic)
362+ deriving (Show, Read, Eq, Generic, NFData)
363+
364+instance Hashable (M.Map AttributeName AtomExpr) where
365+ hashWithSalt salt m = salt `hashWithSalt` M.toList m
335366
336367type ObjModuleName = StringType
337368type ObjFunctionName = StringType
@@ -351,6 +382,8 @@ type DatabaseContextIOExpr = DatabaseContextIOExprBase ()
351382
352383type RestrictionPredicateExpr = RestrictionPredicateExprBase ()
353384
385+instance Hashable RestrictionPredicateExpr
386+
354387type GraphRefRestrictionPredicateExpr = RestrictionPredicateExprBase GraphRefTransactionMarker
355388
356389-- | Restriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.
@@ -362,7 +395,7 @@ data RestrictionPredicateExprBase a =
362395 RelationalExprPredicate (RelationalExprBase a) | --type must be same as true and false relations (no attributes)
363396 AtomExprPredicate (AtomExprBase a) | --atom must evaluate to boolean
364397 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple
365− deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)
398+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)
366399
367400-- child + parent links
368401-- | A transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.
@@ -423,6 +456,8 @@ instance Ord Transaction where
423456
424457type AtomExpr = AtomExprBase ()
425458
459+instance Hashable AtomExpr
460+
426461type GraphRefAtomExpr = AtomExprBase GraphRefTransactionMarker
427462
428463-- | An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.
@@ -431,13 +466,16 @@ data AtomExprBase a = AttributeAtomExpr AttributeName |
431466 FunctionAtomExpr AtomFunctionName [AtomExprBase a] a |
432467 RelationAtomExpr (RelationalExprBase a) |
433468 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a
434− deriving (Eq,Show,Generic, NFData, Foldable, Functor, Traversable)
469+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)
435470
436471-- | Used in tuple creation when creating a relation.
437472data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)
438− deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)
473+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)
439474
440475type ExtendTupleExpr = ExtendTupleExprBase ()
476+
477+instance Hashable ExtendTupleExpr
478+
441479type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker
442480
443481--enumerates the list of functions available to be run as part of tuple expressions
@@ -485,7 +523,12 @@ data AttributeNamesBase a = AttributeNames (S.Set AttributeName) |
485523 UnionAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |
486524 IntersectAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |
487525 RelationalExprAttributeNames (RelationalExprBase a) -- use attribute names from the relational expression's type
488− deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)
526+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)
527+
528+instance Hashable AttributeNames
529+
530+instance Hashable (S.Set AttributeName) where
531+ hashWithSalt salt s = salt `hashWithSalt` S.toList s
489532
490533type AttributeNames = AttributeNamesBase ()
491534
@@ -503,18 +546,22 @@ type GraphRefAttributeExpr = AttributeExprBase GraphRefTransactionMarker
503546-- | Create attributes dynamically.
504547data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |
505548 NakedAttributeExpr Attribute
506− deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)
549+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable, Hashable)
507550
508551-- | Dynamically create a tuple from attribute names and 'AtomExpr's.
509552newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))
510− deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)
511−
553+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)
554+
555+instance Hashable TupleExpr
556+
512557type TupleExpr = TupleExprBase ()
513558
514559type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker
515560
516561data TupleExprsBase a = TupleExprs a [TupleExprBase a]
517− deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)
562+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)
563+
564+instance Hashable TupleExprs
518565
519566type GraphRefTupleExprs = TupleExprsBase GraphRefTransactionMarker
520567
@@ -564,7 +611,8 @@ attrTypeVars (Attribute _ aType) = case aType of
564611 DateTimeAtomType -> S.empty
565612 ByteStringAtomType -> S.empty
566613 BoolAtomType -> S.empty
567− (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList attrs))
614+ RelationalExprAtomType -> S.empty
615+ (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList (attributesVec attrs)))
568616 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap
569617 (TypeVariableType nam) -> S.singleton nam
570618
@@ -587,13 +635,12 @@ atomTypeVars DayAtomType = S.empty
587635atomTypeVars DateTimeAtomType = S.empty
588636atomTypeVars ByteStringAtomType = S.empty
589637atomTypeVars BoolAtomType = S.empty
590−atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList attrs))
638+atomTypeVars RelationalExprAtomType = S.empty
639+atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList (attributesVec attrs)))
591640atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap
592641atomTypeVars (TypeVariableType nam) = S.singleton nam
593642
594643unimplemented :: HasCallStack => a
595−unimplemented = undefined
596−
597−--for serializing GraphRefRelationalExpr as part of transaction serialization
644+unimplemented = error "unimplemented"
598645
599−
646+makeBaseFunctor ''RelationalExprBase
src/lib/ProjectM36/Client.hs+84−135
@@ -1,4 +1,4 @@
1−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, ScopedTypeVariables, MonoLocalBinds, DerivingVia, GeneralizedNewtypeDeriving, PackageImports #-}
1+{-# LANGUAGE DeriveGeneric, ScopedTypeVariables, MonoLocalBinds, DerivingVia #-}
22{-|
33Module: ProjectM36.Client
44
@@ -127,7 +127,6 @@ import ProjectM36.TransGraphRelationalExpression as TGRE (TransGraphRelationalEx
127127import ProjectM36.Persist (DiskSync(..))
128128import ProjectM36.FileLock
129129import ProjectM36.NormalizeExpr
130−import ProjectM36.Server.Types
131130import ProjectM36.Notifications
132131import ProjectM36.Server.RemoteCallTypes
133132import qualified ProjectM36.DisconnectedTransaction as Discon
@@ -135,11 +134,13 @@ import ProjectM36.Relation (typesAsRelation)
135134import ProjectM36.ScriptSession (initScriptSession, ScriptSession)
136135import qualified ProjectM36.Relation as R
137136import Control.Exception.Base
138−import GHC.Conc.Sync
137+import Control.Concurrent.STM
138+import Control.Concurrent.Async
139139
140140import Data.Either (isRight)
141141import Data.UUID.V4 (nextRandom)
142142import Data.Word
143+import Data.Hashable
143144import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)
144145import Control.Concurrent.MVar
145146import Codec.Winery hiding (Schema, schema)
@@ -161,6 +162,7 @@ import Data.Time.Clock
161162import qualified Network.RPC.Curryer.Client as RPC
162163import qualified Network.RPC.Curryer.Server as RPC
163164import Network.Socket (Socket, AddrInfo(..), getAddrInfo, defaultHints, AddrInfoFlag(..), SocketType(..), ServiceName, hostAddressToTuple, SockAddr(..))
165+import GHC.Conc (unsafeIOToSTM)
164166
165167type Hostname = String
166168
@@ -192,7 +194,7 @@ data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCa
192194type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification
193195
194196-- | Used for callbacks from the server when monitored changes have been made.
195−data NotificationMessage = NotificationMessage EvaluatedNotifications
197+newtype NotificationMessage = NotificationMessage EvaluatedNotifications
196198 deriving (Eq, Show, Generic)
197199 deriving Serialise via WineryVariant NotificationMessage
198200
@@ -226,7 +228,7 @@ defaultRemoteConnectionInfo =
226228defaultServerHostname :: Hostname
227229defaultServerHostname = "localhost"
228230
229−data RemoteConnectionConf = RemoteConnectionConf RPC.Connection
231+newtype RemoteConnectionConf = RemoteConnectionConf RPC.Connection
230232
231233data Connection = InProcessConnection InProcessConnectionConf |
232234 RemoteConnection RemoteConnectionConf
@@ -246,9 +248,10 @@ createScriptSession :: [String] -> IO (Maybe ScriptSession)
246248createScriptSession ghcPkgPaths = do
247249 eScriptSession <- initScriptSession ghcPkgPaths
248250 case eScriptSession of
249− Left err -> hPutStrLn stderr ("Failed to load scripting engine- scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled
251+ Left err -> hPutStrLn stderr ("Warning: Haskell scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled
250252 Right s -> pure (Just s)
251253
254+
252255-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.
253256connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)
254257--create a new in-memory database/transaction graph
@@ -264,14 +267,16 @@ connectProjectM36 (InProcessConnectionInfo strat notificationCallback ghcPkgPath
264267 clientNodes <- StmSet.newIO
265268 sessions <- StmMap.newIO
266269 mScriptSession <- createScriptSession ghcPkgPaths
267−
270+ notifAsync <- startNotificationListener clientNodes notificationCallback
268271 let conn = InProcessConnection InProcessConnectionConf {
269272 ipPersistenceStrategy = strat,
270273 ipClientNodes = clientNodes,
271274 ipSessions = sessions,
272275 ipTransactionGraph = graphTvar,
273276 ipScriptSession = mScriptSession,
274− ipLocks = Nothing}
277+ ipLocks = Nothing,
278+ ipCallbackAsync = notifAsync
279+ }
275280 pure (Right conn)
276281 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths
277282 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths
@@ -290,25 +295,34 @@ connectProjectM36 (RemoteConnectionInfo dbName hostName servicePort notification
290295 notificationHandlers =
291296 [RPC.ClientAsyncRequestHandler $
292297 \(NotificationMessage notifications') ->
293− forM_ (M.toList notifications') (\(notName, notInfo) ->
294− notificationCallback notName notInfo)
298+ forM_ (M.toList notifications') (uncurry notificationCallback)
295299 ]
296−-- TODO missing async callback
297− conn <- RPC.connect notificationHandlers (hostAddressToTuple addr) port
298− eRet <- RPC.call conn (Login dbName)
299−-- TODO handle connection errors
300− case eRet of
301− Left err -> error (show err)
302− Right False -> error "wtf"
303− Right True ->
300+ let connectExcHandler (e :: IOException) = pure $ Left (IOExceptionError e)
301+ eConn <- (Right <$> RPC.connect notificationHandlers (hostAddressToTuple addr) port) `catch` connectExcHandler
302+ case eConn of
303+ Left err -> pure (Left err)
304+ Right conn -> do
305+ eRet <- RPC.call conn (Login dbName)
306+ case eRet of
307+ Left err -> error (show err)
308+ Right False -> error "wtf"
309+ Right True ->
304310 --TODO handle connection errors!
305− pure (Right (RemoteConnection (RemoteConnectionConf conn)))
311+ pure (Right (RemoteConnection (RemoteConnectionConf conn)))
306312
307−addClientNode :: DatabaseName ->Connection -> RPC.Locking Socket -> IO ()
308−addClientNode _ (RemoteConnection _) _ = error "addClientNode called on remote connection"
309−addClientNode dbName (InProcessConnection conf) lockSock = atomically (StmSet.insert clientInfo (ipClientNodes conf))
313+--convert RPC errors into exceptions
314+convertRPCErrors :: RPC.ConnectionError -> IO a
315+convertRPCErrors err =
316+ case err of
317+ RPC.TimeoutError -> throw RequestTimeoutException
318+ RPC.CodecError msg -> error $ "decoding message failed on server: " <> msg
319+ RPC.ExceptionError msg -> error $ "server threw exception: " <> msg
320+
321+addClientNode :: Connection -> RPC.Locking Socket -> IO ()
322+addClientNode (RemoteConnection _) _ = error "addClientNode called on remote connection"
323+addClientNode (InProcessConnection conf) lockSock = atomically (StmSet.insert clientInfo (ipClientNodes conf))
310324 where
311− clientInfo = ClientInfo dbName lockSock
325+ clientInfo = RemoteClientInfo lockSock
312326
313327connectPersistentProjectM36 :: PersistenceStrategy ->
314328 DiskSync ->
@@ -334,17 +348,27 @@ connectPersistentProjectM36 strat sync dbdir freshGraph notificationCallback ghc
334348 sessions <- StmMap.newIO
335349 clientNodes <- StmSet.newIO
336350 lockMVar <- newMVar digest
351+ notifAsync <- startNotificationListener clientNodes notificationCallback
337352 let conn = InProcessConnection InProcessConnectionConf {
338353 ipPersistenceStrategy = strat,
339354 ipClientNodes = clientNodes,
340355 ipSessions = sessions,
341356 ipTransactionGraph = tvarGraph,
342357 ipScriptSession = mScriptSession,
343− ipLocks = Just (lockFileH, lockMVar)
358+ ipLocks = Just (lockFileH, lockMVar),
359+ ipCallbackAsync = notifAsync
344360 }
345−
346361 pure (Right conn)
347−
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+
348372-- | Create a new session at the transaction id and return the session's Id.
349373createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)
350374createSessionAtCommit conn@(InProcessConnection _) commitId = do
@@ -390,6 +414,7 @@ closeSession sessionId conn@(RemoteConnection _) = remoteCall conn (CloseSession
390414-- | 'close' cleans up the database access connection and closes any relevant sockets.
391415close :: Connection -> IO ()
392416close (InProcessConnection conf) = do
417+ cancel (ipCallbackAsync conf)
393418 atomically $ do
394419 let sessions = ipSessions conf
395420#if MIN_VERSION_stm_containers(1,0,0)
@@ -403,7 +428,7 @@ close (InProcessConnection conf) = do
403428 Nothing -> pure ()
404429 Just (lockFileH, _) -> closeLockFile lockFileH
405430
406−close (RemoteConnection (RemoteConnectionConf conn)) = do
431+close (RemoteConnection (RemoteConnectionConf conn)) =
407432 RPC.close conn
408433
409434--used only by the server EntryPoints
@@ -421,24 +446,14 @@ excEither = handle handler
421446 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc
422447 | otherwise = pure (Left (UnhandledExceptionError (show exc)))
423448
424−{-
425−safeLogin :: Login -> ProcessId -> Process Bool
426−safeLogin login procId = do
427− ret <- call procId login
428− case ret of
429− Left (_ :: ServerError) -> pure False
430− Right val -> pure val
431−-}
432449
433450remoteCall :: (Serialise a, Serialise b) => Connection -> a -> IO b
434451remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"
435452remoteCall (RemoteConnection (RemoteConnectionConf rpcConn)) arg = do
436453 eRet <- RPC.call rpcConn arg
437454 case eRet of
438− Left err -> error ("connection died " <> show err) --TODO: throw some more specific exceptions
455+ Left err -> convertRPCErrors err
439456 Right val -> pure val
440−
441−
442457
443458sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)
444459sessionForSessionId sessionId sessions =
@@ -600,20 +615,6 @@ executeDatabaseContextIOExpr sessionId (InProcessConnection conf) expr = excEith
600615 pure (Right ())
601616executeDatabaseContextIOExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)
602617
603−{-
604−executeGraphExprSTM_ :: TransactionId -> SessionId -> Session -> Sessions -> TransactionGraphOperator -> TransactionGraph -> TVar TransactionGraph -> STM (Either RelationalError (TransactionGraph, DisconnectedTransaction)
605−executeGraphExprSTM_ freshId sessionId session sessions graphExpr graph graphTVar= do
606− case evalGraphOp freshId (Sess.disconnectedTransaction session) graph graphExpr of
607− Left err -> do
608− when updateGraphOnError (writeTVar graphTVar graph)
609− pure $ Left err
610− Right (discon', graph') -> do
611− writeTVar graphTVar graph'
612− let newSession = Session discon' (Sess.schemaName session)
613− STMMap.insert newSession sessionId sessions
614− pure $ Right graph'
615−-}
616−
617618-- process notifications for commits
618619executeCommitExprSTM_
619620 :: TransactionGraph
@@ -654,77 +655,7 @@ executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do
654655 --if freshId appears in the graph, then we need to pass it on
655656 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]
656657 pure (Right (discon', graph', transIds))
657−{-
658−executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do
659− let strat = ipPersistenceStrategy conf
660− clientNodes = ipClientNodes conf
661− sessions = ipSessions conf
662− graphTvar = ipTransactionGraph conf
663− mLockFileH = ipLocks conf
664− lockHandler body = case graphExpr of
665− Commit -> case mLockFileH of
666− Nothing -> body False
667− Just (lockFileH, lockMVar) -> let acquireLocks = do
668− lastWrittenDigest <- takeMVar lockMVar
669− lockFile lockFileH WriteLock
670− latestDigest <- readGraphTransactionIdDigest strat
671− pure (latestDigest /= lastWrittenDigest)
672−
673− releaseLocks _ = do
674− --still holding the lock- get the latest digest
675− gDigest <- readGraphTransactionIdDigest strat
676− unlockFile lockFileH
677− putMVar lockMVar gDigest
678− in bracket acquireLocks releaseLocks body
679− _ -> body False
680− freshId <- nextRandom
681− lockHandler $ \dbWrittenByOtherProcess -> do
682− --if the database file has been updated since we wrote it last, load it before trying to sync our version done- this can result in TransactionNotAHeadErrors
683− --read transaction data and compare to existing graph
684− --in the future, we can detect if updated transaction graph can be safely merged (such as with a transaction on a separate head) (rebase-able commits should force the user to rebase from the client to confirm that the action makes sense)
685− manip <- atomically $ do
686− eSession <- sessionForSessionId sessionId sessions
687− --handle graph update by other process
688− oldGraph <- readTVar graphTvar
689− case eSession of
690− Left err -> pure (Left err)
691− Right session -> do
692− let mScriptSession = ipScriptSession conf
693− dbdir = case strat of
694− MinimalPersistence x -> x
695− CrashSafePersistence x -> x
696− _ -> error "accessing dbdir on non-persisted connection"
697− eRefreshedGraph <- if dbWrittenByOtherProcess then
698− unsafeIOToSTM (transactionGraphLoad dbdir oldGraph mScriptSession)
699− else
700− pure (Right oldGraph)
701− case eRefreshedGraph of
702− Left err -> pure (Left (DatabaseLoadError err))
703− Right refreshedGraph -> do
704− --snip it
705− eGraph <- executeGraphExprSTM_ dbWrittenByOtherProcess freshId sessionId session sessions graphExpr refreshedGraph graphTvar
706− --snip it
707− case eGraph of
708− Left err -> pure (Left err)
709− Right newGraph -> do
710− --handle commit
711− if isCommit graphExpr then do
712− case transactionForId (Sess.parentId session) oldGraph of
713− Left err -> pure $ Left err
714− Right previousTrans -> do
715− (evaldNots, nodes) <- executeCommitExprSTM_ (Trans.concreteDatabaseContext previousTrans) (Sess.concreteDatabaseContext session) clientNodes
716− nodesToNotify <- toList (StmSet.stream nodes)
717− pure $ Right (evaldNots, nodesToNotify, newGraph)
718− else
719− pure $ Right (M.empty, [], newGraph)
720− case manip of
721− Left err -> return $ Just err
722− Right (notsToFire, nodesToNotify, newGraph) -> do
723− --update filesystem database, if necessary
724− processTransactionGraphPersistence strat newGraph
725− sendNotifications nodesToNotify (ipLocalNode conf) notsToFire
726− pure Nothing
727−-}
658+
728659executeGraphExpr sessionId conn@(RemoteConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)
729660
730661-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.
@@ -733,9 +664,6 @@ executeTransGraphRelationalExpr _ (InProcessConnection conf) tgraphExpr = excEit
733664 let graphTvar = ipTransactionGraph conf
734665 graph <- readTVar graphTvar
735666 pure $ force $ optimizeAndEvalTransGraphRelationalExpr graph tgraphExpr
736−{- case runReader (RE.evalRelationalExpr relExpr) (RE.mkRelationalExprState DBC.empty) of
737− Left err -> pure (Left err)
738− Right rel -> pure (force (Right rel))-}
739667executeTransGraphRelationalExpr sessionId conn@(RemoteConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)
740668
741669-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.
@@ -768,8 +696,10 @@ commit sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr s
768696
769697sendNotifications :: [ClientInfo] -> EvaluatedNotifications -> IO ()
770698sendNotifications clients notifs =
771− unless (M.null notifs) $
772− forM_ (map clientSocket clients) $ \sock -> RPC.sendMessage sock (NotificationMessage notifs)
699+ unless (M.null notifs) $ forM_ clients sender
700+ where
701+ sender (RemoteClientInfo sock) = RPC.sendMessage sock (NotificationMessage notifs)
702+ sender (InProcessClientInfo tvar) = putMVar tvar notifs
773703
774704-- | 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.
775705rollback :: SessionId -> Connection -> IO (Either RelationalError ())
@@ -1071,13 +1001,6 @@ commitLock_ sessionId conf stmBlock = do
10711001 processTransactionGraphPersistence strat transactionIdsToPersist newGraph
10721002 sendNotifications nodesToNotify notsToFire
10731003 pure (Right ())
1074−{-
1075−writeDisconAndGraph_ :: TVar TransactionGraph -> SessionId -> Session -> Sessions -> DisconnectedTransaction -> TransactionGraph -> STM ()
1076−writeDisconAndGraph_ graphTvar sessionId session sessions discon graph = do
1077− writeTVar graphTvar graph
1078− let newSession = Session discon (Sess.schemaName session)
1079− StmMap.insert newSession sessionId sessions
1080−-}
10811004
10821005-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.
10831006withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)
@@ -1144,3 +1067,29 @@ validateMerkleHashes sessionId (InProcessConnection conf) = do
11441067 Left merkleErrs -> pure $ Left $ someErrors (map (\(MerkleValidationError tid expected actual) -> MerkleHashValidationError tid expected actual) merkleErrs)
11451068 Right () -> pure (Right ())
11461069validateMerkleHashes sessionId conn@RemoteConnection{} = remoteCall conn (ExecuteValidateMerkleHashes sessionId)
1070+
1071+type ClientNodes = StmSet.Set ClientInfo
1072+
1073+-- internal structure specific to in-process connections
1074+data InProcessConnectionConf = InProcessConnectionConf {
1075+ ipPersistenceStrategy :: PersistenceStrategy,
1076+ ipClientNodes :: ClientNodes,
1077+ ipSessions :: Sessions,
1078+ ipTransactionGraph :: TVar TransactionGraph,
1079+ ipScriptSession :: Maybe ScriptSession,
1080+ ipLocks :: Maybe (LockFile, MVar LockFileHash), -- nothing when NoPersistence
1081+ ipCallbackAsync :: Async ()
1082+ }
1083+
1084+-- clients may connect associate one socket/mvar with the server to register for change callbacks
1085+data ClientInfo = RemoteClientInfo (RPC.Locking Socket) |
1086+ InProcessClientInfo (MVar EvaluatedNotifications)
1087+
1088+instance Eq ClientInfo where
1089+ (RemoteClientInfo a) == (RemoteClientInfo b) = RPC.lockless a == RPC.lockless b
1090+ (InProcessClientInfo a) == (InProcessClientInfo b) = a == b
1091+ _ == _ = False
1092+
1093+instance Hashable ClientInfo where
1094+ hashWithSalt salt (RemoteClientInfo sock) = hashWithSalt salt (show (RPC.lockless sock))
1095+ hashWithSalt salt (InProcessClientInfo _) = hashWithSalt salt (1::Int)
src/lib/ProjectM36/DataFrame.hs+7−7
@@ -1,8 +1,8 @@
1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, DerivingVia #-}
1+{-# LANGUAGE DeriveGeneric, DerivingVia #-}
22{- A dataframe is a strongly-typed, ordered list of named tuples. A dataframe differs from a relation in that its tuples are ordered.-}
33module ProjectM36.DataFrame where
44import ProjectM36.Base
5−import ProjectM36.Attribute as A
5+import ProjectM36.Attribute as A hiding (drop)
66import ProjectM36.Error
77import qualified ProjectM36.Relation as R
88import ProjectM36.Relation.Show.Term
@@ -81,7 +81,7 @@ compareTupleByOneAttributeName attr tuple1 tuple2 =
8181 Right atom2 -> compareAtoms atom1 atom2
8282
8383atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom
84−atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of
84+atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of
8585 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))
8686 Just index -> case tupVec V.!? index of
8787 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))
@@ -134,12 +134,12 @@ data DataFrameExpr = DataFrameExpr {
134134dataFrameAsHTML :: DataFrame -> T.Text
135135-- web browsers don't display tables with empty cells or empty headers, so we have to insert some placeholders- it's not technically the same, but looks as expected in the browser
136136dataFrameAsHTML df
137− | length (tuples df) == 1 && L.null (attributes df) = style <>
137+ | length (tuples df) == 1 && A.null (attributes df) = style <>
138138 tablestart <>
139139 "<tr><th></th></tr>" <>
140140 "<tr><td></td></tr>" <>
141141 tablefooter <> "</table>"
142− | L.null (tuples df) && L.null (attributes df) = style <>
142+ | L.null (tuples df) && A.null (attributes df) = style <>
143143 tablestart <>
144144 "<tr><th></th></tr>" <>
145145 tablefooter <>
@@ -162,7 +162,7 @@ tuplesAsHTML = foldr folder ""
162162 folder tuple acc = acc <> tupleAsHTML tuple
163163
164164tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]
165−tupleAssocs (DataFrameTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)
165+tupleAssocs (DataFrameTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)
166166
167167
168168tupleAsHTML :: DataFrameTuple -> T.Text
@@ -174,7 +174,7 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>
174174 atomAsHTML atom = atomToText atom
175175
176176attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text
177−attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"
177+attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"
178178 where
179179 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"
180180 ordering attrName = " " <> case L.find (\(AttributeOrder nam _) -> nam == attrName) orders' of
src/lib/ProjectM36/DataTypes/Interval.hs+2
@@ -37,6 +37,7 @@ supportsInterval typ = case typ of
3737 BoolAtomType -> False
3838 RelationAtomType _ -> False
3939 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this
40+ RelationalExprAtomType -> False
4041 TypeVariableType _ -> False
4142
4243supportsOrdering :: AtomType -> Bool
@@ -50,6 +51,7 @@ supportsOrdering typ = case typ of
5051 ByteStringAtomType -> False
5152 BoolAtomType -> False
5253 RelationAtomType _ -> False
54+ RelationalExprAtomType -> False
5355 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this
5456 TypeVariableType _ -> False
5557
src/lib/ProjectM36/DataTypes/Primitive.hs+1
@@ -42,3 +42,4 @@ atomTypeForAtom (ByteStringAtom _) = ByteStringAtomType
4242atomTypeForAtom (BoolAtom _) = BoolAtomType
4343atomTypeForAtom (RelationAtom (Relation attrs _)) = RelationAtomType attrs
4444atomTypeForAtom (ConstructedAtom _ aType _) = aType
45+atomTypeForAtom (RelationalExprAtom _) = RelationalExprAtomType
src/lib/ProjectM36/DataTypes/Sorting.hs+1
@@ -24,6 +24,7 @@ isSortableAtomType typ = case typ of
2424 DateTimeAtomType -> True
2525 ByteStringAtomType -> False
2626 BoolAtomType -> True
27+ RelationalExprAtomType -> False
2728 RelationAtomType _ -> False
2829 ConstructedAtomType _ _ -> False
2930 TypeVariableType _ -> False
src/lib/ProjectM36/Error.hs+10−2
@@ -81,7 +81,7 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)
8181 | RelationValuedAttributesNotSupportedError [AttributeName]
8282 | NotificationNameInUseError NotificationName
8383 | NotificationNameNotInUseError NotificationName
84− | ImportError T.Text -- really? This should be broken out into some other error type- this has nothing to do with relational algebra
84+ | ImportError ImportError'
8585 | ExportError T.Text
8686 | UnhandledExceptionError String
8787 | MergeTransactionError MergeError
@@ -144,4 +144,12 @@ data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |
144144 RelVarInReferencedMoreThanOnce RelVarName |
145145 RelVarOutReferencedMoreThanOnce RelVarName
146146 deriving (Show, Eq, Generic, Typeable, NFData)
147−
147+
148+
149+data ImportError' = InvalidSHA256Error T.Text
150+ | SHA256MismatchError T.Text T.Text
151+ | InvalidFileURIError T.Text
152+ | ImportFileDecodeError T.Text
153+ | ImportFileError T.Text
154+ | ImportDownloadError T.Text
155+ deriving (Show, Eq, Generic, Typeable, NFData)
src/lib/ProjectM36/InclusionDependency.hs+5−6
@@ -4,17 +4,16 @@ import ProjectM36.Attribute
44import ProjectM36.Error
55import ProjectM36.Relation
66import qualified Data.Map as M
7−import qualified Data.Text as T
87
98inclusionDependenciesAsRelation :: InclusionDependencies -> Either RelationalError Relation
109inclusionDependenciesAsRelation incDeps =
1110 mkRelationFromList attrs (map incDepAsAtoms (M.toList incDeps))
1211 where
1312 attrs = attributesFromList [Attribute "name" TextAtomType,
14− Attribute "sub" TextAtomType,
15− Attribute "super" TextAtomType
13+ Attribute "sub" RelationalExprAtomType,
14+ Attribute "super" RelationalExprAtomType
1615 ]
1716 incDepAsAtoms (name, InclusionDependency exprA exprB) = [TextAtom name,
18− TextAtom (T.pack (show exprA)),
19− TextAtom (T.pack (show exprB))]
20−
17+ RelationalExprAtom exprA,
18+ RelationalExprAtom exprB]
19+
src/lib/ProjectM36/IsomorphicSchema.hs+1−1
@@ -1,4 +1,4 @@
1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, LambdaCase, DerivingVia #-}
1+{-# LANGUAGE DeriveGeneric, LambdaCase, DerivingVia #-}
22module ProjectM36.IsomorphicSchema where
33import ProjectM36.Base
44import ProjectM36.Error
src/lib/ProjectM36/Relation.hs+17−22
@@ -9,7 +9,6 @@ import ProjectM36.Tuple
99import qualified ProjectM36.Attribute as A
1010import ProjectM36.TupleSet
1111import ProjectM36.Error
12−import ProjectM36.MiscUtils
1312--import qualified Control.Parallel.Strategies as P
1413import qualified ProjectM36.TypeConstructorDef as TCD
1514import qualified ProjectM36.DataConstructorDef as DCD
@@ -17,7 +16,6 @@ import qualified Data.Text as T
1716import Data.Either (isRight)
1817import System.Random.Shuffle
1918import Control.Monad.Random
20−import Data.List (sort)
2119
2220attributes :: Relation -> Attributes
2321attributes (Relation attrs _ ) = attrs
@@ -35,7 +33,7 @@ atomTypeForName :: AttributeName -> Relation -> Either RelationalError AtomType
3533atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrName attrs
3634
3735mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation
38−mkRelationFromList attrs atomMatrix =
36+mkRelationFromList attrs atomMatrix = do
3937 Relation attrs <$> mkTupleSetFromList attrs atomMatrix
4038
4139emptyRelationWithAttrs :: Attributes -> Relation
@@ -43,11 +41,6 @@ emptyRelationWithAttrs attrs = Relation attrs emptyTupleSet
4341
4442mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation
4543mkRelation attrs tupleSet =
46− --check that all attributes are unique- this cannot be done when creating attributes because the check can become expensive
47− let duplicateAttrNames = dupes (sort (map A.attributeName (V.toList attrs))) in
48− if not (null duplicateAttrNames) then
49− Left (DuplicateAttributeNamesError (S.fromList duplicateAttrNames))
50− else
5144 --check that all tuples have the same keys
5245 --check that all tuples have keys (1-N) where N is the attribute count
5346 case verifyTupleSet attrs tupleSet of
@@ -93,13 +86,12 @@ union (Relation attrs1 tupSet1) (Relation attrs2 tupSet2) =
9386 else
9487 Right $ Relation attrs1 newtuples
9588 where
96− newtuples = RelationTupleSet $ HS.toList . HS.fromList $ asList tupSet1 ++ map (reorderTuple attrs1) (asList tupSet2)
97−
89+ newtuples = tupleSetUnion attrs1 tupSet1 tupSet2
90+
9891project :: S.Set AttributeName -> Relation -> Either RelationalError Relation
9992project attrNames rel@(Relation _ tupSet) = do
10093 newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)
101− let newAttrNameSet = A.attributeNameSet newAttrs
102− newTupleList = map (tupleProject newAttrNameSet) (asList tupSet)
94+ newTupleList <- mapM (tupleProject newAttrs) (asList tupSet)
10395 pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))
10496
10597rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation
@@ -154,7 +146,7 @@ group groupAttrNames newAttrName rel = do
154146 groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)
155147 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)
156148 matchingRelTuple tupIn = case imageRelationFor tupIn rel of
157− Right rel2 -> RelationTuple (V.singleton groupAttr) (V.singleton (RelationAtom rel2))
149+ Right rel2 -> RelationTuple (A.singleton groupAttr) (V.singleton (RelationAtom rel2))
158150 Left _ -> undefined
159151 mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))
160152 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes
@@ -168,7 +160,8 @@ restrictEq :: RelationTuple -> Relation -> Either RelationalError Relation
168160restrictEq tuple = restrict rfilter
169161 where
170162 rfilter :: RelationTuple -> Either RelationalError Bool
171− rfilter tupleIn = pure (tupleIntersection tuple tupleIn == tuple)
163+ rfilter tupleIn = do
164+ pure (tupleIntersection tuple tupleIn == tuple)
172165
173166-- unwrap relation-valued attribute
174167-- return error if relval attrs and nongroup attrs overlap
@@ -190,13 +183,13 @@ ungroup relvalAttrName rel = case attributesForRelval relvalAttrName rel of
190183tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation
191184tupleUngroup relvalAttrName newAttrs tuple = do
192185 relvalRelation <- relationForAttributeName relvalAttrName tuple
186+ let nonGroupAttrs = A.intersection newAttrs (tupleAttributes tuple)
187+ nonGroupTupleProjection <- tupleProject nonGroupAttrs tuple
188+ let folder tupleIn acc = case acc of
189+ Left err -> Left err
190+ Right accRel ->
191+ union accRel $ Relation newAttrs (RelationTupleSet [tupleExtend nonGroupTupleProjection tupleIn])
193192 relFold folder (Right $ Relation newAttrs emptyTupleSet) relvalRelation
194− where
195− nonGroupTupleProjection = tupleProject nonGroupAttrNames tuple
196− nonGroupAttrNames = A.attributeNameSet newAttrs
197− folder tupleIn acc = case acc of
198− Left err -> Left err
199− Right accRel -> union accRel $ Relation newAttrs (RelationTupleSet [tupleExtend nonGroupTupleProjection tupleIn])
200193
201194attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes
202195attributesForRelval relvalAttrName (Relation attrs _) = do
@@ -251,7 +244,8 @@ relMap mapper (Relation attrs tupleSet) =
251244
252245relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation
253246relMogrify mapper newAttributes (Relation _ tupSet) = do
254− newTuples <- mapM mapper (asList tupSet)
247+ newTuples <- mapM (fmap (reorderTuple newAttributes) . mapper) (asList tupSet)
248+
255249 mkRelationFromTuples newAttributes newTuples
256250
257251relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a
@@ -297,7 +291,8 @@ typesAsRelation types = mkRelationFromTuples attrs tuples
297291 dConsType = RelationAtomType subAttrs
298292 tuples = map mkTypeConsDescription types
299293
300− mkTypeConsDescription (tCons, dConsList) = RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])
294+ mkTypeConsDescription (tCons, dConsList) =
295+ RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])
301296
302297 mkDataConsRelation dConsList = case mkRelationFromTuples subAttrs $ map (\dCons -> RelationTuple subAttrs (V.singleton $ TextAtom $ T.intercalate " " (DCD.name dCons:map (T.pack . show) (DCD.fields dCons)))) dConsList of
303298 Left err -> error ("mkRelationFromTuples pooped " ++ show err)
src/lib/ProjectM36/Relation/Parse/CSV.hs+7−3
@@ -38,8 +38,7 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode
3838 let strHeader = V.map decodeUtf8 headerRaw
3939 strMapRecords = V.map convertMap vecMapsRaw
4040 convertMap hmap = HM.fromList $ L.map (decodeUtf8 *** (T.unpack . decodeUtf8)) (HM.toList hmap)
41− attrNames = V.map A.attributeName attrs
42− attrNameSet = S.fromList (V.toList attrNames)
41+ attrNameSet = A.attributeNameSet attrs
4342 headerSet = S.fromList (V.toList strHeader)
4443 parseAtom attrName aType textIn = case APT.parseOnly (parseCSVAtomP attrName tConsMap aType <* APT.endOfInput) textIn of
4544 Left err -> Left (ParseError (T.pack err))
@@ -47,7 +46,7 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode
4746 makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]
4847 makeTupleList tupMap = V.toList $ V.map (\attr ->
4948 either (Left . AttributeMappingError) Right $
50− parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) attrs
49+ parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) (attributesVec attrs)
5150 if attrNameSet == headerSet then do
5251 tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)
5352 case mkRelationFromList attrs tupleList of
@@ -83,6 +82,11 @@ parseCSVAtomP _ _ BoolAtomType = do
8382 case readMaybe bString of
8483 Nothing -> fail ("invalid BoolAtom string: " ++ bString)
8584 Just b -> pure (Right (BoolAtom b))
85+parseCSVAtomP _ _ RelationalExprAtomType = do
86+ reString <- T.unpack <$> takeToEndOfData
87+ case readMaybe reString of
88+ Nothing -> fail ("invalid RelationalExprAtom string: " ++ reString)
89+ Just b -> pure (Right (RelationalExprAtom b))
8690parseCSVAtomP attrName tConsMap typ@(ConstructedAtomType _ tvmap)
8791 | isIntervalAtomType typ = do
8892 begin <- (APT.char '[' >> pure False) <|> (APT.char '(' >> pure True)
src/lib/ProjectM36/Relation/Show/CSV.hs+5−5
@@ -1,7 +1,7 @@
11{-# OPTIONS_GHC -fno-warn-orphans #-}
22module ProjectM36.Relation.Show.CSV where
33import ProjectM36.Base
4−import ProjectM36.Attribute
4+import ProjectM36.Attribute as A
55import Data.Csv
66import ProjectM36.Tuple
77import qualified Data.ByteString.Lazy as BS
@@ -17,13 +17,13 @@ relationAsCSV (Relation attrs tupleSet)
1717 | relValAttrs /= [] =
1818 Left $ RelationValuedAttributesNotSupportedError (map attributeName relValAttrs)
1919 --check that there is at least one attribute
20− | V.null attrs =
20+ | A.null attrs =
2121 Left $ TupleAttributeCountMismatchError 0
2222 | otherwise =
2323 Right $ encodeByName bsAttrNames $ map RecordRelationTuple (asList tupleSet)
2424 where
25− relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) attrs
26− bsAttrNames = V.map (TE.encodeUtf8 . attributeName) attrs
25+ relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) (attributesVec attrs)
26+ bsAttrNames = V.map (TE.encodeUtf8 . attributeName) (attributesVec attrs)
2727
2828{-
2929instance ToRecord RelationTuple where
@@ -36,7 +36,7 @@ instance ToNamedRecord RecordRelationTuple where
3636 toNamedRecord rTuple = namedRecord $ map (\(k,v) -> TE.encodeUtf8 k .= RecordAtom v) (tupleAssocs $ unTuple rTuple)
3737
3838instance DefaultOrdered RecordRelationTuple where
39− headerOrder (RecordRelationTuple tuple) = V.map (TE.encodeUtf8 . attributeName) (tupleAttributes tuple)
39+ headerOrder (RecordRelationTuple tuple) = V.map (TE.encodeUtf8 . attributeName) (attributesVec (tupleAttributes tuple))
4040
4141newtype RecordAtom = RecordAtom {unAtom :: Atom}
4242
src/lib/ProjectM36/Relation/Show/HTML.hs+2−2
@@ -3,6 +3,7 @@ import ProjectM36.Base
33import ProjectM36.Relation
44import ProjectM36.Tuple
55import ProjectM36.Atom
6+import ProjectM36.Attribute as A
67import ProjectM36.AtomType
78import qualified Data.List as L
89import Data.Text (Text, pack)
@@ -11,10 +12,9 @@ import qualified Data.Text.IO as TIO
1112#if __GLASGOW_HASKELL__ < 804
1213import Data.Monoid
1314#endif
14−import qualified Data.Vector as V
1515
1616attributesAsHTML :: Attributes -> Text
17−attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"
17+attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"
1818 where
1919 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> "</th>"
2020
src/lib/ProjectM36/RelationalExpression.hs+148−302
@@ -1,6 +1,7 @@
11{-# LANGUAGE ScopedTypeVariables #-}
22{-# LANGUAGE FlexibleInstances #-}
33{-# LANGUAGE FlexibleContexts #-}
4+{-# LANGUAGE OverloadedStrings #-}
45module ProjectM36.RelationalExpression where
56import ProjectM36.Relation
67import ProjectM36.Tuple
@@ -40,6 +41,8 @@ import Control.Monad.Reader as R hiding (join)
4041import ProjectM36.NormalizeExpr
4142import ProjectM36.WithNameExpr
4243import Test.QuickCheck
44+import qualified Data.Functor.Foldable as Fold
45+import Control.Applicative
4346#ifdef PM36_HASKELL_SCRIPTING
4447import GHC hiding (getContext)
4548import Control.Exception
@@ -107,11 +110,11 @@ askEnv :: GraphRefRelationalExprM GraphRefRelationalExprEnv
107110askEnv = R.ask
108111
109112mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv
110−mergeTuplesIntoGraphRefRelationalExprEnv tupIn e =
111− e{ gre_extra = new_elems }
113+mergeTuplesIntoGraphRefRelationalExprEnv tupIn env =
114+ env { gre_extra = new_elems }
112115 where
113116 new_elems = Just (Left newTuple)
114− mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple e))
117+ mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple env))
115118 newTuple = mkRelationTupleFromMap mergedTupMap
116119
117120mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv
@@ -209,166 +212,13 @@ envContext = re_context
209212setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv
210213setEnvContext e ctx = e { re_context = ctx }
211214
212−{-
213−--full evaluation down the graph
214−eval :: RelationalExpr -> RelationalExprState (Either RelationalError Relation)
215−eval expr = do
216− env <- askEnv
217− eGfExpr <- processRelationalExpr expr
218− case eGfExpr of
219− Left err -> pure (Left err)
220− Right gfExpr -> pure $ evalGraphRefRelationalExpr gfExpr (re_graph env)
221−-}
222−{-
223−--relvar state is needed in evaluation of relational expression but only as read-only in order to extract current relvar values
224−evalRelationalExpr :: RelationalExpr -> RelationalExprState (Either RelationalError GraphRefRelationalExpr)
225−evalRelationalExpr (RelationVariable name _) = do
226− relvarTable <- fmap (relationVariables . envContext) askEnv
227− return $ case M.lookup name relvarTable of
228− Just res -> Right res
229− Nothing -> Left $ RelVarNotDefinedError name
230−
231−evalRelationalExpr (Project attrNames expr) = do
232− eAttrNameSet <- evalAttributeNames attrNames expr
233− case eAttrNameSet of
234− Left err -> pure (Left err)
235− Right attrNameSet -> do
236− rel <- evalRelationalExpr expr
237− case rel of
238− Right rel2 -> pure $ Right (Project (AttributeNames attrNameSet) rel2)
239− Left err -> pure $ Left err
240−
241−evalRelationalExpr (Union exprA exprB) = do
242− relA <- evalRelationalExpr exprA
243− relB <- evalRelationalExpr exprB
244− case relA of
245− Left err -> return $ Left err
246− Right relA2 -> case relB of
247− Left err -> return $ Left err
248− Right relB2 -> return $ Right (Union relA2 relB2)
249−
250−evalRelationalExpr (Join exprA exprB) = do
251− relA <- evalRelationalExpr exprA
252− relB <- evalRelationalExpr exprB
253− case relA of
254− Left err -> return $ Left err
255− Right relA2 -> case relB of
256− Left err -> return $ Left err
257− Right relB2 -> return $ Right (Join relA2 relB2)
258−
259−evalRelationalExpr (Difference exprA exprB) = do
260− relA <- evalRelationalExpr exprA
261− relB <- evalRelationalExpr exprB
262− case relA of
263− Left err -> return $ Left err
264− Right relA2 -> case relB of
265− Left err -> return $ Left err
266− Right relB2 -> return $ Right (Difference relA2 relB2)
267−
268−evalRelationalExpr (MakeStaticRelation attributeSet tupleSet) =
269− case mkRelation attributeSet tupleSet of
270− Right rel -> return $ Right (ExistingRelation rel)
271− Left err -> return $ Left err
272−
273−evalRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do
274− currentContext <- fmap envContext askEnv
275− let tConss = typeConstructorMapping currentContext
276− -- if the mAttrExprs is Nothing, then we should attempt to infer the tuple attributes from the first tuple itself- note that this is not always possible
277− runExceptT $ do
278− mAttrs <- case mAttrExprs of
279− Just _ ->
280− Just . A.attributesFromList <$> mapM evalGraphRefAttrExpr (fromMaybe [] mAttrExprs)
281− Nothing -> pure Nothing
282− tuples <- mapM (liftE . evalTupleExpr mAttrs) tupleExprs
283− let attrs = fromMaybe firstTupleAttrs mAttrs
284− firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)
285− expr <- either throwE pure (mkRelation attrs (RelationTupleSet tuples))
286− pure (ExistingRelation expr)
287−
288−evalRelationalExpr (ExistingRelation rel) = pure (Right (ExistingRelation rel))
289−
290−evalRelationalExpr (Rename oldAttrName newAttrName relExpr) = do
291− evald <- evalRelationalExpr relExpr
292− case evald of
293− Right expr -> return $ Right (Rename oldAttrName newAttrName expr)
294− Left err -> return $ Left err
295−
296−evalRelationalExpr (Group oldAttrNames newAttrName relExpr) = do
297− eOldAttrNameSet <- evalAttributeNames oldAttrNames relExpr
298− case eOldAttrNameSet of
299− Left err -> pure (Left err)
300− Right oldAttrNameSet -> do
301− evald <- evalRelationalExpr relExpr
302− case evald of
303− Right expr -> return $ Right (Group (AttributeNames oldAttrNameSet) newAttrName expr)
304− Left err -> return $ Left err
305−
306−evalRelationalExpr (Ungroup attrName relExpr) = do
307− evald <- evalRelationalExpr relExpr
308− case evald of
309− Right expr -> return $ Right (Ungroup attrName expr)
310− Left err -> return $ Left err
311−
312−evalRelationalExpr (Restrict predicateExpr relExpr) = do
313− evald <- evalRelationalExpr relExpr
314− pred <- processRestrictionPredicateExpr predicateExpr
315− case evald of
316− Left err -> return $ Left err
317− Right expr ->
318− pure $ Right (Restrict pred expr)
319−
320−evalRelationalExpr (Equals relExprA relExprB) = do
321− evaldA <- evalRelationalExpr relExprA
322− evaldB <- evalRelationalExpr relExprB
323− case evaldA of
324− Left err -> return $ Left err
325− Right exprA -> case evaldB of
326− Left err -> return $ Left err
327− Right exprB -> return $ Right (Equals exprA exprB)
328−{-
329−evalRelationalExpr (With views mainExpr) = do
330− rstate <- ask
331−
332− let addScopedView ctx (vname,vexpr) = if vname `M.member` relationVariables ctx then
333− Left (RelVarAlreadyDefinedError vname)
334− else
335− case runState (evalDatabaseContextExpr (Assign vname vexpr)) (freshDatabaseState ctx) of
336− (Left err,_) -> Left err
337− (Right (), (ctx',_,_)) -> Right ctx'
338−
339− case foldM addScopedView (stateElemsContext rstate) views of
340− Left err -> return $ Left err
341− Right ctx'' -> do
342− let evalMainExpr expr = runReader (evalRelationalExpr expr) (RelationalExprEnv ctx'')
343− case evalMainExpr mainExpr of
344− Left err -> return $ Left err
345− Right rel -> return $ Right rel
346−-}
347−--warning: copy-pasta from above- refactor
348−evalRelationalExpr (NotEquals relExprA relExprB) = do
349− evaldA <- evalRelationalExpr relExprA
350− evaldB <- evalRelationalExpr relExprB
351− case evaldA of
352− Left err -> return $ Left err
353− Right exprA -> case evaldB of
354− Left err -> return $ Left err
355− Right exprB -> return $ Right (NotEquals exprA exprB)
356−
357−-- extending a relation adds a single attribute with the results of the per-tuple expression evaluated
358−evalRelationalExpr (Extend tupleExpression relExpr) = do
359− eExpr <- evalRelationalExpr relExpr
360− case eExpr of
361− Left err -> pure (Left err)
362− Right expr -> do
363− tupProc <- processExtendTupleExpr tupleExpression
364− pure (Right (Extend tupProc expr))
365−-}
366215--helper function to process relation variable creation/assignment
367216setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()
368217setRelVar relVarName relExpr = do
369218 currentContext <- getStateContext
370− --prevent recursive relvar definition
371− let newRelVars = M.insert relVarName relExpr $ relationVariables currentContext
219+ --prevent recursive relvar definition by resolving references to relvars in previous states
220+ relExpr' <- resolve relExpr
221+ let newRelVars = M.insert relVarName relExpr' $ relationVariables currentContext
372222 potentialContext = currentContext { relationVariables = newRelVars }
373223 --optimization: if the relexpr is unchanged, skip the update
374224 if M.lookup relVarName (relationVariables currentContext) == Just relExpr then
@@ -381,6 +231,9 @@ setRelVar relVarName relExpr = do
381231 Left err -> dbErr err
382232 Right _ -> putStateContext potentialContext
383233
234+--fast-path insertion- we already know that the previous relvar validated correctly, so we can validate just the relation that is being inserted for attribute matches- without this, even a single tuple relation inserted causes the entire relation to be re-validated unnecessarily
235+--insertIntoRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()
236+
384237-- it is not an error to delete a relvar which does not exist, just like it is not an error to insert a pre-existing tuple into a relation
385238deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()
386239deleteRelVar relVarName = do
@@ -446,20 +299,36 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do
446299
447300evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do
448301 gfExpr <- relVarByName relVarName
449− evalGraphRefDatabaseContextExpr (Assign relVarName
450− (Union
451− gfExpr
452− relExpr))
302+ let optExpr = applyUnionCollapse (Union
303+ relExpr
304+ gfExpr)
305+ evalGraphRefDatabaseContextExpr (Assign relVarName optExpr)
453306
454307evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do
455308 gfExpr <- relVarByName relVarName
456− setRelVar relVarName (Restrict (NotPredicate predicate) gfExpr)
309+ let optExpr = applyRestrictionCollapse (Restrict (NotPredicate predicate) gfExpr)
310+ setRelVar relVarName optExpr
457311
458312--union of restricted+updated portion and the unrestricted+unupdated portion
459313evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do
460314 rvExpr <- relVarByName relVarName
315+ graph <- re_graph <$> dbcRelationalExprEnv
316+ context <- getStateContext
317+ let reEnv = freshGraphRefRelationalExprEnv (Just context) graph
318+ --get the current attributes name in the relvar to ensure that we don't conflict when renaming
319+ eExprType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr rvExpr)
320+ exprType' <- case eExprType of
321+ Left err -> throwError err
322+ Right t -> pure t
461323 let unrestrictedPortion = Restrict (NotPredicate pred') rvExpr
462− tmpAttr attr = "_tmp_" <> attr --this could certainly be improved to verify that there is no attribute name conflict
324+ tmpAttr = tmpAttrC 1
325+ tmpAttrC :: Int -> AttributeName -> AttributeName
326+ tmpAttrC c attr =
327+ let tmpAttrName = "_tmp_" <> T.pack (show c) <> attr in
328+ if tmpAttrName `S.member` A.attributeNameSet (attributes exprType') then
329+ tmpAttrC (c+1) attr
330+ else
331+ tmpAttrName
463332 updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)
464333 projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)
465334 restrictedPortion = Restrict pred' rvExpr
@@ -773,21 +642,9 @@ evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs
773642 Left err -> pure (Left err)
774643 Right dbstate' -> putDBCIOContext (dbc_context dbstate')
775644
776−{-
777−updateTupleWithAtomExprs :: M.Map AttributeName AtomExpr -> DatabaseContext -> TransactionGraph -> RelationTuple -> Either RelationalError RelationTuple
778−updateTupleWithAtomExprs exprMap context graph tupIn = do
779− --resolve all atom exprs
780− let
781− atomsAssoc <- mapM (\(attrName, atomExpr) -> do
782− let atom = unimplemented
783− --atom <- runReader (evalAtomExpr tupIn atomExpr) (mkRelationalExprState context graph)
784− pure (attrName, atom)
785− ) (M.toList exprMap)
786− pure (updateTupleWithAtoms (M.fromList atomsAssoc) tupIn)
787−-}
788645--run verification on all constraints
789646checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()
790−checkConstraints context transId graph@(TransactionGraph graphHeads transSet) =
647+checkConstraints context transId graph@(TransactionGraph graphHeads transSet) = do
791648 mapM_ (uncurry checkIncDep) (M.toList deps)
792649 where
793650 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)
@@ -836,15 +693,6 @@ typeForRelationalExpr expr = do
836693 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)
837694 lift $ except runGf
838695
839−--returns a database context with all tuples removed
840−--this is useful for type checking and optimization
841−{-
842−contextWithEmptyTupleSets :: DatabaseContext -> DatabaseContext
843−contextWithEmptyTupleSets contextIn = contextIn { relationVariables = relVars }
844− where
845− relVars = M.map (\rel -> ExistingRelation (Relation (attributes rel) emptyTupleSet)) (relationVariables contextIn)
846−-}
847−
848696liftE :: (Monad m) => m (Either a b) -> ExceptT a m b
849697liftE v = do
850698 y <- lift v
@@ -1000,58 +848,6 @@ evalGraphRefAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs _) = do
1000848 mapM (evalGraphRefAtomExpr tupIn) dConsArgs
1001849 pure (ConstructedAtom dConsName aType argAtoms)
1002850
1003−{-
1004−evalAtomExpr :: RelationTuple -> AtomExpr -> RelationalExprM Atom
1005−evalAtomExpr tupIn expr =
1006− -}
1007−{-
1008−
1009−evalAtomExpr tupIn (AttributeAtomExpr attrName) = case atomForAttributeName attrName tupIn of
1010− Right atom -> pure (Right atom)
1011− err@(Left (NoSuchAttributeNamesError _)) -> do
1012− rstate <- ask
1013− let stateTup = stateTuple rstate
1014− pure (atomForAttributeName attrName stateTup)
1015− Left err -> pure (Left err)
1016−evalAtomExpr _ (NakedAtomExpr atom) = pure (Right atom)
1017−evalAtomExpr tupIn (FunctionAtomExpr funcName arguments ()) = do
1018− argTypes <- mapM (typeFromAtomExpr (tupleAttributes tupIn)) arguments
1019− context <- fmap stateElemsContext ask
1020− runExceptT $ do
1021− let functions = atomFunctions context
1022− func <- either throwE pure (atomFunctionForName funcName functions)
1023− let expectedArgCount = length (atomFuncType func) - 1
1024− actualArgCount = length argTypes
1025− safeInit [] = [] -- different behavior from normal init
1026− safeInit xs = init xs
1027− if expectedArgCount /= actualArgCount then
1028− throwE (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)
1029− else do
1030− let zippedArgs = zip (safeInit (atomFuncType func)) argTypes
1031− mapM_ (\(expType, eActType) -> do
1032− actType <- either throwE pure eActType
1033− either throwE pure (atomTypeVerify expType actType)) zippedArgs
1034− evaldArgs <- mapM (liftE . evalAtomExpr tupIn) arguments
1035− case evalAtomFunction func evaldArgs of
1036− Left err -> throwE (AtomFunctionUserError err)
1037− Right result -> do
1038− --validate that the result matches the expected type
1039− _ <- either throwE pure (atomTypeVerify (last (atomFuncType func)) (atomTypeForAtom result))
1040− pure result
1041−evalAtomExpr tupIn (RelationAtomExpr relExpr) = do
1042− --merge existing state tuple context into new state tuple context to support an arbitrary number of levels, but new attributes trounce old attributes
1043− rstate <- ask
1044− runExceptT $ do
1045− let newState = mergeTuplesIntoRelationalExprState tupIn rstate
1046− relAtom <- either throwE pure (runReader (evalRelationalExpr relExpr) newState)
1047− pure (RelationAtom relAtom)
1048−evalAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs ()) = runExceptT $ do
1049− rstate <- lift ask
1050− let newState = mergeTuplesIntoRelationalExprState tupIn rstate
1051− aType <- either throwE pure (runReader (typeFromAtomExpr (tupleAttributes tupIn) cons) newState)
1052− argAtoms <- mapM (\arg -> either throwE pure (runReader (evalAtomExpr tupIn arg) newState)) dConsArgs
1053− pure (ConstructedAtom dConsName aType argAtoms)
1054−-}
1055851typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType
1056852typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do
1057853 renv <- askEnv
@@ -1118,7 +914,7 @@ verifyGraphRefAtomExprTypes relIn (FunctionAtomExpr funcName funcArgExprs tid) e
1118914 let handler :: RelationalError -> GraphRefRelationalExprM AtomType
1119915 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)
1120916 handler err = throwError err
1121− verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler
917+ verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler
1122918 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]
1123919 if length funcArgTypes /= length expectedArgTypes - 1 then
1124920 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)
@@ -1164,7 +960,7 @@ evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do
1164960 lift $ except $ resolveAttributes accAttr tupAttr
1165961 mostResolvedTypes <-
1166962 foldM (\acc tup -> do
1167− let zipped = zip (V.toList $ tupleAttributes tup) acc
963+ let zipped = zip (V.toList . attributesVec $ tupleAttributes tup) acc
1168964 accNames = S.fromList $ map A.attributeName acc
1169965 tupNames = A.attributeNameSet (tupleAttributes tup)
1170966 attrNamesDiff = S.union (S.difference accNames tupNames) (S.difference tupNames accNames)
@@ -1175,7 +971,7 @@ evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do
1175971 pure nextTupleAttrs
1176972 else
1177973 throwError (TupleAttributeTypeMismatchError diff)
1178− ) (V.toList $ tupleAttributes headTuple) tailTuples
974+ ) (V.toList . attributesVec $ tupleAttributes headTuple) tailTuples
1179975 pure (A.attributesFromList mostResolvedTypes)
1180976 --strategy: if all the tuple expr transaction markers refer to one location, then we can pass the type constructor mapping from that location, otherwise, we cannot assume that the types are the same
1181977 tConsMap <- case singularTransactions tupleExprL of
@@ -1221,56 +1017,6 @@ evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do
12211017-- _ <- lift $ except (validateTuple tup' tConss)
12221018 pure tup'
12231019
1224−{-
1225−evalAttributeNames :: AttributeNames -> RelationalExpr -> RelationalExprM (Either RelationalError (S.Set AttributeName))
1226−evalAttributeNames attrNames expr = do
1227− eExprType <- typeForRelationalExpr expr
1228− case eExprType of
1229− Left err -> throwError err
1230− Right exprTyp -> do
1231− let typeNameSet = S.fromList (V.toList (A.attributeNames (attributes exprTyp)))
1232− case attrNames of
1233− AttributeNames names ->
1234− case A.projectionAttributesForNames names (attributes exprTyp) of
1235− Left err -> pure (Left err)
1236− Right attrs -> pure (Right (S.fromList (V.toList (A.attributeNames attrs))))
1237−
1238− InvertedAttributeNames names -> do
1239− let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet
1240− if not (S.null nonExistentAttributeNames) then
1241− pure (Left (AttributeNamesMismatchError nonExistentAttributeNames))
1242− else
1243− pure (Right (A.nonMatchingAttributeNameSet names typeNameSet))
1244−
1245− UnionAttributeNames namesA namesB -> do
1246− eNameSetA <- evalAttributeNames namesA expr
1247− case eNameSetA of
1248− Left err -> pure (Left err)
1249− Right nameSetA -> do
1250− eNameSetB <- evalAttributeNames namesB expr
1251− case eNameSetB of
1252− Left err -> pure (Left err)
1253− Right nameSetB ->
1254− pure (Right (S.union nameSetA nameSetB))
1255−
1256− IntersectAttributeNames namesA namesB -> do
1257− eNameSetA <- evalAttributeNames namesA expr
1258− case eNameSetA of
1259− Left err -> pure (Left err)
1260− Right nameSetA -> do
1261− eNameSetB <- evalAttributeNames namesB expr
1262− case eNameSetB of
1263− Left err -> pure (Left err)
1264− Right nameSetB ->
1265− pure (Right (S.intersection nameSetA nameSetB))
1266−
1267− RelationalExprAttributeNames attrExpr -> do
1268− eAttrExprType <- typeForRelationalExpr attrExpr
1269− case eAttrExprType of
1270− Left err -> pure (Left err)
1271− Right attrExprType -> pure (Right (A.attributeNameSet (attributes attrExprType)))
1272−-}
1273−
12741020--temporary implementation until we have a proper planner+executor
12751021evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation
12761022evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do
@@ -1499,7 +1245,7 @@ relationVariablesAsRelation ctx graph = do
14991245 let gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph
15001246 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)
15011247 pure (rvName, gfType)
1502− relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributes rel)]
1248+ relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributesVec (attributes rel))]
15031249 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]
15041250 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of
15051251 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)
@@ -1519,15 +1265,6 @@ evalRelationalExpr expr = do
15191265 Left err -> throwError err
15201266 Right rel -> pure rel
15211267
1522−{-
1523−relVarByName :: RelVarName -> GraphRefRelationalExprM GraphRefRelationalExpr
1524−relVarByName = do
1525− relvars <- relationVariables <$> getStateContext
1526− case M.lookup relVarName relvars of
1527− Nothing -> dbErr (RelVarNotDefinedError relVarName)
1528− Just gfexpr -> pure gfExpr
1529−-}
1530−
15311268class (MonadError RelationalError m, Monad m) => DatabaseContextM m where
15321269 getContext :: m DatabaseContext
15331270
@@ -1544,3 +1281,112 @@ relVarByName rvName = do
15441281 Nothing -> throwError (RelVarNotDefinedError rvName)
15451282 Just gfexpr -> pure gfexpr
15461283
1284+-- | resolve UncommittedTransactionMarker whenever possible- this is important in the DatabaseContext in order to mitigate self-referencing loops for updates
1285+class ResolveGraphRefTransactionMarker a where
1286+ resolve :: a -> DatabaseContextEvalMonad a
1287+
1288+-- s := s union t
1289+instance ResolveGraphRefTransactionMarker GraphRefRelationalExpr where
1290+ resolve (MakeRelationFromExprs mAttrs tupleExprs) =
1291+ MakeRelationFromExprs mAttrs <$> resolve tupleExprs
1292+ resolve orig@MakeStaticRelation{} = pure orig
1293+ resolve orig@ExistingRelation{} = pure orig
1294+ resolve orig@(RelationVariable rvName UncommittedContextMarker) = do
1295+ rvMap <- relationVariables <$> getStateContext
1296+ case M.lookup rvName rvMap of
1297+ Nothing -> pure orig
1298+ Just resolvedRv -> resolve resolvedRv
1299+ resolve orig@RelationVariable{} = pure orig
1300+ resolve (Project attrNames relExpr) = Project <$> resolve attrNames <*> resolve relExpr
1301+ resolve (Union exprA exprB) = Union <$> resolve exprA <*> resolve exprB
1302+ resolve (Join exprA exprB) = Join <$> resolve exprA <*> resolve exprB
1303+ resolve (Rename attrA attrB expr) = Rename attrA attrB <$> resolve expr
1304+ resolve (Difference exprA exprB) = Difference <$> resolve exprA <*> resolve exprB
1305+ resolve (Group namesA nameB expr) = Group <$> resolve namesA <*> pure nameB <*> resolve expr
1306+ resolve (Ungroup nameA expr) = Ungroup nameA <$> resolve expr
1307+ resolve (Restrict restrictExpr relExpr) = Restrict <$> resolve restrictExpr <*> resolve relExpr
1308+ resolve (Equals exprA exprB) = Equals <$> resolve exprA <*> resolve exprB
1309+ resolve (NotEquals exprA exprB) = NotEquals <$> resolve exprA <*> resolve exprB
1310+ resolve (Extend extendExpr relExpr) = Extend <$> resolve extendExpr <*> resolve relExpr
1311+ resolve (With withExprs relExpr) = With <$> mapM (\(nam, expr) -> (,) <$> resolve nam <*> resolve expr) withExprs <*> resolve relExpr
1312+
1313+instance ResolveGraphRefTransactionMarker GraphRefTupleExprs where
1314+ resolve (TupleExprs marker tupleExprs) =
1315+ TupleExprs marker <$> mapM resolve tupleExprs
1316+
1317+instance ResolveGraphRefTransactionMarker GraphRefTupleExpr where
1318+ resolve (TupleExpr tupMap) = do
1319+ tupMap' <- mapM (\(attrName, expr) -> (,) attrName <$> resolve expr ) (M.toList tupMap)
1320+ pure (TupleExpr (M.fromList tupMap'))
1321+
1322+instance ResolveGraphRefTransactionMarker GraphRefAttributeNames where
1323+ resolve orig@AttributeNames{} = pure orig
1324+ resolve orig@InvertedAttributeNames{} = pure orig
1325+ resolve (UnionAttributeNames namesA namesB) = UnionAttributeNames <$> resolve namesA <*> resolve namesB
1326+ resolve (IntersectAttributeNames namesA namesB) = IntersectAttributeNames <$> resolve namesA <*> resolve namesB
1327+ resolve (RelationalExprAttributeNames expr) = RelationalExprAttributeNames <$> resolve expr
1328+
1329+instance ResolveGraphRefTransactionMarker GraphRefRestrictionPredicateExpr where
1330+ resolve TruePredicate = pure TruePredicate
1331+ resolve (AndPredicate exprA exprB) = AndPredicate <$> resolve exprA <*> resolve exprB
1332+ resolve (OrPredicate exprA exprB) = OrPredicate <$> resolve exprA <*> resolve exprB
1333+ resolve (NotPredicate expr) = NotPredicate <$> resolve expr
1334+ resolve (RelationalExprPredicate expr) = RelationalExprPredicate <$> resolve expr
1335+ resolve (AtomExprPredicate expr) = AtomExprPredicate <$> resolve expr
1336+ resolve (AttributeEqualityPredicate nam expr)= AttributeEqualityPredicate nam <$> resolve expr
1337+
1338+instance ResolveGraphRefTransactionMarker GraphRefExtendTupleExpr where
1339+ resolve (AttributeExtendTupleExpr nam atomExpr) = AttributeExtendTupleExpr nam <$> resolve atomExpr
1340+
1341+instance ResolveGraphRefTransactionMarker GraphRefWithNameExpr where
1342+ resolve orig@WithNameExpr{} = pure orig -- match uncommitted marker?
1343+
1344+instance ResolveGraphRefTransactionMarker GraphRefAtomExpr where
1345+ resolve orig@AttributeAtomExpr{} = pure orig
1346+ resolve orig@NakedAtomExpr{} = pure orig
1347+ resolve (FunctionAtomExpr nam atomExprs marker) =
1348+ FunctionAtomExpr nam <$> mapM resolve atomExprs <*> pure marker
1349+ resolve (RelationAtomExpr expr) = RelationAtomExpr <$> resolve expr
1350+ resolve (ConstructedAtomExpr dConsName atomExprs marker) =
1351+ ConstructedAtomExpr dConsName <$> mapM resolve atomExprs <*> pure marker
1352+
1353+--convert series of simple Union queries into MakeStaticRelation
1354+-- this is especially useful for long, nested applications of Union with simple tuples
1355+-- Union (MakeRelation x y) (MakeRelation x y') -> MakeRelation x (y + y')
1356+
1357+--MakeRelationFromExprs Nothing (TupleExprs UncommittedContextMarker [TupleExpr (fromList [("name", NakedAtomExpr (TextAtom "steve"))])])
1358+
1359+applyUnionCollapse :: GraphRefRelationalExpr -> GraphRefRelationalExpr
1360+applyUnionCollapse = Fold.cata opt
1361+ where
1362+ opt :: RelationalExprBaseF GraphRefTransactionMarker GraphRefRelationalExpr -> GraphRefRelationalExpr
1363+ opt (UnionF exprA exprB) | exprA == exprB = exprA
1364+ opt (UnionF
1365+ exprA@(MakeRelationFromExprs mAttrs1 tupExprs1)
1366+ exprB@(MakeRelationFromExprs mAttrs2 tupExprs2)) | tupExprs1 == tupExprs2 = MakeRelationFromExprs (mAttrs1 <|> mAttrs2) tupExprs1
1367+ | tupExprsNull tupExprs1 = exprB
1368+ | tupExprsNull tupExprs2 = exprA
1369+ opt x = Fold.embed x
1370+ tupExprsNull (TupleExprs _ []) = True
1371+ tupExprsNull _ = False
1372+
1373+
1374+--UPDATE optimization- find matching where clause in "lower" levels of renaming
1375+--update x where y=1 set (x:=5,z:=10); update x where y=1 set(x:=6,z:=11)
1376+-- =>
1377+-- update x where y=1 set (x:=6,z:=11)
1378+-- future opt: match individual attributes update x where y=1 set (x:=5); update x where y=1 set (z:=11) => update x where y=1 set (x:=5,z:=11)
1379+
1380+--strategy: try to collapse the top-level update (union (restrict pred MakeRelationFromExpr) expr) if it contains the same predicate and resultant relation
1381+
1382+--DELETE optimization
1383+-- if a restriction matches a previous restriction, combine them
1384+-- O(1) since it only scans at the top level, critical in benchmarks generating redundant deletions
1385+applyRestrictionCollapse :: GraphRefRelationalExpr -> GraphRefRelationalExpr
1386+applyRestrictionCollapse orig@(Restrict npred@(NotPredicate _) expr) =
1387+ case expr of
1388+ orig'@(Restrict npred'@(NotPredicate _) _) | npred == npred' -> orig'
1389+ _ -> orig
1390+applyRestrictionCollapse expr = expr
1391+
1392+
src/lib/ProjectM36/ScriptSession.hs−2
@@ -128,8 +128,6 @@ initScriptSession ghcPkgPaths = do
128128 "uuid",
129129 "vector",
130130 "text",
131− "binary",
132− "vector-binary-instances",
133131 "time",
134132 "project-m36",
135133 "bytestring"]
src/lib/ProjectM36/Serialise/Base.hs+11−2
@@ -1,4 +1,4 @@
1−{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeApplications, TypeSynonymInstances, ScopedTypeVariables, GeneralizedNewtypeDeriving #-}
1+{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeApplications, TypeSynonymInstances, ScopedTypeVariables #-}
22{-# OPTIONS_GHC -fno-warn-orphans #-}
33--Serialise instances for ProjectM36.Base data types- orphan instance city
44module ProjectM36.Serialise.Base where
@@ -10,6 +10,7 @@ import ProjectM36.MerkleHash
1010import Data.UUID
1111import Data.Proxy
1212import Data.Word
13+import ProjectM36.Attribute as A
1314import qualified Data.List.NonEmpty as NE
1415import qualified Data.Vector as V
1516import Data.Time.Calendar (Day,toGregorian,fromGregorian)
@@ -72,5 +73,13 @@ instance Serialise Day where
7273 extractor = fromGregorianTup <$> extractor
7374 decodeCurrent = fromGregorianTup <$> decodeCurrent
7475
76+instance Serialise Attributes where
77+ schemaGen _ = SVector <$> getSchema (Proxy @Attribute)
78+ toBuilder attrs = varInt (V.length (attributesVec attrs)) <> foldMap toBuilder (V.toList (attributesVec attrs))
79+ extractor =
80+ attributesFromList . V.toList <$> extractListBy extractor
7581
76−
82+ decodeCurrent = do
83+ n <- decodeVarInt
84+ l <- replicateM n decodeCurrent
85+ pure (A.attributesFromList l)
src/lib/ProjectM36/Serialise/Error.hs+1
@@ -12,3 +12,4 @@ deriving via WineryVariant MergeError instance Serialise MergeError
1212deriving via WineryVariant ScriptCompilationError instance Serialise ScriptCompilationError
1313deriving via WineryVariant PersistenceError instance Serialise PersistenceError
1414deriving via WineryVariant SchemaError instance Serialise SchemaError
15+deriving via WineryVariant ImportError' instance Serialise ImportError'
src/lib/ProjectM36/Serialise/IsomorphicSchema.hs+1−1
@@ -1,4 +1,4 @@
1−{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeApplications, TypeSynonymInstances, ScopedTypeVariables, GeneralizedNewtypeDeriving #-}
1+{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeSynonymInstances, ScopedTypeVariables #-}
22{-# OPTIONS_GHC -fno-warn-orphans #-}
33module ProjectM36.Serialise.IsomorphicSchema where
44import Codec.Winery
src/lib/ProjectM36/Server.hs+2−2
@@ -1,4 +1,4 @@
1−{-# LANGUAGE ScopedTypeVariables, TypeApplications #-}
1+{-# LANGUAGE ScopedTypeVariables #-}
22module ProjectM36.Server where
33
44import ProjectM36.Client
@@ -24,7 +24,7 @@ requestHandlers testFlag ti =
2424 RequestHandler (\sState (Login dbName) -> do
2525 addClientLogin dbName sState
2626 conn <- getConn sState
27− handleLogin dbName conn (connectionSocket sState)),
27+ handleLogin conn (connectionSocket sState)),
2828 RequestHandler (\sState Logout -> do
2929 conn <- getConn sState
3030 handleLogout ti conn),
src/lib/ProjectM36/Server/Config.hs+6
@@ -12,6 +12,12 @@ data ServerConfig = ServerConfig { persistenceStrategy :: PersistenceStrategy,
1212 }
1313 deriving (Show)
1414
15+data WebsocketServerConfig = WebsocketServerConfig { wsServerConfig :: ServerConfig,
16+ tlsCertificatePath :: Maybe String,
17+ tlsKeyPath :: Maybe String
18+ }
19+ deriving (Show)
20+
1521defaultServerConfig :: ServerConfig
1622defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,
1723 checkFS = True,
src/lib/ProjectM36/Server/EntryPoints.hs+26−24
@@ -5,18 +5,16 @@ import ProjectM36.IsomorphicSchema
55import ProjectM36.Client as C
66import Data.Map
77import Control.Concurrent (threadDelay)
8−import Network.RPC.Curryer.Server
9−import System.Timeout
8+import Network.RPC.Curryer.Server
9+import System.Timeout hiding (Timeout)
1010import Network.Socket
1111import Control.Exception
1212
1313timeoutOrDie :: Maybe Timeout -> IO a -> IO (Maybe a)
1414timeoutOrDie mMicros act =
1515 case mMicros of
16− Nothing -> do
17− ret <- act
18− pure (Just ret)
19− Just micros -> do
16+ Nothing -> Just <$> act
17+ Just micros ->
2018 timeout (fromIntegral micros) act
2119
2220timeoutRelErr :: Maybe Timeout -> IO (Either RelationalError a) -> IO (Either RelationalError a)
@@ -47,13 +45,13 @@ handleExecuteHeadName :: Maybe Timeout -> SessionId -> Connection -> IO (Either
4745handleExecuteHeadName ti sessionId conn =
4846 timeoutRelErr ti (headName sessionId conn)
4947
50−handleLogin :: DatabaseName -> Connection -> Locking Socket -> IO Bool
51−handleLogin dbName conn lockSock = do
52− addClientNode dbName conn lockSock
48+handleLogin :: Connection -> Locking Socket -> IO Bool
49+handleLogin conn lockSock = do
50+ addClientNode conn lockSock
5351 pure True
5452
5553handleExecuteGraphExpr :: Maybe Timeout -> SessionId -> Connection -> TransactionGraphOperator -> IO (Either RelationalError ())
56−handleExecuteGraphExpr ti sessionId conn graphExpr = do
54+handleExecuteGraphExpr ti sessionId conn graphExpr =
5755 timeoutRelErr ti (executeGraphExpr sessionId conn graphExpr)
5856
5957handleExecuteTransGraphRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)
@@ -65,11 +63,11 @@ handleExecuteTypeForRelationalExpr ti sessionId conn relExpr =
6563 timeoutRelErr ti (typeForRelationalExpr sessionId conn relExpr)
6664
6765handleRetrieveInclusionDependencies :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError (Map IncDepName InclusionDependency))
68−handleRetrieveInclusionDependencies ti sessionId conn = do
66+handleRetrieveInclusionDependencies ti sessionId conn =
6967 timeoutRelErr ti (inclusionDependencies sessionId conn)
7068
7169handleRetrievePlanForDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)
72−handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr = do
70+handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr =
7371 timeoutRelErr ti (planForDatabaseContextExpr sessionId conn dbExpr)
7472
7573handleRetrieveTransactionGraph :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)
@@ -89,16 +87,16 @@ handleCreateSessionAtHead ti conn headn =
8987 timeoutRelErr ti (createSessionAtHead conn headn)
9088
9189handleCloseSession :: SessionId -> Connection -> IO ()
92−handleCloseSession sessionId conn =
93− closeSession sessionId conn
90+handleCloseSession =
91+ closeSession
9492
9593handleRetrieveAtomTypesAsRelation :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)
96−handleRetrieveAtomTypesAsRelation ti sessionId conn = do
94+handleRetrieveAtomTypesAsRelation ti sessionId conn =
9795 timeoutRelErr ti (atomTypesAsRelation sessionId conn)
9896
9997-- | Returns a relation which lists the names of relvars in the current session as well as its types.
10098handleRetrieveRelationVariableSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)
101−handleRetrieveRelationVariableSummary ti sessionId conn = do
99+handleRetrieveRelationVariableSummary ti sessionId conn =
102100 timeoutRelErr ti (relationVariablesAsRelation sessionId conn)
103101
104102handleRetrieveAtomFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)
@@ -110,11 +108,11 @@ handleRetrieveDatabaseContextFunctionSummary ti sessionId conn =
110108 timeoutRelErr ti (databaseContextFunctionsAsRelation sessionId conn)
111109
112110handleRetrieveCurrentSchemaName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError SchemaName)
113−handleRetrieveCurrentSchemaName ti sessionId conn = do
111+handleRetrieveCurrentSchemaName ti sessionId conn =
114112 timeoutRelErr ti (currentSchemaName sessionId conn)
115113
116114handleExecuteSchemaExpr :: Maybe Timeout -> SessionId -> Connection -> SchemaExpr -> IO (Either RelationalError ())
117−handleExecuteSchemaExpr ti sessionId conn schemaExpr = do
115+handleExecuteSchemaExpr ti sessionId conn schemaExpr =
118116 timeoutRelErr ti (executeSchemaExpr sessionId conn schemaExpr)
119117
120118handleLogout :: Maybe Timeout -> Connection -> IO Bool
@@ -124,21 +122,25 @@ handleLogout _ _ =
124122
125123handleTestTimeout :: Maybe Timeout -> SessionId -> Connection -> IO Bool
126124handleTestTimeout ti _ _ = do
127− _ <- timeoutOrDie ti (threadDelay 100000 >> pure True)
128− pure True
125+ ret <- timeoutRelErr ti (threadDelay 100000 >> pure (Right ()))
126+ case ret of
127+ Right () -> pure True
128+ Left _ -> pure False
129+
130+
129131
130132handleRetrieveSessionIsDirty :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Bool)
131−handleRetrieveSessionIsDirty ti sessionId conn = do
133+handleRetrieveSessionIsDirty ti sessionId conn =
132134 timeoutRelErr ti (disconnectedTransactionIsDirty sessionId conn)
133135
134136handleExecuteAutoMergeToHead :: Maybe Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())
135−handleExecuteAutoMergeToHead ti sessionId conn strat headName' = do
137+handleExecuteAutoMergeToHead ti sessionId conn strat headName' =
136138 timeoutRelErr ti (autoMergeToHead sessionId conn strat headName')
137139
138140handleRetrieveTypeConstructorMapping :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)
139−handleRetrieveTypeConstructorMapping ti sessionId conn = do
141+handleRetrieveTypeConstructorMapping ti sessionId conn =
140142 timeoutRelErr ti (C.typeConstructorMapping sessionId conn)
141143
142144handleValidateMerkleHashes :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError ())
143−handleValidateMerkleHashes ti sessionId conn = do
145+handleValidateMerkleHashes ti sessionId conn =
144146 timeoutRelErr ti (C.validateMerkleHashes sessionId conn)
src/lib/ProjectM36/Server/ParseArgs.hs+31−14
@@ -17,14 +17,14 @@ parseArgsWithDefaults defaults = ServerConfig <$>
1717 many parseGhcPkgPath <*>
1818 parseTimeout (perRequestTimeout defaults) <*>
1919 parseTestMode
20−
20+
2121parsePersistenceStrategy :: Parser PersistenceStrategy
2222parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>
2323 MinimalPersistence <$> dbdirOpt <|>
2424 pure NoPersistence
25− where
26− dbdirOpt = strOption (short 'd' <>
27− long "database-directory" <>
25+ where
26+ dbdirOpt = strOption (short 'd' <>
27+ long "database-directory" <>
2828 metavar "DIRECTORY" <>
2929 showDefaultWith show
3030 )
@@ -34,43 +34,60 @@ parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>
3434
3535parseTestMode :: Parser Bool
3636parseTestMode = flag True False (long "test-mode" <> hidden)
37−
38−parseCheckFS :: Parser Bool
37+
38+parseCheckFS :: Parser Bool
3939parseCheckFS = flag True False (long "disable-fscheck" <>
4040 help "Disable filesystem check for journaling.")
41−
41+
4242parseDatabaseName :: Parser DatabaseName
4343parseDatabaseName = strOption (short 'n' <>
4444 long "database" <>
4545 metavar "DATABASE_NAME")
4646
47−parseHostname :: Hostname -> Parser Hostname
47+parseHostname :: Hostname -> Parser Hostname
4848parseHostname defHostname = strOption (short 'h' <>
4949 long "hostname" <>
5050 metavar "HOST_NAME" <>
5151 value defHostname)
52−
52+
5353parsePort :: Port -> Parser Port
5454parsePort defPort = option auto (short 'p' <>
5555 long "port" <>
5656 metavar "PORT_NUMBER" <>
5757 value defPort)
58−
58+
5959parseGhcPkgPath :: Parser String
6060parseGhcPkgPath = strOption (long "ghc-pkg-dir" <>
6161 metavar "GHC_PACKAGE_DIRECTORY")
62−
63−parseTimeout :: Int -> Parser Int
62+
63+parseTimeout :: Int -> Parser Int
6464parseTimeout defTimeout = option auto (long "timeout" <>
6565 metavar "MICROSECONDS" <>
6666 value defTimeout)
6767
6868parseConfig :: IO ServerConfig
6969parseConfig = parseConfigWithDefaults defaultServerConfig
70−
70+
7171parseConfigWithDefaults :: ServerConfig -> IO ServerConfig
7272parseConfigWithDefaults defaults = execParser (info (parseArgsWithDefaults defaults <**> helpOption) idm)
7373
74+parseWSConfigWithDefaults :: ServerConfig -> IO WebsocketServerConfig
75+parseWSConfigWithDefaults defaults = execParser (info (parseWSArgsWithDefaults defaults <**> helpOption) idm)
76+
77+parseWSArgsWithDefaults :: ServerConfig -> Parser WebsocketServerConfig
78+parseWSArgsWithDefaults defaults = WebsocketServerConfig <$>
79+ parseArgsWithDefaults defaults <*>
80+ parseTlsCertificatePath <*>
81+ parseTlsKeyPath
82+
83+
84+parseTlsCertificatePath :: Parser (Maybe String)
85+parseTlsCertificatePath = optional $ strOption (long "tls-certificate-path" <>
86+ metavar "TLS_CERTIFICATE_PATH")
87+
88+parseTlsKeyPath :: Parser (Maybe String)
89+parseTlsKeyPath = optional $ strOption (long "tls-key-path" <>
90+ metavar "TLS_KEY_PATH")
7491
7592helpOption :: Parser (a -> a)
7693helpOption = abortOption helpText $ mconcat
@@ -80,6 +97,6 @@ helpOption = abortOption helpText $ mconcat
8097 where
8198#if MIN_VERSION_optparse_applicative(0,16,0)
8299 helpText = ShowHelpText Nothing
83−#else
100+#else
84101 helpText = ShowHelpText
85102#endif
src/lib/ProjectM36/Server/RemoteCallTypes.hs+1−2
@@ -1,4 +1,4 @@
1−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, DerivingVia, DerivingStrategies, DeriveGeneric, CPP #-}
1+{-# LANGUAGE DeriveGeneric, DerivingVia, CPP #-}
22module ProjectM36.Server.RemoteCallTypes where
33import ProjectM36.Base
44import ProjectM36.IsomorphicSchema
@@ -8,7 +8,6 @@ import ProjectM36.TransGraphRelationalExpression
88import ProjectM36.Session
99import ProjectM36.Serialise.DataFrame ()
1010import ProjectM36.Serialise.IsomorphicSchema ()
11−import ProjectM36.Server.Types
1211import GHC.Generics
1312import Codec.Winery
1413
src/lib/ProjectM36/Server/Types.hsdeleted−38
@@ -1,38 +0,0 @@
1−--types shared across server and client modules
2−module ProjectM36.Server.Types where
3−import StmContainers.Set as StmSet
4−import ProjectM36.Base
5−import Data.Hashable
6−import ProjectM36.Sessions
7−import Control.Concurrent.STM
8−import ProjectM36.ScriptSession
9−import ProjectM36.FileLock
10−import Control.Concurrent.MVar
11−import ProjectM36.TransactionGraph.Persist
12−import Network.RPC.Curryer.Server as RPC
13−import Network.Socket
14−
15−-- | The 'Connection' represents either local or remote access to a database. All operations flow through the connection.
16−type ClientNodes = StmSet.Set ClientInfo
17−
18−type DatabaseName = String
19−
20−-- internal structure specific to in-process connections
21−data InProcessConnectionConf = InProcessConnectionConf {
22− ipPersistenceStrategy :: PersistenceStrategy,
23− ipClientNodes :: ClientNodes,
24− ipSessions :: Sessions,
25− ipTransactionGraph :: TVar TransactionGraph,
26− ipScriptSession :: Maybe ScriptSession,
27− ipLocks :: Maybe (LockFile, MVar LockFileHash) -- nothing when NoPersistence
28− }
29−
30−-- clients may connect associate one socket with one database
31−data ClientInfo = ClientInfo { clientDatabaseName :: DatabaseName,
32− clientSocket :: RPC.Locking Socket }
33−
34−instance Eq ClientInfo where
35− a == b = RPC.lockless (clientSocket a) == RPC.lockless (clientSocket b)
36−
37−instance Hashable ClientInfo where
38− hashWithSalt salt ci = hashWithSalt salt (show (RPC.lockless (clientSocket ci)))
src/lib/ProjectM36/Shortcuts.hsnew file+247
@@ -0,0 +1,247 @@
1+{-# OPTIONS_GHC -fno-warn-orphans #-}
2+{-# LANGUAGE ScopedTypeVariables #-}
3+{-# LANGUAGE TypeApplications #-}
4+{-# LANGUAGE FlexibleInstances #-}
5+{-# LANGUAGE MultiParamTypeClasses #-}
6+{-# LANGUAGE TypeFamilies #-}
7+{-# LANGUAGE ExtendedDefaultRules #-}
8+{-# LANGUAGE ExistentialQuantification #-}
9+{-# LANGUAGE FlexibleContexts #-}
10+{-# LANGUAGE GADTs #-}
11+{-# LANGUAGE UndecidableInstances #-}
12+module ProjectM36.Shortcuts where
13+-- users need OverloadedLabels, OverloadedLists, and default(Int,Text) to use these shortcuts.
14+import Data.Text hiding (foldl, map)
15+import ProjectM36.Base
16+import ProjectM36.Relation
17+import ProjectM36.Atomable
18+import Prelude hiding ((!!))
19+import Data.Proxy
20+import GHC.OverloadedLabels
21+import GHC.TypeLits hiding (Text)
22+import qualified Data.Text as T
23+import qualified Data.Map as M
24+import qualified Data.Set as S
25+import GHC.Exts (IsList(..))
26+import Data.Convertible
27+
28+default (Text)
29+
30+instance IsList (AttributeNamesBase ()) where
31+ type Item (AttributeNamesBase ()) = AttributeName
32+ fromList = AttributeNames . S.fromList
33+ toList (AttributeNames ns) = S.toList ns
34+ toList _ = error "needs AttributeNames"
35+
36+instance IsList (TupleExprsBase ()) where
37+ type Item TupleExprs = TupleExpr
38+ fromList ts = TupleExprs () ts
39+ toList (TupleExprs _ ts) = ts
40+
41+instance IsList TupleExpr where
42+ type Item TupleExpr = (AttributeName, AtomExpr)
43+ fromList attributeValues = TupleExpr (M.fromList attributeValues)
44+ toList (TupleExpr attributeValues) = M.toList attributeValues
45+
46+
47+-- #xxx :: Text
48+instance KnownSymbol x => IsLabel x Text where
49+ fromLabel = T.pack $ symbolVal @x Proxy
50+
51+-- #relvarName :: RelationalExpr
52+instance KnownSymbol x => IsLabel x RelationalExpr where
53+ fromLabel = RelationVariable (T.pack $ symbolVal @x Proxy) ()
54+
55+-- *Main> #a Int :: AttributeExpr
56+-- NakedAttributeExpr (Attribute "a" IntAtomType)
57+-- *Main> #a (Attr @[Int]) :: AttributeExpr
58+-- NakedAttributeExpr (Attribute "a" (ConstructedAtomType "List" (fromList [("a",IntAtomType)])))
59+-- can't offer a Relation atomtype -- don't know how to express a Relation type in haskell type. Maybe something a HList of (Text, a) ?
60+--
61+-- ps. I don't understand the usage of "AttributeAndTypeNameExpr AttributeName TypeConstructor a"
62+instance (KnownSymbol x, Atomable a)=> IsLabel x (HaskAtomType a -> AttributeExpr) where
63+ fromLabel = (NakedAttributeExpr . Attribute name) . toAtomType''
64+ where name = T.pack $ symbolVal @x Proxy
65+
66+-- (#a 1) :: ExtendTupleExpr
67+-- no need for :=
68+instance (Convertible a AtomExpr, KnownSymbol x) => IsLabel x (a -> ExtendTupleExpr) where
69+ fromLabel x = AttributeExtendTupleExpr name (convert x)
70+ where name = T.pack $ symbolVal @x Proxy
71+
72+-- #name AtomExpr
73+-- ex. tuple [ #name 3 ]
74+-- default(Text) is needed in client code to avoid `no Atomable Char`
75+instance (Convertible a AtomExpr, KnownSymbol x) => IsLabel x (a -> (AttributeName, AtomExpr)) where
76+ fromLabel = \x -> (name, convert x)
77+ where name = T.pack $ symbolVal @x Proxy
78+
79+-- *Main> #a [1] :: AtomExpr
80+-- FunctionAtomExpr "a" [NakedAtomExpr (IntegerAtom 1)] ()
81+--
82+-- This usage is not working in RestrictionPredicateExpr and AttributeExtendTupleExpr. Use f "a" [1] instead.
83+instance (KnownSymbol x, Convertible a AtomExpr) => IsLabel x ([a] -> AtomExpr) where
84+ fromLabel = \as' -> FunctionAtomExpr name (map convert as') ()
85+ where name = T.pack $ symbolVal @x Proxy
86+
87+instance (KnownSymbol x) => IsLabel x AtomExpr where
88+ fromLabel = AttributeAtomExpr name
89+ where name = T.pack $ symbolVal @x Proxy
90+
91+
92+data HaskAtomType a where
93+ Int :: HaskAtomType Int
94+ Integer :: HaskAtomType Integer
95+ Double :: HaskAtomType Double
96+ Text :: HaskAtomType Text
97+-- Day :: HaskAtomType Day
98+-- DateTime :: HaskAtomType DateTime
99+-- ByteString :: HaskAtomType ByteString
100+ Bool :: HaskAtomType Bool
101+ Attr :: Atomable a => HaskAtomType a -- a Proxy-like value for type application.
102+
103+toAtomType'' :: Atomable a => HaskAtomType a -> AtomType
104+toAtomType'' (_ :: HaskAtomType a) = toAtomType (Proxy @a)
105+
106+-- usage: relation [tuple [#a 1, #b "b"], tuple [#a 2, #b "b"]]
107+relation :: [TupleExpr] -> RelationalExpr
108+relation ts = MakeRelationFromExprs Nothing (TupleExprs () ts)
109+
110+relation' :: [AttributeExprBase ()] -> [TupleExpr] -> RelationalExpr
111+relation' as' ts = MakeRelationFromExprs (Just as') (TupleExprs () ts)
112+
113+-- usage: tuple [#name "Mike",#age 6]
114+tuple :: [(AttributeName, AtomExpr)] -> TupleExprBase ()
115+tuple as' = TupleExpr (M.fromList as')
116+
117+-- #a rename [#b `as` #c]
118+rename :: RelationalExpr -> [(AttributeName,AttributeName)] -> RelationalExpr
119+rename relExpr renameList = case renameList of
120+ [] -> Restrict TruePredicate relExpr
121+ renames ->
122+ foldl (\acc (old,new) -> Rename old new acc) relExpr renames
123+
124+--project !!
125+-- #a !! [#b,#c]
126+infix 9 !!
127+(!!) :: RelationalExpr -> AttributeNames -> RelationalExpr
128+relExpr !! xs = Project xs relExpr
129+
130+--join ><
131+-- #a >< #b
132+(><) :: RelationalExpr -> RelationalExpr -> RelationalExpr
133+a >< b = Join a b
134+
135+allBut :: AttributeNames -> AttributeNames
136+allBut (AttributeNames ns) = InvertedAttributeNames ns
137+allBut _ = error "give allBut something other than attribute names."
138+
139+allFrom :: RelationalExpr -> AttributeNames
140+allFrom = RelationalExprAttributeNames
141+
142+as :: AttributeNames -> AttributeName -> (AttributeNames, AttributeName)
143+as = (,)
144+
145+-- #a `group` ([#b,#c] `as` #d)
146+group :: RelationalExpr -> (AttributeNames, AttributeName) -> RelationalExpr
147+group relExpr (aNames, aName) = Group aNames aName relExpr
148+
149+-- #a `ungroup` #b
150+ungroup :: RelationalExpr -> AttributeName -> RelationalExpr
151+ungroup relExpr aName = Ungroup aName relExpr
152+
153+-- *Main> #a #:= true #: ( #b (f "count" [1,2]))
154+-- Assign "a" (Extend (AttributeExtendTupleExpr "b" (FunctionAtomExpr "count" [NakedAtomExpr (IntegerAtom 1),NakedAtomExpr (IntegerAtom 2)] ())) (ExistingRelation (Relation attributesFromList [] (RelationTupleSet {asList = [RelationTuple attributesFromList [] []]}))))
155+(#:) :: RelationalExpr -> ExtendTupleExpr -> RelationalExpr
156+a #: b = Extend b a
157+infix 8 #:
158+
159+instance Convertible AtomExpr AtomExpr where
160+ safeConvert n = Right n
161+
162+instance Convertible RelVarName AtomExpr where
163+ safeConvert n = Right $ RelationAtomExpr (RelationVariable n ())
164+
165+instance Convertible RelationalExpr AtomExpr where
166+ safeConvert relExpr = Right $ RelationAtomExpr relExpr
167+
168+instance Convertible RelVarName RelationalExpr where
169+ safeConvert n = Right $ RelationVariable n ()
170+
171+-- @ in tutd
172+-- (@@) "aaa"
173+(@@) :: AttributeName -> AtomExpr
174+(@@) = AttributeAtomExpr
175+
176+-- works in RestrictedPredicateExpr and AttributeExtendTupleExpr
177+-- usage: f "gte" [1]
178+f :: Convertible a AtomExpr => AtomFunctionName -> [a] -> AtomExpr
179+f n as' = FunctionAtomExpr n (map convert as') ()
180+
181+-- DatabaseContextExpr
182+-- define
183+(#::) :: RelVarName -> [AttributeExpr] -> DatabaseContextExpr
184+s #:: xs = Define s xs
185+infix 5 #::
186+
187+-- assign
188+(#:=) :: RelVarName -> RelationalExpr -> DatabaseContextExpr
189+s #:= r = Assign s r
190+infix 5 #:=
191+
192+class Boolean a b where
193+ (&&&) :: a -> b -> RestrictionPredicateExpr
194+ infixl 6 &&&
195+ (|||) :: a -> b -> RestrictionPredicateExpr
196+ infixl 5 |||
197+
198+-- where: @~ mimics the restriction symbol in algebra
199+-- usage: true #: (#a 1) @~ #a ?= 1 &&& not' false ||| (f "gte" [1])
200+(@~) :: Convertible a RestrictionPredicateExpr => RelationalExpr -> a -> RelationalExpr
201+(@~) relExpr resPreExpr = Restrict (convert resPreExpr) relExpr
202+infix 4 @~
203+
204+true :: RelationalExpr
205+true = ExistingRelation relationTrue
206+
207+false :: RelationalExpr
208+false = ExistingRelation relationFalse
209+
210+trueP :: RestrictionPredicateExprBase a
211+trueP = TruePredicate
212+
213+falseP :: RestrictionPredicateExprBase a
214+falseP = NotPredicate TruePredicate
215+
216+(?=) :: Convertible a AtomExpr => AttributeName -> a -> RestrictionPredicateExpr
217+(?=) name a = AttributeEqualityPredicate name (convert a)
218+infix 9 ?=
219+
220+not' :: Convertible a RestrictionPredicateExpr => a -> RestrictionPredicateExpr
221+not' = NotPredicate . convert
222+
223+instance (Convertible a RestrictionPredicateExpr, Convertible b RestrictionPredicateExpr) => Boolean a b where
224+ a &&& b = AndPredicate (convert a) (convert b)
225+ a ||| b = OrPredicate (convert a) (convert b)
226+
227+instance {-# Incoherent #-} Atomable a => Convertible a RestrictionPredicateExpr where
228+ safeConvert n = Right $ AtomExprPredicate $ toAtomExpr . toAtom $ n
229+
230+instance {-# Incoherent #-} Convertible RelationalExpr RestrictionPredicateExpr where
231+ safeConvert a = Right $ RelationalExprPredicate a
232+
233+instance {-# Incoherent #-} Convertible AtomExpr RestrictionPredicateExpr where
234+ safeConvert a = Right $ AtomExprPredicate a
235+
236+instance {-# Incoherent #-} Convertible RestrictionPredicateExpr RestrictionPredicateExpr where
237+ safeConvert a = Right a
238+
239+instance {-# Incoherent #-} Atomable a => Convertible a AtomExpr where
240+ safeConvert n = Right $ toAtomExpr . toAtom $ n
241+
242+toAtomExpr :: Atom -> AtomExpr
243+toAtomExpr (ConstructedAtom n _ xs) = ConstructedAtomExpr n (toAtomExpr <$> xs) ()
244+toAtomExpr a = NakedAtomExpr a
245+
246+
247+
src/lib/ProjectM36/StaticOptimizer.hs+4−3
@@ -22,8 +22,6 @@ import qualified Data.Set as S
2222
2323-- the static optimizer performs optimizations which need not take any specific-relation statistics into account
2424
25−--import Debug.Trace
26−
2725data GraphRefSOptRelationalExprEnv =
2826 GraphRefSOptRelationalExprEnv
2927 {
@@ -179,7 +177,7 @@ fullOptimizeGraphRefRelationalExpr expr = do
179177optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr
180178optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e
181179
182−optimizeGraphRefRelationalExpr e@(MakeRelationFromExprs _ _) = pure e
180+optimizeGraphRefRelationalExpr e@MakeRelationFromExprs{} = pure e
183181
184182optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e
185183
@@ -209,6 +207,8 @@ optimizeGraphRefRelationalExpr (Union exprA exprB) = do
209207 case (optExprA, optExprB) of
210208 (Restrict predA (RelationVariable nameA sA),
211209 Restrict predB (RelationVariable nameB sB)) | nameA == nameB && sA == sB -> pure (Restrict (AndPredicate predA predB) (RelationVariable nameA sA))
210+ (exprA', exprB') | isEmptyRelationExpr exprA' -> pure exprB'
211+ | isEmptyRelationExpr exprB' -> pure exprA'
212212 _ -> if optExprA == optExprB then
213213 pure optExprA
214214 else
@@ -575,3 +575,4 @@ applyStaticRestrictionPushdown expr = case expr of
575575-- no optimizations available
576576optimizeDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextIOExpr
577577optimizeDatabaseContextIOExpr = pure
578+
src/lib/ProjectM36/TransactionGraph.hs+2−2
@@ -1,4 +1,4 @@
1−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, CPP, FlexibleContexts, DerivingVia #-}
1+{-# LANGUAGE DeriveGeneric, CPP, FlexibleContexts, DerivingVia #-}
22module ProjectM36.TransactionGraph where
33import ProjectM36.Base
44import ProjectM36.Error
@@ -384,7 +384,7 @@ subGraphOfFirstCommonAncestor origGraph resultHeads currentTrans' goalTrans trav
384384 else do
385385 currentTransChildren <- childTransactions currentTrans' origGraph
386386 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren
387− searchChild start = pathToTransaction origGraph start goalTrans (S.insert currentTrans' traverseSet)
387+ searchChild start' = pathToTransaction origGraph start' goalTrans (S.insert currentTrans' traverseSet)
388388 childSearches = map searchChild (S.toList searchChildren)
389389 errors = lefts childSearches
390390 pathsFound = rights childSearches
src/lib/ProjectM36/Tuple.hs+47−33
@@ -1,7 +1,7 @@
11module ProjectM36.Tuple where
22import ProjectM36.Base
33import ProjectM36.Error
4−import ProjectM36.Attribute
4+import ProjectM36.Attribute as A
55import ProjectM36.Atom
66import ProjectM36.AtomType
77import ProjectM36.DataTypes.Primitive
@@ -15,19 +15,19 @@ import Control.Arrow
1515import Data.Maybe
1616
1717emptyTuple :: RelationTuple
18−emptyTuple = RelationTuple V.empty V.empty
18+emptyTuple = RelationTuple mempty mempty
1919
2020tupleSize :: RelationTuple -> Int
21−tupleSize (RelationTuple tupAttrs _) = V.length tupAttrs
21+tupleSize (RelationTuple tupAttrs _) = arity tupAttrs
2222
2323tupleAttributeNameSet :: RelationTuple -> S.Set AttributeName
24−tupleAttributeNameSet (RelationTuple tupAttrs _) = S.fromList $ V.toList $ V.map attributeName tupAttrs
24+tupleAttributeNameSet (RelationTuple tupAttrs _) = attributeNameSet tupAttrs
2525
2626tupleAttributes :: RelationTuple -> Attributes
2727tupleAttributes (RelationTuple tupAttrs _) = tupAttrs
2828
2929tupleAssocs :: RelationTuple -> [(AttributeName, Atom)]
30−tupleAssocs (RelationTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)
30+tupleAssocs (RelationTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)
3131
3232orderedTupleAssocs :: RelationTuple -> [(AttributeName, Atom)]
3333orderedTupleAssocs tup@(RelationTuple attrVec _) = map (\attr -> (attributeName attr, atomForAttr (attributeName attr))) oAttrs
@@ -42,7 +42,7 @@ tupleAtoms :: RelationTuple -> V.Vector Atom
4242tupleAtoms (RelationTuple _ tupVec) = tupVec
4343
4444atomForAttributeName :: AttributeName -> RelationTuple -> Either RelationalError Atom
45−atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of
45+atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of
4646 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))
4747 Just index -> case tupVec V.!? index of
4848 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))
@@ -59,7 +59,7 @@ vectorIndicesForAttributeNames attrNameVec attrs = if not $ V.null unknownAttrNa
5959 Right $ V.map mapper attrNameVec
6060 where
6161 unknownAttrNames = V.filter (`V.notElem` attributeNames attrs) attrNameVec
62− mapper attrName = fromMaybe (error "logic failure in vectorIndicesForAttributeNames") (V.elemIndex attrName (V.map attributeName attrs))
62+ mapper attrName = fromMaybe (error "logic failure in vectorIndicesForAttributeNames") (V.elemIndex attrName (attributeNames attrs))
6363
6464
6565relationForAttributeName :: AttributeName -> RelationTuple -> Either RelationalError Relation
@@ -86,10 +86,10 @@ mkRelationTuples attrs = map mapper
8686 mapper = mkRelationTuple attrs
8787
8888mkRelationTupleFromMap :: M.Map AttributeName Atom -> RelationTuple
89−mkRelationTupleFromMap attrMap = RelationTuple attrs (V.map (attrMap M.!) attrNames)
89+mkRelationTupleFromMap attrMap = RelationTuple (attributesFromList attrs) (V.map (attrMap M.!) (V.fromList attrNames))
9090 where
91− attrNames = V.fromList (M.keys attrMap)
92− attrs = V.map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames
91+ attrNames = M.keys attrMap
92+ attrs = map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames
9393
9494--return error if attribute names match but their types do not
9595singleTupleSetJoin :: Attributes -> RelationTuple -> RelationTupleSet -> Either RelationalError [RelationTuple]
@@ -120,8 +120,8 @@ singleTupleJoin joinedAttrs tup1@(RelationTuple tupAttrs1 _) tup2@(RelationTuple
120120 return $ Just $ RelationTuple joinedAttrs newVec
121121 where
122122 keysIntersection = V.map attributeName attrsIntersection
123− attrsIntersection = V.filter (`V.elem` tupAttrs1) tupAttrs2
124− newVec = V.map (findAtomForAttributeName . attributeName) joinedAttrs
123+ attrsIntersection = V.filter (`V.elem` attributesVec tupAttrs1) (attributesVec tupAttrs2)
124+ newVec = V.map (findAtomForAttributeName . attributeName) (attributesVec joinedAttrs)
125125 --search both tuples for the attribute
126126 findAtomForAttributeName attrName = head $ rights $ fmap (atomForAttributeName attrName) [tup1, tup2]
127127
@@ -138,23 +138,31 @@ vectorUnion v1 v2 = V.foldr folder v1 v2
138138tupleExtend :: RelationTuple -> RelationTuple -> RelationTuple
139139tupleExtend (RelationTuple tupAttrs1 tupVec1) (RelationTuple tupAttrs2 tupVec2) = RelationTuple newAttrs newVec
140140 where
141− newAttrs = tupAttrs1 V.++ tupAttrs2
142− newVec = tupVec1 V.++ tupVec2
141+ newAttrs = tupAttrs1 <> tupAttrs2
142+ newVec = tupVec1 <> tupVec2
143143
144144tupleAtomExtend :: AttributeName -> Atom -> RelationTuple -> RelationTuple
145145tupleAtomExtend newAttrName atom tupIn = tupleExtend tupIn newTup
146146 where
147− newTup = RelationTuple (V.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)
147+ newTup = RelationTuple (A.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)
148148
149−--this could be cheaper- it may not be wortwhile to update all the tuples for projection, but then the attribute management must be slightly different- perhaps the attributes should be a vector of association tuples [(name, index)]
150−tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple
149+{-tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple
151150tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec
152151 where
153− deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) attrs
152+ deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) (attributesVec attrs)
154153 indexDeleter = V.ifilter (\index _ -> V.notElem index deleteIndices)
155− newAttrs = indexDeleter attrs
154+ newAttrs = case A.projectionAttributesForNames projectAttrs attrs of
155+ Left err -> error (show (err, projectAttrs, attrs))
156+ Right attrs' -> attrs'
156157 newTupVec = indexDeleter tupVec
157−
158+-}
159+-- remember that the attributes order matters
160+tupleProject :: Attributes -> RelationTuple -> Either RelationalError RelationTuple
161+tupleProject projectAttrs tup = do
162+ newTupVec <- foldM (\acc attr ->
163+ V.snoc acc <$> atomForAttributeName (attributeName attr) tup
164+ ) V.empty (attributesVec projectAttrs)
165+ pure $ reorderTuple projectAttrs (RelationTuple projectAttrs newTupVec)
158166--return the attributes and atoms which are equal in both vectors
159167--semi-join
160168tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple
@@ -162,12 +170,14 @@ tupleIntersection tuple1 tuple2 = RelationTuple newAttrs newTupVec
162170 where
163171 attrs1 = tupleAttributes tuple1
164172 attrs2 = tupleAttributes tuple2
165− matchingIndices = V.findIndices (\attr -> V.elem attr attrs2 &&
166− atomForAttributeName (attributeName attr) tuple1 ==
167− atomForAttributeName (attributeName attr) tuple2
168− ) attrs1
173+ intersectAttrs = A.intersection attrs1 attrs2
174+ matchingIndices = V.findIndices (\attr -> A.member attr intersectAttrs &&
175+ atomForAttributeName (attributeName attr) tuple1 ==
176+ atomForAttributeName (attributeName attr) tuple2) (attributesVec attrs1)
169177 indexFilter = V.ifilter (\index _ -> V.elem index matchingIndices)
170− newAttrs = indexFilter attrs1
178+ newAttrs = case A.projectionAttributesForNames (A.attributeNameSet intersectAttrs) attrs1 of
179+ Left _ -> mempty
180+ Right attrs' -> attrs'
171181 newTupVec = indexFilter (tupleAtoms tuple1)
172182
173183-- | An optimized form of tuple update which updates vectors efficiently.
@@ -175,19 +185,20 @@ updateTupleWithAtoms :: M.Map AttributeName Atom -> RelationTuple -> RelationTup
175185updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec
176186 where
177187 updateKeysSet = M.keysSet updateMap
178− updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed attrs)
188+ updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed (attributesVec attrs))
179189 newVec = V.update tupVec updateVec
180190 updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec
181191
182192tupleToMap :: RelationTuple -> M.Map AttributeName Atom
183193tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList
184194 where
185− assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed attrs)
195+ assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed (attributesVec attrs))
186196
197+-- | Validate that the tuple has the correct attributes in the correct order
187198verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple
188−verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs
199+verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs
189200 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in
190− if V.length attrs /= V.length tupleTypes then
201+ if A.arity attrs /= V.length tupleTypes then
191202 Left $ TupleAttributeCountMismatchError 0
192203 else do
193204 mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)
@@ -196,15 +207,18 @@ verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs
196207--two tuples can be equal but the vectors of attributes could be out-of-order
197208--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering
198209reorderTuple :: Attributes -> RelationTuple -> RelationTuple
199−reorderTuple attrs tupIn = if tupleAttributes tupIn == attrs then
210+reorderTuple attrs tupIn = if attributesAndOrderEqual (tupleAttributes tupIn) attrs then
200211 tupIn
201212 else
202− RelationTuple attrs (V.map mapper attrs)
213+ RelationTuple attrs (V.map mapper (attributesVec attrs))
203214 where
204215 mapper attr = case atomForAttributeName (attributeName attr) tupIn of
205− Left err -> error ("logic bug in reorderTuple: " ++ show err)
216+ Left err -> error ("logic bug in reorderTuple: " ++ show err <> show tupIn)
206217 Right atom -> atom
207218
208219--used in Generics derivation for ADTs without named attributes
209220trimTuple :: Int -> RelationTuple -> RelationTuple
210−trimTuple index (RelationTuple attrs vals) = RelationTuple (V.drop index attrs) (V.drop index vals)
221+trimTuple index (RelationTuple attrs vals) =
222+ RelationTuple newAttrs (V.drop index vals)
223+ where
224+ newAttrs = A.drop index attrs
src/lib/ProjectM36/TupleSet.hs+7
@@ -31,3 +31,10 @@ mkTupleSet attrs tuples = verifyTupleSet attrs (RelationTupleSet tuples)
3131
3232mkTupleSetFromList :: Attributes -> [[Atom]] -> Either RelationalError RelationTupleSet
3333mkTupleSetFromList attrs atomMatrix = mkTupleSet attrs $ map (mkRelationTuple attrs . V.fromList) atomMatrix
34+
35+
36+-- | Union two tuplesets while reordering their attribute/atom mapping properly.
37+tupleSetUnion :: Attributes -> RelationTupleSet -> RelationTupleSet -> RelationTupleSet
38+tupleSetUnion targetAttrs tupSet1 tupSet2 = RelationTupleSet $ HS.toList . HS.fromList $ reorder (asList tupSet1) ++ reorder (asList tupSet2)
39+ where
40+ reorder = map (reorderTuple targetAttrs)
src/lib/ProjectM36/Tupleable.hs+9−8
@@ -38,7 +38,7 @@ import qualified Data.Text as T
3838import qualified Data.Vector as V
3939import GHC.Generics
4040import ProjectM36.Atomable
41−import ProjectM36.Attribute hiding (null)
41+import ProjectM36.Attribute as A hiding (null, toList)
4242import ProjectM36.Base
4343import ProjectM36.DataTypes.Primitive
4444import ProjectM36.Error
@@ -89,7 +89,7 @@ toInsertExpr vals rvName = do
8989
9090-- | Convert a 'Tupleable' to a create a 'Define' expression which can be used to create an empty relation variable. Use 'toInsertExpr' to insert the actual tuple data. This function is typically used with 'Data.Proxy'.
9191toDefineExpr :: forall a proxy. Tupleable a => proxy a -> RelVarName -> DatabaseContextExpr
92−toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList attrs))
92+toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList (attributesVec attrs)))
9393 where
9494 attrs = toAttributes (Proxy :: Proxy a)
9595
@@ -228,11 +228,12 @@ instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) whe
228228 toTupleG opts (M1 v) = RelationTuple attrs atoms
229229 where
230230 attrsToCheck = toAttributesG opts v
231− counter = V.generate (V.length attrsToCheck) id
232− attrs = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then
231+ counter = V.generate (arity attrsToCheck) id
232+ attrs = attributesFromList (V.toList attrsV)
233+ attrsV = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then
233234 Attribute ("attr" <> T.pack (show (num + 1))) typ
234235 else
235− attr) counter attrsToCheck
236+ attr) counter (attributesVec attrsToCheck)
236237 atoms = V.fromList (toAtomsG v)
237238 toAttributesG opts (M1 v) = toAttributesG opts v
238239 fromTupleG opts tup = M1 <$> fromTupleG opts tup
@@ -241,7 +242,7 @@ instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) whe
241242-- product types
242243instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where
243244 toTupleG = error "toTupleG"
244− toAttributesG opts ~(x :*: y) = toAttributesG opts x V.++ toAttributesG opts y --a bit of extra laziness prevents whnf so that we can use toAttributes (undefined :: Test2T Int Int) without throwing an exception
245+ toAttributesG opts ~(x :*: y) = toAttributesG opts x <> toAttributesG opts y --a bit of extra laziness prevents whnf so that we can use toAttributes (undefined :: Test2T Int Int) without throwing an exception
245246 fromTupleG opts tup = (:*:) <$> fromTupleG opts tup <*> fromTupleG opts processedTuple
246247 where
247248 processedTuple = if isRecordTypeG (undefined :: a x) then
@@ -253,7 +254,7 @@ instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where
253254--selector/record
254255instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where
255256 toTupleG = error "toTupleG"
256− toAttributesG opts m@(M1 v) = V.singleton (Attribute modifiedName aType)
257+ toAttributesG opts m@(M1 v) = A.singleton (Attribute modifiedName aType)
257258 where
258259 name = T.pack (selName m)
259260 modifiedName = if T.null name then
@@ -268,7 +269,7 @@ instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where
268269 val <- atomv atom
269270 pure (M1 val)
270271 where
271− expectedAtomType = atomType (V.head (toAttributesG opts (undefined :: M1 S c a x)))
272+ expectedAtomType = atomType (V.head (attributesVec (toAttributesG opts (undefined :: M1 S c a x))))
272273 atomv atom = maybe (Left (AtomTypeMismatchError
273274 expectedAtomType
274275 (atomTypeForAtom atom)
src/lib/ProjectM36/WithNameExpr.hs+4−2
@@ -42,9 +42,11 @@ substituteWithNameMacros macros (NotEquals exprA exprB) =
4242substituteWithNameMacros macros (Extend extendTup expr) =
4343 Extend (substituteWitNameMacrosExtendTupleExpr macros extendTup) (substituteWithNameMacros macros expr)
4444substituteWithNameMacros macros (With moreMacros expr) =
45− --collect and override existing macros and recurse
45+ --collect and update nested with exprs
4646 let newMacros = foldr macroFolder macros moreMacros
47− macroFolder (wnexpr, mexpr) acc = filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, mexpr)] in
47+ macroFolder (wnexpr, mexpr) acc =
48+ let subExpr = substituteWithNameMacros macros mexpr in
49+ filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, subExpr)] in
4850 --scan for a match- if it exists, replace it (representing a with clause at a lower level
4951 substituteWithNameMacros newMacros expr
5052
stack.ghc8.0.yamldeleted−48
@@ -1,48 +0,0 @@
1−# This file was automatically generated by stack init
2−# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/
3−
4−# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)
5−resolver: lts-8.5
6−
7−# Local packages, usually specified by relative directory name
8−packages:
9−- '.'
10−# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
11−extra-deps:
12−- git: https://github.com/agentm/curryer.git
13− commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c
14−- data-accessor-transformers-0.2.1.7
15−- data-interval-1.2.0
16−- extended-reals-0.2.1.0
17−- gnuplot-0.5.4.1
18−- text-1.2.2.1
19−- aeson-1.2.1.00
20−- deferred-folds-0.6.12
21−- rset-1.0.0
22−
23−# Override default flag values for local packages and extra-deps
24−flags: {}
25−
26−# Extra package databases containing global packages
27−extra-package-dbs: []
28−
29−# Control whether we use the GHC we find on the path
30−# system-ghc: true
31−
32−# Require a specific version of stack, using version ranges
33−# require-stack-version: -any # Default
34−# require-stack-version: >= 1.0.0
35−
36−# Override the architecture used by stack, especially useful on Windows
37−# arch: i386
38−# arch: x86_64
39−
40−# Extra directories used by stack for building
41−# extra-include-dirs: [/path/to/dir]
42−# extra-lib-dirs: [/path/to/dir]
43−
44−# Allow a newer minor version of GHC than the snapshot specifies
45−# compiler-check: newer-minor
46−
47−allow-newer: true
48−
stack.ghc8.10.yamlnew file+19
@@ -0,0 +1,19 @@
1+resolver: lts-17.13
2+packages:
3+ - "."
4+
5+extra-deps:
6+ - git: https://github.com/agentm/curryer.git
7+ commit: 74ecaac619ad1165a4517d5c0f4e530493bda130
8+ - git: https://github.com/composewell/streamly.git
9+ commit: ac3af8749194f1788704dda8667d0b3807075cc2
10+ - fast-builder-0.1.2.1
11+ - rset-1.0.0
12+ - winery-1.3.2
13+ - barbies-th-0.1.8
14+ - base16-bytestring-1.0.1.0
15+
16+flags:
17+ project-m36:
18+ stack: true
19+# allow-newer: true
stack.ghc8.2.yamldeleted−50
@@ -1,50 +0,0 @@
1−# This file was automatically generated by stack init
2−# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/
3−
4−# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)
5−resolver: lts-11.20
6−
7−# Local packages, usually specified by relative directory name
8−packages:
9−- '.'
10−
11−# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
12−extra-deps:
13−- git: https://github.com/agentm/curryer.git
14− commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c
15−- data-accessor-transformers-0.2.1.7
16−- data-interval-1.2.0
17−- extended-reals-0.2.1.0
18−- gnuplot-0.5.4.1
19−- text-1.2.2.1
20−- aeson-1.2.1.00
21−- rset-1.0.0
22−
23−# Override default flag values for local packages and extra-deps
24−flags:
25− project-m36:
26− stack: true
27−
28−# Extra package databases containing global packages
29−extra-package-dbs: []
30−
31−# Control whether we use the GHC we find on the path
32−# system-ghc: true
33−
34−# Require a specific version of stack, using version ranges
35−# require-stack-version: -any # Default
36−# require-stack-version: >= 1.0.0
37−
38−# Override the architecture used by stack, especially useful on Windows
39−# arch: i386
40−# arch: x86_64
41−
42−# Extra directories used by stack for building
43−# extra-include-dirs: [/path/to/dir]
44−# extra-lib-dirs: [/path/to/dir]
45−
46−# Allow a newer minor version of GHC than the snapshot specifies
47−# compiler-check: newer-minor
48−
49−allow-newer: true
50−
stack.ghc8.4.yamldeleted−46
@@ -1,46 +0,0 @@
1−# This file was automatically generated by stack init
2−# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/
3−
4−# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)
5−resolver: lts-12.26
6−
7−# Local packages, usually specified by relative directory name
8−packages:
9−- '.'
10−# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
11−extra-deps:
12−- git: https://github.com/agentm/curryer.git
13− commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c
14−- data-interval-1.3.0
15−- extended-reals-0.2.3.0
16−- rset-1.0.0
17−- hashable-time-0.2.0.2
18−- network-transport-tcp-0.6.0
19−
20−# Override default flag values for local packages and extra-deps
21−flags:
22− project-m36:
23− stack: true
24−
25−# Extra package databases containing global packages
26−extra-package-dbs: []
27−
28−# Control whether we use the GHC we find on the path
29−# system-ghc: true
30−
31−# Require a specific version of stack, using version ranges
32−# require-stack-version: -any # Default
33−# require-stack-version: >= 1.0.0
34−
35−# Override the architecture used by stack, especially useful on Windows
36−# arch: i386
37−# arch: x86_64
38−
39−# Extra directories used by stack for building
40−# extra-include-dirs: [/path/to/dir]
41−# extra-lib-dirs: [/path/to/dir]
42−
43−# Allow a newer minor version of GHC than the snapshot specifies
44−# compiler-check: newer-minor
45−
46−allow-newer: true
stack.ghc8.6.yaml+25−12
@@ -2,23 +2,36 @@
22# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/
33
44# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)
5−resolver: lts-14.3
5+resolver: lts-14.27
66
77# Local packages, usually specified by relative directory name
88packages:
9−- '.'
9+ - "."
1010# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
1111extra-deps:
12−- git: https://github.com/agentm/curryer.git
13− commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c
14−- extended-reals-0.2.3.0
15−- data-interval-2.0.1
16−- stm-containers-1.1.0.4
17−- stm-hamt-1.2.0.4
18−- rset-1.0.0
19−- hashable-time-0.2.0.2
20−- network-transport-tcp-0.6.0
21−- megaparsec-7.0.5
12+ - git: https://github.com/agentm/curryer.git
13+ commit: 74ecaac619ad1165a4517d5c0f4e530493bda130
14+ - git: https://github.com/composewell/streamly.git
15+ commit: ac3af8749194f1788704dda8667d0b3807075cc2
16+ - fast-builder-0.1.2.1
17+ - winery-1.3.2
18+ - barbies-2.0.2.0
19+ - barbies-th-0.1.7
20+ - extended-reals-0.2.3.0
21+ - data-interval-2.0.1
22+ - stm-containers-1.1.0.4
23+ - stm-hamt-1.2.0.4
24+ - rset-1.0.0
25+ - hashable-time-0.2.0.2
26+ - network-transport-tcp-0.6.0
27+ - megaparsec-7.0.5
28+ - prettyprinter-1.7.0
29+ - prettyprinter-ansi-terminal-1.1.2
30+ - fusion-plugin-types-0.1.0
31+ - base16-bytestring-1.0.1.0
32+ - modern-uri-0.3.4.0
33+ - cryptohash-sha256-0.11.102.0
34+ - http-types-0.12.3
2235
2336# Override default flag values for local packages and extra-deps
2437flags:
stack.ghc8.8.yaml+24−14
@@ -6,22 +6,32 @@ resolver: lts-16.4
66
77# Local packages, usually specified by relative directory name
88packages:
9−- '.'
9+ - "."
1010# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
1111extra-deps:
12−- git: https://github.com/agentm/curryer.git
13− commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c
14−- extended-reals-0.2.3.0
15−- data-interval-2.0.1
16−- stm-containers-1.1.0.4
17−- stm-hamt-1.2.0.4
18−- rset-1.0.0
19−- hashable-time-0.2.0.2
20−- network-transport-tcp-0.7.0
21−- megaparsec-7.0.5
22−- network-2.8.0.1
23−- primitive-extras-0.8
24−- primitive-unlifted-0.1.3.0
12+ - git: https://github.com/agentm/curryer.git
13+ commit: 74ecaac619ad1165a4517d5c0f4e530493bda130
14+ - git: https://github.com/composewell/streamly.git
15+ commit: ac3af8749194f1788704dda8667d0b3807075cc2
16+ - fast-builder-0.1.2.1
17+ - winery-1.3.2
18+ - barbies-2.0.2.0
19+ - barbies-th-0.1.7
20+ - extended-reals-0.2.3.0
21+ - data-interval-2.0.1
22+ - stm-containers-1.1.0.4
23+ - stm-hamt-1.2.0.4
24+ - rset-1.0.0
25+ - hashable-time-0.2.0.2
26+ - network-transport-tcp-0.7.0
27+ - megaparsec-7.0.5
28+ - network-2.8.0.1
29+ - primitive-extras-0.8
30+ - primitive-unlifted-0.1.3.0
31+ - prettyprinter-1.7.0
32+ - prettyprinter-ansi-terminal-1.1.2
33+ - base16-bytestring-1.0.1.0
34+ - modern-uri-0.3.4.0
2535
2636# Override default flag values for local packages and extra-deps
2737flags:
test/Client/Simple.hs+1−2
@@ -9,7 +9,6 @@ import System.IO.Temp
99import System.FilePath
1010import ProjectM36.TupleSet
1111import ProjectM36.Attribute
12−import qualified Data.Vector as V
1312import qualified Data.Map as M
1413
1514main :: IO ()
@@ -59,7 +58,7 @@ testSimpleCommitFailure = TestCase $ do
5958 execute $ Assign "x" (ExistingRelation relationTrue)
6059 --cause error
6160 execute $ Assign "x" (MakeStaticRelation failAttrs emptyTupleSet)
62− let expectedErr = Left (RelError (RelationTypeMismatchError V.empty failAttrs))
61+ let expectedErr = Left (RelError (RelationTypeMismatchError mempty failAttrs))
6362 assertEqual "dbc error" expectedErr err
6463
6564-- #176 default merge couldn't handle Update
test/Relation/Basic.hs+13−12
@@ -3,8 +3,6 @@ import ProjectM36.Base
33import ProjectM36.Relation
44import ProjectM36.Error
55import ProjectM36.DateExamples
6−import ProjectM36.TupleSet
7−import ProjectM36.Attribute hiding (null, attributeNames)
86import ProjectM36.DataTypes.Primitive
97import ProjectM36.RelationalExpression
108import ProjectM36.TransactionGraph
@@ -25,8 +23,8 @@ testList = TestList [testRelation "relationTrue" relationTrue, testRelation "rel
2523 testRelation "products" productsRel,
2624 testRelation "supplierProducts" supplierProductsRel,
2725 testMkRelationFromExprsBadAttrs,
28− testDuplicateAttributes,
29− testExistingRelationType
26+ testExistingRelationType,
27+ testReorderTuple
3028 ]
3129
3230main :: IO ()
@@ -65,7 +63,7 @@ validateAttrTypesMatchTupleAttrTypes rel@(Relation attrs tupSet) = foldr (\tuple
6563 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of
6664 Left _ -> False
6765 Right atom -> Right (atomTypeForAtom atom) ==
68− A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributes rel)
66+ A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributesVec (attributes rel))
6967
7068simpleRel :: Relation
7169simpleRel = case mkRelation attrs tupleSet of
@@ -103,16 +101,19 @@ testMkRelationFromExprsBadAttrs = TestCase $ do
103101 Left err -> assertEqual "tuple type mismatch" (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "badAttr2" IntAtomType])) err
104102 Right _ -> assertFailure "expected tuple type mismatch"
105103
106−--creating an empty relation with duplicate attribute names should fail
107−testDuplicateAttributes :: Test
108−testDuplicateAttributes = TestCase $ do
109− let eRel = mkRelation attrs emptyTupleSet
110− attrs = attributesFromList [Attribute "a" IntAtomType, Attribute "a" TextAtomType]
111− assertEqual "duplicate attribute names" (Left (DuplicateAttributeNamesError (S.singleton "a"))) eRel
112−
113104testExistingRelationType :: Test
114105testExistingRelationType = TestCase $ do
115106 (graph, _) <- freshTransactionGraph dateExamples
116107 let typeResult = runRelationalExprM reenv (typeForRelationalExpr (ExistingRelation relationTrue))
117108 reenv = mkRelationalExprEnv dateExamples graph
118109 assertEqual "ExistingRelation with tuples type" (Right relationFalse) typeResult
110+
111+-- | Ensure that tuple reordering honors the
112+testReorderTuple :: Test
113+testReorderTuple = TestCase $ do
114+ let tup1 = mkRelationTuple attrs1 (V.fromList [IntAtom 4, TextAtom "test"])
115+ attrs1 = A.attributesFromList [Attribute "a" IntAtomType, Attribute "b" TextAtomType]
116+ attrs2 = A.attributesFromList [Attribute "b" TextAtomType, Attribute "a" IntAtomType]
117+ actual = reorderTuple attrs2 tup1
118+ expected = mkRelationTuple attrs2 (V.fromList [TextAtom "test", IntAtom 4])
119+ assertEqual "reorderTuple" expected actual
test/Relation/Tupleable.hs+18−6
@@ -8,13 +8,13 @@
88 , DataKinds
99 , TypeOperators
1010 , AllowAmbiguousTypes
11+ , DerivingVia
1112 #-}
1213import Test.HUnit
1314import ProjectM36.Tupleable.Deriving
1415import ProjectM36.Atomable
15−import ProjectM36.Attribute
16+import ProjectM36.Attribute as A
1617import ProjectM36.Error
17−import Data.Binary
1818import ProjectM36.Base
1919import Control.DeepSeq (NFData)
2020import qualified Data.Vector as V
@@ -23,6 +23,7 @@ import qualified Data.Text as T
2323import qualified Data.Set as S
2424import System.Exit
2525import Data.Proxy
26+import Codec.Winery
2627
2728{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}
2829
@@ -30,35 +31,43 @@ data Test1T = Test1C {
3031 attrA :: Integer
3132 }
3233 deriving (Generic, Eq, Show)
34+ deriving Serialise via WineryRecord Test1T
3335
3436data Test2T = Test2C {
3537 attrB :: Integer,
3638 attrC :: Integer
3739 }
3840 deriving (Generic, Eq, Show)
41+ deriving Serialise via WineryRecord Test2T
3942
4043data Test3T = Test3C Integer
4144 deriving (Generic, Eq, Show)
45+ deriving Serialise via WineryVariant Test3T
4246
4347data Test4T = Test4C
4448 deriving (Generic, Eq, Show)
49+ deriving Serialise via WineryVariant Test4T
4550
4651data Test5T = Test5C1 Integer |
4752 Test5C2 Integer
4853 deriving (Generic, Eq, Show)
54+ deriving Serialise via WineryVariant Test5T
4955
5056data Test6T = Test6C T.Text Integer Double
5157 deriving (Generic, Eq, Show)
5258
5359data Test7A = Test7AC Integer
54− deriving (Generic, Show, Eq, Binary, NFData, Atomable)
60+ deriving (Generic, Show, Eq, NFData, Atomable)
61+ deriving Serialise via WineryVariant Test7A
5562
5663
5764data Test7T = Test7C Test7A
5865 deriving (Generic, Show, Eq)
66+ deriving Serialise via WineryVariant Test7T
5967
6068data Test8T = Test8C
6169 deriving (Generic, Show, Eq)
70+ deriving Serialise via WineryVariant Test8T
6271
6372data Test9T = Test9C
6473 {
@@ -67,6 +76,7 @@ data Test9T = Test9C
6776 attr9C :: Double
6877 }
6978 deriving (Generic, Show, Eq)
79+ deriving Serialise via WineryRecord Test9T
7080
7181data Test10T = Test10C {
7282 longAttrNameA10 :: Integer,
@@ -74,6 +84,7 @@ data Test10T = Test10C {
7484 longMixed_attr_NameC10 :: Integer
7585 }
7686 deriving (Generic, Show, Eq)
87+ deriving Serialise via WineryRecord Test10T
7788
7889instance Tupleable Test1T
7990
@@ -99,7 +110,7 @@ main = do
99110 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
100111
101112testList :: Test
102−testList = TestList [testADT1, testADT2, testADT3, testADT4, testADT6, testADT7, testADT8, testInsertExpr, testDefineExpr, testUpdateExpr, testUpdateExprEmptyAttrs, testDeleteExpr, testUpdateExprWrongAttr, testReorderedTuple, testAddPrefixField, testDropPrefixField, testAddSuffixField, testDropSuffixField, testUpperCaseField, testLowerCaseField, testTitleCaseField, testCamelCaseField, testPascalCaseField, testSnakeCaseField, testSpinalCaseField, testTrainCaseField, testAsIsCodec, testAsIsField, testComposeRLCodec, testComposeRLField, testComposeLRCodec, testComposeLRField]
113+testList = TestList [testADT1, testADT2, testADT3, testADT4, testADT6, testADT7, testADT8 ,testInsertExpr, testDefineExpr, testUpdateExpr, testUpdateExprEmptyAttrs, testDeleteExpr, testUpdateExprWrongAttr, testReorderedTuple, testAddPrefixField, testDropPrefixField, testAddSuffixField, testDropSuffixField, testUpperCaseField, testLowerCaseField, testTitleCaseField, testCamelCaseField, testPascalCaseField, testSnakeCaseField, testSpinalCaseField, testTrainCaseField, testAsIsCodec, testAsIsField, testComposeRLCodec, testComposeRLField, testComposeLRCodec, testComposeLRField]
103114
104115testADT1 :: Test
105116testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))
@@ -137,7 +148,7 @@ testADT7 :: Test
137148testADT7 = TestCase $ do
138149 let example = Test7C (Test7AC 3)
139150 assertEqual "atom type" (Right example) (fromTuple (toTuple example))
140− let expectedAttrs = V.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))
151+ let expectedAttrs = A.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))
141152 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))
142153
143154testADT8 :: Test
@@ -211,7 +222,8 @@ testDeleteExpr = TestCase $ do
211222testReorderedTuple :: Test
212223testReorderedTuple = TestCase $ do
213224 let tupleRev :: RelationTuple -> RelationTuple
214− tupleRev (RelationTuple v1 v2) = RelationTuple (V.reverse v1) (V.reverse v2)
225+ tupleRev (RelationTuple v1 v2) = RelationTuple (revAttrs v1) (V.reverse v2)
226+ revAttrs attrs = A.attributesFromList (reverse (A.toList attrs))
215227 expected = Test2C {attrB = 3,
216228 attrC = 4}
217229 actual = fromTuple . tupleRev . toTuple $ expected
test/Server/Main.hs+19−20
@@ -5,7 +5,6 @@ test client/server interaction
55import Test.HUnit
66import ProjectM36.Client
77import qualified ProjectM36.Client as C
8−import ProjectM36.Server.EntryPoints
98import ProjectM36.Server
109import ProjectM36.Server.Config
1110import ProjectM36.Relation
@@ -14,16 +13,8 @@ import ProjectM36.IsomorphicSchema
1413import ProjectM36.Base
1514
1615import System.Exit
17−
16+import Network.Socket (SockAddr(..))
1817import Control.Concurrent
19−import Network.Transport (EndPointAddress)
20−
21−#if MIN_VERSION_network_transport_tcp(0,6,0)
22−import Network.Transport.TCP.Internal (encodeEndPointAddress, decodeEndPointAddress)
23−#else
24−import Network.Transport.TCP (encodeEndPointAddress, decodeEndPointAddress)
25−#endif
26−
2718import Data.Either (isRight)
2819import Control.Exception
2920import System.IO.Temp
@@ -32,6 +23,8 @@ import System.FilePath
3223import System.Directory
3324#endif
3425
26+type Timeout = Int
27+
3528testList :: SessionId -> Connection -> MVar () -> Test
3629testList sessionId conn notificationTestMVar = TestList $ serverTests ++ sessionTests
3730 where
@@ -49,7 +42,7 @@ testList sessionId conn notificationTestMVar = TestList $ serverTests ++ session
4942 testRelationVariableSummary,
5043 testNotification notificationTestMVar
5144 ]
52− serverTests = [testRequestTimeout, testFileDescriptorCount]
45+ serverTests = [testRequestTimeout, testFileDescriptorCount, testClientConnectFail]
5346
5447main :: IO ()
5548main = do
@@ -69,11 +62,9 @@ main = do
6962testDatabaseName :: DatabaseName
7063testDatabaseName = "test"
7164
72−testConnection :: EndPointAddress -> MVar () -> IO (Either ConnectionError (SessionId, Connection))
73−testConnection serverAddress mvar = do
74− let Just (host, service, _) = decodeEndPointAddress serverAddress
75− serverAddress' = encodeEndPointAddress host service 1
76− let connInfo = RemoteProcessConnectionInfo testDatabaseName (NodeId serverAddress') (testNotificationCallback mvar)
65+testConnection :: Port -> MVar () -> IO (Either ConnectionError (SessionId, Connection))
66+testConnection serverPort mvar = do
67+ let connInfo = RemoteConnectionInfo testDatabaseName "127.0.0.1" (show serverPort) (testNotificationCallback mvar)
7768 --putStrLn ("testConnection: " ++ show serverAddress)
7869 eConn <- connectProjectM36 connInfo
7970 case eConn of
@@ -85,7 +76,7 @@ testConnection serverAddress mvar = do
8576 Right sessionId -> pure $ Right (sessionId, conn)
8677
8778-- | A version of 'launchServer' which returns the port on which the server is listening on a secondary thread
88−launchTestServer :: Timeout -> IO (EndPointAddress, ThreadId)
79+launchTestServer :: Timeout -> IO (Port, ThreadId)
8980launchTestServer ti = do
9081 addressMVar <- newEmptyMVar
9182 tid <- forkIO $
@@ -99,9 +90,9 @@ launchTestServer ti = do
9990 }
10091
10192 launchServer config (Just addressMVar) >> pure ()
102− endPointAddress <- takeMVar addressMVar
93+ (SockAddrInet port _) <- takeMVar addressMVar
10394 --liftIO $ putStrLn ("launched server on " ++ show endPointAddress)
104− pure (endPointAddress, tid)
95+ pure (fromIntegral port, tid)
10596
10697testRelationalExpr :: SessionId -> Connection -> Test
10798testRelationalExpr sessionId conn = TestCase $ do
@@ -217,7 +208,7 @@ testRequestTimeout = TestCase $ do
217208 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure
218209 Right (session, testConn) -> do
219210 res <- catchJust (\exc -> if exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))
220− assertBool "exception was not thrown" (not res)
211+ assertBool "timeout exception was not thrown" (not res)
221212 killThread serverTid
222213
223214testFileDescriptorCount :: Test
@@ -247,3 +238,11 @@ fdCount = do
247238--pass on non-linux platforms
248239testFileDescriptorCount = TestCase (pure ())
249240#endif
241+
242+testClientConnectFail :: Test
243+testClientConnectFail = TestCase $ do
244+ let connInfo = RemoteConnectionInfo "nonexistentdb" "127.0.0.1" "7777" emptyNotificationCallback
245+ eConn <- connectProjectM36 connInfo
246+ case eConn of
247+ Left (IOExceptionError _) -> pure ()
248+ _ -> assertFailure "connection failure failed"
test/Server/WebSocket.hs+3−9
@@ -18,12 +18,6 @@ import Data.Aeson
1818import qualified Data.Map as M
1919import qualified Data.ByteString.Lazy as BS
2020import ProjectM36.Relation
21−#if MIN_VERSION_network_transport_tcp(0,6,0)
22−import Network.Transport.TCP.Internal (decodeEndPointAddress)
23−#else
24−import Network.Transport.TCP (decodeEndPointAddress)
25−#endif
26−
2721
2822--start the websocket server
2923-- run some tutoriald against it
@@ -37,12 +31,12 @@ launchTestServer = do
3731 testDatabaseName = "test"
3832 -- start normal server
3933 _ <- forkIO (launchServer config (Just addressMVar) >> pure ())
40− serverAddress <- takeMVar addressMVar
34+ (SockAddrInet dbPort _) <- takeMVar addressMVar
4135 let wsServerHost = "127.0.0.1"
4236 wsServerPort = 8889
43− Just (dbHost, dbPort, _) = decodeEndPointAddress serverAddress
37+ dbHost = "127.0.0.1"
4438 -- start websocket server proxy -- runServer doesn't support returning an arbitrary socket
45− _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (read dbPort) dbHost))
39+ _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (fromIntegral dbPort) dbHost))
4640 --wait for socket to be listening
4741 waitForListenSocket 5 (fromIntegral wsServerPort)
4842 pure (fromIntegral wsServerPort, testDatabaseName)
test/TutorialD/Interpreter/Import/ImportTest.hsnew file+47
@@ -0,0 +1,47 @@
1+import Test.HUnit
2+import ProjectM36.Base
3+import TutorialD.Interpreter.Import.TutorialD
4+import System.Exit
5+import qualified Data.Text as T
6+import System.IO.Temp
7+import System.FilePath
8+import qualified Data.Map as M
9+import System.IO
10+import System.Directory
11+import qualified Data.ByteString as BS
12+import qualified Data.Text.Encoding as TE
13+import Text.URI hiding (makeAbsolute)
14+
15+main :: IO ()
16+main = do
17+ tcounts <- runTestTT $ TestList [testTutdFileImport
18+ ,testTutdHTTPSImport
19+ ]
20+ if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
21+
22+testTutdFileImport :: Test
23+testTutdFileImport = TestCase $
24+ withSystemTempFile "m.tutd" $ \tempPath handle -> do
25+ BS.hPut handle (TE.encodeUtf8 "x:=relation{tuple{a 5,b \"spam\"}}; y:=relation{tuple{b \"漢字\"}}")
26+ hClose handle
27+ let expectedExpr = MultipleExpr [
28+ Assign "x" (MakeRelationFromExprs Nothing
29+ $ TupleExprs () [TupleExpr (M.fromList [("a", NakedAtomExpr $ IntegerAtom 5),
30+ ("b", NakedAtomExpr $ TextAtom "spam")])]),
31+ Assign "y" (MakeRelationFromExprs Nothing
32+ $ TupleExprs () [TupleExpr (M.fromList [("b", NakedAtomExpr (TextAtom "漢字"))])])]
33+ --on Windows, the file URI should not include the drive letter "/c/Users..." -> "/Users"
34+ let uri = "file://" <> map (\c -> if c == '\\' then '/' else c) ( joinDrive "/" (dropDrive tempPath))
35+ fileURI <- mkURI (T.pack uri)
36+ imported <- importTutorialDFromFile fileURI Nothing
37+ assertEqual "import tutd" (Right expectedExpr) imported
38+
39+testTutdHTTPSImport :: Test
40+testTutdHTTPSImport = TestCase $ do
41+ uri <- mkURI "https://raw.githubusercontent.com/agentm/project-m36/master/test/TutorialD/Interpreter/Import/httpimporttest.tutd"
42+ let hash = "effe32b247586dc3ac0079fc241b9618d41d189afcaeb7907edbe5a8b45992a4"
43+ expected = Right (MultipleExpr [Assign "x" (RelationVariable "true" ()),Assign "y" (RelationVariable "false" ())])
44+ actual <- importTutorialDViaHTTP uri (Just hash)
45+ assertEqual "github https" expected actual
46+
47+
test/TutorialD/Interpreter/Import/TutorialD.hsdeleted−29
@@ -1,29 +0,0 @@
1−import Test.HUnit
2−import ProjectM36.Base
3−import TutorialD.Interpreter.Import.TutorialD
4−import System.Exit
5−import System.IO.Temp
6−import qualified Data.Map as M
7−import System.IO
8−import qualified Data.ByteString as BS
9−import qualified Data.Text.Encoding as TE
10−
11−main :: IO ()
12−main = do
13− tcounts <- runTestTT $ TestList [testTutdImport]
14− if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
15−
16−testTutdImport :: Test
17−testTutdImport = TestCase $
18− withSystemTempFile "m.tutd" $ \tempPath handle -> do
19− BS.hPut handle (TE.encodeUtf8 "x:=relation{tuple{a 5,b \"spam\"}}; y:=relation{tuple{b \"漢字\"}}")
20− hClose handle
21− let expectedExpr = MultipleExpr [
22− Assign "x" (MakeRelationFromExprs Nothing
23− $ TupleExprs () [TupleExpr (M.fromList [("a", NakedAtomExpr $ IntegerAtom 5),
24− ("b", NakedAtomExpr $ TextAtom "spam")])]),
25− Assign "y" (MakeRelationFromExprs Nothing
26− $ TupleExprs () [TupleExpr (M.fromList [("b", NakedAtomExpr (TextAtom "漢字"))])])]
27− imported <- importTutorialD tempPath
28− assertEqual "import tutd" (Right expectedExpr) imported
29−
test/TutorialD/Interpreter/Import/httpimporttest.tutdnew file+2
@@ -0,0 +1,2 @@
1+x:=true;
2+y:=false;
test/TutorialD/Interpreter.hs → test/TutorialD/InterpreterTest.hsrenamed+37−7
@@ -79,13 +79,16 @@ main = do
7979 testInvalidDataConstructor,
8080 testBasicList,
8181 testRelationDeclarationMismatch,
82− testInvalidTuples
82+ testInvalidTuples,
83+ testSelfReferencingUncommittedContext,
84+ testUnionAndIntersectionAttributeExprs
8385 ]
8486
8587simpleRelTests :: Test
8688simpleRelTests = TestCase $ do
8789 (graph, transId) <- freshTransactionGraph dateExamples
88− mapM_ (\(tutd, expected) -> assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups
90+ mapM_ (\(tutd, expected) ->
91+ assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups
8992 where
9093 testTups = [("x:=true", Right relationTrue),
9194 ("x:=false", Right relationFalse),
@@ -120,7 +123,8 @@ simpleRelTests = TestCase $ do
120123 ("x:=relation{tuple{a 5}} : {b:=6}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 6])]),
121124 ("x:=relation{tuple{a 5}} : {b:=add(@a,5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 10])]),
122125 ("x:=relation{tuple{a 5}} : {b:=add(@a,\"spam\")}", Left (AtomFunctionTypeError "add" 2 IntegerAtomType TextAtomType)),
123− ("x:=relation{tuple{a 5}} : {b:=add(add(@a,2),5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 12])])
126+ ("x:=relation{tuple{a 5}} : {b:=add(add(@a,2),5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 12])]),
127+ ("x:=false:{a:=1,b:=2}", mkRelationFromTuples simpleDAttributes [])
124128 ]
125129 simpleAAttributes = A.attributesFromList [Attribute "a" IntegerAtomType]
126130 simpleBAttributes = A.attributesFromList [Attribute "d" IntegerAtomType]
@@ -132,7 +136,8 @@ simpleRelTests = TestCase $ do
132136dateExampleRelTests :: Test
133137dateExampleRelTests = TestCase $ do
134138 (graph, transId) <- freshTransactionGraph dateExamples
135− mapM_ (\(tutd, expected) -> assertTutdEqual dateExamples transId graph expected tutd) testTups
139+ mapM_ (\(tutd, expected) ->
140+ assertTutdEqual dateExamples transId graph expected tutd) testTups
136141 where
137142 simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]
138143 maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)
@@ -230,7 +235,7 @@ transactionGraphAddCommitTest = TestCase $ do
230235 commit sessionId dbconn >>= eitherFail
231236 discon <- disconnectedTransaction_ sessionId dbconn
232237 let context = Discon.concreteDatabaseContext discon
233− assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just (RelationVariable "s" UncommittedContextMarker))
238+ assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just (ExistingRelation suppliersRel))
234239
235240transactionRollbackTest :: Test
236241transactionRollbackTest = TestCase $ do
@@ -357,7 +362,7 @@ testComments :: Test
357362testComments = TestCase $ do
358363 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
359364 mapM_ (executeTutorialD sessionId dbconn) [
360− ":branch testbranch --test comment\n",
365+ ":branch testbranch --test comment",
361366 ":jumphead {- test comment -} master"]
362367
363368-- create a graph and query from two disparate contexts
@@ -540,7 +545,7 @@ testListConstructedAtom = TestCase $ do
540545testTypeChecker :: Test
541546testTypeChecker = TestCase $ do
542547 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
543− let err1 = "AtomFunctionTypeError \"max\" 1 (RelationAtomType [Attribute \"_\" IntegerAtomType]) IntegerAtomType"
548+ let err1 = "AtomFunctionTypeError \"max\" 1"
544549 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"
545550
546551--exercise expression parser
@@ -660,6 +665,10 @@ testWithClause = TestCase $ do
660665 executeTutorialD sessionId dbconn "x:=with (x as s) x"
661666 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())
662667 assertEqual "with x as s" (Right suppliersRel) eX
668+
669+ executeTutorialD sessionId dbconn "y:=with(a as true) (with (b as a) b)"
670+ eY <- executeRelationalExpr sessionId dbconn (RelationVariable "y" ())
671+ assertEqual "nested with" (Right relationTrue) eY
663672
664673 let err1 = "RelVarAlreadyDefinedError"
665674 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"
@@ -700,3 +709,24 @@ testInvalidTuples = TestCase $ do
700709 expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{b 2}}"
701710 expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{a 2, b 3}}"
702711-- expectTutorialDErr sessionId dbconn (T.isPrefixOf "ParseErrorBundle") ":showexpr relation{tuple{a 2, a 3}}" --parse failure can't be validated with this function
712+
713+testSelfReferencingUncommittedContext :: Test
714+testSelfReferencingUncommittedContext = TestCase $ do
715+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
716+ executeTutorialD sessionId dbconn "s:=s union s"
717+ eS <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())
718+ _ <- rollback sessionId dbconn
719+ eSorig <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())
720+ assertEqual "s=s'" eSorig eS
721+
722+testUnionAndIntersectionAttributeExprs :: Test
723+testUnionAndIntersectionAttributeExprs = TestCase $ do
724+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
725+ executeTutorialD sessionId dbconn "x:=s{intersection of {all but sname} {sname}}"
726+ xRel <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())
727+ assertEqual "intersection attrs" (Right relationTrue) xRel
728+
729+ executeTutorialD sessionId dbconn "y:=s{union of {all but sname} {sname}}"
730+ yRel <- executeRelationalExpr sessionId dbconn (RelationVariable "y" ())
731+ assertEqual "union attrs" (Right suppliersRel) yRel
732+
test/TutorialD/PrinterTest.hsnew file+47
@@ -0,0 +1,47 @@
1+{-# LANGUAGE OverloadedStrings #-}
2+import Test.HUnit
3+import ProjectM36.Base
4+import System.Exit
5+import Data.Text.Prettyprint.Doc
6+import Data.Map (fromList)
7+import TutorialD.Printer ()
8+import TutorialD.Interpreter.RelationalExpr
9+import Text.Megaparsec
10+import Data.Text (pack)
11+
12+testList :: Test
13+testList = TestList [
14+ testPretty "true" (RelationVariable "true" ()),
15+ testPretty "relation{tuple{a 3, b \"x\"}, tuple{a 4, b \"y\"}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",NakedAtomExpr (IntegerAtom 3)),("b",NakedAtomExpr (TextAtom "x"))]),TupleExpr (fromList [("a",NakedAtomExpr (IntegerAtom 4)),("b",NakedAtomExpr (TextAtom "y"))])])),
16+ testPretty "true:{a:=1, b:=1}" (Extend (AttributeExtendTupleExpr "b" (NakedAtomExpr (IntegerAtom 1))) (Extend (AttributeExtendTupleExpr "a" (NakedAtomExpr (IntegerAtom 1))) (RelationVariable "true" ()))),
17+ testPretty "relation{tuple{a fromGregorian(2014, 2, 4)}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",FunctionAtomExpr "fromGregorian" [NakedAtomExpr (IntegerAtom 2014),NakedAtomExpr (IntegerAtom 2),NakedAtomExpr (IntegerAtom 4)] ())])])),
18+ testPretty "relation{tuple{a bytestring(\"dGVzdGRhdGE=\")}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",FunctionAtomExpr "bytestring" [NakedAtomExpr (TextAtom "dGVzdGRhdGE=")] ())])])),
19+ testPretty "relation{tuple{a t}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",NakedAtomExpr (BoolAtom True))])])),
20+ testPretty "relation{tuple{a Cons 4 (Cons 5 Empty)}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",ConstructedAtomExpr "Cons" [NakedAtomExpr (IntegerAtom 4),ConstructedAtomExpr "Cons" [NakedAtomExpr (IntegerAtom 5),ConstructedAtomExpr "Empty" [] ()] ()] ())])])),
21+ testPretty "relation{a Int, b Text, c Bool}{}" (MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "a" (ADTypeConstructor "Int" []) (),AttributeAndTypeNameExpr "b" (ADTypeConstructor "Text" []) (),AttributeAndTypeNameExpr "c" (ADTypeConstructor "Bool" []) ()]) (TupleExprs () [])),
22+ testPretty "relation{a relation{b Int}}{}" (MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "a" (RelationAtomTypeConstructor [AttributeAndTypeNameExpr "b" (ADTypeConstructor "Int" []) ()]) ()]) (TupleExprs () []))
23+ ]
24+
25+main :: IO ()
26+main = do
27+ tcounts <- runTestTT testList
28+ if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
29+
30+testPretty :: String -> RelationalExpr -> Test
31+testPretty tutdStr relExprADT =
32+ TestCase $ do
33+ let relExprStr = show (pretty relExprADT)
34+ print relExprStr
35+ roundTrip <- parseRelExpr relExprStr
36+ {-tutdIn <- parseRelExpr tutdStr
37+ print ("tutd parsed", tutdIn)-}
38+ assertEqual ("pretty ADT " <> tutdStr) tutdStr relExprStr
39+ assertEqual ("round-trip " <> tutdStr) relExprADT roundTrip
40+
41+--round trip tutoriald
42+parseRelExpr :: String -> IO RelationalExpr
43+parseRelExpr tutdStr =
44+ case parse relExprP "test" (pack tutdStr) of
45+ Left err ->
46+ assertFailure (show err)
47+ Right parsed -> pure parsed
test/scripts.hs+5−2
@@ -4,6 +4,8 @@ import TutorialD.Interpreter.Import.TutorialD
44import System.Directory
55import Data.List (isSuffixOf)
66import System.Exit
7+import qualified Data.Text as T
8+import Text.URI
79
810testList :: IO Test
911testList = do
@@ -20,7 +22,8 @@ main = do
2022
2123testScript :: FilePath -> Test
2224testScript tutdFile = TestCase $ do
23− eImport <- importTutorialD tutdFile
25+ fileURI <- mkURI (T.pack ("file://" <> tutdFile))
26+ eImport <- importTutorialDFromFile fileURI Nothing
2427 case eImport of
2528 Left err -> assertFailure ("tutd import failure in " ++ tutdFile ++ ": " ++ show err)
26− Right _ -> pure ()
29+ Right _ -> pure ()