git.iko.soy/project-m36
on master help sign in
swap
44feeff170 ahead, 0 behind
134 files changed+4430−2230
since splitsnapshots
unifiedsplit
.appveyor.yml−1 .github/workflows/ci.yaml+69 .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+25 README.markdown+11−3 cabal.project+7−6 default.nix+1 docker.nix+18 docs/15_minute_tutorial.markdown+64−67 docs/data_independence.markdown+8−2 docs/import_export_csv.markdown+2−2 docs/introduction_to_projectm36.markdown+27−8 docs/introduction_to_the_relational_algebra.markdown+2−2 docs/merkle_transaction_graph.markdown+33 docs/reaching_out_of_the_tarpit.markdown+1−1 docs/transaction_graph_operators.markdown+6−4 docs/tupleable.markdown+19 docs/tutd_cheatsheet.markdown+3−1 docs/tutd_tutorial.markdown+56−2 examples/DerivingCustomTupleable.hs+54 examples/Plantfarm.hs+446 examples/SimpleClient.hs+1−1 examples/blog.hs+4−3 examples/hair.hs+4−3 examples/out_of_the_tarpit.hs+11−7 examples/out_of_the_tarpit.tutd+4−4 jupyter/TutorialD Notebook Walkthrough.ipynb+1−1 nix/sources.json+50 nix/sources.nix+171 project-m36.cabal+137−156 release.nix+36 scripts/DateExamples.tutd+2−2 scripts/multiline.tutd+2 shell.nix+1 src/bin/ProjectM36/Client/Json.hs+4−1 src/bin/ProjectM36/Server/RemoteCallTypes/Json.hs+30−2 src/bin/ProjectM36/Server/WebSocket.hs+3−2 src/bin/ProjectM36/Server/WebSocket/websocket-client.html+1−1 src/bin/ProjectM36/Server/WebSocket/websocket-server.hs+48−18 src/bin/TutorialD/Interpreter.hs+4−2 src/bin/TutorialD/Interpreter/Base.hs+29−8 src/bin/TutorialD/Interpreter/DatabaseContextExpr.hs+4−4 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/Interpreter/TransactionGraphOperator.hs+12−3 src/bin/TutorialD/Printer.hs+165 src/bin/TutorialD/tutd.hs+14−18 src/lib/ProjectM36/Arbitrary.hs+6−1 src/lib/ProjectM36/Atom.hs+1 src/lib/ProjectM36/AtomFunction.hs+13−1 src/lib/ProjectM36/AtomFunctionError.hs+1−2 src/lib/ProjectM36/AtomType.hs+9−8 src/lib/ProjectM36/Atomable.hs+4−20 src/lib/ProjectM36/Attribute.hs+148−29 src/lib/ProjectM36/Base.hs+103−109 src/lib/ProjectM36/Client.hs+186−298 src/lib/ProjectM36/DataFrame.hs+21−14 src/lib/ProjectM36/DataTypes/Interval.hs+2 src/lib/ProjectM36/DataTypes/Primitive.hs+1 src/lib/ProjectM36/DataTypes/Sorting.hs+1 src/lib/ProjectM36/DatabaseContext.hs+17−2 src/lib/ProjectM36/DatabaseContextFunction.hs+12−1 src/lib/ProjectM36/DatabaseContextFunctionError.hs+1−2 src/lib/ProjectM36/Error.hs+19−14 src/lib/ProjectM36/GraphRefRelationalExpr.hs+6−9 src/lib/ProjectM36/InclusionDependency.hs+5−6 src/lib/ProjectM36/IsomorphicSchema.hs+2−4 src/lib/ProjectM36/MerkleHash.hs+9 src/lib/ProjectM36/NormalizeExpr.hs+1−1 src/lib/ProjectM36/Persist.hs+3−4 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/Relation/Show/Term.hs+3 src/lib/ProjectM36/RelationalExpression.hs+204−339 src/lib/ProjectM36/ScriptSession.hs+11−4 src/lib/ProjectM36/Serialise/AtomFunctionError.hs+7 src/lib/ProjectM36/Serialise/Base.hs+85 src/lib/ProjectM36/Serialise/DataFrame.hs+13 src/lib/ProjectM36/Serialise/DatabaseContextFunctionError.hs+7 src/lib/ProjectM36/Serialise/Error.hs+15 src/lib/ProjectM36/Serialise/IsomorphicSchema.hs+7 src/lib/ProjectM36/Serialise/MergeError.hs+1 src/lib/ProjectM36/Server.hs+166−90 src/lib/ProjectM36/Server/Config.hs+6 src/lib/ProjectM36/Server/EntryPoints.hs+125−153 src/lib/ProjectM36/Server/ParseArgs.hs+38−15 src/lib/ProjectM36/Server/RemoteCallTypes.hs+67−35 src/lib/ProjectM36/Shortcuts.hs+247 src/lib/ProjectM36/StaticOptimizer.hs+18−20 src/lib/ProjectM36/TransGraphPlanExpr.hs−5 src/lib/ProjectM36/TransGraphRelationalExpression.hs+2−19 src/lib/ProjectM36/Transaction.hs+10−5 src/lib/ProjectM36/Transaction/Persist.hs+17−17 src/lib/ProjectM36/TransactionGraph.hs+83−27 src/lib/ProjectM36/TransactionGraph/Merge.hs+1−1 src/lib/ProjectM36/TransactionGraph/Persist.hs−3 src/lib/ProjectM36/TransactionInfo.hs+5−3 src/lib/ProjectM36/Tuple.hs+47−33 src/lib/ProjectM36/TupleSet.hs+7 src/lib/ProjectM36/Tupleable.hs+108−34 src/lib/ProjectM36/Tupleable/Deriving.hs+229 src/lib/ProjectM36/WithNameExpr.hs+5−3 stack.ghc8.0.yaml−50 stack.ghc8.10.yaml+19 stack.ghc8.2.yaml−51 stack.ghc8.4.yaml−48 stack.ghc8.6.yaml+25−16 stack.ghc8.8.yaml+25−17 test/Client/Simple.hs+1−2 test/Relation/Atomable.hs+28−15 test/Relation/Basic.hs+13−12 test/Relation/Tupleable.hs+187−9 test/Server/Main.hs+19−20 test/Server/WebSocket.hs+3−9 test/TransactionGraph/Merge.hs+25−15 test/TransactionGraph/Persist.hs+64−7 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+48−9 test/TutorialD/PrinterTest.hs+47 test/scripts.hs+5−2
.appveyor.yml−1
@@ -17,7 +17,6 @@ environment:
1717 global:
1818 STACK_ROOT: "c:\\sr"
1919 matrix:
20− - YAML: "stack.ghc8.2.yaml"
2120 - YAML: "stack.ghc8.6.yaml"
2221
2322platform:
.github/workflows/ci.yamlnew file+69
@@ -0,0 +1,69 @@
1+name: "CI"
2+on:
3+ pull_request:
4+ push:
5+jobs:
6+ dockerimage:
7+ runs-on: ubuntu-latest
8+ steps:
9+ - uses: actions/checkout@v2.3.1
10+ - uses: cachix/install-nix-action@v12
11+ with:
12+ nix_path: nixpkgs=channel:nixos-unstable
13+ - uses: cachix/cachix-action@v8
14+ with:
15+ name: project-m36
16+ signingKey: "${{ secrets.CACHIX_SIGNING_KEY }}"
17+ - run: cachix use iohk
18+ - name: docker load
19+ run: docker load < $(nix-build docker.nix)
20+ - name: docker login
21+ if: ${{ github.ref == 'refs/heads/master' }}
22+ run: echo ${{secrets.DOCKERHUB_PASSWORD}} | docker login --username ${{secrets.DOCKERHUB_USER}} --password-stdin
23+ - name: docker tag with version
24+ run: docker tag project-m36:latest projectm36/project-m36:$(awk '/^Version:/ {print $2}' project-m36.cabal)
25+ if: ${{ github.ref == 'refs/heads/master' }}
26+ - name: docker tag latest
27+ run: docker tag project-m36:latest projectm36/project-m36:latest
28+ if: ${{ github.ref == 'refs/heads/master' }}
29+ - run: docker push projectm36/project-m36
30+ if: ${{ github.ref == 'refs/heads/master' }}
31+
32+ stack-build:
33+ runs-on: ${{ matrix.os }}
34+ strategy:
35+ matrix:
36+ os: [ubuntu-latest]
37+ ghc:
38+ - ghc8.10
39+ - ghc8.8
40+ - ghc8.6
41+ include:
42+ - os: macos-latest
43+ ghc: ghc8.10
44+ env:
45+ STACK_YAML: stack.${{ matrix.ghc }}.yaml
46+ steps:
47+ - uses: actions/checkout@v2
48+ - name: Cache
49+ uses: actions/cache@v1
50+ with:
51+ path: ~/.stack
52+ key: ${{ runner.os }}-build-stack-${{ matrix.ghc }}-${{ hashFiles(env.STACK_YAML) }}-${{ hashFiles('**/*.cabal') }}
53+ restore-keys: |
54+ ${{ runner.os }}-build-stack-${{ matrix.ghc }}-${{ hashFiles(env.STACK_YAML) }}
55+ ${{ runner.os }}-build-stack-${{ matrix.ghc }}
56+ - name: Fix macOS cache bug
57+ run: rm -rf ~/.stack/setup-exe-cache
58+ - name: Build
59+ run: stack build --ghc-options -O2 --local-bin-path out --copy-bins
60+ - name: Test
61+ run: stack test --stack-yaml=${{ env.STACK_YAML }}
62+ - name: HLint
63+ run: curl -sSL https://raw.github.com/ndmitchell/hlint/master/misc/run.sh | sh -s .
64+ - name: Haddock
65+ run: stack --no-install-ghc --system-ghc --no-haddock-deps haddock
66+ - uses: actions/upload-artifact@v2
67+ with:
68+ name: project-m36-${{ matrix.os }}-${{ matrix.ghc }}
69+ path: out/
.gitignore+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+25
@@ -1,3 +1,28 @@
1+# 2021-04-01 (v0.9.3)
2+
3+* add new ":importtutd <URI> <SHA256 hash>" feature to import TutorialD from a local file or a HTTP/HTTPS URI
4+
5+# 2020-12-27 (v0.9.0)
6+
7+* replace unmaintained distributed-process-client-server RPC package with new curryer RPC package
8+* drop support for GHC 8.2 and GHC 8.4 due to dependency on DerivingVia extension
9+
10+# 2020-11-21 (v0.8.2)
11+
12+* support multiple extend expressions in TutorialD
13+* fix parsing of Bool atoms in TutorialD
14+* fix database context expressions which include self-references such as `s:=s union s`
15+* show constraints as TutorialD when using tutd console
16+* add `RelationalExprAtom` data type useful for storing `RelationalExpr` within the database
17+
18+# 2020-10-05 (v0.8.1)
19+
20+* support GHC 8.10
21+
22+# 2020-05-25 (v0.8)
23+
24+* refactor backend to maximize laziness: [An Architecture for Data Independence](docs/data_independence.markdown)
25+
126# 2019-09-07 (v0.7)
227
328* fix case sensitivity issue with relation variables in tutd
README.markdown+11−3
@@ -4,8 +4,8 @@
44[![Public Domain](https://img.shields.io/badge/license-Public%20Domain-brightgreen.svg)](http://unlicense.org)
55[![Hackage](https://img.shields.io/hackage/v/project-m36.svg)](http://hackage.haskell.org/package/project-m36)
66[![Hackage dependency status](https://img.shields.io/hackage-deps/v/project-m36.svg)](http://packdeps.haskellers.com/feed?needle=project-m36)
7−[![Build status](https://travis-ci.org/agentm/project-m36.svg?branch=master)](https://travis-ci.org/agentm/project-m36)
87[![Windows Build status](https://ci.appveyor.com/api/projects/status/q7jyddd6dy1ibqdo/branch/master?svg=true)](https://ci.appveyor.com/project/agentm/project-m36)
8+[![Github Workflow status](https://github.com/agentm/project-m36/workflows/CI/badge.svg)](https://github.com/agentm/project-m36/actions?query=workflow%3ACI)
99
1010
1111*Software can always be made faster, but rarely can it be made more correct.*
@@ -14,6 +14,12 @@
1414
1515Project:M36 implements a relational algebra engine as inspired by the writings of Chris Date.
1616
17+## Quick Install
18+
19+Project:M36 can be downloaded and run via docker, which supports Windows 10, macOS, and Linux.
20+
21+Run `docker run -it projectm36/project-m36 tutd` to start the TutorialD command line interface.
22+
1723## Description
1824
1925Unlike most database management systems (DBMS), Project:M36 is opinionated software which adheres strictly to the mathematics of the relational algebra. The purpose of this adherence is to prove that software which implements mathematically-sound design principles reaps benefits in the form of code clarity, consistency, performance, and future-proofing.
@@ -38,7 +44,7 @@ Project:M36 supports multiple frontends which target different audiences.
3844
3945* [Developer's Blog](https://agentm.github.io/project-m36/)
4046* [Mailing List/Discussion Group](https://groups.google.com/d/forum/project-m36)
41−* 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)
4248* [Hackage](https://hackage.haskell.org/package/project-m36)
4349* [Diogo Biazus' Project:M36 Video Tutorial](https://www.youtube.com/watch?v=_GC_lxlVEnE)
4450
@@ -61,6 +67,7 @@ Project:M36 supports multiple frontends which target different audiences.
61671. [ACID Database Properties](docs/acid_assessment.markdown)
62681. [On NULL (in SQL)](docs/on_null.markdown)
63691. [Reaching "Out of the Tarpit" with Project:M36](docs/reaching_out_of_the_tarpit.markdown)
70+1. [An Architecture for Data Independence](docs/data_independence.markdown)
6471
6572### Advanced Features
6673
@@ -77,6 +84,7 @@ Project:M36 supports multiple frontends which target different audiences.
77841. [Isomorphic Schemas](docs/isomorphic_schemas.markdown)
78851. [Replication](docs/replication.markdown)
79861. [Basic Operator Benchmarks](https://rawgit.com/agentm/project-m36/master/docs/basic_benchmarks.html)
87+1. [Merkle Transaction Hashes](docs/merkle_transaction_graph.markdown)
8088
8189### Integrations
8290
@@ -86,7 +94,7 @@ Project:M36 supports multiple frontends which target different audiences.
8694
8795## Development
8896
89−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.
9098
9199## Related Projects
92100
cabal.project+7−6
@@ -1,9 +1,10 @@
1−-- this is needed for GHC8 until distributed-process-extras is updated on Hackage with increased upper bounds
21packages: project-m36.cabal
3−allow-newer: distributed-process-extras:time,distributed-process-extras:binary,distributed-process-client-server:binary,distributed-process-client-server:time,distributed-process-async:time,distributed-process-async:binary,distributed-process-extras:stm,distributed-process-extras:containers,network-transport-tcp:containers,distributed-process-client-server:stm,distributed-process-client-server:containers,distributed-process-async:stm,distributed-process-async:containers,distributed-process:hashable,distributed-process-extras:hashable,distributed-process-client-server:hashable,distributed-process-async:hashable
42
5−--necessary for GHC 8.6 support :/
3+package *
4+ split-sections: True
5+
6+--high-performance streaming library
67source-repository-package
7− type: git
8− location: https://github.com/agentm/distributed-process.git
9− tag: f352e097fbe494ad648b4e09249f865893ae90a3
8+ type: git
9+ location: https://github.com/composewell/streamly.git
10+ tag: ac3af8749194f1788704dda8667d0b3807075cc2
default.nixnew file+1
@@ -0,0 +1 @@
1+(import ./release.nix { }).project
docker.nixnew file+18
@@ -0,0 +1,18 @@
1+{ compiler ? "ghc8104"
2+, sources ? import ./nix/sources.nix
3+, pkgs ? import sources.nixpkgs { }
4+}:
5+let
6+ release = import ./release.nix { inherit pkgs compiler sources; };
7+ static-project-m36 = pkgs.haskell.lib.dontCheck (pkgs.haskell.lib.justStaticExecutables release.project);
8+in
9+pkgs.dockerTools.buildImage {
10+ name = "project-m36";
11+ tag = "latest";
12+ contents = [ static-project-m36 ];
13+ # expose default project-m36 and websocket server ports
14+ config = {
15+ Env = [ "LC_ALL=en_US.UTF-8" ];
16+ ExposedPorts = { "6543/tcp" = { }; "8000/tcp" = { }; };
17+ };
18+}
docs/15_minute_tutorial.markdown+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/data_independence.markdown+8−2
@@ -88,14 +88,20 @@ Typical databases implement various strategies for audit logging, including:
8888
8989Project:M36, through its inherent ability to travel the append-only transaction graph, enables audit-logging by allowing users to checkout previous transaction states. Committed transaction states are immutable, so no relation pollution or secondary database is necessary.
9090
91−## Selective Caching
91+### Selective Caching
9292
9393Typical databases materialize entire tuple sets representing each named relation (relation variable), but there is nothing special about relations that happen to be named. Data independence allows us to cache answers to common or even anticipated queries- this allows the schema to be normalized and unmaterialized while the *denormalized* query results are materialized cached. This flexibility saves disk space and allows the cache to be much more dynamic than in a typical DBMS.
9494
95−## Never-Materialized Tuples Replace Partitions
95+### Never-Materialized Tuples Replace Partitions
9696
9797Queries on very large relations often very often restricted (filtered by tuple) to generate subsets which are often partitioned, for example, by an event's date. Instead of requiring DBMS users to manually partition and slice their data in one, fixed, particular way, Project:M36's cacheing system will only cache those tuples that serve the interests of the queries. With something like an LRU cache, a data independent architecture will naturally cache "partitions" of the full relation without manual intervention.
9898
99+### Elimination of DBA role
100+
101+Databases essential to a business function are often guarded by a human database administrator (DBA) whose role it is to monitor database performance and to play gatekeeper to database schema changes as the database grows. This role is necessary because database tuning can be an arcane skill, rife with pitfalls for those who don't know the database software inside-and-out. This is a direct cause of data dependence, forcing DBAs to manually enforce data partitioning and shuffling data to different servers, configuring database replicas, and making Faustian bargains to "denormalize" tables for analytical workloads.
102+
103+A data independent architecture eliminates this role by allowing the database to make the optimal choices itself. This means that the database can respond to schema changes immediately, without manual repartitioning or denormalization steps.
104+
99105## Conclusion
100106
101107Project:M36's backend architecture enables new optimizations and features that are sorely lacking in existing DBMSes. By leveraging its novel transaction graph and deferred evaluation, Project:M36 handles more DBMS use-cases.
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+27−8
@@ -15,16 +15,35 @@ The relational algebra is the mathematical model underpinning Project:M36. When
1515
1616## Binary Releases
1717
18−### Windows
19−Project:M36 now provides binary installations for Windows. Check the (releases page)[https://github.com/agentm/project-m36/releases] for downloads.
18+The quickest and preferred method of installation is via docker, which works on Linux, macOS, and Windows. Docker downloads and runs preconfigured software in secure, sandboxed containers, preventing third-party software from altering the host system without your permission.
2019
21−### MacOS X
20+### Install Docker:
2221
23−Binary releases are not yet available for MacOS X, but compiling from source is easy.
22+* [Windows 10 Docker Installation](https://docs.docker.com/docker-for-windows/wsl/)
23+* [MacOS Docker Installation](https://docs.docker.com/docker-for-mac/install/)
24+* [Linux Docker Installation](https://docs.docker.com/engine/install/#server)
2425
25−### Linux
26+### Run TutorialD from Docker Image
2627
27−The currently-preferred method of installation is from source. A future enhancement would be installation from deb or rpm.
28+This downloads the docker image tagged "latest" and runs `tutd`, the TutorialD command line interface. Try the [15-Minute TutorialD Tutorial](15_minute_tutorial.markdown) and try some expressions.
29+
30+```bash
31+docker run -it projectm36/project-m36 tutd
32+```
33+
34+### Run Project:M36 Server
35+
36+The default port for the project-m36 server is 6543.
37+
38+```bash
39+docker run --network host projectm36/project-m36 project-m36-server -n <database_name>
40+```
41+
42+### Connect to Project:M36 Server
43+
44+```bash
45+docker run --network host projectm36/project-m36
46+```
2847
2948## Source Installation
3049
@@ -32,7 +51,7 @@ Requirements:
3251
3352To build with stack:
3453
35−* [GHC 8.4.4 or greater](https://www.haskell.org/downloads)
54+* [GHC 8.6.5 or greater](https://www.haskell.org/downloads)
3655* [Haskell stack](https://docs.haskellstack.org/en/stable/README/)
3756* Linux, macOS, or Microsoft Windows
3857
@@ -44,7 +63,7 @@ Compilation steps:
4463
4564At this point, the TutorialD interactive interpreter can be run using ```stack exec tutd```.
4665
47−Alternative building with GHC 8.4.4 or greater:
66+Alternative building with GHC 8.6.5 or greater:
4867
4968* ```cabal new-build```
5069
docs/introduction_to_the_relational_algebra.markdown+2−2
@@ -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|
@@ -378,7 +378,7 @@ Since a value can store any (immutable) type, it can certainly hold a relation.
378378
379379For example, in SQL, if one wants to collect some aggregate data over some tuples while still returning the individual tuples, in the best case, the aggregate information must be repeated for every individual tuple. In the worst case, two separate queries are required since nested tables are not supported.
380380
381−In the relational algebra, The aggregate value can be placed alongside the relation value from whic the aggregate was derived.
381+In the relational algebra, The aggregate value can be placed alongside the relation value from which the aggregate was derived.
382382
383383Example:
384384
docs/merkle_transaction_graph.markdownnew file+33
@@ -0,0 +1,33 @@
1+# Project:M36: Merkle Hashing for Transaction Graph
2+
3+## Introduction
4+
5+Project:M36 supports an append-only transaction graph model (similar to git) whereby new transactions can be added to the graph but not removed. As with any graph, each node can contain a Merkle hash which ensures not only that it's state since being added to the graph has not changed but also that none of its parent nodes all the way to the root node (initial state) have not been modified. This validation has a number of use cases.
6+
7+## Usage
8+
9+Project:M36 automatically adds Merkle hashes to every transaction. All data which represents the database state at that transaction is included in the hash including (but not limited to) relation variable definitions, atom and database context functions, constraints, and types.
10+
11+Project:M36 validates all merkle hashes at database startup. For users who need validation after the database is started, the user can issue `:validatemerklehashes` at the `tutd` command line.
12+
13+### Audit Logging
14+
15+Project:M36 supports audit logging by allowing users to travel to transactions in the past and recreate the database state at that past point-in-time. To ensure that those past states cannot be modified either by malicious on-disk or in-memory changes, each transaction is protected by its own Merkle hash. If the calculated hash does not match the stored hash, Project:M36 can immediately report which transaction triggered the tamper-proof log.
16+
17+### Reproducibility
18+
19+Since a Merkle tree is effectively immutable except to add more nodes, it can be used to save and restore a whole database with very high confidence in the results. This feature could also be used to restore a database partially; for example, to duplicate just the latest database state on a second machine for OLAP analysis.
20+
21+### High-Availability
22+
23+Merkle tree hashes can be used to assert database integrity across high-availibility or database replication. Since the hash covers all database state, it can be used to validate log-shipping-based replication. Corrupted cache tuple data can be easily detected and flushed.
24+
25+## Merkle Hashes in Other DBMSes
26+
27+While Merkle hashes have become prevalent in blockchain-style databases, they have not made many appearances in typical SQL databases. This is likely due to the fact that such databases consider any additional operations against the large tuple stores as prohibitively expensive. Project:M36 is able to skirt this cost by only hashing database update expressions rather than the result of these executed expressions. This also means that the Merkle hash can be computed against transactions which have been created but never executed.
28+
29+## Conclusion
30+
31+Merkle hashes are an obvious improvement to any graph-based transaction log and are a low-cost method of ensuring data integrity.
32+
33+A further improvement could allow users to specify an initial key provided by an admin user to salt the hash used to create the database. Additionally, a multi-user system could allow individual users to sign their committed transactions. The signature would then be included in the Merkle hash.
docs/reaching_out_of_the_tarpit.markdown+1−1
@@ -57,7 +57,7 @@ Project:M36 implements multiple interfaces:
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/transaction_graph_operators.markdown+6−4
@@ -43,15 +43,17 @@ TutorialD (master/main): :rollback
4343In order to navigate the transaction graph, one must specify transaction UUIDs. Viewing the entirety of the transaction graph as a relation is a single command.
4444
4545```
46−TutorialD (master/main): :showgraph
47−┌─────────────┬──────────┬──────────────────────────────────────┬────────────────────────────┬──────────────────────────────┐
48−│current::Bool│head::Text│id::Text │parents::relation {id::Text}│stamp::DateTime │
49−├─────────────┼──────────┼──────────────────────────────────────┼────────────────────────────┼──────────────────────────────┤
46+┌─────────────┬────────────────────────────────────────────┬──────────┬──────────────────────────────────────┬────────────────────────────────────────┬─────────────────────────────────┐
47+│current::Bool│hash::ByteString │head::Text│id::Text │parents::relation {id::Text} │stamp::DateTime │
48+├─────────────┼────────────────────────────────────────────┼──────────┼──────────────────────────────────────┼────────────────────────────────────────┼─────────────────────────────────┤
49+
5050
5151<big result elided>
5252```
5353The "current" attribute is a boolean value. If true, the transaction is the parent of the current database context. Commits will be children of this transaction.
5454
55+The "hash" attribute contains the merkle tree hash for the given transaction. This can be used to ensure that the transaction graph has been used in an append-only fashion, ensuring historical state and audit log integrity.
56+
5557The "head" attribute is a boolean value indicating whether or not the transaction is a "head" node of its graph. Head nodes are nodes which have no children.
5658
5759The "id" attribute is the UUID needed in order to navigate the graph.
docs/tupleable.markdown+19
@@ -23,6 +23,25 @@ instance Tupleable Person
2323
2424Now, ```Person``` values can be marshaled between the database and the client. The attribute names appearing in the Haskell data type will appear identically in the server with the same types.
2525
26+### Changing Options
27+
28+If our field names don't exactly match attribute names, but follow a common pattern, we can derive Tupleable with custom options. Let's say each field on person has a prefix "person", but we still want to use the attribute names without the prefix. We can make use of the ProjectM36.Tupleable module to accomplish our goal like so:
29+
30+```haskell
31+import ProjectM36.Tupleable.Deriving
32+
33+data Person = Person {
34+ personName :: Text,
35+ personEmployeeNumber :: Int,
36+ personLikesHorses :: Bool
37+ }
38+ deriving stock Generic
39+ deriving Tupleable
40+ via Codec (Field (DropPrefix "person" >>> CamelCase)) Person
41+```
42+
43+The extensions DerivingGeneric, DerivingVia, TypeOperators, and DataKinds must be enabled for this code to compile. See the documentation on Hackage for all available options.
44+
2645## Usage
2746
2847The ```Tupleable``` module includes the following functions:
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/DerivingCustomTupleable.hsnew file+54
@@ -0,0 +1,54 @@
1+{-# LANGUAGE DeriveGeneric, DerivingVia, GeneralizedNewtypeDeriving, TypeOperators, DataKinds, OverloadedStrings #-}
2+
3+import ProjectM36.Tupleable.Deriving
4+import ProjectM36.Atomable (Atomable)
5+import Control.DeepSeq (NFData)
6+import Data.Text (Text)
7+import GHC.Generics (Generic)
8+import Codec.Winery
9+
10+newtype BlogId = BlogId { getBlogId :: Int }
11+ deriving stock (Eq, Ord, Show, Generic)
12+ deriving newtype (Num)
13+ deriving Serialise via WineryRecord BlogId
14+
15+instance NFData BlogId
16+instance Atomable BlogId
17+
18+data Blog = Blog
19+ { blogId :: BlogId
20+ , blogTitle :: Text
21+ , blogAuthorName :: Text
22+ }
23+ deriving stock (Show, Generic)
24+ deriving (Tupleable)
25+ via Codec (Field (DropPrefix "blog" >>> CamelCase)) Blog
26+ deriving Serialise via WineryRecord Blog
27+
28+data Comment = Comment
29+ { commentAuthorName :: Text
30+ , commentComment :: Text
31+ , commentFor :: BlogId
32+ }
33+ deriving stock (Show, Generic)
34+ deriving (Tupleable)
35+ via Codec (Field (DropPrefix "comment" >>> CamelCase)) Comment
36+ deriving Serialise via WineryRecord Comment
37+
38+main :: IO ()
39+main = do
40+ let exampleBlog = Blog
41+ { blogId = 0
42+ , blogTitle = "Cat Pics"
43+ , blogAuthorName = "Alice"
44+ }
45+ exampleComment = Comment
46+ { commentAuthorName = "Bob"
47+ , commentComment = "great"
48+ , commentFor = 0
49+ }
50+ print exampleBlog
51+ print (toTuple exampleBlog)
52+ putStrLn ""
53+ print exampleComment
54+ print (toTuple exampleComment)
examples/Plantfarm.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/SimpleClient.hs+1−1
@@ -6,7 +6,7 @@ import Data.Text.IO as TIO
66main :: IO ()
77main = do
88 -- 1. create a ConnectionInfo
9− let connInfo = RemoteProcessConnectionInfo "mytestdb" (createNodeId "127.0.0.1" defaultServerPort) emptyNotificationCallback
9+ let connInfo = RemoteConnectionInfo "mytestdb" "127.0.0.1" (show defaultServerPort) emptyNotificationCallback
1010 -- 2. conncted to the remote database
1111 eConn <- connectProjectM36 connInfo
1212 case eConn of
examples/blog.hs+4−3
@@ -1,5 +1,5 @@
11-- a simple example of a blog schema
2−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings, CPP #-}
2+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings, CPP, DerivingVia #-}
33
44import ProjectM36.Client
55import ProjectM36.Base
@@ -10,7 +10,6 @@ import ProjectM36.Tuple (atomForAttributeName)
1010
1111import Data.Either
1212import GHC.Generics
13−import Data.Binary
1413import qualified Data.Text as T
1514import qualified Data.Text.Lazy as TL
1615import Data.Time.Clock
@@ -22,6 +21,7 @@ import Data.Monoid
2221#endif
2322import Data.List
2423import Control.Monad (when, forM_)
24+import Codec.Winery
2525
2626import Web.Scotty as S
2727import Text.Blaze.Html5 (h1, h2, h3, p, form, input, (!), toHtml, Html, a, toValue, hr, textarea)
@@ -52,7 +52,8 @@ data Comment = Comment {
5252instance Tupleable Comment
5353
5454data Category = Food | Cats | Photos | Other T.Text -- note that this data type could not be represented by an "enumeration" as found in SQL databases
55− deriving (Atomable, Eq, Show, NFData, Binary, Generic) -- derive Atomable so that values of this type can be stored as a database value
55+ deriving (Atomable, Eq, Show, NFData, Generic) -- derive Atomable so that values of this type can be stored as a database value
56+ deriving Serialise via WineryVariant Category -- derive Serialisable to be able to transmit this data remotely
5657
5758-- add some short-hand error handling- your application should have proper handling
5859handleIOError :: Show e => IO (Either e a) -> IO a
examples/hair.hs+4−3
@@ -1,16 +1,17 @@
1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings #-}
1+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings, DerivingVia #-}
22import ProjectM36.Client
33import ProjectM36.Relation.Show.Term
44import GHC.Generics
55import Data.Text
6−import Data.Binary
76import Control.DeepSeq
87import qualified Data.Map as M
98import qualified Data.Text.IO as TIO
109import Data.Proxy
10+import Codec.Winery
1111
1212data Hair = Bald | Brown | Blond | OtherColor Text
13− deriving (Generic, Show, Eq, Binary, NFData, Atomable)
13+ deriving (Generic, Show, Eq, NFData, Atomable)
14+ deriving Serialise via WineryVariant Hair
1415
1516main :: IO ()
1617main = do
examples/out_of_the_tarpit.hs+11−7
@@ -1,5 +1,5 @@
11-- the Out-of-the-Tarpit example in Haskell and Project:M36
2−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings #-}
2+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings, DerivingVia #-}
33import ProjectM36.Client
44import ProjectM36.DataTypes.Primitive
55import ProjectM36.Tupleable
@@ -7,11 +7,11 @@ import ProjectM36.Relation
77import ProjectM36.Error
88import Data.Either
99import GHC.Generics
10−import Data.Binary
1110import Control.DeepSeq
1211import qualified Data.Text as T
1312import Data.Time.Calendar
1413import Data.Proxy
14+import Codec.Winery
1515
1616--create various database value (atom) types
1717type Price = Double
@@ -21,16 +21,20 @@ type Name = T.Text
2121type Address = T.Text
2222
2323data RoomType = Kitchen | Bathroom | LivingRoom
24− deriving (Generic, Atomable, Eq, Show, Binary, NFData)
24+ deriving (Generic, Atomable, Eq, Show, NFData)
25+ deriving Serialise via WineryVariant RoomType
2526
2627data PriceBand = Low | Medium | High | Premium
27− deriving (Generic, Atomable, Eq, Show, Binary, NFData)
28+ deriving (Generic, Atomable, Eq, Show, NFData)
29+ deriving Serialise via WineryVariant PriceBand
2830
2931data AreaCode = City | Suburban | Rural
30− deriving (Generic, Atomable, Eq, Show, Binary, NFData)
32+ deriving (Generic, Atomable, Eq, Show, NFData)
33+ deriving Serialise via WineryVariant AreaCode
3134
3235data SpeedBand = VeryFastBand | FastBand | MediumBand | SlowBand
33− deriving (Generic, Atomable, Eq, Show, Binary, NFData)
36+ deriving (Generic, Atomable, Eq, Show, NFData)
37+ deriving Serialise via WineryVariant SpeedBand
3438
3539main :: IO ()
3640main = do
@@ -257,4 +261,4 @@ handleIOErrors m = do
257261 [] -> pure (rights eErrs)
258262 errs -> handleError (Left (someErrors errs))
259263
260−
264+
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); }
project-m36.cabal+137−156
@@ -1,6 +1,8 @@
1+Cabal-Version: 2.2
12Name: project-m36
2−Version: 0.8
3−License: PublicDomain
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
46Build-Type: Simple
57Homepage: https://github.com/agentm/project-m36
68Bug-Reports: https://github.com/agentm/project-m36/issues
@@ -8,7 +10,6 @@ Author: AgentM
810Stability: experimental
911Category: Relational Algebra
1012Maintainer: agentm@themactionfaction.com
11−Cabal-Version: >= 1.10
1213Synopsis: Relational Algebra Engine
1314Description: A relational algebra engine which can be used to persist and query Haskell data types.
1415Extra-Source-Files: Changelog.markdown README.markdown
@@ -34,9 +35,9 @@ Flag haskell-scripting
3435 Default: True
3536
3637Library
37− Build-Depends: base>=4.8 && < 4.14, ghc-paths, mtl, containers, unordered-containers, hashable, haskeline, directory, MonadRandom, random-shuffle, uuid >= 1.3.12, cassava >= 0.4.5.1 && < 0.6, text, bytestring, deepseq, deepseq-generics, vector, parallel, monad-parallel, exceptions, transformers, gnuplot, binary, filepath, zlib, directory, vector-binary-instances, temporary, stm, time, hashable-time, old-locale, rset, attoparsec, either, base64-bytestring, data-interval, extended-reals, network-transport, aeson >= 1.1, path-pieces, conduit, resourcet, http-api-data, semigroups, QuickCheck, quickcheck-instances, distributed-process-client-server >= 0.2.3, distributed-process >= 0.7.4, distributed-process-extras >= 0.3.2, distributed-process-async >= 0.2.4.1, network-transport-tcp >= 0.6.0, network-transport, list-t, stm-containers >= 0.2.15, foldl, optparse-applicative, Glob, cryptohash-sha256
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)
39− Build-Depends: ghc >= 8.2 && < 8.9
40+ Build-Depends: ghc >= 8.2 && < 8.11
4041 CPP-Options: -DPM36_HASKELL_SCRIPTING
4142 if impl(ghc>= 8) && flag(haskell-scripting)
4243 build-depends:
@@ -51,6 +52,8 @@ Library
5152 ProjectM36.TransactionGraph.Merge,
5253 ProjectM36.TransGraphRelationalExpression,
5354 ProjectM36.Base,
55+ ProjectM36.Serialise.Base,
56+ ProjectM36.Serialise.Error,
5457 ProjectM36.DataFrame,
5558 ProjectM36.Attribute,
5659 ProjectM36.AttributeNames,
@@ -60,6 +63,7 @@ Library
6063 ProjectM36.AtomFunction,
6164 ProjectM36.AtomFunctionError,
6265 ProjectM36.ScriptSession,
66+ ProjectM36.Shortcuts,
6367 ProjectM36.DatabaseContextFunction,
6468 ProjectM36.DatabaseContextFunctionError,
6569 ProjectM36.DatabaseContextFunctionUtils,
@@ -79,6 +83,7 @@ Library
7983 ProjectM36.Relation.Parse.CSV,
8084 ProjectM36.IsomorphicSchema,
8185 ProjectM36.InclusionDependency,
86+ ProjectM36.MerkleHash,
8287 ProjectM36.Client,
8388 ProjectM36.Client.Simple,
8489 ProjectM36.Persist,
@@ -88,6 +93,7 @@ Library
8893 ProjectM36.AtomFunctions.Primitive,
8994 ProjectM36.Atomable,
9095 ProjectM36.Tupleable,
96+ ProjectM36.Tupleable.Deriving,
9197 ProjectM36.DataConstructorDef,
9298 ProjectM36.DataTypes.Basic,
9399 ProjectM36.DataTypes.Sorting,
@@ -108,6 +114,10 @@ Library
108114 ProjectM36.Server.EntryPoints,
109115 ProjectM36.Server.ParseArgs,
110116 ProjectM36.Server.RemoteCallTypes,
117+ ProjectM36.Serialise.AtomFunctionError,
118+ ProjectM36.Serialise.DataFrame,
119+ ProjectM36.Serialise.DatabaseContextFunctionError,
120+ ProjectM36.Serialise.IsomorphicSchema,
111121 ProjectM36.Session,
112122 ProjectM36.Sessions,
113123 ProjectM36.Transaction.Persist,
@@ -126,19 +136,19 @@ Library
126136 Other-Modules: ProjectM36.Win32Handle
127137 else
128138 --219- too many exported symbols under Windows and GHC 8.4
129− GHC-Options: -rdynamic
139+ GHC-Options: -rdynamic -fexternal-interpreter
130140 C-sources: cbits/DirectoryFsync.c, cbits/darwin_statfs.c
131141 Build-Depends: unix
132142 CC-Options: -fPIC
133143 Hs-Source-Dirs: ./src/lib
134144 Default-Language: Haskell2010
135145 Default-Extensions: OverloadedStrings, CPP
136− if !flag(stack)
146+ if !flag(stack)
137147 Build-Depends: deferred-folds
138148
139149Executable tutd
140150 if flag(haskell-scripting)
141− Build-Depends: ghc >= 8.2 && < 8.9
151+ Build-Depends: ghc >= 8.2 && < 8.11
142152 Build-Depends: base >=4.8 && <5.0,
143153 ghc-paths,
144154 project-m36,
@@ -153,13 +163,11 @@ Executable tutd
153163 MonadRandom, MonadRandom,
154164 vector,
155165 text,
156− vector-binary-instances,
157166 time,
158167 hashable-time,
159168 bytestring,
160169 stm,
161170 deepseq,
162− binary,
163171 data-interval,
164172 parallel,
165173 cassava,
@@ -167,7 +175,7 @@ Executable tutd
167175 directory,
168176 filepath,
169177 temporary,
170− megaparsec >= 5.2.0 && < 9,
178+ megaparsec >= 5.2.0 && < 10,
171179 haskeline,
172180 random, MonadRandom,
173181 base64-bytestring,
@@ -175,7 +183,15 @@ Executable tutd
175183 attoparsec,
176184 stm-containers >= 1.0.0,
177185 list-t,
178− parser-combinators
186+ parser-combinators,
187+ curryer-rpc,
188+ prettyprinter,
189+ cryptohash-sha256,
190+ --due to decode signature change
191+ base16-bytestring >= 1.0.0.0,
192+ http-conduit,
193+ modern-uri,
194+ http-types
179195 Other-Modules: TutorialD.Interpreter,
180196 TutorialD.Interpreter.Base,
181197 TutorialD.Interpreter.DatabaseContextExpr,
@@ -194,6 +210,7 @@ Executable tutd
194210 TutorialD.Interpreter.SchemaOperator,
195211 TutorialD.Interpreter.TransGraphRelationalOperator,
196212 TutorialD.Interpreter.SchemaOperator
213+ TutorialD.Printer
197214 main-is: TutorialD/tutd.hs
198215 CC-Options: -fPIC
199216 GHC-Options: -Wall -threaded
@@ -203,12 +220,11 @@ Executable tutd
203220
204221Executable project-m36-server
205222 if flag(haskell-scripting)
206− Build-Depends: ghc >= 8.2 && < 8.9
223+ Build-Depends: ghc >= 8.2 && < 8.11
207224 Build-Depends: base,
208225 ghc-paths,
209− project-m36,
210− binary,
211226 transformers,
227+ project-m36,
212228 temporary,
213229 data-interval,
214230 deepseq,
@@ -221,7 +237,6 @@ Executable project-m36-server
221237 optparse-applicative,
222238 hashable-time,
223239 time,
224− vector-binary-instances,
225240 text,
226241 deepseq-generics,
227242 mtl,
@@ -243,7 +258,7 @@ Executable project-m36-server
243258Executable bigrel
244259 Default-Language: Haskell2010
245260 Default-Extensions: OverloadedStrings
246− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, 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
247262 Other-Modules: TutorialD.Interpreter.Base,
248263 TutorialD.Interpreter.DatabaseContextExpr,
249264 TutorialD.Interpreter.RelationalExpr,
@@ -254,6 +269,13 @@ Executable bigrel
254269 if flag(profiler)
255270 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
256271
272+Common commontest
273+ Default-Language: Haskell2010
274+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators, winery, curryer-rpc, prettyprinter, base64-bytestring, modern-uri, http-types, http-conduit, base16-bytestring,cryptohash-sha256
275+ Default-Extensions: OverloadedStrings
276+ GHC-Options: -Wall -threaded
277+ Hs-Source-Dirs: test, src/bin
278+
257279Benchmark basic-benchmark
258280 Default-Language: Haskell2010
259281 Default-Extensions: OverloadedStrings
@@ -265,240 +287,202 @@ Benchmark basic-benchmark
265287 if flag(profiler)
266288 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
267289
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+
268302Test-Suite test-tutoriald
269− Default-Language: Haskell2010
270− Default-Extensions: OverloadedStrings
303+ import: commontest
271304 type: exitcode-stdio-1.0
272− main-is: test/TutorialD/Interpreter.hs
273− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, list-t, project-m36, random, MonadRandom, semigroups, parser-combinators
274− 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
275− GHC-Options: -Wall -threaded
276− Hs-Source-Dirs: ./src/bin, ., test
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
277308
278309Test-Suite test-tutoriald-atomfunctionscript
279− Default-Language: Haskell2010
280− Default-Extensions: OverloadedStrings
310+ import: commontest
281311 type: exitcode-stdio-1.0
282− 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
283− main-is: test/TutorialD/Interpreter/AtomFunctionScript.hs
284− Build-Depends: base, HUnit, project-m36, uuid, containers, megaparsec, text, vector, directory, bytestring, mtl, haskeline, random, MonadRandom, semigroups, time, parser-combinators
285− GHC-Options: -Wall -threaded
286− Hs-Source-Dirs: ./src/bin, ./test, .
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
287314
288315Test-Suite test-tutoriald-databasecontextfunctionscript
289− Default-Language: Haskell2010
290− Default-Extensions: OverloadedStrings
316+ import: commontest
291317 type: exitcode-stdio-1.0
292− 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
293− main-is: test/TutorialD/Interpreter/DatabaseContextFunctionScript.hs
294− Build-Depends: base, HUnit, project-m36, uuid, containers, megaparsec, text, vector, directory, bytestring, mtl, haskeline, random, MonadRandom, semigroups, time, parser-combinators
295− GHC-Options: -Wall -threaded
296− Hs-Source-Dirs: ./src/bin, ./test, .
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
297320
298321Test-Suite test-relation
299− Default-Language: Haskell2010
300− Default-Extensions: OverloadedStrings
322+ import: commontest
301323 type: exitcode-stdio-1.0
302− main-is: test/Relation/Basic.hs
303− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, transformers
304− GHC-Options: -Wall -threaded
324+ main-is: Relation/Basic.hs
305325
306326Test-Suite test-static-optimizer
307− Default-Language: Haskell2010
308− Default-Extensions: OverloadedStrings
327+ import: commontest
309328 type: exitcode-stdio-1.0
310− main-is: test/Relation/StaticOptimizer.hs
311− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, transformers
312− GHC-Options: -Wall -threaded
329+ main-is: Relation/StaticOptimizer.hs
313330
314331Test-Suite test-transactiongraph-persist
315− Default-Language: Haskell2010
316− Default-Extensions: OverloadedStrings
332+ import: commontest
317333 type: exitcode-stdio-1.0
318− main-is: test/TransactionGraph/Persist.hs
319− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, random, MonadRandom, semigroups, parser-combinators
320− Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples
321− Hs-Source-Dirs: ., ./src/bin
322− GHC-Options: -Wall -threaded
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
323336
324337Test-Suite test-relation-import-csv
325− Default-Language: Haskell2010
326− Default-Extensions: OverloadedStrings
338+ import: commontest
327339 type: exitcode-stdio-1.0
328− main-is: test/Relation/Import/CSV.hs
329− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36
330− GHC-Options: -Wall -threaded
340+ main-is: Relation/Import/CSV.hs
331341
332342Test-Suite test-tutoriald-import-tutoriald
333− Default-Language: Haskell2010
334− Default-Extensions: OverloadedStrings
343+ import: commontest
335344 type: exitcode-stdio-1.0
336− main-is: test/TutorialD/Interpreter/Import/TutorialD.hs
337− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, random, MonadRandom, semigroups, parser-combinators
338− 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
339− GHC-Options: -Wall -threaded
340− 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
341347
342348Test-Suite test-relation-export-csv
343− Default-Language: Haskell2010
344− Default-Extensions: OverloadedStrings
349+ import: commontest
345350 type: exitcode-stdio-1.0
346− main-is: test/Relation/Export/CSV.hs
347− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36
348− GHC-Options: -Wall -threaded
351+ main-is: Relation/Export/CSV.hs
349352
350353Test-Suite test-transactiongraph-merge
351− Default-Language: Haskell2010
352− Default-Extensions: OverloadedStrings
354+ import: commontest
353355 type: exitcode-stdio-1.0
354− main-is: test/TransactionGraph/Merge.hs
355− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, template-haskell, transformers, aeson, conduit, either, path-pieces, http-api-data, stm-containers, list-t, project-m36
356− 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
357364
358365benchmark bench
359− Default-Language: Haskell2010
360− Default-Extensions: OverloadedStrings
366+ import: commontest
361367 type: exitcode-stdio-1.0
362368 main-is: benchmark/Relation.hs
363− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, criterion, stm-containers, project-m36
364− GHC-Options: -Wall -rtsopts -threaded
365− Hs-Source-Dirs: ./src/bin
366369
367370Test-Suite test-server
368− Default-Language: Haskell2010
369− Default-Extensions: OverloadedStrings
371+ import: commontest
370372 type: exitcode-stdio-1.0
371− main-is: test/Server/Main.hs
372− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, project-m36, network-transport, semigroups
373− HS-Source-Dirs: ., ./src/bin
374− GHC-Options: -Wall -threaded
373+ main-is: Server/Main.hs
374+
375375
376376Executable Example-SimpleClient
377377 Default-Language: Haskell2010
378378 Default-Extensions: OverloadedStrings
379− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, ghc, ghc-paths, project-m36, random, MonadRandom
379+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, ghc, ghc-paths, project-m36, random, MonadRandom
380380 Main-Is: examples/SimpleClient.hs
381381 GHC-Options: -Wall -threaded
382382
383383Executable Example-OutOfTheTarpit
384384 Default-Language: Haskell2010
385385 Default-Extensions: OverloadedStrings
386− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36
386+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery
387387 Main-Is: examples/out_of_the_tarpit.hs
388388 GHC-Options: -Wall -threaded
389389
390390Executable Example-Blog
391391 Default-Language: Haskell2010
392392 Default-Extensions: OverloadedStrings
393− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, scotty, blaze-html, http-types
393+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, scotty, blaze-html, http-types, winery
394394 Main-Is: examples/blog.hs
395395 GHC-Options: -Wall -threaded
396396
397−
398397Executable Example-Hair
399398 Default-Language: Haskell2010
400399 Default-Extensions: OverloadedStrings
401− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36
400+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery
402401 Main-Is: examples/hair.hs
403402 GHC-Options: -Wall -threaded
404403
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+
405411Executable Example-CustomTupleable
406412 Default-Language: Haskell2010
407413 Default-Extensions: OverloadedStrings
408− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36
414+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery
409415 Main-Is: examples/CustomTupleable.hs
410416 GHC-Options: -Wall -threaded
411417
412−Test-Suite test-scripts
418+Executable Example-DerivingCustomTupleable
419+ if impl(ghc>=8.6)
420+ Buildable: True
421+ else
422+ Buildable: False
413423 Default-Language: Haskell2010
414− Default-Extensions: OverloadedStrings
415− type: exitcode-stdio-1.0
416− main-is: test/scripts.hs
417− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, project-m36, random, MonadRandom, semigroups, parser-combinators
418− 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
424+ Build-Depends: base, text, deepseq, project-m36, winery
425+ Main-Is: examples/DerivingCustomTupleable.hs
419426 GHC-Options: -Wall -threaded
420− Hs-Source-Dirs: ., ./src/bin
427+
428+Test-Suite test-scripts
429+ import: commontest
430+ type: exitcode-stdio-1.0
431+ main-is: scripts.hs
432+ Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Printer
421433
422434Executable project-m36-websocket-server
423435 Default-Language: Haskell2010
424− Build-Depends: base, aeson, path-pieces, either, conduit, http-api-data, template-haskell, websockets, aeson, optparse-applicative, project-m36, containers, bytestring, text, vector, uuid, megaparsec, haskeline, mtl, directory, base64-bytestring, random, MonadRandom, time, network-transport-tcp, semigroups, attoparsec, parser-combinators
436+ Build-Depends: base, aeson, path-pieces, either, conduit, http-api-data, template-haskell, websockets, aeson, optparse-applicative, project-m36, containers, bytestring, text, vector, uuid, megaparsec, haskeline, mtl, directory, base64-bytestring, random, MonadRandom, time, semigroups, attoparsec, parser-combinators, prettyprinter, network, modern-uri, http-conduit, base16-bytestring, http-types, cryptohash-sha256, wai, wai-websockets, warp, warp-tls
425437 Main-Is: ProjectM36/Server/WebSocket/websocket-server.hs
426− 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
427439 GHC-Options: -Wall -threaded
428440 Hs-Source-Dirs: ./src/bin
429441 Default-Extensions: OverloadedStrings
430442
431443Test-Suite test-websocket-server
432− Default-Language: Haskell2010
444+ import: commontest
433445 type: exitcode-stdio-1.0
434− main-is: test/Server/WebSocket.hs
435− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, network-transport-tcp, semigroups, parser-combinators
436− 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
437− Default-Extensions: OverloadedStrings
438− GHC-Options: -Wall -threaded
439− 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
440448
441449Test-Suite test-isomorphic-schemas
442− Default-Language: Haskell2010
450+ import: commontest
443451 type: exitcode-stdio-1.0
444− main-is: test/IsomorphicSchema.hs
445− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36
446− Default-Extensions: OverloadedStrings
447− GHC-Options: -Wall -threaded
448− Hs-Source-Dirs: ./src/bin, .
452+ main-is: IsomorphicSchema.hs
449453
450454Test-Suite test-atomable
451− Default-Language: Haskell2010
455+ import: commontest
452456 type: exitcode-stdio-1.0
453− main-is: test/Relation/Atomable.hs
454− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators
455− 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
456− Default-Extensions: OverloadedStrings
457− GHC-Options: -Wall -threaded
458− 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
459459
460460Test-Suite test-multiprocess-access
461− Default-Language: Haskell2010
461+ import: commontest
462462 type: exitcode-stdio-1.0
463− main-is: test/MultiProcessDatabaseAccess.hs
464− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom
465− Default-Extensions: OverloadedStrings
466− GHC-Options: -Wall -threaded
467− Hs-Source-Dirs: ./src/bin, ., test/
463+ main-is: MultiProcessDatabaseAccess.hs
468464
469465Test-Suite test-transactiongraph-automerge
470− Default-Language: Haskell2010
466+ import: commontest
471467 type: exitcode-stdio-1.0
472− main-is: test/TransactionGraph/Automerge.hs
473− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators
474− 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
475− Default-Extensions: OverloadedStrings
476− GHC-Options: -Wall -threaded
477− 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
478470
479471Test-Suite test-tupleable
480− Default-Language: Haskell2010
472+ import: commontest
481473 type: exitcode-stdio-1.0
482− main-is: test/Relation/Tupleable.hs
483− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups
484− Default-Extensions: OverloadedStrings
485− GHC-Options: -Wall -threaded
486− Hs-Source-Dirs: ./src/bin, ., test/
474+ main-is: Relation/Tupleable.hs
487475
488476Test-Suite test-client-simple
489− Default-Language: Haskell2010
490− Main-Is: test/Client/Simple.hs
477+ import: commontest
478+ Main-Is: Client/Simple.hs
491479 type: exitcode-stdio-1.0
492− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups
493− Default-Extensions: OverloadedStrings
494− GHC-Options: -Wall -threaded
495− Hs-Source-Dirs: ./src/bin, ., test/
496480
497481-- test for file handle leaks
498482Executable handles
499483 Default-Language: Haskell2010
500484 Default-Extensions: OverloadedStrings
501− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, 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
502486 main-is: benchmark/Handles.hs
503487 Other-Modules: TutorialD.Interpreter,
504488 TutorialD.Interpreter.Base,
@@ -517,17 +501,14 @@ Executable handles
517501 TutorialD.Interpreter.TransGraphRelationalOperator,
518502 TutorialD.Interpreter.TransactionGraphOperator,
519503 TutorialD.Interpreter.Types
504+ TutorialD.Printer
520505 GHC-Options: -Wall -threaded -rtsopts
521506 HS-Source-Dirs: ./src/bin
522507 if flag(profiler)
523508 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
524509
525510Test-Suite test-dataframe
526− Default-Language: Haskell2010
527− Main-Is: test/DataFrame.hs
511+ import: commontest
528512 type: exitcode-stdio-1.0
529− 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
530− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators
531− Default-Extensions: OverloadedStrings
532− GHC-Options: -Wall -threaded
533− Hs-Source-Dirs: ./src/bin, ., test/
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.nixnew file+36
@@ -0,0 +1,36 @@
1+{ compiler ? "ghc8104"
2+, sources ? import ./nix/sources.nix
3+, pkgs ? import sources.nixpkgs { }
4+}:
5+let
6+ doJailbreak = pkgs.haskell.lib.doJailbreak;
7+ needsCocoa = drv:
8+ if pkgs.stdenv.isDarwin
9+ then drv.overrideDerivation (old:
10+ { buildInputs = [ pkgs.darwin.apple_sdk.frameworks.Cocoa ] ++ old.buildInputs; }
11+ )
12+ else drv;
13+
14+ haskellPackages = pkgs.haskell.packages.${compiler}.override {
15+ overrides = self: super: {
16+ curryer-rpc = self.callCabal2nix "curryer-rpc" sources.curryer { };
17+ streamly = doJailbreak (needsCocoa (self.callCabal2nix "streamly" sources.streamly { }));
18+ project-m36 = ((self.callCabal2nixWithOptions "project-m36" ./. "-f-haskell-scripting" { }));
19+ };
20+ };
21+in
22+{
23+ project = haskellPackages.project-m36;
24+
25+ shell = haskellPackages.shellFor {
26+ packages = p: [
27+ p.project-m36
28+ ];
29+ buildInputs = [
30+ haskellPackages.ghcid
31+ haskellPackages.hlint
32+ pkgs.docker
33+ ];
34+ withHoogle = true;
35+ };
36+}
scripts/DateExamples.tutd+2−2
@@ -20,7 +20,7 @@ sp := relation{tuple{s# "S1",p# "P1",qty 300},
2020 tuple{s# "S3",p# "P2",qty 200},
2121 tuple{s# "S4",p# "P4",qty 300},
2222 tuple{s# "S4",p# "P5",qty 400}};
23−key s_pkey {s#} s
24−key p_key {p#} p
23+key s_pkey {s#} s;
24+key p_key {p#} p;
2525foreign key s_sp_fk sp{s#} in s{s#};
2626foreign key p_sp_fk sp{p#} in p{p#};
scripts/multiline.tutdnew file+2
@@ -0,0 +1,2 @@
1+x:=relation{
2+tuple{ x 2}} -- nice
shell.nixnew file+1
@@ -0,0 +1 @@
1+(import ./release.nix { }).shell
src/bin/ProjectM36/Client/Json.hs+4−1
@@ -3,6 +3,7 @@ module ProjectM36.Client.Json where
33import Data.Aeson
44import ProjectM36.Server.RemoteCallTypes.Json ()
55import ProjectM36.Client
6+import ProjectM36.TransactionGraph
67import Control.Exception (IOException)
78
89instance ToJSON EvaluatedNotification
@@ -11,4 +12,6 @@ instance FromJSON EvaluatedNotification
1112instance ToJSON ConnectionError
1213
1314instance ToJSON IOException where
14− toJSON err = object ["IOException" .= show err]
15+ toJSON err = object ["IOException" .= show err]
16+
17+instance ToJSON MerkleValidationError
src/bin/ProjectM36/Server/RemoteCallTypes/Json.hs+30−2
@@ -10,6 +10,8 @@ import ProjectM36.DataTypes.Primitive
1010import ProjectM36.Error
1111import ProjectM36.IsomorphicSchema
1212import ProjectM36.Server.RemoteCallTypes
13+import ProjectM36.MerkleHash
14+import ProjectM36.Attribute as A
1315
1416import Data.Aeson
1517import Data.ByteString.Base64 as B64
@@ -43,8 +45,11 @@ instance FromJSON ExecuteRelationalExpr
4345instance ToJSON Relation
4446instance FromJSON Relation
4547
46−instance ToJSON Attribute
47−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"
4853
4954instance ToJSON ExtendTupleExpr
5055instance FromJSON ExtendTupleExpr
@@ -98,6 +103,8 @@ instance ToJSON Atom where
98103 "val" .= i ]
99104 toJSON atom@(RelationAtom i) = object [ "type" .= atomTypeForAtom atom,
100105 "val" .= i ]
106+ toJSON atom@(RelationalExprAtom i) = object [ "type" .= atomTypeForAtom atom,
107+ "val" .= i ]
101108 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [
102109 "dataconstructorname" .= dConsName,
103110 "type" .= toJSON atomtype,
@@ -125,6 +132,7 @@ instance FromJSON Atom where
125132 Left err -> fail ("Failed to parse base64-encoded ByteString: " ++ err)
126133 Right bs -> pure (ByteStringAtom bs)
127134 BoolAtomType -> BoolAtom <$> o .: "val"
135+ RelationalExprAtomType -> RelationalExprAtom <$> o .: "val"
128136
129137instance ToJSON Notification
130138instance FromJSON Notification
@@ -132,6 +140,21 @@ instance FromJSON Notification
132140instance ToJSON ScriptCompilationError
133141instance FromJSON ScriptCompilationError
134142
143+instance ToJSON MerkleHash where
144+ toJSON h = object [ "merklehash" .= decodeUtf8 (B64.encode (_unMerkleHash h))]
145+instance FromJSON MerkleHash where
146+ parseJSON = withObject "merklehash" $ \o -> do
147+ b64bs <- encodeUtf8 <$> o .: "merklehash"
148+ case B64.decode b64bs of
149+ Left err -> fail ("Failed to parse merkle hash: " ++ err)
150+ Right bs -> pure (MerkleHash bs)
151+
152+instance ToJSON Attributes where
153+ toJSON attrs = object ["attributes" .= map toJSON (A.toList attrs)]
154+instance FromJSON Attributes where
155+ parseJSON = withObject "Attributes" $ \o ->
156+ A.attributesFromList <$> o .: "attributes"
157+
135158instance ToJSON RelationalError
136159instance FromJSON RelationalError
137160
@@ -141,6 +164,9 @@ instance FromJSON SchemaError
141164instance ToJSON MergeError
142165instance FromJSON MergeError
143166
167+instance ToJSON ImportError'
168+instance FromJSON ImportError'
169+
144170instance ToJSON DatabaseContextFunctionError
145171instance FromJSON DatabaseContextFunctionError
146172
@@ -155,3 +181,5 @@ instance FromJSON AtomFunctionError
155181
156182instance ToJSON WithNameExpr
157183instance FromJSON WithNameExpr
184+
185+
src/bin/ProjectM36/Server/WebSocket.hs+3−2
@@ -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
@@ -85,7 +86,7 @@ notificationCallback conn notifName evaldNotif = WS.sendTextData conn (encode (o
8586
8687--this creates a new database for each connection- perhaps not what we want (?)
8788createConnection :: WS.Connection -> DatabaseName -> Port -> Hostname -> IO (Either ConnectionError Connection)
88−createConnection wsconn dbname port host = connectProjectM36 (RemoteProcessConnectionInfo dbname (createNodeId host port) (notificationCallback wsconn))
89+createConnection wsconn dbname port host = connectProjectM36 (RemoteConnectionInfo dbname host (show port) (notificationCallback wsconn))
8990
9091sendError :: (ToJSON a) => WS.Connection -> a -> IO ()
9192sendError conn err = WS.sendTextData conn (encode (object ["displayerror" .= err]))
@@ -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+48−18
@@ -1,33 +1,63 @@
11{-# LANGUAGE CPP #-}
2−import ProjectM36.Server.WebSocket
3−import ProjectM36.Server.Config
4−import ProjectM36.Server.ParseArgs
5−import ProjectM36.Server
6−import Control.Concurrent
7−import qualified Network.WebSockets as WS
8−
9−#if MIN_VERSION_network_transport_tcp(0,6,0)
10−import Network.Transport.TCP.Internal (decodeEndPointAddress)
11−#else
12−import Network.Transport.TCP (decodeEndPointAddress)
13−#endif
142
3+import Control.Concurrent
154import Control.Exception
5+import Control.Monad (when)
6+import Data.Maybe (isJust)
7+import Data.String (fromString)
8+import Network.HTTP.Types (status400)
9+import Network.Socket
10+import Network.Wai (Application, responseLBS)
11+import Network.Wai.Handler.Warp
12+import Network.Wai.Handler.WarpTLS (runTLS, tlsSettings)
13+import qualified Network.Wai.Handler.WebSockets as WS
14+import Network.WebSockets (defaultConnectionOptions)
15+import ProjectM36.Server
16+import ProjectM36.Server.Config
17+import ProjectM36.Server.ParseArgs
18+import ProjectM36.Server.WebSocket
1619
1720main :: IO ()
1821main = do
1922 -- launch normal project-m36-server
2023 addressMVar <- newEmptyMVar
21− serverConfig <- parseConfigWithDefaults (defaultServerConfig { bindPort = 8000, bindHost = "127.0.0.1" })
24+ wsConfig <- parseWSConfigWithDefaults (defaultServerConfig {bindPort = 8000, bindHost = "127.0.0.1"})
25+
2226 --usurp the serverConfig for our websocket server and make the proxied server run locally
23− let wsHost = bindHost serverConfig
27+ let serverConfig = wsServerConfig wsConfig
28+ wsHost = bindHost serverConfig
2429 wsPort = bindPort serverConfig
2530 serverHost = "127.0.0.1"
2631 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+
2738 _ <- forkFinally (launchServer serverConfig' (Just addressMVar) >> pure ()) (either throwIO pure)
2839 --wait for server to be listening
29− address <- takeMVar addressMVar
30− let Just (_, serverPort, _) = decodeEndPointAddress address
31− --this built-in server is apparently not meant for production use, but it's easier to test than starting up the wai or snap interfaces
32− WS.runServer wsHost (fromIntegral wsPort) (websocketProxyServer (read serverPort) serverHost)
40+ addr <- takeMVar addressMVar
41+ let port =
42+ case addr of
43+ SockAddrInet port' _ -> fromIntegral port'
44+ _ -> error "unsupported socket address (IPv4 only currently)"
45+ wsApp = websocketProxyServer port serverHost
46+ waiApp = WS.websocketsOr defaultConnectionOptions wsApp backupApp
47+ settings = warpSettings wsHost (fromIntegral wsPort)
48+
49+ case (configCertificateFile, configKeyFile) of
50+ (Just certificate, Just key) -> runTLS (tlsSettings certificate key) settings waiApp
51+ _ -> runSettings settings waiApp
52+
53+backupApp :: Application
54+backupApp _ respond = respond $ responseLBS status400 [] "Not a WebSocket request"
3355
56+warpSettings :: HostName -> Port -> Settings
57+warpSettings host port =
58+ setHost (fromString host)
59+ . setPort port
60+ . setServerName "project-m36"
61+ . setTimeout 3600
62+ . setGracefulShutdownTimeout (Just 5)
63+ $ defaultSettings
src/bin/TutorialD/Interpreter.hs+4−2
@@ -34,6 +34,7 @@ import Data.Monoid
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
@@ -227,7 +229,7 @@ type TutorialDExec = String
227229type CheckFS = Bool
228230
229231data InterpreterConfig = LocalInterpreterConfig PersistenceStrategy HeadName (Maybe TutorialDExec) [GhcPkgPath] CheckFS |
230− RemoteInterpreterConfig C.NodeId C.DatabaseName HeadName (Maybe TutorialDExec) CheckFS
232+ RemoteInterpreterConfig C.Hostname C.Port C.DatabaseName HeadName (Maybe TutorialDExec) CheckFS
231233
232234outputNotificationCallback :: C.NotificationCallback
233235outputNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received " ++ show notName ++ ":\n" ++ "\n" ++ prettyEvaluatedNotification evaldNot
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+4−4
@@ -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
@@ -206,8 +207,7 @@ interpretDatabaseContextExpr context transId graph tutdstring =
206207 Left err -> Left $ PM36E.ParseError (T.pack (show err))
207208 Right parsed -> do
208209 let env = RE.mkDatabaseContextEvalEnv transId graph
209− x <- RE.dbc_context <$> RE.runDatabaseContextEvalMonad context env (optimizeAndEvalDatabaseContextExpr True parsed)
210− pure x
210+ RE.dbc_context <$> RE.runDatabaseContextEvalMonad context env (optimizeAndEvalDatabaseContextExpr True parsed)
211211
212212{-
213213--no optimization
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/Interpreter/TransactionGraphOperator.hs+12−3
@@ -2,8 +2,9 @@
22module TutorialD.Interpreter.TransactionGraphOperator where
33import TutorialD.Interpreter.Base
44import ProjectM36.TransactionGraph hiding (autoMergeToHead)
5−import ProjectM36.Client
5+import ProjectM36.Client as C
66import ProjectM36.Base
7+import ProjectM36.Relation (relationTrue)
78import Data.Functor
89
910data ConvenienceTransactionGraphOperator = AutoMergeToHead MergeStrategy HeadName
@@ -71,6 +72,9 @@ mergeTransactionsP = do
7172 reservedOp ":mergetrans"
7273 MergeTransactions <$> mergeTransactionStrategyP <*> identifier <*> identifier
7374
75+validateMerkleHashesP :: Parser ROTransactionGraphOperator
76+validateMerkleHashesP = reservedOp ":validatemerklehashes" $> ValidateMerkleHashes
77+
7478transactionGraphOpP :: Parser TransactionGraphOperator
7579transactionGraphOpP =
7680 jumpToHeadP
@@ -83,7 +87,7 @@ transactionGraphOpP =
8387 <|> mergeTransactionsP
8488
8589roTransactionGraphOpP :: Parser ROTransactionGraphOperator
86−roTransactionGraphOpP = showGraphP
90+roTransactionGraphOpP = showGraphP <|> validateMerkleHashesP
8791
8892
8993
@@ -101,6 +105,11 @@ interpretOps newUUID trans@(DisconnectedTransaction _ context) transGraph instri
101105
102106evalROGraphOp :: SessionId -> Connection -> ROTransactionGraphOperator -> IO (Either RelationalError Relation)
103107evalROGraphOp sessionId conn ShowGraph = transactionGraphAsRelation sessionId conn
108+evalROGraphOp sessionId conn ValidateMerkleHashes = do
109+ eVal <- C.validateMerkleHashes sessionId conn
110+ case eVal of
111+ Left err -> pure (Left err)
112+ Right _ -> pure (Right relationTrue)
104113
105114evalConvenienceGraphOp :: SessionId -> Connection -> ConvenienceTransactionGraphOperator -> IO (Either RelationalError ())
106−evalConvenienceGraphOp sessionId conn (AutoMergeToHead strat head') = autoMergeToHead sessionId conn strat head'
115+evalConvenienceGraphOp sessionId conn (AutoMergeToHead strat head') = autoMergeToHead sessionId conn strat head'
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/bin/TutorialD/tutd.hs+14−18
@@ -5,8 +5,10 @@ import ProjectM36.Client
55import ProjectM36.Server.ParseArgs
66import ProjectM36.Server
77import System.IO
8+import GHC.IO.Encoding
89import Options.Applicative
910import System.Exit
11+import Control.Monad
1012#if __GLASGOW_HASKELL__ < 804
1113import Data.Monoid
1214#endif
@@ -20,7 +22,7 @@ import qualified Data.Text as T
2022
2123parseArgs :: Parser InterpreterConfig
2224parseArgs = LocalInterpreterConfig <$> parsePersistenceStrategy <*> parseHeadName <*> parseTutDExec <*> many parseGhcPkgPath <*> parseCheckFS <|>
23− RemoteInterpreterConfig <$> parseNodeId <*> parseDatabaseName <*> parseHeadName <*> parseTutDExec <*> parseCheckFS
25+ RemoteInterpreterConfig <$> parseHostname "127.0.0.1" <*> parsePort defaultServerPort <*> parseDatabaseName <*> parseHeadName <*> parseTutDExec <*> parseCheckFS
2426
2527parseHeadName :: Parser HeadName
2628parseHeadName = option auto (long "head" <>
@@ -29,19 +31,6 @@ parseHeadName = option auto (long "head" <>
2931 value "master"
3032 )
3133
32−parseNodeId :: Parser NodeId
33−parseNodeId = createNodeId <$>
34− strOption (long "host" <>
35− short 'h' <>
36− help "Remote host name" <>
37− metavar "HOSTNAME" <>
38− value "127.0.0.1") <*>
39− option auto (long "port" <>
40− metavar "PORT NUMBER" <>
41− short 'p' <>
42− help "Remote port" <>
43− value defaultServerPort)
44−
4534--just execute some tutd and exit
4635parseTutDExec :: Parser (Maybe TutorialDExec)
4736parseTutDExec = optional $ strOption (long "exec-tutd" <>
@@ -55,19 +44,19 @@ opts = info (parseArgs <**> helpOption) idm
5544
5645connectionInfoForConfig :: InterpreterConfig -> ConnectionInfo
5746connectionInfoForConfig (LocalInterpreterConfig pStrategy _ _ ghcPkgPaths _) = InProcessConnectionInfo pStrategy outputNotificationCallback ghcPkgPaths
58−connectionInfoForConfig (RemoteInterpreterConfig remoteNodeId remoteDBName _ _ _) = RemoteProcessConnectionInfo remoteDBName remoteNodeId outputNotificationCallback
47+connectionInfoForConfig (RemoteInterpreterConfig remoteHost remotePort remoteDBName _ _ _) = RemoteConnectionInfo remoteDBName remoteHost (show remotePort) outputNotificationCallback
5948
6049headNameForConfig :: InterpreterConfig -> HeadName
6150headNameForConfig (LocalInterpreterConfig _ headn _ _ _) = headn
62−headNameForConfig (RemoteInterpreterConfig _ _ headn _ _) = headn
51+headNameForConfig (RemoteInterpreterConfig _ _ _ headn _ _) = headn
6352
6453execTutDForConfig :: InterpreterConfig -> Maybe String
6554execTutDForConfig (LocalInterpreterConfig _ _ t _ _) = t
66−execTutDForConfig (RemoteInterpreterConfig _ _ _ t _) = t
55+execTutDForConfig (RemoteInterpreterConfig _ _ _ _ t _) = t
6756
6857checkFSForConfig :: InterpreterConfig -> Bool
6958checkFSForConfig (LocalInterpreterConfig _ _ _ _ c) = c
70−checkFSForConfig (RemoteInterpreterConfig _ _ _ _ c) = c
59+checkFSForConfig (RemoteInterpreterConfig _ _ _ _ _ c) = c
7160
7261persistenceStrategyForConfig :: InterpreterConfig -> Maybe PersistenceStrategy
7362persistenceStrategyForConfig (LocalInterpreterConfig strat _ _ _ _) = Just strat
@@ -86,8 +75,15 @@ printWelcome = do
8675 putStrLn "A full tutorial is available at:"
8776 putStrLn "https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown"
8877
78+-- | If the locale is set to ASCII, upgrade it to UTF-8 because tutd outputs UTF-8-encoded attributes. This is especially important in light docker images where the locale data may be missing.
79+setLocaleIfNecessary :: IO ()
80+setLocaleIfNecessary = do
81+ l <- getLocaleEncoding
82+ when (textEncodingName l == "ASCII") (setLocaleEncoding utf8)
83+
8984main :: IO ()
9085main = do
86+ setLocaleIfNecessary
9187 interpreterConfig <- execParser opts
9288 let connInfo = connectionInfoForConfig interpreterConfig
9389 fscheck <- checkFSType (checkFSForConfig interpreterConfig) (fromMaybe NoPersistence (persistenceStrategyForConfig interpreterConfig))
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/AtomFunction.hs+13−1
@@ -1,6 +1,7 @@
11{-# LANGUAGE CPP #-}
22module ProjectM36.AtomFunction where
33import ProjectM36.Base
4+import ProjectM36.Serialise.Base ()
45import ProjectM36.Error
56import ProjectM36.Relation
67import ProjectM36.AtomType
@@ -9,7 +10,8 @@ import ProjectM36.ScriptSession
910import qualified ProjectM36.Attribute as A
1011import qualified Data.HashSet as HS
1112import qualified Data.Text as T
12−
13+import qualified Data.ByteString.Lazy as BL
14+import Codec.Winery
1315
1416foldAtomFuncType :: AtomType -> AtomType -> [AtomType]
1517--the underscore in the attribute name means that any attributes are acceptable
@@ -87,3 +89,13 @@ atomFunctionsAsRelation funcs = mkRelationFromList attrs tups
8789 atomFuncToTuple aFunc = [TextAtom (atomFuncName aFunc),
8890 TextAtom (atomFuncTypeToText aFunc)]
8991 atomFuncTypeToText aFunc = T.intercalate " -> " (map prettyAtomType (atomFuncType aFunc))
92+
93+--for calculating the merkle hash
94+hashBytes :: AtomFunction -> BL.ByteString
95+hashBytes func = BL.fromChunks [serialise (atomFuncName func),
96+ serialise (atomFuncType func),
97+ bodyBin
98+ ]
99+ where
100+ bodyBin = case atomFuncBody func of
101+ AtomFunctionBody mScript _ -> serialise mScript
src/lib/ProjectM36/AtomFunctionError.hs+1−2
@@ -1,6 +1,5 @@
11{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}
22module ProjectM36.AtomFunctionError where
3−import Data.Binary
43import GHC.Generics
54import Control.DeepSeq
65import Data.Text
@@ -14,5 +13,5 @@ data AtomFunctionError = AtomFunctionUserError String |
1413 AtomTypeDoesNotSupportOrderingError Text |
1514 AtomTypeDoesNotSupportIntervalError Text |
1615 AtomFunctionBytesDecodingError String
17− deriving(Generic, Eq, Show, Binary, NFData)
16+ deriving(Generic, Eq, Show, NFData)
1817
src/lib/ProjectM36/AtomType.hs+9−8
@@ -211,7 +211,7 @@ isValidAtomTypeForTypeConstructor (ConstructedAtomType tConsName _) (ADTypeConst
211211
212212isValidAtomTypeForTypeConstructor (RelationAtomType attrs) (RelationAtomTypeConstructor attrExprs) tConsMap = do
213213 evaldAtomTypes <- mapM (\expr -> atomTypeForAttributeExpr expr tConsMap M.empty) attrExprs
214− mapM_ (uncurry resolveAtomType) (zip (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,18 +314,18 @@ 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
321321validateAttributes :: TypeConstructorMapping -> Attributes -> Either RelationalError ()
322322validateAttributes tConss attrs =
323− if length errs > 0 then
323+ if not (null errs) then
324324 Left (someErrors errs)
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+4−20
@@ -13,29 +13,16 @@ import qualified Data.Map as M
1313import qualified Data.Text as T
1414import qualified Data.Vector as V
1515import Control.DeepSeq (NFData)
16−import Data.Binary
1716import Control.Applicative
1817import Data.Time.Calendar
1918import Data.ByteString (ByteString)
2019import Data.Time.Clock
2120import Data.Proxy
2221import qualified Data.List.NonEmpty as NE
22+import Codec.Winery
2323
24−--also add haskell scripting atomable support
25−--rename this module to Atomable along with test
26−
27−{-
28−data Test1T = Test1C Int
29− deriving (Generic, Show, Eq, Binary, NFData, Atomable)
30−
31−data Test2T = Test2C Int Int
32− deriving (Generic, Show, Eq, Binary, NFData, Atomable)
33−
34−data Test3T = Test3Ca | Test3Cb
35− deriving (Generic, Show, Eq, Binary, NFData, Atomable)
36−-}
3724-- | All database values ("atoms") adhere to the 'Atomable' typeclass. This class is derivable allowing new datatypes to be easily marshaling between Haskell values and database values.
38−class (Eq a, NFData a, Binary a, Show a) => Atomable a where
25+class (Eq a, NFData a, Serialise a, Show a) => Atomable a where
3926 toAtom :: a -> Atom
4027 default toAtom :: (Generic a, AtomableG (Rep a)) => a -> Atom
4128 toAtom v = toAtomG (from v) (toAtomTypeG (from v))
@@ -165,10 +152,6 @@ instance Atomable a => Atomable (NE.NonEmpty a) where
165152 toAtomType _ = ConstructedAtomType "NonEmptyList" (M.singleton "a" (toAtomType (Proxy :: Proxy a)))
166153 toAddTypeExpr _ = NoOperation
167154
168−#if !MIN_VERSION_binary(0,8,4)
169−instance Binary a => Binary (NE.NonEmpty a)
170−#endif
171−
172155-- Generics
173156class AtomableG g where
174157 --type AtomTG g
@@ -252,8 +235,9 @@ typeToTypeConstructor x@DayAtomType = PrimitiveTypeConstructor "Day" x
252235typeToTypeConstructor x@DateTimeAtomType = PrimitiveTypeConstructor "DateTime" x
253236typeToTypeConstructor x@ByteStringAtomType = PrimitiveTypeConstructor "ByteString" x
254237typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x
238+typeToTypeConstructor x@RelationalExprAtomType = PrimitiveTypeConstructor "RelationalExpr" x
255239typeToTypeConstructor (RelationAtomType attrs)
256− = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList attrs
240+ = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList (attributesVec attrs)
257241 where
258242 attrToAttrExpr (Attribute n t) = AttributeAndTypeNameExpr n (typeToTypeConstructor t) ()
259243typeToTypeConstructor (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+103−109
@@ -1,10 +1,12 @@
1−{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveFoldable, DeriveFunctor, DeriveTraversable #-}
1+{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveTraversable, DerivingVia, TemplateHaskell, TypeFamilies #-}
22{-# OPTIONS_GHC -fno-warn-orphans #-}
33
44module ProjectM36.Base where
55import ProjectM36.DatabaseContextFunctionError
66import ProjectM36.AtomFunctionError
7+import ProjectM36.MerkleHash
78
9+import Data.Functor.Foldable.TH
810import qualified Data.Map as M
911import qualified Data.HashSet as HS
1012import Data.Hashable (Hashable, hashWithSalt)
@@ -17,16 +19,17 @@ import GHC.Stack
1719import qualified Data.Vector as V
1820import qualified Data.List as L
1921import Data.Text (Text,unpack)
20−import Data.Binary
21−import Data.Vector.Binary()
2222import Data.Time.Clock
23−import Data.Time.Clock.POSIX
24−import Data.Time.Calendar (Day,toGregorian,fromGregorian)
2523import Data.Hashable.Time ()
24+import Data.Time.Calendar (Day)
2625import Data.Typeable
2726import Data.ByteString (ByteString)
2827import qualified Data.List.NonEmpty as NE
28+import Data.Vector.Instances ()
29+
2930type StringType = Text
31+
32+type DatabaseName = String
3033
3134-- | Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.
3235data Atom = IntegerAtom Integer |
@@ -38,8 +41,9 @@ data Atom = IntegerAtom Integer |
3841 ByteStringAtom ByteString |
3942 BoolAtom Bool |
4043 RelationAtom Relation |
44+ RelationalExprAtom RelationalExpr | --used for returning inc deps
4145 ConstructedAtom DataConstructorName AtomType [Atom]
42− deriving (Eq, Show, Binary, Typeable, NFData, Generic)
46+ deriving (Eq, Show, Typeable, NFData, Generic, Read)
4347
4448instance Hashable Atom where
4549 hashWithSalt salt (ConstructedAtom dConsName _ atoms) = salt `hashWithSalt` atoms
@@ -53,16 +57,7 @@ instance Hashable Atom where
5357 hashWithSalt salt (ByteStringAtom bs) = salt `hashWithSalt` bs
5458 hashWithSalt salt (BoolAtom b) = salt `hashWithSalt` b
5559 hashWithSalt salt (RelationAtom r) = salt `hashWithSalt` r
56−
57−instance Binary UTCTime where
58− put utc = put $ toRational (utcTimeToPOSIXSeconds utc)
59− get = posixSecondsToUTCTime . fromRational <$> (get :: Get Rational)
60−
61−instance Binary Day where
62− put day = put $ toGregorian day
63− get = do
64− (y,m,d) <- get :: Get (Integer, Int, Int)
65− return (fromGregorian y m d)
60+ hashWithSalt salt (RelationalExprAtom re) = salt `hashWithSalt` re
6661
6762-- 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.
6863-- | The AtomType uniquely identifies the type of a atom.
@@ -76,13 +71,15 @@ data AtomType = IntAtomType |
7671 BoolAtomType |
7772 RelationAtomType Attributes |
7873 ConstructedAtomType TypeConstructorName TypeVarMap |
74+ RelationalExprAtomType |
7975 TypeVariableType TypeVarName
8076 --wildcard used in Atom Functions and tuples for data constructors which don't provide all arguments to the type constructor
81− deriving (Eq, NFData, Generic, Binary, Show)
77+ deriving (Eq, NFData, Generic, Show, Read, Hashable)
8278
8379instance Ord AtomType where
8480 compare = undefined
85−
81+
82+-- this should probably be an ordered dictionary in order to be able to round-trip these arguments
8683type TypeVarMap = M.Map TypeVarName AtomType
8784
8885instance Hashable TypeVarMap where
@@ -97,25 +94,37 @@ isRelationAtomType _ = False
9794type AttributeName = StringType
9895
9996-- | A relation's type is composed of attribute names and types.
100−data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Generic, NFData, Binary)
97+data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Read, Generic, NFData)
10198
10299instance Hashable Attribute where
103100 hashWithSalt salt (Attribute attrName _) = hashWithSalt salt attrName
104101
102+type AttributesHash = Int
103+
105104-- | 'Attributes' represent the head of a relation.
106−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
107122
108−-- | Equality function for a set of attributes.
109−attributesEqual :: Attributes -> Attributes -> Bool
110−attributesEqual attrs1 attrs2 = attrsAsSet attrs1 == attrsAsSet attrs2
111− where
112− attrsAsSet = HS.fromList . V.toList
113−
114123sortedAttributesIndices :: Attributes -> [(Int, Attribute)]
115−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))
116125
117126-- | The relation's tuple set is the body of the relation.
118−newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic, Binary)
127+newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic, Read)
119128
120129instance Read Relation where
121130 readsPrec = error "relation read not supported"
@@ -131,8 +140,8 @@ instance NFData RelationTupleSet where rnf = genericRnf
131140instance Hashable RelationTuple where
132141 --sanity check the tuple for attribute and tuple counts
133142 --this bit me when tuples were being hashed before being verified
134− hashWithSalt salt (RelationTuple attrs tupVec) = if V.length attrs /= V.length tupVec then
135− 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))
136145 else
137146 salt `hashWithSalt`
138147 sortedAttrs `hashWithSalt`
@@ -143,25 +152,23 @@ instance Hashable RelationTuple where
143152 sortedTupVec = V.map (\(index, _) -> tupVec V.! index) $ V.fromList sortedAttrsIndices
144153
145154-- | A tuple is a set of attributes mapped to their 'Atom' values.
146−data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Generic)
147−
148−instance Binary RelationTuple
155+data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Read, Generic)
149156
150157instance Eq RelationTuple where
151− (==) tuple1@(RelationTuple attrs1 _) tuple2@(RelationTuple attrs2 _) = attributesEqual attrs1 attrs2 && atomsEqual
158+ tuple1@(RelationTuple attrs1 _) == tuple2@(RelationTuple attrs2 _) =
159+ attrs1 == attrs2 && atomsEqual
152160 where
153− atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) attrs of
161+ atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) (attributesVec attrs) of
154162 Nothing -> Nothing
155163 Just index -> tupVec V.!? index
156− 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)
157165
158166instance NFData RelationTuple where rnf = genericRnf
159167
160−
161168data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)
162169
163170instance Eq Relation where
164− Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attributesEqual attrs1 attrs2 && tupSet1 == tupSet2
171+ Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attrs1 == attrs2 && tupSet1 == tupSet2
165172
166173instance NFData Relation where rnf = genericRnf
167174
@@ -172,8 +179,6 @@ instance Hashable Relation where
172179 where
173180 sortedAttrs = map snd (sortedAttributesIndices attrs)
174181
175−instance Binary Relation
176−
177182-- | Used to represent the number of tuples in a relation.
178183data RelationCardinality = Countable | Finite Int deriving (Eq, Show, Generic, Ord)
179184
@@ -218,17 +223,15 @@ data RelationalExprBase a =
218223 --Summarize :: AtomExpr -> AttributeName -> RelationalExpr -> RelationalExpr -> RelationalExpr -- a special case of Extend
219224 --Evaluate relationalExpr with scoped views
220225 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)
221− deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)
222−
223−instance Binary RelationalExpr
226+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)
224227
228+instance Hashable RelationalExpr
229+
225230data WithNameExprBase a = WithNameExpr RelVarName a
226− deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)
231+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable, Hashable)
227232
228233type WithNameExpr = WithNameExprBase ()
229234
230−instance Binary WithNameExpr
231−
232235type GraphRefWithNameExpr = WithNameExprBase GraphRefTransactionMarker
233236
234237type NotificationName = StringType
@@ -240,22 +243,22 @@ data Notification = Notification {
240243 reportOldExpr :: RelationalExpr, --run the expression in the pre-change context
241244 reportNewExpr :: RelationalExpr --run the expression in the post-change context
242245 }
243− deriving (Show, Eq, Binary, Generic, NFData)
246+ deriving (Show, Eq, Generic, NFData)
244247
245248type TypeVarName = StringType
246249
247250-- | Metadata definition for type constructors such as @data Either a b@.
248251data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |
249252 PrimitiveTypeConstructorDef TypeConstructorName AtomType
250− deriving (Show, Generic, Binary, Eq, NFData)
253+ deriving (Show, Generic, Eq, NFData, Hashable, Read)
251254
252255-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int
253256type TypeConstructor = TypeConstructorBase ()
254257data TypeConstructorBase a = ADTypeConstructor TypeConstructorName [TypeConstructor] |
255− PrimitiveTypeConstructor TypeConstructorName AtomType |
256− RelationAtomTypeConstructor [AttributeExprBase a] |
257− TypeVariable TypeVarName
258− deriving (Show, Generic, Binary, Eq, NFData)
258+ PrimitiveTypeConstructor TypeConstructorName AtomType |
259+ RelationAtomTypeConstructor [AttributeExprBase a] |
260+ TypeVariable TypeVarName
261+ deriving (Show, Generic, Eq, NFData, Hashable, Read)
259262
260263type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]
261264
@@ -265,20 +268,20 @@ type DataConstructorName = StringType
265268type AtomTypeName = StringType
266269
267270-- | Used to define a data constructor in a type constructor context such as @Left a | Right b@
268−data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Binary, Generic, NFData)
271+data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Generic, NFData, Hashable, Read)
269272
270273type DataConstructorDefs = [DataConstructorDef]
271274
272275data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |
273276 DataConstructorDefTypeVarNameArg TypeVarName
274− deriving (Show, Generic, Binary, Eq, NFData)
277+ deriving (Show, Generic, Eq, NFData, Hashable, Read)
275278
276279type InclusionDependencies = M.Map IncDepName InclusionDependency
277280type RelationVariables = M.Map RelVarName GraphRefRelationalExpr
278281
279282data GraphRefTransactionMarker = TransactionMarker TransactionId |
280283 UncommittedContextMarker
281− deriving (Eq, Show, Binary, Generic, NFData, Ord)
284+ deriving (Eq, Show, Generic, NFData, Ord)
282285
283286-- a fundamental relational expr to which other relational expressions compile
284287type GraphRefRelationalExpr = RelationalExprBase GraphRefTransactionMarker
@@ -289,17 +292,18 @@ type Subschemas = M.Map SchemaName Schema
289292
290293-- | Every transaction has one concrete database context and any number of isomorphic subschemas.
291294data Schemas = Schemas DatabaseContext Subschemas
295+ deriving (Generic)
292296
293297-- | The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time.
294298-- I spent some time thinking about whether the VirtualDatabaseContext/Schema and DatabaseContext data constructors should be the same constructor, but that would allow relation variables to be created in a "virtual" context which would appear to defeat the isomorphisms of the contexts. It should be possible to switch to an alternative schema to view the same equivalent information without information loss. However, allowing all contexts to reference another context while maintaining its own relation variables, new types, etc. could be interesting from a security perspective. For example, if a user creates a new relvar in a virtual context, then does it necessarily appear in all linked contexts? After deliberation, I think the relvar should appear in *all* linked contexts to retain the isomorphic properties, even when the isomorphism is for a subset of the context. This hints that the IsoMorphs should allow for "fall-through"; that is, when a relvar is not defined in the virtual context (for morphing), then the lookup should fall through to the underlying context.
295299newtype Schema = Schema SchemaIsomorphs
296− deriving (Generic, Binary)
300+ deriving (Generic)
297301
298302data SchemaIsomorph = IsoRestrict RelVarName RestrictionPredicateExpr (RelVarName, RelVarName) |
299303 IsoRename RelVarName RelVarName |
300304 IsoUnion (RelVarName, RelVarName) RestrictionPredicateExpr RelVarName --maps two relvars to one relvar
301305 -- IsoTypeConstructor in morphAttrExpr
302− deriving (Generic, Binary, Show)
306+ deriving (Generic, Show)
303307
304308type SchemaIsomorphs = [SchemaIsomorph]
305309
@@ -315,9 +319,7 @@ data DatabaseContext = DatabaseContext {
315319type IncDepName = StringType
316320
317321-- | Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.
318−data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData)
319−
320−instance Binary InclusionDependency
322+data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData, Hashable, Read)
321323
322324type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr
323325
@@ -326,9 +328,9 @@ type DatabaseContextExprName = StringType
326328
327329type DatabaseContextExpr = DatabaseContextExprBase ()
328330
329−type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker
331+instance Hashable DatabaseContextExpr
330332
331−instance Binary GraphRefDatabaseContextExpr
333+type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker
332334
333335-- | Database context expressions modify the database context.
334336data DatabaseContextExprBase a =
@@ -357,9 +359,10 @@ data DatabaseContextExprBase a =
357359 ExecuteDatabaseContextFunction DatabaseContextFunctionName [AtomExprBase a] |
358360
359361 MultipleExpr [DatabaseContextExprBase a]
360− deriving (Show, Eq, Generic)
362+ deriving (Show, Read, Eq, Generic, NFData)
361363
362−instance Binary DatabaseContextExpr
364+instance Hashable (M.Map AttributeName AtomExpr) where
365+ hashWithSalt salt m = salt `hashWithSalt` M.toList m
363366
364367type ObjModuleName = StringType
365368type ObjFunctionName = StringType
@@ -371,7 +374,7 @@ data DatabaseContextIOExprBase a =
371374 AddDatabaseContextFunction DatabaseContextFunctionName [TypeConstructor] DatabaseContextFunctionBodyScript |
372375 LoadDatabaseContextFunctions ObjModuleName ObjFunctionName FilePath |
373376 CreateArbitraryRelation RelVarName [AttributeExprBase a] Range
374− deriving (Show, Eq, Generic, Binary)
377+ deriving (Show, Eq, Generic)
375378
376379type GraphRefDatabaseContextIOExpr = DatabaseContextIOExprBase GraphRefTransactionMarker
377380
@@ -379,6 +382,8 @@ type DatabaseContextIOExpr = DatabaseContextIOExprBase ()
379382
380383type RestrictionPredicateExpr = RestrictionPredicateExprBase ()
381384
385+instance Hashable RestrictionPredicateExpr
386+
382387type GraphRefRestrictionPredicateExpr = RestrictionPredicateExprBase GraphRefTransactionMarker
383388
384389-- | Restriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.
@@ -390,9 +395,7 @@ data RestrictionPredicateExprBase a =
390395 RelationalExprPredicate (RelationalExprBase a) | --type must be same as true and false relations (no attributes)
391396 AtomExprPredicate (AtomExprBase a) | --atom must evaluate to boolean
392397 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple
393− deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)
394−
395−instance Binary RestrictionPredicateExpr
398+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)
396399
397400-- child + parent links
398401-- | 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.
@@ -402,6 +405,7 @@ type TransactionHeads = M.Map HeadName Transaction
402405
403406-- | The transaction graph is the global database's state which references every committed transaction.
404407data TransactionGraph = TransactionGraph TransactionHeads (S.Set Transaction)
408+ deriving Generic
405409
406410transactionHeadsForGraph :: TransactionGraph -> TransactionHeads
407411transactionHeadsForGraph (TransactionGraph hs _) = hs
@@ -413,7 +417,8 @@ transactionsForGraph (TransactionGraph _ ts) = ts
413417-- The `TransactionDiff`s represent child/edge relationships to previous transactions (branches or continuations of the same branch).
414418data TransactionInfo = TransactionInfo {
415419 parents :: TransactionParents,
416− stamp :: UTCTime
420+ stamp :: UTCTime,
421+ merkleHash :: MerkleHash
417422 } deriving (Show, Generic)
418423
419424type TransactionParents = NE.NonEmpty TransactionId
@@ -423,12 +428,11 @@ data TransactionInfo = TransactionInfo TransactionId TransactionDiffs UTCTime |
423428 deriving (Show, Generic)
424429-}
425430
426−instance Binary TransactionInfo
427−
428431-- | Every set of modifications made to the database are atomically committed to the transaction graph as a transaction.
429432type TransactionId = UUID
430433
431434data Transaction = Transaction TransactionId TransactionInfo Schemas
435+ deriving Generic
432436
433437-- | The disconnected transaction represents an in-progress workspace used by sessions before changes are committed. This is similar to git's "index". After a transaction is committed, it is "connected" in the transaction graph and can no longer be modified.
434438data DisconnectedTransaction = DisconnectedTransaction TransactionId Schemas DirtyFlag
@@ -452,6 +456,8 @@ instance Ord Transaction where
452456
453457type AtomExpr = AtomExprBase ()
454458
459+instance Hashable AtomExpr
460+
455461type GraphRefAtomExpr = AtomExprBase GraphRefTransactionMarker
456462
457463-- | An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.
@@ -460,18 +466,17 @@ data AtomExprBase a = AttributeAtomExpr AttributeName |
460466 FunctionAtomExpr AtomFunctionName [AtomExprBase a] a |
461467 RelationAtomExpr (RelationalExprBase a) |
462468 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a
463− deriving (Eq,Show,Generic, NFData, Foldable, Functor, Traversable)
469+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)
464470
465−instance Binary AtomExpr
466−
467471-- | Used in tuple creation when creating a relation.
468472data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)
469− deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)
473+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)
470474
471475type ExtendTupleExpr = ExtendTupleExprBase ()
472−type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker
473476
474−instance Binary ExtendTupleExpr
477+instance Hashable ExtendTupleExpr
478+
479+type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker
475480
476481--enumerates the list of functions available to be run as part of tuple expressions
477482type AtomFunctions = HS.HashSet AtomFunction
@@ -483,6 +488,7 @@ type AtomFunctionBodyScript = StringType
483488type AtomFunctionBodyType = [Atom] -> Either AtomFunctionError Atom
484489
485490data AtomFunctionBody = AtomFunctionBody (Maybe AtomFunctionBodyScript) AtomFunctionBodyType
491+ deriving Generic
486492
487493instance NFData AtomFunctionBody where
488494 rnf (AtomFunctionBody mScript _) = rnf mScript
@@ -517,14 +523,17 @@ data AttributeNamesBase a = AttributeNames (S.Set AttributeName) |
517523 UnionAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |
518524 IntersectAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |
519525 RelationalExprAttributeNames (RelationalExprBase a) -- use attribute names from the relational expression's type
520− 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
521532
522533type AttributeNames = AttributeNamesBase ()
523534
524535type GraphRefAttributeNames = AttributeNamesBase GraphRefTransactionMarker
525536
526−instance Binary AttributeNames
527−
528537-- | The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.
529538data PersistenceStrategy = NoPersistence | -- ^ no filesystem persistence/memory-only database
530539 MinimalPersistence FilePath | -- ^ fsync off, not crash-safe
@@ -537,27 +546,27 @@ type GraphRefAttributeExpr = AttributeExprBase GraphRefTransactionMarker
537546-- | Create attributes dynamically.
538547data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |
539548 NakedAttributeExpr Attribute
540− deriving (Eq, Show, Generic, Binary, NFData, Foldable, Functor, Traversable)
549+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable, Hashable)
541550
542551-- | Dynamically create a tuple from attribute names and 'AtomExpr's.
543552newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))
544− deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)
545−
546−instance Binary TupleExpr
553+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)
554+
555+instance Hashable TupleExpr
547556
548557type TupleExpr = TupleExprBase ()
549558
550559type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker
551560
552561data TupleExprsBase a = TupleExprs a [TupleExprBase a]
553− deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)
562+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)
563+
564+instance Hashable TupleExprs
554565
555566type GraphRefTupleExprs = TupleExprsBase GraphRefTransactionMarker
556567
557568type TupleExprs = TupleExprsBase ()
558569
559−instance Binary TupleExprs
560−
561570data MergeStrategy =
562571 -- | After a union merge, the merge transaction is a result of union'ing relvars of the same name, introducing all uniquely-named relvars, union of constraints, union of atom functions, notifications, and types (unless the names and definitions collide, e.g. two types of the same name with different definitions)
563572 UnionMergeStrategy |
@@ -565,7 +574,7 @@ data MergeStrategy =
565574 UnionPreferMergeStrategy HeadName |
566575 -- | Similar to the our/theirs merge strategy in git, the merge transaction's context is identical to that of the last transaction in the selected branch.
567576 SelectedBranchMergeStrategy HeadName
568− deriving (Eq, Show, Binary, Generic, NFData)
577+ deriving (Eq, Show, Generic, NFData)
569578
570579type DatabaseContextFunctionName = StringType
571580
@@ -602,7 +611,8 @@ attrTypeVars (Attribute _ aType) = case aType of
602611 DateTimeAtomType -> S.empty
603612 ByteStringAtomType -> S.empty
604613 BoolAtomType -> S.empty
605− (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList attrs))
614+ RelationalExprAtomType -> S.empty
615+ (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList (attributesVec attrs)))
606616 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap
607617 (TypeVariableType nam) -> S.singleton nam
608618
@@ -625,28 +635,12 @@ atomTypeVars DayAtomType = S.empty
625635atomTypeVars DateTimeAtomType = S.empty
626636atomTypeVars ByteStringAtomType = S.empty
627637atomTypeVars BoolAtomType = S.empty
628−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)))
629640atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap
630641atomTypeVars (TypeVariableType nam) = S.singleton nam
631642
632643unimplemented :: HasCallStack => a
633−unimplemented = undefined
634−
635−--for serializing GraphRefRelationalExpr as part of transaction serialization
636−instance Binary (TupleExprsBase GraphRefTransactionMarker)
637−
638−instance Binary (TupleExprBase GraphRefTransactionMarker)
639−
640−instance Binary GraphRefRelationalExpr
641−
642−instance Binary (AtomExprBase GraphRefTransactionMarker)
643−
644−instance Binary (AttributeNamesBase GraphRefTransactionMarker)
645−
646−instance Binary (RestrictionPredicateExprBase GraphRefTransactionMarker)
647−
648−instance Binary (ExtendTupleExprBase GraphRefTransactionMarker)
649−
650−instance Binary GraphRefWithNameExpr
644+unimplemented = error "unimplemented"
651645
652−
646+makeBaseFunctor ''RelationalExprBase
src/lib/ProjectM36/Client.hs+186−298
@@ -1,4 +1,4 @@
1−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, ScopedTypeVariables, BangPatterns, MonoLocalBinds #-}
1+{-# LANGUAGE DeriveGeneric, ScopedTypeVariables, MonoLocalBinds, DerivingVia #-}
22{-|
33Module: ProjectM36.Client
44
@@ -9,6 +9,7 @@ module ProjectM36.Client
99 Connection(..),
1010 Port,
1111 Hostname,
12+ ServiceName,
1213 DatabaseName,
1314 ConnectionError(..),
1415 connectProjectM36,
@@ -43,6 +44,7 @@ module ProjectM36.Client
4344 defaultDatabaseName,
4445 defaultRemoteConnectionInfo,
4546 defaultHeadName,
47+ addClientNode,
4648 PersistenceStrategy(..),
4749 RelationalExpr,
4850 RelationalExprBase(..),
@@ -53,11 +55,9 @@ module ProjectM36.Client
5355 Attribute(..),
5456 MergeStrategy(..),
5557 attributesFromList,
56− createNodeId,
5758 createSessionAtCommit,
5859 createSessionAtHead,
5960 closeSession,
60− addClientNode,
6161 callTestTimeout_,
6262 RelationCardinality(..),
6363 TransactionGraphOperator(..),
@@ -67,7 +67,6 @@ module ProjectM36.Client
6767 TransGraphRelationalExpr,
6868 TransactionIdLookup(..),
6969 TransactionIdHeadBacktrack(..),
70− NodeId(..),
7170 Atom(..),
7271 Session,
7372 SessionId,
@@ -80,6 +79,7 @@ module ProjectM36.Client
8079 databaseContextExprForUniqueKey,
8180 databaseContextExprForForeignKey,
8281 createScriptedAtomFunction,
82+ ProjectM36.Client.validateMerkleHashes,
8383 AttributeExprBase(..),
8484 TypeConstructorBase(..),
8585 TypeConstructorDef(..),
@@ -106,6 +106,7 @@ module ProjectM36.Client
106106 ) where
107107import ProjectM36.Base hiding (inclusionDependencies) --defined in this module as well
108108import qualified ProjectM36.Base as B
109+import ProjectM36.Serialise.Error ()
109110import ProjectM36.Error
110111import ProjectM36.Atomable
111112import ProjectM36.AtomFunction as AF
@@ -118,7 +119,7 @@ import Control.Monad.State
118119import qualified ProjectM36.RelationalExpression as RE
119120import ProjectM36.DatabaseContext (basicDatabaseContext)
120121import qualified ProjectM36.TransactionGraph as Graph
121−import ProjectM36.TransactionGraph
122+import ProjectM36.TransactionGraph as TG
122123import qualified ProjectM36.Transaction as Trans
123124import ProjectM36.TransactionGraph.Persist
124125import ProjectM36.Attribute
@@ -133,28 +134,16 @@ import ProjectM36.Relation (typesAsRelation)
133134import ProjectM36.ScriptSession (initScriptSession, ScriptSession)
134135import qualified ProjectM36.Relation as R
135136import Control.Exception.Base
136−import GHC.Conc.Sync
137−
138−import Network.Transport (Transport(closeTransport))
139−#if MIN_VERSION_network_transport_tcp(0,7,0)
140−import Network.Transport.TCP (createTransport, defaultTCPParameters, defaultTCPAddr)
141−import Network.Transport.TCP.Internal (encodeEndPointAddress)
142−#elif MIN_VERSION_network_transport_tcp(0,6,0)
143−import Network.Transport.TCP (createTransport, defaultTCPParameters)
144−import Network.Transport.TCP.Internal (encodeEndPointAddress)
145−#else
146−import Network.Transport.TCP (encodeEndPointAddress, createTransport, defaultTCPParameters)
147−#endif
137+import Control.Concurrent.STM
138+import Control.Concurrent.Async
148139
149−import Control.Distributed.Process.Node (newLocalNode, initRemoteTable, runProcess, LocalNode, forkProcess, closeLocalNode)
150−import Control.Distributed.Process.Extras.Internal.Types (whereisRemote)
151−import Control.Distributed.Process.ManagedProcess.Client (call, safeCall)
152140import Data.Either (isRight)
153141import Data.UUID.V4 (nextRandom)
154142import Data.Word
155−import Control.Distributed.Process (ProcessId, Process, receiveWait, send, match, NodeId(..), reconnect)
143+import Data.Hashable
156144import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)
157145import Control.Concurrent.MVar
146+import Codec.Winery hiding (Schema, schema)
158147import qualified Data.Map as M
159148#if MIN_VERSION_stm_containers(1,0,0)
160149import qualified StmContainers.Map as StmMap
@@ -166,19 +155,19 @@ import qualified STMContainers.Set as StmSet
166155import qualified ProjectM36.Session as Sess
167156import ProjectM36.Session
168157import ProjectM36.Sessions
169−import Data.Binary (Binary)
170158import GHC.Generics (Generic)
171159import Control.DeepSeq (force)
172160import System.IO
173161import Data.Time.Clock
174−import Data.Typeable
162+import qualified Network.RPC.Curryer.Client as RPC
163+import qualified Network.RPC.Curryer.Server as RPC
164+import Network.Socket (Socket, AddrInfo(..), getAddrInfo, defaultHints, AddrInfoFlag(..), SocketType(..), ServiceName, hostAddressToTuple, SockAddr(..))
165+import GHC.Conc (unsafeIOToSTM)
175166
176167type Hostname = String
177168
178169type Port = Word16
179170
180−type DatabaseName = String
181−
182171-- | The type for notifications callbacks in the client. When a registered notification fires due to a changed relational expression evaluation, the server propagates the notifications to the clients in the form of the callback.
183172type NotificationCallback = NotificationName -> EvaluatedNotification -> IO ()
184173
@@ -198,15 +187,16 @@ data RequestTimeoutException = RequestTimeoutException
198187
199188instance Exception RequestTimeoutException
200189
201−-- | Construct a 'ConnectionInfo' to describe how to make the 'Connection'. The database can be run within the current process or running remotely via distributed-process.
202−data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCallback [GhcPkgPath]|
203− RemoteProcessConnectionInfo DatabaseName NodeId NotificationCallback
190+-- | Construct a 'ConnectionInfo' to describe how to make the 'Connection'. The database can be run within the current process or running remotely via RPC.
191+data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCallback [GhcPkgPath] |
192+ RemoteConnectionInfo DatabaseName Hostname ServiceName NotificationCallback
204193
205194type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification
206195
207196-- | Used for callbacks from the server when monitored changes have been made.
208197newtype NotificationMessage = NotificationMessage EvaluatedNotifications
209− deriving (Binary, Eq, Show, Generic)
198+ deriving (Eq, Show, Generic)
199+ deriving Serialise via WineryVariant NotificationMessage
210200
211201-- | When a notification is fired, the 'reportOldExpr' is evaluated in the commit's pre-change context while the 'reportNewExpr' is evaluated in the post-change context and they are returned along with the original notification.
212202data EvaluatedNotification = EvaluatedNotification {
@@ -214,13 +204,10 @@ data EvaluatedNotification = EvaluatedNotification {
214204 reportOldRelation :: Either RelationalError Relation,
215205 reportNewRelation :: Either RelationalError Relation
216206 }
217− deriving(Binary, Eq, Show, Generic)
207+ deriving (Eq, Show, Generic)
208+ deriving Serialise via WineryRecord EvaluatedNotification
218209
219210
220−-- | Create a 'NodeId' for use in connecting to a remote server using distributed-process.
221−createNodeId :: Hostname -> Port -> NodeId
222−createNodeId host port = NodeId $ encodeEndPointAddress host (show port) 1
223−
224211-- | Use this for connecting to remote servers on the default port.
225212defaultServerPort :: Port
226213defaultServerPort = 6543
@@ -235,82 +222,36 @@ defaultHeadName = "master"
235222
236223-- | Create a connection configuration which connects to the localhost on the default server port and default server database name. The configured notification callback is set to ignore all events.
237224defaultRemoteConnectionInfo :: ConnectionInfo
238−defaultRemoteConnectionInfo = RemoteProcessConnectionInfo defaultDatabaseName (createNodeId "127.0.0.1" defaultServerPort) emptyNotificationCallback
225+defaultRemoteConnectionInfo =
226+ RemoteConnectionInfo defaultDatabaseName defaultServerHostname (show defaultServerPort) emptyNotificationCallback
239227
240−-- | The 'Connection' represents either local or remote access to a database. All operations flow through the connection.
241−type ClientNodes = StmSet.Set ProcessId
228+defaultServerHostname :: Hostname
229+defaultServerHostname = "localhost"
242230
243−-- internal structure specific to in-process connections
244−data InProcessConnectionConf = InProcessConnectionConf {
245− ipPersistenceStrategy :: PersistenceStrategy,
246− ipClientNodes :: ClientNodes,
247− ipSessions :: Sessions,
248− ipTransactionGraph :: TVar TransactionGraph,
249− ipScriptSession :: Maybe ScriptSession,
250− ipLocalNode :: LocalNode,
251− ipTransport :: Transport, -- we hold onto this so that we can close it gracefully
252− ipLocks :: Maybe (LockFile, MVar LockFileHash) -- nothing when NoPersistence
253− }
254−
255−data RemoteProcessConnectionConf = RemoteProcessConnectionConf {
256− rLocalNode :: LocalNode,
257− rProcessId :: ProcessId, --remote processId
258− rTransport :: Transport --the TCP socket transport
259− }
231+newtype RemoteConnectionConf = RemoteConnectionConf RPC.Connection
260232
261233data Connection = InProcessConnection InProcessConnectionConf |
262− RemoteProcessConnection RemoteProcessConnectionConf
234+ RemoteConnection RemoteConnectionConf
263235
264236-- | There are several reasons why a connection can fail.
265237data ConnectionError = SetupDatabaseDirectoryError PersistenceError |
266238 IOExceptionError IOException |
267239 NoSuchDatabaseByNameError DatabaseName |
240+ DatabaseValidationError [MerkleValidationError] |
268241 LoginError
269242 deriving (Show, Eq, Generic)
270243
271244remoteDBLookupName :: DatabaseName -> String
272245remoteDBLookupName = (++) "db-"
273246
274−createLocalNode :: IO (LocalNode, Transport)
275−createLocalNode = do
276−#if MIN_VERSION_network_transport_tcp(0,7,0)
277− eLocalTransport <- createTransport (defaultTCPAddr "127.0.0.1" "0") defaultTCPParameters
278−#elif MIN_VERSION_network_transport_tcp(0,6,0)
279− eLocalTransport <- createTransport "127.0.0.1" "0" (\sn -> ("127.0.0.1", sn)) defaultTCPParameters
280−#else
281− eLocalTransport <- createTransport "127.0.0.1" "0" defaultTCPParameters
282−#endif
283− case eLocalTransport of
284− Left err -> error ("failed to create transport: " ++ show err)
285− Right localTransport -> do
286− localNode <- newLocalNode localTransport initRemoteTable
287− pure (localNode, localTransport)
288−
289−notificationListener :: NotificationCallback -> Process ()
290−notificationListener callback = do
291− --pid <- getSelfPid
292− --liftIO $ putStrLn $ "LISTENER THREAD START " ++ show pid
293− _ <- forever $
294− receiveWait [
295− match (\(NotificationMessage eNots) ->
296− --say $ "NOTIFICATION: " ++ show eNots
297− -- when notifications are thrown, they are not adjusted for the current schema which could be problematic, but we don't have access to the current session here
298− liftIO $ mapM_ (uncurry callback) (M.toList eNots)
299− )
300− ]
301− --say "LISTENER THREAD EXIT"
302− pure ()
303−
304−startNotificationListener :: LocalNode -> NotificationCallback -> IO ProcessId
305−startNotificationListener localNode callback = forkProcess localNode (notificationListener callback)
306−
307247createScriptSession :: [String] -> IO (Maybe ScriptSession)
308248createScriptSession ghcPkgPaths = do
309249 eScriptSession <- initScriptSession ghcPkgPaths
310250 case eScriptSession of
311− 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
312252 Right s -> pure (Just s)
313253
254+
314255-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.
315256connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)
316257--create a new in-memory database/transaction graph
@@ -325,42 +266,63 @@ connectProjectM36 (InProcessConnectionInfo strat notificationCallback ghcPkgPath
325266 graphTvar <- newTVarIO freshGraph
326267 clientNodes <- StmSet.newIO
327268 sessions <- StmMap.newIO
328− (localNode, transport) <- createLocalNode
329− notificationPid <- startNotificationListener localNode notificationCallback
330269 mScriptSession <- createScriptSession ghcPkgPaths
331−
270+ notifAsync <- startNotificationListener clientNodes notificationCallback
332271 let conn = InProcessConnection InProcessConnectionConf {
333272 ipPersistenceStrategy = strat,
334273 ipClientNodes = clientNodes,
335274 ipSessions = sessions,
336275 ipTransactionGraph = graphTvar,
337276 ipScriptSession = mScriptSession,
338− ipLocalNode = localNode,
339− ipTransport = transport,
340− ipLocks = Nothing}
341− addClientNode conn notificationPid
277+ ipLocks = Nothing,
278+ ipCallbackAsync = notifAsync
279+ }
342280 pure (Right conn)
343281 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths
344282 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths
345283
346−connectProjectM36 (RemoteProcessConnectionInfo databaseName serverNodeId notificationCallback) = do
347− connStatus <- newEmptyMVar
348− (localNode, transport) <- createLocalNode
349− let dbName = remoteDBLookupName databaseName
350− --putStrLn $ "Connecting to " ++ show serverNodeId ++ " " ++ dbName
351− notificationListenerPid <- startNotificationListener localNode notificationCallback
352− runProcess localNode $ do
353− --even a failed connection retains an open socket!
354− mServerProcessId <- whereisRemote serverNodeId dbName
355− case mServerProcessId of
356− Nothing -> liftIO $ putMVar connStatus $ Left (NoSuchDatabaseByNameError databaseName)
357− Just serverProcessId -> do
358− loginConfirmation <- safeLogin (Login notificationListenerPid) serverProcessId
359− if not loginConfirmation then
360− liftIO $ putMVar connStatus (Left LoginError)
361− else
362− liftIO $ putMVar connStatus (Right $ RemoteProcessConnection RemoteProcessConnectionConf {rLocalNode = localNode, rProcessId = serverProcessId, rTransport = transport})
363− takeMVar connStatus
284+connectProjectM36 (RemoteConnectionInfo dbName hostName servicePort notificationCallback) = do
285+ --TODO- add notification callback thread
286+ let resolutionHints = defaultHints { addrFlags = [AI_NUMERICHOST, AI_NUMERICSERV],
287+ addrSocketType = Stream
288+ }
289+ resolved <- getAddrInfo (Just resolutionHints) (Just hostName) (Just servicePort)
290+ case resolved of
291+ [] -> error ("DNS resolution failed for" <> hostName <> ":" <> servicePort)
292+ addrInfo:_ -> do
293+ --supports IPv4 only for now
294+ let (SockAddrInet port addr) = addrAddress addrInfo
295+ notificationHandlers =
296+ [RPC.ClientAsyncRequestHandler $
297+ \(NotificationMessage notifications') ->
298+ forM_ (M.toList notifications') (uncurry notificationCallback)
299+ ]
300+ let connectExcHandler (e :: IOException) = pure $ Left (IOExceptionError e)
301+ eConn <- (Right <$> RPC.connect notificationHandlers (hostAddressToTuple addr) port) `catch` connectExcHandler
302+ case eConn of
303+ Left err -> pure (Left err)
304+ Right conn -> do
305+ eRet <- RPC.call conn (Login dbName)
306+ case eRet of
307+ Left err -> error (show err)
308+ Right False -> error "wtf"
309+ Right True ->
310+ --TODO handle connection errors!
311+ pure (Right (RemoteConnection (RemoteConnectionConf conn)))
312+
313+--convert RPC errors into exceptions
314+convertRPCErrors :: RPC.ConnectionError -> IO a
315+convertRPCErrors err =
316+ case err of
317+ RPC.TimeoutError -> throw RequestTimeoutException
318+ RPC.CodecError msg -> error $ "decoding message failed on server: " <> msg
319+ RPC.ExceptionError msg -> error $ "server threw exception: " <> msg
320+
321+addClientNode :: Connection -> RPC.Locking Socket -> IO ()
322+addClientNode (RemoteConnection _) _ = error "addClientNode called on remote connection"
323+addClientNode (InProcessConnection conf) lockSock = atomically (StmSet.insert clientInfo (ipClientNodes conf))
324+ where
325+ clientInfo = RemoteClientInfo lockSock
364326
365327connectPersistentProjectM36 :: PersistenceStrategy ->
366328 DiskSync ->
@@ -379,32 +341,40 @@ connectPersistentProjectM36 strat sync dbdir freshGraph notificationCallback ghc
379341 case graph of
380342 Left err' -> return $ Left (SetupDatabaseDirectoryError err')
381343 Right graph' -> do
382− tvarGraph <- newTVarIO graph'
383− sessions <- StmMap.newIO
384− clientNodes <- StmSet.newIO
385− (localNode, transport) <- createLocalNode
386− lockMVar <- newMVar digest
387− let conn = InProcessConnection InProcessConnectionConf {
344+ case TG.validateMerkleHashes graph' of
345+ Left merkleErrs -> pure (Left (DatabaseValidationError merkleErrs))
346+ Right _ -> do
347+ tvarGraph <- newTVarIO graph'
348+ sessions <- StmMap.newIO
349+ clientNodes <- StmSet.newIO
350+ lockMVar <- newMVar digest
351+ notifAsync <- startNotificationListener clientNodes notificationCallback
352+ let conn = InProcessConnection InProcessConnectionConf {
388353 ipPersistenceStrategy = strat,
389354 ipClientNodes = clientNodes,
390355 ipSessions = sessions,
391356 ipTransactionGraph = tvarGraph,
392357 ipScriptSession = mScriptSession,
393− ipLocalNode = localNode,
394− ipTransport = transport,
395− ipLocks = Just (lockFileH, lockMVar)
358+ ipLocks = Just (lockFileH, lockMVar),
359+ ipCallbackAsync = notifAsync
396360 }
361+ pure (Right conn)
362+
363+--startup local async process to handle notification callbacks
364+startNotificationListener :: ClientNodes -> NotificationCallback -> IO (Async ())
365+startNotificationListener cNodes notificationCallback = do
366+ inProcessClientInfo@(InProcessClientInfo notifMVar) <- InProcessClientInfo <$> newEmptyMVar
367+ atomically $ StmSet.insert inProcessClientInfo cNodes
368+ async $ forever $ do
369+ notifs <- takeMVar notifMVar
370+ forM_ (M.toList notifs) $ uncurry notificationCallback
397371
398− notificationPid <- startNotificationListener localNode notificationCallback
399− addClientNode conn notificationPid
400− pure (Right conn)
401−
402372-- | Create a new session at the transaction id and return the session's Id.
403373createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)
404374createSessionAtCommit conn@(InProcessConnection _) commitId = do
405375 newSessionId <- nextRandom
406376 atomically $ createSessionAtCommit_ commitId newSessionId conn
407−createSessionAtCommit conn@(RemoteProcessConnection _) uuid = remoteCall conn (CreateSessionAtCommit uuid)
377+createSessionAtCommit conn@(RemoteConnection _) uuid = remoteCall conn (CreateSessionAtCommit uuid)
408378
409379createSessionAtCommit_ :: TransactionId -> SessionId -> Connection -> STM (Either RelationalError SessionId)
410380createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do
@@ -421,7 +391,7 @@ createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do
421391 Nothing -> do
422392 StmMap.insert (Session freshDiscon defaultSchemaName) newSessionId sessions
423393 pure $ Right newSessionId
424−createSessionAtCommit_ _ _ (RemoteProcessConnection _) = error "createSessionAtCommit_ called on remote connection"
394+createSessionAtCommit_ _ _ (RemoteConnection _) = error "createSessionAtCommit_ called on remote connection"
425395
426396-- | Call 'createSessionAtHead' with a transaction graph's head's name to create a new session pinned to that head. This function returns a 'SessionId' which can be used in other function calls to reference the point in the transaction graph.
427397createSessionAtHead :: Connection -> HeadName -> IO (Either RelationalError SessionId)
@@ -433,22 +403,18 @@ createSessionAtHead conn@(InProcessConnection conf) headn = do
433403 case transactionForHead headn graph of
434404 Nothing -> pure $ Left (NoSuchHeadNameError headn)
435405 Just trans -> createSessionAtCommit_ (transactionId trans) newSessionId conn
436−createSessionAtHead conn@(RemoteProcessConnection _) headn = remoteCall conn (CreateSessionAtHead headn)
437−
438−-- | Used internally for server connections to keep track of remote nodes for the purpose of sending notifications later.
439−addClientNode :: Connection -> ProcessId -> IO ()
440−addClientNode (RemoteProcessConnection _) _ = error "addClientNode called on remote connection"
441−addClientNode (InProcessConnection conf) newProcessId = atomically (StmSet.insert newProcessId (ipClientNodes conf))
406+createSessionAtHead conn@(RemoteConnection _) headn = remoteCall conn (CreateSessionAtHead headn)
442407
443408-- | Discards a session, eliminating any uncommitted changes present in the session.
444409closeSession :: SessionId -> Connection -> IO ()
445410closeSession sessionId (InProcessConnection conf) =
446411 atomically $ StmMap.delete sessionId (ipSessions conf)
447−closeSession sessionId conn@(RemoteProcessConnection _) = remoteCall conn (CloseSession sessionId)
412+closeSession sessionId conn@(RemoteConnection _) = remoteCall conn (CloseSession sessionId)
448413
449414-- | 'close' cleans up the database access connection and closes any relevant sockets.
450415close :: Connection -> IO ()
451416close (InProcessConnection conf) = do
417+ cancel (ipCallbackAsync conf)
452418 atomically $ do
453419 let sessions = ipSessions conf
454420#if MIN_VERSION_stm_containers(1,0,0)
@@ -457,22 +423,18 @@ close (InProcessConnection conf) = do
457423 StmMap.deleteAll sessions
458424#endif
459425 pure ()
460− closeLocalNode (ipLocalNode conf)
461− closeTransport (ipTransport conf)
462426 let mLocks = ipLocks conf
463427 case mLocks of
464428 Nothing -> pure ()
465429 Just (lockFileH, _) -> closeLockFile lockFileH
466430
467−close conn@(RemoteProcessConnection conf) = do
468− _ <- remoteCall conn Logout :: IO Bool
469− closeLocalNode (rLocalNode conf)
470− closeTransport (rTransport conf)
431+close (RemoteConnection (RemoteConnectionConf conn)) =
432+ RPC.close conn
471433
472434--used only by the server EntryPoints
473435closeRemote_ :: Connection -> IO ()
474436closeRemote_ (InProcessConnection _) = error "invalid call of closeRemote_ on InProcessConnection"
475−closeRemote_ (RemoteProcessConnection conf) = runProcess (rLocalNode conf) (reconnect (rProcessId conf))
437+closeRemote_ (RemoteConnection (RemoteConnectionConf conn)) = RPC.close conn
476438
477439 --we need to actually close the localNode's connection to the remote
478440--within the database server, we must catch and handle all exception lest they take down the database process- this handling might be different for other use-cases
@@ -483,35 +445,15 @@ excEither = handle handler
483445 where
484446 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc
485447 | otherwise = pure (Left (UnhandledExceptionError (show exc)))
486−
487−runProcessResult :: LocalNode -> Process a -> IO a
488−runProcessResult localNode proc = do
489− ret <- newEmptyMVar
490− runProcess localNode $ do
491− val <- proc
492− liftIO $ putMVar ret val
493− takeMVar ret
494−
495−safeLogin :: Login -> ProcessId -> Process Bool
496−safeLogin login procId = do
497− ret <- call procId login
498− case ret of
499− Left (_ :: ServerError) -> pure False
500− Right val -> pure val
501448
502−remoteCall :: (Binary a, Binary b, Typeable a, Typeable b) => Connection -> a -> IO b
449+
450+remoteCall :: (Serialise a, Serialise b) => Connection -> a -> IO b
503451remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"
504−remoteCall (RemoteProcessConnection conf) arg = runProcessResult localNode $ do
505− ret <- safeCall serverProcessId arg
506− case ret of
507− Left err -> error ("server died: " ++ show err)
508− Right ret' -> case ret' of
509− Left RequestTimeoutError -> liftIO (throwIO RequestTimeoutException)
510− Left (ProcessDiedError _) -> liftIO (throwIO RemoteProcessDiedException)
511− Right val -> pure val
512− where
513− localNode = rLocalNode conf
514− serverProcessId = rProcessId conf
452+remoteCall (RemoteConnection (RemoteConnectionConf rpcConn)) arg = do
453+ eRet <- RPC.call rpcConn arg
454+ case eRet of
455+ Left err -> convertRPCErrors err
456+ Right val -> pure val
515457
516458sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)
517459sessionForSessionId sessionId sessions =
@@ -546,7 +488,7 @@ currentSchemaName sessionId (InProcessConnection conf) = atomically $ do
546488 case eSession of
547489 Left err -> pure (Left err)
548490 Right session -> pure (Right (Sess.schemaName session))
549−currentSchemaName sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveCurrentSchemaName sessionId)
491+currentSchemaName sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveCurrentSchemaName sessionId)
550492
551493-- | Switch to the named isomorphic schema.
552494setCurrentSchemaName :: SessionId -> Connection -> SchemaName -> IO (Either RelationalError ())
@@ -558,7 +500,7 @@ setCurrentSchemaName sessionId (InProcessConnection conf) sname = atomically $ d
558500 Right session -> case Sess.setSchemaName sname session of
559501 Left err -> pure (Left err)
560502 Right newSession -> StmMap.insert newSession sessionId sessions >> pure (Right ())
561−setCurrentSchemaName sessionId conn@(RemoteProcessConnection _) sname = remoteCall conn (ExecuteSetCurrentSchema sessionId sname)
503+setCurrentSchemaName sessionId conn@(RemoteConnection _) sname = remoteCall conn (ExecuteSetCurrentSchema sessionId sname)
562504
563505-- | Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.
564506executeRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)
@@ -582,7 +524,7 @@ executeRelationalExpr sessionId (InProcessConnection conf) expr = excEither $ at
582524 Right rel -> pure (force (Right rel)) -- this is necessary so that any undefined/error exceptions are spit out here
583525 Left err -> pure (Left err)
584526
585−executeRelationalExpr sessionId conn@(RemoteProcessConnection _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)
527+executeRelationalExpr sessionId conn@(RemoteConnection _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)
586528
587529-- | Execute a database context expression in the context of the session and connection. Database expressions modify the current session's disconnected transaction but cannot modify the transaction graph.
588530executeDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())
@@ -616,7 +558,7 @@ executeDatabaseContextExpr sessionId (InProcessConnection conf) expr = excEither
616558 newSession = Session newDiscon (Sess.schemaName session)
617559 StmMap.insert newSession sessionId sessions
618560 pure (Right ())
619−executeDatabaseContextExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)
561+executeDatabaseContextExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)
620562
621563-- | Similar to a git rebase, 'autoMergeToHead' atomically creates a temporary branch and merges it to the latest commit of the branch referred to by the 'HeadName' and commits the merge. This is useful to reduce incidents of 'TransactionIsNotAHeadError's but at the risk of merge errors (thus making it similar to rebasing). Alternatively, as an optimization, if a simple commit is possible (meaning that the head has not changed), then a fast-forward commit takes place instead.
622564autoMergeToHead :: SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())
@@ -645,7 +587,7 @@ autoMergeToHead sessionId (InProcessConnection conf) strat headName' = do
645587 Left err -> pure (Left err)
646588 Right ((discon', graph'), transactionIdsAdded) ->
647589 pure (Right (discon', graph', transactionIdsAdded))
648−autoMergeToHead sessionId conn@(RemoteProcessConnection _) strat headName' = remoteCall conn (ExecuteAutoMergeToHead sessionId strat headName')
590+autoMergeToHead sessionId conn@(RemoteConnection _) strat headName' = remoteCall conn (ExecuteAutoMergeToHead sessionId strat headName')
649591
650592-- | Execute a database context IO-monad-based expression for the given session and connection. `DatabaseContextIOExpr`s modify the DatabaseContext but cannot be purely implemented.
651593--this is almost completely identical to executeDatabaseContextExpr above
@@ -671,22 +613,8 @@ executeDatabaseContextIOExpr sessionId (InProcessConnection conf) expr = excEith
671613 context' = RE.dbc_context newState
672614 atomically $ StmMap.insert newSession sessionId sessions
673615 pure (Right ())
674−executeDatabaseContextIOExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)
616+executeDatabaseContextIOExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)
675617
676−{-
677−executeGraphExprSTM_ :: TransactionId -> SessionId -> Session -> Sessions -> TransactionGraphOperator -> TransactionGraph -> TVar TransactionGraph -> STM (Either RelationalError (TransactionGraph, DisconnectedTransaction)
678−executeGraphExprSTM_ freshId sessionId session sessions graphExpr graph graphTVar= do
679− case evalGraphOp freshId (Sess.disconnectedTransaction session) graph graphExpr of
680− Left err -> do
681− when updateGraphOnError (writeTVar graphTVar graph)
682− pure $ Left err
683− Right (discon', graph') -> do
684− writeTVar graphTVar graph'
685− let newSession = Session discon' (Sess.schemaName session)
686− STMMap.insert newSession sessionId sessions
687− pure $ Right graph'
688−-}
689−
690618-- process notifications for commits
691619executeCommitExprSTM_
692620 :: TransactionGraph
@@ -727,78 +655,8 @@ executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do
727655 --if freshId appears in the graph, then we need to pass it on
728656 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]
729657 pure (Right (discon', graph', transIds))
730−{-
731−executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do
732− let strat = ipPersistenceStrategy conf
733− clientNodes = ipClientNodes conf
734− sessions = ipSessions conf
735− graphTvar = ipTransactionGraph conf
736− mLockFileH = ipLocks conf
737− lockHandler body = case graphExpr of
738− Commit -> case mLockFileH of
739− Nothing -> body False
740− Just (lockFileH, lockMVar) -> let acquireLocks = do
741− lastWrittenDigest <- takeMVar lockMVar
742− lockFile lockFileH WriteLock
743− latestDigest <- readGraphTransactionIdDigest strat
744− pure (latestDigest /= lastWrittenDigest)
745−
746− releaseLocks _ = do
747− --still holding the lock- get the latest digest
748− gDigest <- readGraphTransactionIdDigest strat
749− unlockFile lockFileH
750− putMVar lockMVar gDigest
751− in bracket acquireLocks releaseLocks body
752− _ -> body False
753− freshId <- nextRandom
754− lockHandler $ \dbWrittenByOtherProcess -> do
755− --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
756− --read transaction data and compare to existing graph
757− --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)
758− manip <- atomically $ do
759− eSession <- sessionForSessionId sessionId sessions
760− --handle graph update by other process
761− oldGraph <- readTVar graphTvar
762− case eSession of
763− Left err -> pure (Left err)
764− Right session -> do
765− let mScriptSession = ipScriptSession conf
766− dbdir = case strat of
767− MinimalPersistence x -> x
768− CrashSafePersistence x -> x
769− _ -> error "accessing dbdir on non-persisted connection"
770− eRefreshedGraph <- if dbWrittenByOtherProcess then
771− unsafeIOToSTM (transactionGraphLoad dbdir oldGraph mScriptSession)
772− else
773− pure (Right oldGraph)
774− case eRefreshedGraph of
775− Left err -> pure (Left (DatabaseLoadError err))
776− Right refreshedGraph -> do
777− --snip it
778− eGraph <- executeGraphExprSTM_ dbWrittenByOtherProcess freshId sessionId session sessions graphExpr refreshedGraph graphTvar
779− --snip it
780− case eGraph of
781− Left err -> pure (Left err)
782− Right newGraph -> do
783− --handle commit
784− if isCommit graphExpr then do
785− case transactionForId (Sess.parentId session) oldGraph of
786− Left err -> pure $ Left err
787− Right previousTrans -> do
788− (evaldNots, nodes) <- executeCommitExprSTM_ (Trans.concreteDatabaseContext previousTrans) (Sess.concreteDatabaseContext session) clientNodes
789− nodesToNotify <- toList (StmSet.stream nodes)
790− pure $ Right (evaldNots, nodesToNotify, newGraph)
791− else
792− pure $ Right (M.empty, [], newGraph)
793− case manip of
794− Left err -> return $ Just err
795− Right (notsToFire, nodesToNotify, newGraph) -> do
796− --update filesystem database, if necessary
797− processTransactionGraphPersistence strat newGraph
798− sendNotifications nodesToNotify (ipLocalNode conf) notsToFire
799− pure Nothing
800−-}
801−executeGraphExpr sessionId conn@(RemoteProcessConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)
658+
659+executeGraphExpr sessionId conn@(RemoteConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)
802660
803661-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.
804662executeTransGraphRelationalExpr :: SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)
@@ -806,10 +664,7 @@ executeTransGraphRelationalExpr _ (InProcessConnection conf) tgraphExpr = excEit
806664 let graphTvar = ipTransactionGraph conf
807665 graph <- readTVar graphTvar
808666 pure $ force $ optimizeAndEvalTransGraphRelationalExpr graph tgraphExpr
809−{- case runReader (RE.evalRelationalExpr relExpr) (RE.mkRelationalExprState DBC.empty) of
810− Left err -> pure (Left err)
811− Right rel -> pure (force (Right rel))-}
812−executeTransGraphRelationalExpr sessionId conn@(RemoteProcessConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)
667+executeTransGraphRelationalExpr sessionId conn@(RemoteConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)
813668
814669-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.
815670executeSchemaExpr :: SessionId -> Connection -> Schema.SchemaExpr -> IO (Either RelationalError ())
@@ -832,23 +687,24 @@ executeSchemaExpr sessionId (InProcessConnection conf) schemaExpr = atomically $
832687 newSession = Session (DisconnectedTransaction (Discon.parentId discon) newSchemas False) (Sess.schemaName session)
833688 StmMap.insert newSession sessionId sessions
834689 pure (Right ())
835−executeSchemaExpr sessionId conn@(RemoteProcessConnection _) schemaExpr = remoteCall conn (ExecuteSchemaExpr sessionId schemaExpr)
690+executeSchemaExpr sessionId conn@(RemoteConnection _) schemaExpr = remoteCall conn (ExecuteSchemaExpr sessionId schemaExpr)
836691
837692-- | After modifying a 'DatabaseContext', 'commit' the transaction to the transaction graph at the head which the session is referencing. This will also trigger checks for any notifications which need to be propagated.
838693commit :: SessionId -> Connection -> IO (Either RelationalError ())
839694commit sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Commit
840−commit sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Commit)
841−
842−sendNotifications :: [ProcessId] -> LocalNode -> EvaluatedNotifications -> IO ()
843−sendNotifications pids localNode nots = mapM_ sendNots pids
844− where
845− sendNots remoteClientPid =
846− unless (M.null nots) $ runProcess localNode $ send remoteClientPid (NotificationMessage nots)
847−
695+commit sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Commit)
696+
697+sendNotifications :: [ClientInfo] -> EvaluatedNotifications -> IO ()
698+sendNotifications clients notifs =
699+ unless (M.null notifs) $ forM_ clients sender
700+ where
701+ sender (RemoteClientInfo sock) = RPC.sendMessage sock (NotificationMessage notifs)
702+ sender (InProcessClientInfo tvar) = putMVar tvar notifs
703+
848704-- | 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.
849705rollback :: SessionId -> Connection -> IO (Either RelationalError ())
850706rollback sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Rollback
851−rollback sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)
707+rollback sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)
852708
853709-- | Write the transaction graph to disk. This function can be used to incrementally write new transactions to disk.
854710processTransactionGraphPersistence :: PersistenceStrategy -> [TransactionId] -> TransactionGraph -> IO ()
@@ -864,7 +720,7 @@ readGraphTransactionIdDigest (CrashSafePersistence dbdir) = readGraphTransaction
864720-- | Return a relation whose type would match that of the relational expression if it were executed. This is useful for checking types and validating a relational expression's types.
865721typeForRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)
866722typeForRelationalExpr sessionId conn@(InProcessConnection _) relExpr = atomically $ typeForRelationalExprSTM sessionId conn relExpr
867−typeForRelationalExpr sessionId conn@(RemoteProcessConnection _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)
723+typeForRelationalExpr sessionId conn@(RemoteConnection _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)
868724
869725typeForRelationalExprSTM :: SessionId -> Connection -> RelationalExpr -> STM (Either RelationalError Relation)
870726typeForRelationalExprSTM sessionId (InProcessConnection conf) relExpr = do
@@ -901,7 +757,7 @@ inclusionDependencies sessionId (InProcessConnection conf) = do
901757 else
902758 pure (Schema.inclusionDependenciesInSchema schema (B.inclusionDependencies context))
903759
904−inclusionDependencies sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveInclusionDependencies sessionId)
760+inclusionDependencies sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveInclusionDependencies sessionId)
905761
906762typeConstructorMapping :: SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)
907763typeConstructorMapping sessionId (InProcessConnection conf) = do
@@ -912,7 +768,7 @@ typeConstructorMapping sessionId (InProcessConnection conf) = do
912768 Left err -> pure $ Left err
913769 Right (session, _) -> --warning, no schema support for typeconstructors
914770 pure (Right (B.typeConstructorMapping (Sess.concreteDatabaseContext session)))
915−typeConstructorMapping sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveTypeConstructorMapping sessionId)
771+typeConstructorMapping sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveTypeConstructorMapping sessionId)
916772
917773-- | Return an optimized database expression which is logically equivalent to the input database expression. This function can be used to determine which expression will actually be evaluated.
918774planForDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)
@@ -932,7 +788,7 @@ planForDatabaseContextExpr sessionId (InProcessConnection conf) dbExpr = do
932788 else -- don't show any optimization because the current optimization infrastructure relies on access to the base context- this probably underscores the need for each schema to have its own DatabaseContext, even if it is generated on-the-fly-}
933789 pure (Left NonConcreteSchemaPlanError)
934790
935−planForDatabaseContextExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)
791+planForDatabaseContextExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)
936792
937793-- | Return a relation which represents the current state of the global transaction graph. The attributes are
938794-- * current- boolean attribute representing whether or not the current session references this transaction
@@ -950,7 +806,7 @@ transactionGraphAsRelation sessionId (InProcessConnection conf) = do
950806 Right session ->
951807 graphAsRelation (Sess.disconnectedTransaction session) <$> readTVar tvar
952808
953−transactionGraphAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveTransactionGraph sessionId)
809+transactionGraphAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveTransactionGraph sessionId)
954810
955811-- | Returns the names and types of the relation variables in the current 'Session'.
956812relationVariablesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)
@@ -972,7 +828,7 @@ relationVariablesAsRelation sessionId (InProcessConnection conf) = do
972828 let schemaContext = context {relationVariables = relvars }
973829 pure $ RE.relationVariablesAsRelation schemaContext graph
974830
975−relationVariablesAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)
831+relationVariablesAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)
976832
977833-- | Returns the names and types of the atom functions in the current 'Session'.
978834atomFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)
@@ -985,7 +841,7 @@ atomFunctionsAsRelation sessionId (InProcessConnection conf) = do
985841 Right (session, _) ->
986842 pure (AF.atomFunctionsAsRelation (atomFunctions (concreteDatabaseContext session)))
987843
988−atomFunctionsAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveAtomFunctionSummary sessionId)
844+atomFunctionsAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveAtomFunctionSummary sessionId)
989845
990846databaseContextFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)
991847databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do
@@ -997,7 +853,7 @@ databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do
997853 Right (session, _) ->
998854 pure (DCF.databaseContextFunctionsAsRelation (dbcFunctions (concreteDatabaseContext session)))
999855
1000−databaseContextFunctionsAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveDatabaseContextFunctionSummary sessionId)
856+databaseContextFunctionsAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveDatabaseContextFunctionSummary sessionId)
1001857
1002858-- | Returns the transaction id for the connection's disconnected transaction committed parent transaction.
1003859headTransactionId :: SessionId -> Connection -> IO (Either RelationalError TransactionId)
@@ -1008,7 +864,7 @@ headTransactionId sessionId (InProcessConnection conf) = do
1008864 case eSession of
1009865 Left err -> pure (Left err)
1010866 Right session -> pure $ Right (Sess.parentId session)
1011−headTransactionId sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveHeadTransactionId sessionId)
867+headTransactionId sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveHeadTransactionId sessionId)
1012868
1013869headNameSTM_ :: SessionId -> Sessions -> TVar TransactionGraph -> STM (Either RelationalError HeadName)
1014870headNameSTM_ sessionId sessions graphTvar = do
@@ -1028,7 +884,7 @@ headName sessionId (InProcessConnection conf) = do
1028884 let sessions = ipSessions conf
1029885 graphTvar = ipTransactionGraph conf
1030886 atomically (headNameSTM_ sessionId sessions graphTvar)
1031−headName sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteHeadName sessionId)
887+headName sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteHeadName sessionId)
1032888
1033889-- | Returns a listing of all available atom types.
1034890atomTypesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)
@@ -1042,7 +898,7 @@ atomTypesAsRelation sessionId (InProcessConnection conf) = do
1042898 case typesAsRelation (B.typeConstructorMapping (Sess.concreteDatabaseContext session)) of
1043899 Left err -> pure (Left err)
1044900 Right rel -> pure (Right rel)
1045−atomTypesAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)
901+atomTypesAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)
1046902
1047903disconnectedTransactionIsDirty :: SessionId -> Connection -> IO (Either RelationalError Bool)
1048904disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do
@@ -1053,12 +909,12 @@ disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do
1053909 Left err -> pure (Left err)
1054910 Right session ->
1055911 pure (Right (isDirty session))
1056−disconnectedTransactionIsDirty sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveSessionIsDirty sessionId)
912+disconnectedTransactionIsDirty sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveSessionIsDirty sessionId)
1057913
1058914--used only for testing- we expect this to throw an exception
1059915callTestTimeout_ :: SessionId -> Connection -> IO Bool
1060916callTestTimeout_ _ (InProcessConnection _) = error "bad testing call"
1061−callTestTimeout_ sessionId conn@(RemoteProcessConnection _) = remoteCall conn (TestTimeout sessionId)
917+callTestTimeout_ sessionId conn@(RemoteConnection _) = remoteCall conn (TestTimeout sessionId)
1062918
1063919--used in tests only
1064920transactionGraph_ :: Connection -> IO TransactionGraph
@@ -1143,15 +999,8 @@ commitLock_ sessionId conf stmBlock = do
1143999 Right (notsToFire, nodesToNotify, newGraph, transactionIdsToPersist) -> do
11441000 --update filesystem database, if necessary
11451001 processTransactionGraphPersistence strat transactionIdsToPersist newGraph
1146− sendNotifications nodesToNotify (ipLocalNode conf) notsToFire
1002+ sendNotifications nodesToNotify notsToFire
11471003 pure (Right ())
1148−{-
1149−writeDisconAndGraph_ :: TVar TransactionGraph -> SessionId -> Session -> Sessions -> DisconnectedTransaction -> TransactionGraph -> STM ()
1150−writeDisconAndGraph_ graphTvar sessionId session sessions discon graph = do
1151− writeTVar graphTvar graph
1152− let newSession = Session discon (Sess.schemaName session)
1153− StmMap.insert newSession sessionId sessions
1154−-}
11551004
11561005-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.
11571006withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)
@@ -1203,5 +1052,44 @@ executeDataFrameExpr sessionId conn@(InProcessConnection _) dfExpr = do
12031052 let dFrame' = maybe dFrame (`DF.drop'` dFrame) (DF.offset dfExpr)
12041053 dFrame'' = maybe dFrame' (`DF.take'` dFrame') (DF.limit dfExpr)
12051054 pure (Right dFrame'')
1206−executeDataFrameExpr sessionId conn@(RemoteProcessConnection _) dfExpr = remoteCall conn (ExecuteDataFrameExpr sessionId dfExpr)
1055+executeDataFrameExpr sessionId conn@(RemoteConnection _) dfExpr = remoteCall conn (ExecuteDataFrameExpr sessionId dfExpr)
12071056
1057+validateMerkleHashes :: SessionId -> Connection -> IO (Either RelationalError ())
1058+validateMerkleHashes sessionId (InProcessConnection conf) = do
1059+ let sessions = ipSessions conf
1060+ atomically $ do
1061+ eSession <- sessionForSessionId sessionId sessions
1062+ case eSession of
1063+ Left err -> pure (Left err)
1064+ Right _ -> do
1065+ graph <- readTVar (ipTransactionGraph conf)
1066+ case Graph.validateMerkleHashes graph of
1067+ Left merkleErrs -> pure $ Left $ someErrors (map (\(MerkleValidationError tid expected actual) -> MerkleHashValidationError tid expected actual) merkleErrs)
1068+ Right () -> pure (Right ())
1069+validateMerkleHashes sessionId conn@RemoteConnection{} = remoteCall conn (ExecuteValidateMerkleHashes sessionId)
1070+
1071+type ClientNodes = StmSet.Set ClientInfo
1072+
1073+-- internal structure specific to in-process connections
1074+data InProcessConnectionConf = InProcessConnectionConf {
1075+ ipPersistenceStrategy :: PersistenceStrategy,
1076+ ipClientNodes :: ClientNodes,
1077+ ipSessions :: Sessions,
1078+ ipTransactionGraph :: TVar TransactionGraph,
1079+ ipScriptSession :: Maybe ScriptSession,
1080+ ipLocks :: Maybe (LockFile, MVar LockFileHash), -- nothing when NoPersistence
1081+ ipCallbackAsync :: Async ()
1082+ }
1083+
1084+-- clients may connect associate one socket/mvar with the server to register for change callbacks
1085+data ClientInfo = RemoteClientInfo (RPC.Locking Socket) |
1086+ InProcessClientInfo (MVar EvaluatedNotifications)
1087+
1088+instance Eq ClientInfo where
1089+ (RemoteClientInfo a) == (RemoteClientInfo b) = RPC.lockless a == RPC.lockless b
1090+ (InProcessClientInfo a) == (InProcessClientInfo b) = a == b
1091+ _ == _ = False
1092+
1093+instance Hashable ClientInfo where
1094+ hashWithSalt salt (RemoteClientInfo sock) = hashWithSalt salt (show (RPC.lockless sock))
1095+ hashWithSalt salt (InProcessClientInfo _) = hashWithSalt salt (1::Int)
src/lib/ProjectM36/DataFrame.hs+21−14
@@ -1,8 +1,8 @@
1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}
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
@@ -16,15 +16,19 @@ import qualified Data.List as L
1616import qualified Data.Set as S
1717import Data.Maybe
1818import qualified Data.Text as T
19−import Data.Binary
2019import Control.Arrow
2120#if __GLASGOW_HASKELL__ < 804
2221import Data.Monoid
2322#endif
2423
25−data AttributeOrderExpr = AttributeOrderExpr AttributeName Order deriving (Show, Generic, Binary)
26−data AttributeOrder = AttributeOrder AttributeName Order deriving (Show, Generic, Binary)
27−data Order = AscendingOrder | DescendingOrder deriving (Eq, Show, Generic, Binary)
24+data AttributeOrderExpr = AttributeOrderExpr AttributeName Order
25+ deriving (Show, Generic)
26+
27+data AttributeOrder = AttributeOrder AttributeName Order
28+ deriving (Show, Generic)
29+
30+data Order = AscendingOrder | DescendingOrder
31+ deriving (Eq, Show, Generic)
2832
2933ascending :: T.Text
3034ascending = "⬆"
@@ -39,9 +43,11 @@ data DataFrame = DataFrame {
3943 orders :: [AttributeOrder],
4044 attributes :: Attributes,
4145 tuples :: [DataFrameTuple]
42− } deriving (Show, Generic, Binary)
46+ }
47+ deriving (Show, Generic)
4348
44−data DataFrameTuple = DataFrameTuple Attributes (V.Vector Atom) deriving (Eq, Show, Generic, Binary)
49+data DataFrameTuple = DataFrameTuple Attributes (V.Vector Atom)
50+ deriving (Eq, Show, Generic)
4551
4652sortDataFrameBy :: [AttributeOrder] -> DataFrame -> Either RelationalError DataFrame
4753sortDataFrameBy attrOrders frame = do
@@ -75,7 +81,7 @@ compareTupleByOneAttributeName attr tuple1 tuple2 =
7581 Right atom2 -> compareAtoms atom1 atom2
7682
7783atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom
78−atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of
84+atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of
7985 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))
8086 Just index -> case tupVec V.!? index of
8187 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))
@@ -122,17 +128,18 @@ data DataFrameExpr = DataFrameExpr {
122128 orderExprs :: [AttributeOrderExpr],
123129 offset :: Maybe Integer,
124130 limit :: Maybe Integer
125− } deriving (Show, Binary, Generic)
131+ }
132+ deriving (Show, Generic)
126133
127134dataFrameAsHTML :: DataFrame -> T.Text
128135-- 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
129136dataFrameAsHTML df
130− | length (tuples df) == 1 && L.null (attributes df) = style <>
137+ | length (tuples df) == 1 && A.null (attributes df) = style <>
131138 tablestart <>
132139 "<tr><th></th></tr>" <>
133140 "<tr><td></td></tr>" <>
134141 tablefooter <> "</table>"
135− | L.null (tuples df) && L.null (attributes df) = style <>
142+ | L.null (tuples df) && A.null (attributes df) = style <>
136143 tablestart <>
137144 "<tr><th></th></tr>" <>
138145 tablefooter <>
@@ -155,7 +162,7 @@ tuplesAsHTML = foldr folder ""
155162 folder tuple acc = acc <> tupleAsHTML tuple
156163
157164tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]
158−tupleAssocs (DataFrameTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)
165+tupleAssocs (DataFrameTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)
159166
160167
161168tupleAsHTML :: DataFrameTuple -> T.Text
@@ -167,7 +174,7 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>
167174 atomAsHTML atom = atomToText atom
168175
169176attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text
170−attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"
177+attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"
171178 where
172179 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"
173180 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/DatabaseContext.hs+17−2
@@ -1,11 +1,15 @@
11module ProjectM36.DatabaseContext where
22import ProjectM36.Base
3+import Control.Monad (void)
34import qualified Data.Map as M
45import qualified Data.HashSet as HS
56import ProjectM36.DataTypes.Basic
67import ProjectM36.AtomFunctions.Basic
7−import ProjectM36.DatabaseContextFunction
88import ProjectM36.Relation
9+import qualified Data.ByteString.Lazy as BL
10+import ProjectM36.AtomFunction as AF
11+import ProjectM36.DatabaseContextFunction as DBCF
12+import Codec.Winery
913
1014empty :: DatabaseContext
1115empty = DatabaseContext { inclusionDependencies = M.empty,
@@ -17,7 +21,7 @@ empty = DatabaseContext { inclusionDependencies = M.empty,
1721
1822-- | Remove TransactionId markers on GraphRefRelationalExpr
1923stripGraphRefRelationalExpr :: GraphRefRelationalExpr -> RelationalExpr
20−stripGraphRefRelationalExpr = fmap (const ())
24+stripGraphRefRelationalExpr = void
2125
2226-- | convert an existing database context into its constituent expression.
2327databaseContextAsDatabaseContextExpr :: DatabaseContext -> DatabaseContextExpr
@@ -37,3 +41,14 @@ basicDatabaseContext = DatabaseContext { inclusionDependencies = M.empty,
3741 notifications = M.empty,
3842 typeConstructorMapping = basicTypeConstructorMapping
3943 }
44+
45+--for building the Merkle hash
46+hashBytes :: DatabaseContext -> BL.ByteString
47+hashBytes ctx = BL.fromChunks [incDeps, rvs, nots, tConsMap] <> atomFs <> dbcFs
48+ where
49+ incDeps = serialise (inclusionDependencies ctx)
50+ rvs = serialise (relationVariables ctx)
51+ atomFs = HS.foldr (mappend . AF.hashBytes) mempty (atomFunctions ctx)
52+ dbcFs = HS.foldr (mappend . DBCF.hashBytes) mempty (dbcFunctions ctx)
53+ nots = serialise (notifications ctx)
54+ tConsMap = serialise (typeConstructorMapping ctx)
src/lib/ProjectM36/DatabaseContextFunction.hs+12−1
@@ -3,6 +3,7 @@ module ProjectM36.DatabaseContextFunction where
33--implements functions which operate as: [Atom] -> DatabaseContextExpr -> Either RelationalError DatabaseContextExpr
44import ProjectM36.Base
55import ProjectM36.Error
6+import ProjectM36.Serialise.Base ()
67import ProjectM36.Attribute as A
78import ProjectM36.Relation
89import ProjectM36.AtomType
@@ -10,6 +11,8 @@ import qualified Data.HashSet as HS
1011import qualified Data.Map as M
1112import ProjectM36.ScriptSession
1213import qualified Data.Text as T
14+import qualified Data.ByteString.Lazy as BL
15+import Codec.Winery
1316
1417emptyDatabaseContextFunction :: DatabaseContextFunctionName -> DatabaseContextFunction
1518emptyDatabaseContextFunction name = DatabaseContextFunction {
@@ -77,4 +80,12 @@ databaseContextFunctionsAsRelation dbcFuncs = mkRelationFromList attrs tups
7780 dbcFuncToTuple func = [TextAtom (dbcFuncName func),
7881 TextAtom (dbcTextType (dbcFuncType func))]
7982 dbcTextType typ = T.intercalate " -> " (map prettyAtomType typ ++ ["DatabaseContext", "DatabaseContext"])
80−
83+
84+-- for merkle hash
85+hashBytes :: DatabaseContextFunction -> BL.ByteString
86+hashBytes func = BL.fromChunks [fname, ftype, fbody]
87+ where
88+ fname = serialise (dbcFuncName func)
89+ ftype = serialise (dbcFuncType func)
90+ fbody = case dbcFuncBody func of
91+ DatabaseContextFunctionBody mBody _ -> serialise mBody
src/lib/ProjectM36/DatabaseContextFunctionError.hs+1−2
@@ -1,9 +1,8 @@
11{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}
22module ProjectM36.DatabaseContextFunctionError where
33import GHC.Generics
4−import Data.Binary
54import Control.DeepSeq
65
76{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}
87data DatabaseContextFunctionError = DatabaseContextFunctionUserError String
9− deriving (Generic, Eq, Show, Binary, NFData)
8+ deriving (Generic, Eq, Show, NFData)
src/lib/ProjectM36/Error.hs+19−14
@@ -1,6 +1,7 @@
11{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}
22module ProjectM36.Error where
33import ProjectM36.Base
4+import ProjectM36.MerkleHash
45import ProjectM36.DatabaseContextFunctionError
56import ProjectM36.AtomFunctionError
67import qualified Data.Set as S
@@ -8,7 +9,6 @@ import Control.DeepSeq (NFData, rnf)
89import Control.DeepSeq.Generics (genericRnf)
910import GHC.Generics (Generic)
1011import qualified Data.Text as T
11−import Data.Binary
1212import Data.Typeable
1313import Control.Exception
1414
@@ -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
@@ -101,14 +101,16 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)
101101
102102 | NoUncommittedContextInEvalError
103103 | TupleExprsReferenceMultipleMarkersError
104−
104+
105+ | MerkleHashValidationError TransactionId MerkleHash MerkleHash
106+
105107 | MultipleErrors [RelationalError]
106− deriving (Show,Eq,Generic,Binary,Typeable, NFData)
108+ deriving (Show,Eq,Generic,Typeable, NFData)
107109
108110data PersistenceError = InvalidDirectoryError FilePath |
109111 MissingTransactionError TransactionId |
110112 WrongDatabaseFormatVersionError String String
111− deriving (Show, Eq, Generic, Binary, NFData)
113+ deriving (Show, Eq, Generic, NFData)
112114
113115--collapse list of errors into normal error- if there is just one, just return one
114116someErrors :: [RelationalError] -> RelationalError
@@ -126,7 +128,7 @@ data MergeError = SelectedHeadMismatchMergeError |
126128 StrategyViolatesComponentMergeError | --failed merge in inc deps, relvars, etc.
127129 StrategyViolatesRelationVariableMergeError |
128130 StrategyViolatesTypeConstructorMergeError
129− deriving (Show, Eq, Generic, Binary, Typeable)
131+ deriving (Show, Eq, Generic, Typeable)
130132
131133instance NFData MergeError where rnf = genericRnf
132134
@@ -134,17 +136,20 @@ data ScriptCompilationError = TypeCheckCompilationError String String | --expect
134136 SyntaxErrorCompilationError String |
135137 ScriptCompilationDisabledError |
136138 OtherScriptCompilationError String
137− deriving (Show, Eq, Generic, Binary, Typeable, NFData)
139+ deriving (Show, Eq, Generic, Typeable, NFData)
138140
139141instance Exception ScriptCompilationError
140142
141143data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |
142144 RelVarInReferencedMoreThanOnce RelVarName |
143145 RelVarOutReferencedMoreThanOnce RelVarName
144− deriving (Show, Eq, Generic, Binary, Typeable, NFData)
145−
146−
147−-- errors returned from the distributed-process call handlers
148−data ServerError = RequestTimeoutError |
149− ProcessDiedError String
150− deriving (Generic, Binary, Eq)
146+ deriving (Show, Eq, Generic, Typeable, NFData)
147+
148+
149+data ImportError' = InvalidSHA256Error T.Text
150+ | SHA256MismatchError T.Text T.Text
151+ | InvalidFileURIError T.Text
152+ | ImportFileDecodeError T.Text
153+ | ImportFileError T.Text
154+ | ImportDownloadError T.Text
155+ deriving (Show, Eq, Generic, Typeable, NFData)
src/lib/ProjectM36/GraphRefRelationalExpr.hs+6−9
@@ -26,15 +26,12 @@ instance Monoid SingularTransactionRef where
2626
2727-- | return `Just transid` if this GraphRefRelationalExpr refers to just one transaction in the graph. This is useful for determining if certain optimizations can apply.
2828singularTransaction :: Foldable t => t GraphRefTransactionMarker -> SingularTransactionRef
29−singularTransaction expr =
30− if S.null transSet then
31− NoTransactionsRef
32− else if S.size transSet == 1 then
33− SingularTransactionRef (head (S.toList transSet))
34− else
35− MultipleTransactionsRef
29+singularTransaction expr
30+ | S.null transSet = NoTransactionsRef
31+ | S.size transSet == 1 = SingularTransactionRef (head (S.toList transSet))
32+ | otherwise = MultipleTransactionsRef
3633 where
37− transSet = foldr (\transId acc -> S.insert transId acc) S.empty expr
34+ transSet = foldr S.insert S.empty expr
3835
3936-- | Return True if two 'GraphRefRelationalExpr's both refer exclusively to the same transaction (or none at all).
4037inSameTransaction :: GraphRefRelationalExpr -> GraphRefRelationalExpr -> Maybe GraphRefTransactionMarker
@@ -45,4 +42,4 @@ inSameTransaction exprA exprB = case (stA, stB) of
4542 stB = singularTransaction exprB
4643
4744singularTransactions :: (Foldable f, Foldable t) => f (t GraphRefTransactionMarker) -> SingularTransactionRef
48−singularTransactions fs = foldMap singularTransaction fs
45+singularTransactions = foldMap singularTransaction
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+2−4
@@ -1,4 +1,4 @@
1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, LambdaCase #-}
1+{-# LANGUAGE DeriveGeneric, LambdaCase, DerivingVia #-}
22module ProjectM36.IsomorphicSchema where
33import ProjectM36.Base
44import ProjectM36.Error
@@ -9,7 +9,6 @@ import ProjectM36.RelationalExpression
99import qualified ProjectM36.AttributeNames as AN
1010import Control.Monad
1111import GHC.Generics
12−import Data.Binary
1312import qualified Data.Map as M
1413import qualified Data.Set as S
1514import qualified Data.List as L
@@ -28,8 +27,7 @@ import Data.Monoid
2827
2928data SchemaExpr = AddSubschema SchemaName SchemaIsomorphs |
3029 RemoveSubschema SchemaName
31− deriving (Generic, Binary, Show)
32−
30+ deriving (Generic, Show)
3331
3432isomorphs :: Schema -> SchemaIsomorphs
3533isomorphs (Schema i) = i
src/lib/ProjectM36/MerkleHash.hsnew file+9
@@ -0,0 +1,9 @@
1+{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveGeneric, DerivingVia #-}
2+module ProjectM36.MerkleHash where
3+import Data.ByteString (ByteString)
4+import GHC.Generics
5+import Control.DeepSeq (NFData)
6+
7+newtype MerkleHash = MerkleHash { _unMerkleHash :: ByteString }
8+ deriving (Show, Eq, Generic, Monoid, Semigroup, NFData)
9+
src/lib/ProjectM36/NormalizeExpr.hs+1−1
@@ -121,7 +121,7 @@ processTupleExprs (TupleExprs () tupleExprs) = do
121121 TupleExprs marker <$> mapM processTupleExpr tupleExprs
122122
123123processTupleExpr :: TupleExpr -> ProcessExprM GraphRefTupleExpr
124−processTupleExpr (TupleExpr tMap) = do
124+processTupleExpr (TupleExpr tMap) =
125125 TupleExpr . M.fromList <$> mapM (\(k,v) -> (,) k <$> processAtomExpr v) (M.toList tMap)
126126
127127--convert AttributeExpr to GraphRefAttributeExpr
src/lib/ProjectM36/Persist.hs+3−4
@@ -36,7 +36,6 @@ import Foreign.C
3636#endif
3737
3838import System.IO (withFile, IOMode(WriteMode), Handle)
39−import qualified Data.ByteString.Lazy as BS
4039import qualified Data.ByteString as BS'
4140import qualified Data.Text.Encoding as TE
4241
@@ -100,10 +99,10 @@ syncDirectory :: DiskSync -> FilePath -> IO ()
10099syncDirectory FsyncDiskSync path = directoryFsync path
101100syncDirectory NoDiskSync _ = pure ()
102101
103−writeBSFileSync :: DiskSync -> FilePath -> BS.ByteString -> IO ()
102+writeBSFileSync :: DiskSync -> FilePath -> BS'.ByteString -> IO ()
104103writeBSFileSync sync path bstring =
105104 withFile path WriteMode $ \handle -> do
106− BS.hPut handle bstring
105+ BS'.hPut handle bstring
107106 syncHandle sync handle
108107
109108directoryFsync :: FilePath -> IO ()
@@ -131,4 +130,4 @@ fdCount = do
131130 fds <- getDirectoryContents FDDIR
132131 pure ((length fds) - 2)
133132--not supported on non-linux
134−#endif
133+#endif
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/Relation/Show/Term.hs+3
@@ -9,6 +9,8 @@ import ProjectM36.Attribute hiding (null)
99import qualified Data.List as L
1010import qualified Data.Text as T
1111import Control.Arrow hiding (left)
12+import Data.ByteString.Base64 as B64
13+import qualified Data.Text.Encoding as TE
1214#if __GLASGOW_HASKELL__ < 804
1315import Data.Monoid
1416#endif
@@ -97,6 +99,7 @@ showAtom :: Int -> Atom -> StringType
9799showAtom _ (RelationAtom rel) = renderTable $ relationAsTable rel
98100showAtom level (ConstructedAtom dConsName _ atoms) = showParens (level >= 1 && not (null atoms)) $ T.concat (L.intersperse " " (dConsName : map (showAtom 1) atoms))
99101showAtom _ (TextAtom t) = "\"" <> t <> "\""
102+showAtom _ (ByteStringAtom bs) = TE.decodeUtf8 (B64.encode bs)
100103showAtom _ atom = atomToText atom
101104
102105renderTable :: Table -> StringType
src/lib/ProjectM36/RelationalExpression.hs+204−339
@@ -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
@@ -22,6 +23,7 @@ import qualified Data.Map as M
2223import qualified Data.HashSet as HS
2324import qualified Data.Set as S
2425import Control.Monad.State hiding (join)
26+import Data.Bifunctor (second)
2527import Data.Maybe
2628import Data.Either
2729import Data.Char (isUpper)
@@ -39,6 +41,8 @@ import Control.Monad.Reader as R hiding (join)
3941import ProjectM36.NormalizeExpr
4042import ProjectM36.WithNameExpr
4143import Test.QuickCheck
44+import qualified Data.Functor.Foldable as Fold
45+import Control.Applicative
4246#ifdef PM36_HASKELL_SCRIPTING
4347import GHC hiding (getContext)
4448import Control.Exception
@@ -90,10 +94,10 @@ runRelationalExprM :: RelationalExprEnv -> RelationalExprM a -> Either Relationa
9094runRelationalExprM env m = runIdentity (runExceptT (runReaderT m env))
9195
9296reGraph :: RelationalExprM TransactionGraph
93−reGraph = re_graph <$> R.ask
97+reGraph = asks re_graph
9498
9599reContext :: RelationalExprM DatabaseContext
96−reContext = re_context <$> R.ask
100+reContext = asks re_context
97101
98102mkRelationalExprEnv :: DatabaseContext -> TransactionGraph -> RelationalExprEnv
99103mkRelationalExprEnv ctx graph =
@@ -106,11 +110,11 @@ askEnv :: GraphRefRelationalExprM GraphRefRelationalExprEnv
106110askEnv = R.ask
107111
108112mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv
109−mergeTuplesIntoGraphRefRelationalExprEnv tupIn e =
110− e{ gre_extra = new_elems }
113+mergeTuplesIntoGraphRefRelationalExprEnv tupIn env =
114+ env { gre_extra = new_elems }
111115 where
112116 new_elems = Just (Left newTuple)
113− mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple e))
117+ mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple env))
114118 newTuple = mkRelationTupleFromMap mergedTupMap
115119
116120mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv
@@ -138,12 +142,12 @@ data DatabaseContextEvalEnv = DatabaseContextEvalEnv
138142 }
139143
140144mkDatabaseContextEvalEnv :: TransactionId -> TransactionGraph -> DatabaseContextEvalEnv
141−mkDatabaseContextEvalEnv tid graph = DatabaseContextEvalEnv tid graph
145+mkDatabaseContextEvalEnv = DatabaseContextEvalEnv
142146
143147type DatabaseContextEvalMonad a = RWST DatabaseContextEvalEnv () DatabaseContextEvalState (ExceptT RelationalError Identity) a
144148
145149runDatabaseContextEvalMonad :: DatabaseContext -> DatabaseContextEvalEnv -> DatabaseContextEvalMonad () -> Either RelationalError DatabaseContextEvalState
146−runDatabaseContextEvalMonad ctx env m = runIdentity (runExceptT (fst <$> (execRWST m env freshEnv)))
150+runDatabaseContextEvalMonad ctx env m = runIdentity (runExceptT (fst <$> execRWST m env freshEnv))
147151 where
148152 freshEnv = mkDatabaseContextEvalState ctx
149153
@@ -159,7 +163,7 @@ dbcRelationalExprEnv =
159163 mkRelationalExprEnv <$> getStateContext <*> dbcGraph
160164
161165getStateContext :: DatabaseContextEvalMonad DatabaseContext
162−getStateContext = dbc_context <$> get
166+getStateContext = gets dbc_context
163167
164168putStateContext :: DatabaseContext -> DatabaseContextEvalMonad ()
165169putStateContext ctx' = do
@@ -200,7 +204,7 @@ freshGraphRefRelationalExprEnv mctx graph = GraphRefRelationalExprEnv {
200204 }
201205
202206gfGraph :: GraphRefRelationalExprM TransactionGraph
203−gfGraph = gre_graph <$> R.ask
207+gfGraph = asks gre_graph
204208
205209envContext :: RelationalExprEnv -> DatabaseContext
206210envContext = re_context
@@ -208,166 +212,13 @@ envContext = re_context
208212setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv
209213setEnvContext e ctx = e { re_context = ctx }
210214
211−{-
212−--full evaluation down the graph
213−eval :: RelationalExpr -> RelationalExprState (Either RelationalError Relation)
214−eval expr = do
215− env <- askEnv
216− eGfExpr <- processRelationalExpr expr
217− case eGfExpr of
218− Left err -> pure (Left err)
219− Right gfExpr -> pure $ evalGraphRefRelationalExpr gfExpr (re_graph env)
220−-}
221−{-
222−--relvar state is needed in evaluation of relational expression but only as read-only in order to extract current relvar values
223−evalRelationalExpr :: RelationalExpr -> RelationalExprState (Either RelationalError GraphRefRelationalExpr)
224−evalRelationalExpr (RelationVariable name _) = do
225− relvarTable <- fmap (relationVariables . envContext) askEnv
226− return $ case M.lookup name relvarTable of
227− Just res -> Right res
228− Nothing -> Left $ RelVarNotDefinedError name
229−
230−evalRelationalExpr (Project attrNames expr) = do
231− eAttrNameSet <- evalAttributeNames attrNames expr
232− case eAttrNameSet of
233− Left err -> pure (Left err)
234− Right attrNameSet -> do
235− rel <- evalRelationalExpr expr
236− case rel of
237− Right rel2 -> pure $ Right (Project (AttributeNames attrNameSet) rel2)
238− Left err -> pure $ Left err
239−
240−evalRelationalExpr (Union exprA exprB) = do
241− relA <- evalRelationalExpr exprA
242− relB <- evalRelationalExpr exprB
243− case relA of
244− Left err -> return $ Left err
245− Right relA2 -> case relB of
246− Left err -> return $ Left err
247− Right relB2 -> return $ Right (Union relA2 relB2)
248−
249−evalRelationalExpr (Join exprA exprB) = do
250− relA <- evalRelationalExpr exprA
251− relB <- evalRelationalExpr exprB
252− case relA of
253− Left err -> return $ Left err
254− Right relA2 -> case relB of
255− Left err -> return $ Left err
256− Right relB2 -> return $ Right (Join relA2 relB2)
257−
258−evalRelationalExpr (Difference exprA exprB) = do
259− relA <- evalRelationalExpr exprA
260− relB <- evalRelationalExpr exprB
261− case relA of
262− Left err -> return $ Left err
263− Right relA2 -> case relB of
264− Left err -> return $ Left err
265− Right relB2 -> return $ Right (Difference relA2 relB2)
266−
267−evalRelationalExpr (MakeStaticRelation attributeSet tupleSet) =
268− case mkRelation attributeSet tupleSet of
269− Right rel -> return $ Right (ExistingRelation rel)
270− Left err -> return $ Left err
271−
272−evalRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do
273− currentContext <- fmap envContext askEnv
274− let tConss = typeConstructorMapping currentContext
275− -- 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
276− runExceptT $ do
277− mAttrs <- case mAttrExprs of
278− Just _ ->
279− Just . A.attributesFromList <$> mapM evalGraphRefAttrExpr (fromMaybe [] mAttrExprs)
280− Nothing -> pure Nothing
281− tuples <- mapM (liftE . evalTupleExpr mAttrs) tupleExprs
282− let attrs = fromMaybe firstTupleAttrs mAttrs
283− firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)
284− expr <- either throwE pure (mkRelation attrs (RelationTupleSet tuples))
285− pure (ExistingRelation expr)
286−
287−evalRelationalExpr (ExistingRelation rel) = pure (Right (ExistingRelation rel))
288−
289−evalRelationalExpr (Rename oldAttrName newAttrName relExpr) = do
290− evald <- evalRelationalExpr relExpr
291− case evald of
292− Right expr -> return $ Right (Rename oldAttrName newAttrName expr)
293− Left err -> return $ Left err
294−
295−evalRelationalExpr (Group oldAttrNames newAttrName relExpr) = do
296− eOldAttrNameSet <- evalAttributeNames oldAttrNames relExpr
297− case eOldAttrNameSet of
298− Left err -> pure (Left err)
299− Right oldAttrNameSet -> do
300− evald <- evalRelationalExpr relExpr
301− case evald of
302− Right expr -> return $ Right (Group (AttributeNames oldAttrNameSet) newAttrName expr)
303− Left err -> return $ Left err
304−
305−evalRelationalExpr (Ungroup attrName relExpr) = do
306− evald <- evalRelationalExpr relExpr
307− case evald of
308− Right expr -> return $ Right (Ungroup attrName expr)
309− Left err -> return $ Left err
310−
311−evalRelationalExpr (Restrict predicateExpr relExpr) = do
312− evald <- evalRelationalExpr relExpr
313− pred <- processRestrictionPredicateExpr predicateExpr
314− case evald of
315− Left err -> return $ Left err
316− Right expr ->
317− pure $ Right (Restrict pred expr)
318−
319−evalRelationalExpr (Equals relExprA relExprB) = do
320− evaldA <- evalRelationalExpr relExprA
321− evaldB <- evalRelationalExpr relExprB
322− case evaldA of
323− Left err -> return $ Left err
324− Right exprA -> case evaldB of
325− Left err -> return $ Left err
326− Right exprB -> return $ Right (Equals exprA exprB)
327−{-
328−evalRelationalExpr (With views mainExpr) = do
329− rstate <- ask
330−
331− let addScopedView ctx (vname,vexpr) = if vname `M.member` relationVariables ctx then
332− Left (RelVarAlreadyDefinedError vname)
333− else
334− case runState (evalDatabaseContextExpr (Assign vname vexpr)) (freshDatabaseState ctx) of
335− (Left err,_) -> Left err
336− (Right (), (ctx',_,_)) -> Right ctx'
337−
338− case foldM addScopedView (stateElemsContext rstate) views of
339− Left err -> return $ Left err
340− Right ctx'' -> do
341− let evalMainExpr expr = runReader (evalRelationalExpr expr) (RelationalExprEnv ctx'')
342− case evalMainExpr mainExpr of
343− Left err -> return $ Left err
344− Right rel -> return $ Right rel
345−-}
346−--warning: copy-pasta from above- refactor
347−evalRelationalExpr (NotEquals relExprA relExprB) = do
348− evaldA <- evalRelationalExpr relExprA
349− evaldB <- evalRelationalExpr relExprB
350− case evaldA of
351− Left err -> return $ Left err
352− Right exprA -> case evaldB of
353− Left err -> return $ Left err
354− Right exprB -> return $ Right (NotEquals exprA exprB)
355−
356−-- extending a relation adds a single attribute with the results of the per-tuple expression evaluated
357−evalRelationalExpr (Extend tupleExpression relExpr) = do
358− eExpr <- evalRelationalExpr relExpr
359− case eExpr of
360− Left err -> pure (Left err)
361− Right expr -> do
362− tupProc <- processExtendTupleExpr tupleExpression
363− pure (Right (Extend tupProc expr))
364−-}
365215--helper function to process relation variable creation/assignment
366216setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()
367217setRelVar relVarName relExpr = do
368218 currentContext <- getStateContext
369− --prevent recursive relvar definition
370− 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
371222 potentialContext = currentContext { relationVariables = newRelVars }
372223 --optimization: if the relexpr is unchanged, skip the update
373224 if M.lookup relVarName (relationVariables currentContext) == Just relExpr then
@@ -380,6 +231,9 @@ setRelVar relVarName relExpr = do
380231 Left err -> dbErr err
381232 Right _ -> putStateContext potentialContext
382233
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+
383237-- 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
384238deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()
385239deleteRelVar relVarName = do
@@ -445,20 +299,36 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do
445299
446300evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do
447301 gfExpr <- relVarByName relVarName
448− evalGraphRefDatabaseContextExpr (Assign relVarName
449− (Union
450− gfExpr
451− relExpr))
302+ let optExpr = applyUnionCollapse (Union
303+ relExpr
304+ gfExpr)
305+ evalGraphRefDatabaseContextExpr (Assign relVarName optExpr)
452306
453307evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do
454308 gfExpr <- relVarByName relVarName
455− setRelVar relVarName (Restrict (NotPredicate predicate) gfExpr)
309+ let optExpr = applyRestrictionCollapse (Restrict (NotPredicate predicate) gfExpr)
310+ setRelVar relVarName optExpr
456311
457312--union of restricted+updated portion and the unrestricted+unupdated portion
458313evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do
459314 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
460323 let unrestrictedPortion = Restrict (NotPredicate pred') rvExpr
461− 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
462332 updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)
463333 projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)
464334 restrictedPortion = Restrict pred' rvExpr
@@ -544,9 +414,9 @@ evalGraphRefDatabaseContextExpr (RemoveTypeConstructor tConsName) = do
544414 let newTypes = filter (\(tCons, _) -> TCD.name tCons /= tConsName) oldTypes
545415 putStateContext $ currentContext { typeConstructorMapping = newTypes }
546416
547−evalGraphRefDatabaseContextExpr (MultipleExpr exprs) = do
417+evalGraphRefDatabaseContextExpr (MultipleExpr exprs) =
548418 --the multiple expressions must pass the same context around- not the old unmodified context
549− mapM_ (\expr -> evalGraphRefDatabaseContextExpr expr) exprs
419+ mapM_ evalGraphRefDatabaseContextExpr exprs
550420
551421evalGraphRefDatabaseContextExpr (RemoveAtomFunction funcName) = do
552422 currentContext <- getStateContext
@@ -576,7 +446,7 @@ evalGraphRefDatabaseContextExpr (ExecuteDatabaseContextFunction funcName atomArg
576446 context <- getStateContext
577447 graph <- dbcGraph
578448 --resolve atom arguments
579− let eAtomTypes = mapM (\atomExpr -> runGraphRefRelationalExprM gfEnv (typeForGraphRefAtomExpr emptyAttributes atomExpr)) atomArgExprs
449+ let eAtomTypes = mapM (runGraphRefRelationalExprM gfEnv . typeForGraphRefAtomExpr emptyAttributes) atomArgExprs
580450 eFunc = databaseContextFunctionForName funcName (dbcFunctions context)
581451 gfEnv = freshGraphRefRelationalExprEnv (Just context) graph
582452 case eFunc of
@@ -591,11 +461,13 @@ evalGraphRefDatabaseContextExpr (ExecuteDatabaseContextFunction funcName atomArg
591461 case eAtomTypes of
592462 Left err -> dbErr err
593463 Right atomTypes -> do
594− let mValidTypes = map (\(expType, actType) -> case atomTypeVerify expType actType of
595− Left err -> Just err
596− Right _ -> Nothing) (zip (dbcFuncType func) atomTypes)
464+ let mValidTypes = zipWith (\ expType actType
465+ -> case atomTypeVerify expType actType of
466+ Left err -> Just err
467+ Right _ -> Nothing)
468+ (dbcFuncType func) atomTypes
597469 typeErrors = catMaybes mValidTypes
598− eAtomArgs = map (\arg -> runGraphRefRelationalExprM gfEnv (evalGraphRefAtomExpr emptyTuple arg)) atomArgExprs
470+ eAtomArgs = map (runGraphRefRelationalExprM gfEnv . evalGraphRefAtomExpr emptyTuple) atomArgExprs
599471 if length (lefts eAtomArgs) > 1 then
600472 dbErr (someErrors (lefts eAtomArgs))
601473 else if not (null typeErrors) then
@@ -639,8 +511,7 @@ getDBCIOContext = dbc_context <$> RWS.get
639511getDBCIORelationalExprEnv :: DatabaseContextIOEvalMonad RelationalExprEnv
640512getDBCIORelationalExprEnv = do
641513 context <- getDBCIOContext
642− env <- RWS.ask
643− pure $ mkRelationalExprEnv context (dbcio_graph env)
514+ mkRelationalExprEnv context . dbcio_graph <$> RWS.ask
644515
645516evalGraphRefDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> DatabaseContextIOEvalMonad (Either RelationalError ())
646517#if !defined(PM36_HASKELL_SCRIPTING)
@@ -739,6 +610,7 @@ evalGraphRefDatabaseContextIOExpr (LoadDatabaseContextFunctions modName funcName
739610 Right dbcListFunc -> let newContext = currentContext { dbcFunctions = mergedFuncs }
740611 mergedFuncs = HS.union (dbcFunctions currentContext) (HS.fromList dbcListFunc)
741612 in putDBCIOContext newContext
613+#endif
742614evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs range) = do
743615 --Define
744616 currentContext <- getDBCIOContext
@@ -769,29 +641,21 @@ evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs
769641 case runDatabaseContextEvalMonad currentContext evalEnv (setRelVar relVarName (ExistingRelation rel)) of
770642 Left err -> pure (Left err)
771643 Right dbstate' -> putDBCIOContext (dbc_context dbstate')
772−#endif
773−{-
774−updateTupleWithAtomExprs :: M.Map AttributeName AtomExpr -> DatabaseContext -> TransactionGraph -> RelationTuple -> Either RelationalError RelationTuple
775−updateTupleWithAtomExprs exprMap context graph tupIn = do
776− --resolve all atom exprs
777− let
778− atomsAssoc <- mapM (\(attrName, atomExpr) -> do
779− let atom = unimplemented
780− --atom <- runReader (evalAtomExpr tupIn atomExpr) (mkRelationalExprState context graph)
781− pure (attrName, atom)
782− ) (M.toList exprMap)
783− pure (updateTupleWithAtoms (M.fromList atomsAssoc) tupIn)
784−-}
644+
785645--run verification on all constraints
786646checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()
787−checkConstraints context transId graph@(TransactionGraph graphHeads transSet) =
647+checkConstraints context transId graph@(TransactionGraph graphHeads transSet) = do
788648 mapM_ (uncurry checkIncDep) (M.toList deps)
789649 where
790650 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)
791651 tempStamp = UTCTime { utctDay = fromGregorian 2000 1 1,
792652 utctDayTime = secondsToDiffTime 0 }
793653 tempSchemas = Schemas context M.empty
794− tempTrans = Transaction U.nil (TransactionInfo (transId NE.:| []) tempStamp) tempSchemas
654+ tempTrans = Transaction U.nil tempTransInfo tempSchemas
655+ tempTransInfo = TransactionInfo { parents = transId NE.:| [],
656+ stamp = tempStamp,
657+ merkleHash = mempty
658+ }
795659
796660 deps = inclusionDependencies context
797661 -- no optimization available here, really? perhaps the optimizer should be passed down to here or the eval function should be passed through the environment
@@ -827,16 +691,7 @@ typeForRelationalExpr expr = do
827691 let gfExpr = runProcessExprM UncommittedContextMarker (processRelationalExpr expr)
828692 gfEnv = freshGraphRefRelationalExprEnv (Just context) graph
829693 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)
830− lift $ except $ runGf
831−
832−--returns a database context with all tuples removed
833−--this is useful for type checking and optimization
834−{-
835−contextWithEmptyTupleSets :: DatabaseContext -> DatabaseContext
836−contextWithEmptyTupleSets contextIn = contextIn { relationVariables = relVars }
837− where
838− relVars = M.map (\rel -> ExistingRelation (Relation (attributes rel) emptyTupleSet)) (relationVariables contextIn)
839−-}
694+ lift $ except runGf
840695
841696liftE :: (Monad m) => m (Either a b) -> ExceptT a m b
842697liftE v = do
@@ -929,7 +784,7 @@ tupleExprCheckNewAttrName attrName rel = if isRight (attributeForName attrName r
929784 Right rel
930785
931786extendGraphRefTupleExpressionProcessor :: Relation -> GraphRefExtendTupleExpr -> GraphRefRelationalExprM (Attributes, RelationTuple -> Either RelationalError RelationTuple)
932−extendGraphRefTupleExpressionProcessor relIn (AttributeExtendTupleExpr newAttrName atomExpr) = do
787+extendGraphRefTupleExpressionProcessor relIn (AttributeExtendTupleExpr newAttrName atomExpr) =
933788-- renv <- askEnv
934789 -- check that the attribute name is not in use
935790 case tupleExprCheckNewAttrName newAttrName relIn of
@@ -971,7 +826,7 @@ evalGraphRefAtomExpr tupIn (FunctionAtomExpr funcName arguments tid) = do
971826 throwError (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)
972827 else do
973828 let zippedArgs = zip (safeInit (atomFuncType func)) argTypes
974− mapM_ (\(expType, actType) -> do
829+ mapM_ (\(expType, actType) ->
975830 lift $ except (atomTypeVerify expType actType)) zippedArgs
976831 evaldArgs <- mapM (evalGraphRefAtomExpr tupIn) arguments
977832 case evalAtomFunction func evaldArgs of
@@ -993,58 +848,6 @@ evalGraphRefAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs _) = do
993848 mapM (evalGraphRefAtomExpr tupIn) dConsArgs
994849 pure (ConstructedAtom dConsName aType argAtoms)
995850
996−{-
997−evalAtomExpr :: RelationTuple -> AtomExpr -> RelationalExprM Atom
998−evalAtomExpr tupIn expr =
999− -}
1000−{-
1001−
1002−evalAtomExpr tupIn (AttributeAtomExpr attrName) = case atomForAttributeName attrName tupIn of
1003− Right atom -> pure (Right atom)
1004− err@(Left (NoSuchAttributeNamesError _)) -> do
1005− rstate <- ask
1006− let stateTup = stateTuple rstate
1007− pure (atomForAttributeName attrName stateTup)
1008− Left err -> pure (Left err)
1009−evalAtomExpr _ (NakedAtomExpr atom) = pure (Right atom)
1010−evalAtomExpr tupIn (FunctionAtomExpr funcName arguments ()) = do
1011− argTypes <- mapM (typeFromAtomExpr (tupleAttributes tupIn)) arguments
1012− context <- fmap stateElemsContext ask
1013− runExceptT $ do
1014− let functions = atomFunctions context
1015− func <- either throwE pure (atomFunctionForName funcName functions)
1016− let expectedArgCount = length (atomFuncType func) - 1
1017− actualArgCount = length argTypes
1018− safeInit [] = [] -- different behavior from normal init
1019− safeInit xs = init xs
1020− if expectedArgCount /= actualArgCount then
1021− throwE (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)
1022− else do
1023− let zippedArgs = zip (safeInit (atomFuncType func)) argTypes
1024− mapM_ (\(expType, eActType) -> do
1025− actType <- either throwE pure eActType
1026− either throwE pure (atomTypeVerify expType actType)) zippedArgs
1027− evaldArgs <- mapM (liftE . evalAtomExpr tupIn) arguments
1028− case evalAtomFunction func evaldArgs of
1029− Left err -> throwE (AtomFunctionUserError err)
1030− Right result -> do
1031− --validate that the result matches the expected type
1032− _ <- either throwE pure (atomTypeVerify (last (atomFuncType func)) (atomTypeForAtom result))
1033− pure result
1034−evalAtomExpr tupIn (RelationAtomExpr relExpr) = do
1035− --merge existing state tuple context into new state tuple context to support an arbitrary number of levels, but new attributes trounce old attributes
1036− rstate <- ask
1037− runExceptT $ do
1038− let newState = mergeTuplesIntoRelationalExprState tupIn rstate
1039− relAtom <- either throwE pure (runReader (evalRelationalExpr relExpr) newState)
1040− pure (RelationAtom relAtom)
1041−evalAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs ()) = runExceptT $ do
1042− rstate <- lift ask
1043− let newState = mergeTuplesIntoRelationalExprState tupIn rstate
1044− aType <- either throwE pure (runReader (typeFromAtomExpr (tupleAttributes tupIn) cons) newState)
1045− argAtoms <- mapM (\arg -> either throwE pure (runReader (evalAtomExpr tupIn arg) newState)) dConsArgs
1046− pure (ConstructedAtom dConsName aType argAtoms)
1047−-}
1048851typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType
1049852typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do
1050853 renv <- askEnv
@@ -1111,7 +914,7 @@ verifyGraphRefAtomExprTypes relIn (FunctionAtomExpr funcName funcArgExprs tid) e
1111914 let handler :: RelationalError -> GraphRefRelationalExprM AtomType
1112915 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)
1113916 handler err = throwError err
1114− verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler
917+ verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler
1115918 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]
1116919 if length funcArgTypes /= length expectedArgTypes - 1 then
1117920 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)
@@ -1148,26 +951,38 @@ evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do
1148951 [] -> pure emptyAttributes
1149952 (headTuple:tailTuples) -> do
1150953 --gather up resolved atom types or throw an error if an attribute cannot be made concrete from the inferred types- this could still fail if the type cannot be inferred (e.g. from [Nothing, Nothing])
1151− let mostResolvedTypes =
1152− foldr (\tup acc ->
1153− fmap (\(tupAttr,accAttr) -> --if the attribute is a constructedatomtype, we can recurse into it to potentially resolve type variables
1154− if isResolvedAttribute accAttr then
1155− accAttr
1156− else
1157− case resolveAttributes accAttr tupAttr of
1158− Left _ -> accAttr
1159− Right val -> val) (zip (V.toList $ tupleAttributes tup) acc)) (V.toList $ tupleAttributes headTuple) tailTuples
954+ let
955+ processTupleAttrs (tupAttr, accAttr) =
956+ --if the attribute is a constructedatomtype, we can recurse into it to potentially resolve type variables
957+ if isResolvedAttribute accAttr && tupAttr == accAttr then
958+ pure accAttr
959+ else
960+ lift $ except $ resolveAttributes accAttr tupAttr
961+ mostResolvedTypes <-
962+ foldM (\acc tup -> do
963+ let zipped = zip (V.toList . attributesVec $ tupleAttributes tup) acc
964+ accNames = S.fromList $ map A.attributeName acc
965+ tupNames = A.attributeNameSet (tupleAttributes tup)
966+ attrNamesDiff = S.union (S.difference accNames tupNames) (S.difference tupNames accNames)
967+ unless (null attrNamesDiff) (throwError (AttributeNamesMismatchError attrNamesDiff))
968+ nextTupleAttrs <- mapM processTupleAttrs zipped
969+ let diff = A.attributesDifference (A.attributesFromList nextTupleAttrs) (A.attributesFromList acc)
970+ if diff == A.emptyAttributes then
971+ pure nextTupleAttrs
972+ else
973+ throwError (TupleAttributeTypeMismatchError diff)
974+ ) (V.toList . attributesVec $ tupleAttributes headTuple) tailTuples
1160975 pure (A.attributesFromList mostResolvedTypes)
1161976 --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
1162977 tConsMap <- case singularTransactions tupleExprL of
1163− SingularTransactionRef commonTransId -> do
978+ SingularTransactionRef commonTransId ->
1164979 typeConstructorMapping <$> gfDatabaseContextForMarker commonTransId
1165− NoTransactionsRef -> do
980+ NoTransactionsRef ->
1166981 typeConstructorMapping <$> gfDatabaseContextForMarker fixedMarker
1167982 -- if there are multiple transaction markers in the TupleExprs, then we can't assume a single type constructor mapping- this could be improved in the future, but if all the tuples are fully resolved, then we don't need further resolution
1168983 _ -> throwError TupleExprsReferenceMultipleMarkersError
1169984 lift $ except $ validateAttributes tConsMap finalAttrs
1170− mapM (\tup -> lift $ except $ resolveTypesInTuple finalAttrs tConsMap tup) tuples
985+ mapM (lift . except . resolveTypesInTuple finalAttrs tConsMap) tuples
1171986
1172987
1173988--resolveAttributes (Attribute "gonk" (ConstructedAtomType "Either" (fromList [("a",IntegerAtomType),("b",TypeVariableType "b")]))) (Attribute "gonk" (ConstructedAtomType "Either" (fromList [("a",TypeVariableType "a"),("b",TextAtomType)])))
@@ -1202,56 +1017,6 @@ evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do
12021017-- _ <- lift $ except (validateTuple tup' tConss)
12031018 pure tup'
12041019
1205−{-
1206−evalAttributeNames :: AttributeNames -> RelationalExpr -> RelationalExprM (Either RelationalError (S.Set AttributeName))
1207−evalAttributeNames attrNames expr = do
1208− eExprType <- typeForRelationalExpr expr
1209− case eExprType of
1210− Left err -> throwError err
1211− Right exprTyp -> do
1212− let typeNameSet = S.fromList (V.toList (A.attributeNames (attributes exprTyp)))
1213− case attrNames of
1214− AttributeNames names ->
1215− case A.projectionAttributesForNames names (attributes exprTyp) of
1216− Left err -> pure (Left err)
1217− Right attrs -> pure (Right (S.fromList (V.toList (A.attributeNames attrs))))
1218−
1219− InvertedAttributeNames names -> do
1220− let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet
1221− if not (S.null nonExistentAttributeNames) then
1222− pure (Left (AttributeNamesMismatchError nonExistentAttributeNames))
1223− else
1224− pure (Right (A.nonMatchingAttributeNameSet names typeNameSet))
1225−
1226− UnionAttributeNames namesA namesB -> do
1227− eNameSetA <- evalAttributeNames namesA expr
1228− case eNameSetA of
1229− Left err -> pure (Left err)
1230− Right nameSetA -> do
1231− eNameSetB <- evalAttributeNames namesB expr
1232− case eNameSetB of
1233− Left err -> pure (Left err)
1234− Right nameSetB ->
1235− pure (Right (S.union nameSetA nameSetB))
1236−
1237− IntersectAttributeNames namesA namesB -> do
1238− eNameSetA <- evalAttributeNames namesA expr
1239− case eNameSetA of
1240− Left err -> pure (Left err)
1241− Right nameSetA -> do
1242− eNameSetB <- evalAttributeNames namesB expr
1243− case eNameSetB of
1244− Left err -> pure (Left err)
1245− Right nameSetB ->
1246− pure (Right (S.intersection nameSetA nameSetB))
1247−
1248− RelationalExprAttributeNames attrExpr -> do
1249− eAttrExprType <- typeForRelationalExpr attrExpr
1250− case eAttrExprType of
1251− Left err -> pure (Left err)
1252− Right attrExprType -> pure (Right (A.attributeNameSet (attributes attrExprType)))
1253−-}
1254−
12551020--temporary implementation until we have a proper planner+executor
12561021evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation
12571022evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do
@@ -1313,7 +1078,7 @@ evalGraphRefRelationalExpr (Extend extendTupleExpr expr) = do
13131078 rel <- evalGraphRefRelationalExpr expr
13141079 (newAttrs, tupProc) <- extendGraphRefTupleExpressionProcessor rel extendTupleExpr
13151080 lift $ except $ relMogrify tupProc newAttrs rel
1316−evalGraphRefRelationalExpr expr@With{} = do
1081+evalGraphRefRelationalExpr expr@With{} =
13171082 --strategy A: add relation variables to the contexts in the graph
13181083 --strategy B: drop in macros in place (easier programmatically)
13191084 --strategy B implementation
@@ -1341,7 +1106,7 @@ typeForGraphRefRelationalExpr (ExistingRelation rel) = pure (emptyRelationWithAt
13411106typeForGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do
13421107 mAttrs <- case mAttrExprs of
13431108 Just attrExprs -> do
1344− attrs <- mapM (\e -> evalGraphRefAttributeExpr e) attrExprs
1109+ attrs <- mapM evalGraphRefAttributeExpr attrExprs
13451110 pure (Just (attributesFromList attrs))
13461111 Nothing -> pure Nothing
13471112 tuples <- evalGraphRefTupleExprs mAttrs tupleExprs
@@ -1386,9 +1151,9 @@ typeForGraphRefRelationalExpr (Restrict pred' expr) = do
13861151 expr' <- typeForGraphRefRelationalExpr expr
13871152 filt <- predicateRestrictionFilter (attributes expr') pred'
13881153 lift $ except $ restrict filt expr'
1389−typeForGraphRefRelationalExpr Equals{} = do
1154+typeForGraphRefRelationalExpr Equals{} =
13901155 pure relationFalse
1391−typeForGraphRefRelationalExpr NotEquals{} = do
1156+typeForGraphRefRelationalExpr NotEquals{} =
13921157 pure relationFalse
13931158typeForGraphRefRelationalExpr (Extend extendTupleExpr expr) = do
13941159 rel <- typeForGraphRefRelationalExpr expr
@@ -1400,7 +1165,7 @@ typeForGraphRefRelationalExpr expr@(With withs _) = do
14001165 case M.lookup macroName rvs of
14011166 Just _ -> lift $ except $ Left (RelVarAlreadyDefinedError macroName) --this error does not include the transaction marker, but should be good enough to identify the cause
14021167 Nothing -> pure ()
1403− mapM_ checkMacroName (map fst withs)
1168+ mapM_ (checkMacroName . fst) withs
14041169 typeForGraphRefRelationalExpr expr'
14051170
14061171evalGraphRefAttributeNames :: GraphRefAttributeNames -> GraphRefRelationalExpr -> GraphRefRelationalExprM (S.Set AttributeName)
@@ -1446,7 +1211,7 @@ evalGraphRefAttributeExpr (AttributeAndTypeNameExpr attrName tCons tid) = do
14461211evalGraphRefAttributeExpr (NakedAttributeExpr attr) = pure attr
14471212
14481213mkEmptyRelVars :: RelationVariables -> RelationVariables
1449−mkEmptyRelVars rvMap = M.map mkEmptyRelVar rvMap
1214+mkEmptyRelVars = M.map mkEmptyRelVar
14501215 where
14511216 mkEmptyRelVar expr@MakeRelationFromExprs{} = expr --do not truncate here because we might lose essential type information in emptying the tuples
14521217 mkEmptyRelVar (MakeStaticRelation attrs _) = MakeStaticRelation attrs emptyTupleSet
@@ -1463,7 +1228,7 @@ mkEmptyRelVars rvMap = M.map mkEmptyRelVar rvMap
14631228 mkEmptyRelVar (Equals exprA exprB) = Equals (mkEmptyRelVar exprA) (mkEmptyRelVar exprB)
14641229 mkEmptyRelVar (NotEquals exprA exprB) = NotEquals (mkEmptyRelVar exprA) (mkEmptyRelVar exprB)
14651230 mkEmptyRelVar (Extend extTuple expr) = Extend extTuple (mkEmptyRelVar expr)
1466− mkEmptyRelVar (With macros expr) = With (map (\(rv, expr') -> (rv, mkEmptyRelVar expr')) macros) (mkEmptyRelVar expr)
1231+ mkEmptyRelVar (With macros expr) = With (map (second mkEmptyRelVar) macros) (mkEmptyRelVar expr)
14671232
14681233
14691234dbErr :: RelationalError -> DatabaseContextEvalMonad ()
@@ -1480,7 +1245,7 @@ relationVariablesAsRelation ctx graph = do
14801245 let gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph
14811246 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)
14821247 pure (rvName, gfType)
1483− relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributes rel)]
1248+ relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributesVec (attributes rel))]
14841249 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]
14851250 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of
14861251 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)
@@ -1500,15 +1265,6 @@ evalRelationalExpr expr = do
15001265 Left err -> throwError err
15011266 Right rel -> pure rel
15021267
1503−{-
1504−relVarByName :: RelVarName -> GraphRefRelationalExprM GraphRefRelationalExpr
1505−relVarByName = do
1506− relvars <- relationVariables <$> getStateContext
1507− case M.lookup relVarName relvars of
1508− Nothing -> dbErr (RelVarNotDefinedError relVarName)
1509− Just gfexpr -> pure gfExpr
1510−-}
1511−
15121268class (MonadError RelationalError m, Monad m) => DatabaseContextM m where
15131269 getContext :: m DatabaseContext
15141270
@@ -1525,3 +1281,112 @@ relVarByName rvName = do
15251281 Nothing -> throwError (RelVarNotDefinedError rvName)
15261282 Just gfexpr -> pure gfexpr
15271283
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+11−4
@@ -18,6 +18,7 @@ import System.Info (os, arch)
1818import Data.Text (Text, unpack)
1919import Data.Maybe
2020import GHC.Paths (libdir)
21+import System.Environment
2122#if __GLASGOW_HASKELL__ >= 800
2223import GHC.LanguageExtensions
2324import GHCi.ObjLink
@@ -78,6 +79,8 @@ initScriptSession ghcPkgPaths = do
7879 handleGhcException excHandler $ runGhc (Just libdir) $ do
7980 dflags <- getSessionDynFlags
8081 let ghcVersion = projectVersion dflags
82+ -- get nix packages dir, if available
83+ mNixLibDir <- liftIO $ lookupEnv "NIX_GHC_LIBDIR"
8184
8285 sandboxPkgPaths <- liftIO $ concat <$> mapM glob [
8386 --"./dist-newstyle/packagedb/ghc-" ++ ghcVersion, --rely on cabal 3's ghc.environment install: "cabal install --lib project-m36"
@@ -89,7 +92,7 @@ initScriptSession ghcPkgPaths = do
8992 --homeDir </> ".cabal/store/ghc-" ++ ghcVersion ++ "/package.db"
9093 ]
9194
92− let localPkgPaths = map PkgConfFile (ghcPkgPaths ++ sandboxPkgPaths)
95+ let localPkgPaths = map PkgConfFile (ghcPkgPaths ++ sandboxPkgPaths ++ maybeToList mNixLibDir)
9396
9497 let dflags' = applyGopts . applyXopts $ dflags { hscTarget = HscInterpreted ,
9598 ghcLink = LinkInMemory,
@@ -125,8 +128,6 @@ initScriptSession ghcPkgPaths = do
125128 "uuid",
126129 "vector",
127130 "text",
128− "binary",
129− "vector-binary-instances",
130131 "time",
131132 "project-m36",
132133 "bytestring"]
@@ -144,7 +145,9 @@ initScriptSession ghcPkgPaths = do
144145 ideclSourceSrc = Nothing,
145146#endif
146147
147−#if __GLASGOW_HASKELL__ >= 806
148+#if __GLASGOW_HASKELL__ >= 810
149+ ideclExt = noExtField,
150+#elif __GLASGOW_HASKELL__ >= 806
148151 ideclExt = NoExt,
149152#endif
150153 ideclName = noLoc mn,
@@ -152,7 +155,11 @@ initScriptSession ghcPkgPaths = do
152155 ideclSource = False,
153156 ideclSafe = True,
154157 ideclImplicit = False,
158+#if __GLASGOW_HASKELL__ >= 810
159+ ideclQualified = if isJust mQual then QualifiedPre else NotQualified,
160+#else
155161 ideclQualified = isJust mQual,
162+#endif
156163 ideclAs = mQual,
157164 ideclHiding = Nothing
158165 }
src/lib/ProjectM36/Serialise/AtomFunctionError.hsnew file+7
@@ -0,0 +1,7 @@
1+{-# LANGUAGE DerivingVia, StandaloneDeriving #-}
2+{-# OPTIONS_GHC -fno-warn-orphans #-}
3+module ProjectM36.Serialise.AtomFunctionError where
4+import Codec.Winery
5+import ProjectM36.AtomFunctionError
6+
7+deriving via WineryVariant AtomFunctionError instance Serialise AtomFunctionError
src/lib/ProjectM36/Serialise/Base.hsnew file+85
@@ -0,0 +1,85 @@
1+{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeApplications, TypeSynonymInstances, ScopedTypeVariables #-}
2+{-# OPTIONS_GHC -fno-warn-orphans #-}
3+--Serialise instances for ProjectM36.Base data types- orphan instance city
4+module ProjectM36.Serialise.Base where
5+import Codec.Winery hiding (Schema)
6+import Codec.Winery.Internal
7+import Control.Monad
8+import ProjectM36.Base
9+import ProjectM36.MerkleHash
10+import Data.UUID
11+import Data.Proxy
12+import Data.Word
13+import ProjectM36.Attribute as A
14+import qualified Data.List.NonEmpty as NE
15+import qualified Data.Vector as V
16+import Data.Time.Calendar (Day,toGregorian,fromGregorian)
17+
18+deriving via WineryVariant Atom instance Serialise Atom
19+deriving via WineryVariant AtomType instance Serialise AtomType
20+deriving via WineryVariant Attribute instance Serialise Attribute
21+deriving via WineryVariant RelationTupleSet instance Serialise RelationTupleSet
22+deriving via WineryVariant RelationTuple instance Serialise RelationTuple
23+deriving via WineryVariant Relation instance Serialise Relation
24+deriving via WineryVariant RelationCardinality instance Serialise RelationCardinality
25+deriving via WineryVariant (RelationalExprBase a) instance Serialise a => Serialise (RelationalExprBase a)
26+deriving via WineryVariant (WithNameExprBase a) instance Serialise a => Serialise (WithNameExprBase a)
27+deriving via WineryVariant Notification instance Serialise Notification
28+deriving via WineryVariant TypeConstructorDef instance Serialise TypeConstructorDef
29+deriving via WineryVariant (TypeConstructorBase a) instance Serialise a => Serialise (TypeConstructorBase a)
30+deriving via WineryVariant DataConstructorDef instance Serialise DataConstructorDef
31+deriving via WineryVariant DataConstructorDefArg instance Serialise DataConstructorDefArg
32+deriving via WineryVariant GraphRefTransactionMarker instance Serialise GraphRefTransactionMarker
33+deriving via WineryVariant SchemaIsomorph instance Serialise SchemaIsomorph
34+deriving via WineryVariant InclusionDependency instance Serialise InclusionDependency
35+deriving via WineryVariant (DatabaseContextExprBase a) instance Serialise a => Serialise (DatabaseContextExprBase a)
36+deriving via WineryVariant (DatabaseContextIOExprBase a) instance Serialise a => Serialise (DatabaseContextIOExprBase a)
37+deriving via WineryVariant (RestrictionPredicateExprBase a) instance Serialise a => Serialise (RestrictionPredicateExprBase a)
38+deriving via WineryVariant TransactionInfo instance Serialise TransactionInfo
39+deriving via WineryVariant (AtomExprBase a) instance Serialise a => Serialise (AtomExprBase a)
40+deriving via WineryVariant MerkleHash instance Serialise MerkleHash
41+deriving via WineryVariant (AttributeExprBase a) instance Serialise a => Serialise (AttributeExprBase a)
42+deriving via WineryVariant (TupleExprsBase a) instance Serialise a => Serialise (TupleExprsBase a)
43+deriving via WineryVariant (TupleExprBase a) instance Serialise a => Serialise (TupleExprBase a)
44+deriving via WineryVariant (AttributeNamesBase a) instance Serialise a => Serialise (AttributeNamesBase a)
45+deriving via WineryVariant (ExtendTupleExprBase a) instance Serialise a => Serialise (ExtendTupleExprBase a)
46+deriving via WineryVariant Schema instance Serialise Schema
47+deriving via WineryVariant MergeStrategy instance Serialise MergeStrategy
48+
49+fromWordsTup :: (Word32, Word32, Word32, Word32) -> TransactionId
50+fromWordsTup (a,b,c,d) = fromWords a b c d
51+
52+instance Serialise TransactionId where
53+ schemaGen _ = getSchema (Proxy @(Word32, Word32, Word32, Word32))
54+ toBuilder uuid = toBuilder (toWords uuid)
55+ extractor = fromWordsTup <$> extractor
56+ decodeCurrent = fromWordsTup <$> decodeCurrent
57+
58+instance Serialise a => Serialise (NE.NonEmpty a) where
59+ schemaGen _ = SVector <$> getSchema (Proxy @a)
60+ toBuilder xs = varInt (length xs) <> foldMap toBuilder xs
61+ extractor = NE.fromList . V.toList <$> extractListBy extractor --use nonempty instead to replace error with winery error
62+ decodeCurrent = do
63+ n <- decodeVarInt
64+ l <- replicateM n decodeCurrent
65+ pure (NE.fromList l)
66+
67+fromGregorianTup :: (Integer, Int, Int) -> Day
68+fromGregorianTup (a, b, c) = fromGregorian a b c
69+
70+instance Serialise Day where
71+ schemaGen _ = getSchema (Proxy @(Integer, Int, Int))
72+ toBuilder day = toBuilder (toGregorian day)
73+ extractor = fromGregorianTup <$> extractor
74+ decodeCurrent = fromGregorianTup <$> decodeCurrent
75+
76+instance Serialise Attributes where
77+ schemaGen _ = SVector <$> getSchema (Proxy @Attribute)
78+ toBuilder attrs = varInt (V.length (attributesVec attrs)) <> foldMap toBuilder (V.toList (attributesVec attrs))
79+ extractor =
80+ attributesFromList . V.toList <$> extractListBy extractor
81+
82+ decodeCurrent = do
83+ n <- decodeVarInt
84+ l <- replicateM n decodeCurrent
85+ pure (A.attributesFromList l)
src/lib/ProjectM36/Serialise/DataFrame.hsnew file+13
@@ -0,0 +1,13 @@
1+{-# LANGUAGE DerivingVia, StandaloneDeriving #-}
2+{-# OPTIONS_GHC -fno-warn-orphans #-}
3+module ProjectM36.Serialise.DataFrame where
4+import Codec.Winery
5+import ProjectM36.DataFrame
6+import ProjectM36.Serialise.Base ()
7+
8+deriving via WineryVariant AttributeOrderExpr instance Serialise AttributeOrderExpr
9+deriving via WineryVariant AttributeOrder instance Serialise AttributeOrder
10+deriving via WineryVariant Order instance Serialise Order
11+deriving via WineryRecord DataFrame instance Serialise DataFrame
12+deriving via WineryVariant DataFrameTuple instance Serialise DataFrameTuple
13+deriving via WineryRecord DataFrameExpr instance Serialise DataFrameExpr
src/lib/ProjectM36/Serialise/DatabaseContextFunctionError.hsnew file+7
@@ -0,0 +1,7 @@
1+{-# LANGUAGE DerivingVia, StandaloneDeriving #-}
2+{-# OPTIONS_GHC -fno-warn-orphans #-}
3+module ProjectM36.Serialise.DatabaseContextFunctionError where
4+import Codec.Winery
5+import ProjectM36.DatabaseContextFunctionError
6+
7+deriving via WineryVariant DatabaseContextFunctionError instance Serialise DatabaseContextFunctionError
src/lib/ProjectM36/Serialise/Error.hsnew file+15
@@ -0,0 +1,15 @@
1+{-# LANGUAGE DerivingVia, StandaloneDeriving #-}
2+{-# OPTIONS_GHC -fno-warn-orphans #-}
3+module ProjectM36.Serialise.Error where
4+import ProjectM36.Error
5+import Codec.Winery
6+import ProjectM36.Serialise.Base ()
7+import ProjectM36.Serialise.AtomFunctionError ()
8+import ProjectM36.Serialise.DatabaseContextFunctionError ()
9+
10+deriving via WineryVariant RelationalError instance Serialise RelationalError
11+deriving via WineryVariant MergeError instance Serialise MergeError
12+deriving via WineryVariant ScriptCompilationError instance Serialise ScriptCompilationError
13+deriving via WineryVariant PersistenceError instance Serialise PersistenceError
14+deriving via WineryVariant SchemaError instance Serialise SchemaError
15+deriving via WineryVariant ImportError' instance Serialise ImportError'
src/lib/ProjectM36/Serialise/IsomorphicSchema.hsnew file+7
@@ -0,0 +1,7 @@
1+{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeSynonymInstances, ScopedTypeVariables #-}
2+{-# OPTIONS_GHC -fno-warn-orphans #-}
3+module ProjectM36.Serialise.IsomorphicSchema where
4+import Codec.Winery
5+import ProjectM36.IsomorphicSchema
6+
7+deriving via WineryVariant SchemaExpr instance Serialise SchemaExpr
src/lib/ProjectM36/Serialise/MergeError.hsnew file+1
@@ -0,0 +1 @@
1+
src/lib/ProjectM36/Server.hs+166−90
@@ -7,76 +7,119 @@ import ProjectM36.Server.RemoteCallTypes
77import ProjectM36.Server.Config (ServerConfig(..))
88import ProjectM36.FSType
99
10−import Control.Monad.IO.Class (liftIO)
11−#if MIN_VERSION_network_transport_tcp(0,7,0)
12−import Network.Transport.TCP (createTransport, defaultTCPParameters, defaultTCPAddr)
13−#else
14−import Network.Transport.TCP (createTransport, defaultTCPParameters)
15−#endif
16−import Network.Transport (EndPointAddress(..), newEndPoint, address)
17−import Control.Distributed.Process.Node (initRemoteTable, runProcess, newLocalNode, initRemoteTable)
18−import Control.Distributed.Process.Extras.Time (Delay(..))
19−import Control.Distributed.Process (Process, register, getSelfPid)
20−import Control.Distributed.Process.ManagedProcess (defaultProcess, UnhandledMessagePolicy(..), ProcessDefinition(..), handleCall, serve, InitHandler, InitResult(..))
21−import Control.Concurrent.MVar (putMVar, MVar)
10+import Control.Concurrent.MVar (MVar)
2211import System.IO (stderr, hPutStrLn)
2312import System.FilePath (takeDirectory)
2413import System.Directory (doesDirectoryExist)
14+import Network.RPC.Curryer.Server
15+import Network.Socket
16+import qualified StmContainers.Map as StmMap
17+import Control.Concurrent.STM
2518
26−-- the state should be a mapping of remote connection to the disconnected transaction- the graph should be the same, so discon must be removed from the stm tuple
27−--trying to refactor this for less repetition is very challenging because the return type cannot be polymorphic or the distributed-process call gets confused and drops messages
28−serverDefinition :: Bool -> Timeout -> ProcessDefinition Connection
29−serverDefinition testBool ti = defaultProcess {
30− apiHandlers = [
31− handleCall (\conn (ExecuteHeadName sessionId) -> handleExecuteHeadName ti sessionId conn),
32− handleCall (\conn (ExecuteRelationalExpr sessionId expr) -> handleExecuteRelationalExpr ti sessionId conn expr),
33− handleCall (\conn (ExecuteDataFrameExpr sessionId expr) -> handleExecuteDataFrameExpr ti sessionId conn expr),
34− handleCall (\conn (ExecuteDatabaseContextExpr sessionId expr) -> handleExecuteDatabaseContextExpr ti sessionId conn expr),
35− handleCall (\conn (ExecuteDatabaseContextIOExpr sessionId expr) -> handleExecuteDatabaseContextIOExpr ti sessionId conn expr),
36− handleCall (\conn (ExecuteGraphExpr sessionId expr) -> handleExecuteGraphExpr ti sessionId conn expr),
37− handleCall (\conn (ExecuteTransGraphRelationalExpr sessionId expr) -> handleExecuteTransGraphRelationalExpr ti sessionId conn expr),
38− handleCall (\conn (ExecuteTypeForRelationalExpr sessionId expr) -> handleExecuteTypeForRelationalExpr ti sessionId conn expr),
39− handleCall (\conn (RetrieveInclusionDependencies sessionId) -> handleRetrieveInclusionDependencies ti sessionId conn),
40− handleCall (\conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr),
41− handleCall (\conn (RetrieveHeadTransactionId sessionId) -> handleRetrieveHeadTransactionId ti sessionId conn),
42− handleCall (\conn (RetrieveTransactionGraph sessionId) -> handleRetrieveTransactionGraph ti sessionId conn),
43− handleCall (\conn (Login procId) -> handleLogin ti conn procId),
44− handleCall (\conn (CreateSessionAtHead headn) -> handleCreateSessionAtHead ti conn headn),
45− handleCall (\conn (CreateSessionAtCommit commitId) -> handleCreateSessionAtCommit ti conn commitId),
46− handleCall (\conn (CloseSession sessionId) -> handleCloseSession ti sessionId conn),
47− handleCall (\conn (RetrieveAtomTypesAsRelation sessionId) -> handleRetrieveAtomTypesAsRelation ti sessionId conn),
48− handleCall (\conn (RetrieveRelationVariableSummary sessionId) -> handleRetrieveRelationVariableSummary ti sessionId conn),
49− handleCall (\conn (RetrieveAtomFunctionSummary sessionId) -> handleRetrieveAtomFunctionSummary ti sessionId conn),
50− handleCall (\conn (RetrieveDatabaseContextFunctionSummary sessionId) -> handleRetrieveDatabaseContextFunctionSummary ti sessionId conn),
51− handleCall (\conn (RetrieveCurrentSchemaName sessionId) -> handleRetrieveCurrentSchemaName ti sessionId conn),
52− handleCall (\conn (ExecuteSchemaExpr sessionId schemaExpr) -> handleExecuteSchemaExpr ti sessionId conn schemaExpr),
53− handleCall (\conn (RetrieveSessionIsDirty sessionId) -> handleRetrieveSessionIsDirty ti sessionId conn),
54− handleCall (\conn (ExecuteAutoMergeToHead sessionId strat headName') -> handleExecuteAutoMergeToHead ti sessionId conn strat headName'),
55− handleCall (\conn (RetrieveTypeConstructorMapping sessionId) -> handleRetrieveTypeConstructorMapping ti sessionId conn),
56− handleCall (\conn Logout -> handleLogout ti conn)
57− ] ++ testModeHandlers,
58− unhandledMessagePolicy = Terminate
59− --unhandledMessagePolicy = Log
60− }
61− where
62− testModeHandlers = [handleCall (\conn (TestTimeout sessionId) -> handleTestTimeout ti sessionId conn) | testBool]
63−
64−initServer :: InitHandler (Connection, DatabaseName, Maybe (MVar EndPointAddress), EndPointAddress) Connection
65−initServer (conn, dbname, mAddressMVar, saddress) = do
66− registerDB dbname
67− case mAddressMVar of
68− Nothing -> pure ()
69− Just addressMVar -> liftIO $ putMVar addressMVar saddress
70− --traceShowM ("server started on " ++ show saddress)
71− pure $ InitOk conn Infinity
19+type TestMode = Bool
7220
73−registerDB :: DatabaseName -> Process ()
74−registerDB dbname = do
75− self <- getSelfPid
76− let dbname' = remoteDBLookupName dbname
77− register dbname' self
78− --liftIO $ putStrLn $ "registered " ++ (show self) ++ " " ++ dbname'
79−
21+requestHandlers :: TestMode -> Maybe Timeout -> RequestHandlers ServerState
22+requestHandlers testFlag ti =
23+ [
24+ RequestHandler (\sState (Login dbName) -> do
25+ addClientLogin dbName sState
26+ conn <- getConn sState
27+ handleLogin conn (connectionSocket sState)),
28+ RequestHandler (\sState Logout -> do
29+ conn <- getConn sState
30+ handleLogout ti conn),
31+ RequestHandler $ \sState (ExecuteHeadName sessionId) -> do
32+ --socket -> dbname --maybe create a socket->client state mapping in the server state, too
33+ conn <- getConn sState
34+ handleExecuteHeadName ti sessionId conn,
35+ RequestHandler (\sState (ExecuteRelationalExpr sessionId expr) -> do
36+ conn <- getConn sState
37+ handleExecuteRelationalExpr ti sessionId conn expr),
38+ RequestHandler (\sState (ExecuteDataFrameExpr sessionId expr) -> do
39+ conn <- getConn sState
40+ handleExecuteDataFrameExpr ti sessionId conn expr),
41+ RequestHandler (\sState (ExecuteDatabaseContextExpr sessionId expr) -> do
42+ conn <- getConn sState
43+ handleExecuteDatabaseContextExpr ti sessionId conn expr),
44+ RequestHandler (\sState (ExecuteDatabaseContextIOExpr sessionId expr) -> do
45+ conn <- getConn sState
46+ handleExecuteDatabaseContextIOExpr ti sessionId conn expr),
47+ RequestHandler (\sState (ExecuteGraphExpr sessionId expr) -> do
48+ conn <- getConn sState
49+ handleExecuteGraphExpr ti sessionId conn expr),
50+ RequestHandler (\sState (ExecuteTransGraphRelationalExpr sessionId expr) -> do
51+ conn <- getConn sState
52+ handleExecuteTransGraphRelationalExpr ti sessionId conn expr),
53+ RequestHandler (\sState (ExecuteTypeForRelationalExpr sessionId expr) -> do
54+ conn <- getConn sState
55+ handleExecuteTypeForRelationalExpr ti sessionId conn expr),
56+ RequestHandler (\sState (RetrieveInclusionDependencies sessionId) -> do
57+ conn <- getConn sState
58+ handleRetrieveInclusionDependencies ti sessionId conn),
59+ RequestHandler (\sState (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> do
60+ conn <- getConn sState
61+ handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr),
62+ RequestHandler (\sState (RetrieveHeadTransactionId sessionId) -> do
63+ conn <- getConn sState
64+ handleRetrieveHeadTransactionId ti sessionId conn),
65+ RequestHandler (\sState (RetrieveTransactionGraph sessionId) -> do
66+ conn <- getConn sState
67+ handleRetrieveTransactionGraph ti sessionId conn),
68+ RequestHandler (\sState (CreateSessionAtHead headn) -> do
69+ conn <- getConn sState
70+ handleCreateSessionAtHead ti conn headn),
71+ RequestHandler (\sState (CreateSessionAtCommit commitId) -> do
72+ conn <- getConn sState
73+ handleCreateSessionAtCommit ti conn commitId),
74+ RequestHandler (\sState (CloseSession sessionId) -> do
75+ conn <- getConn sState
76+ handleCloseSession sessionId conn),
77+ RequestHandler (\sState (RetrieveAtomTypesAsRelation sessionId) -> do
78+ conn <- getConn sState
79+ handleRetrieveAtomTypesAsRelation ti sessionId conn),
80+ RequestHandler (\sState (RetrieveRelationVariableSummary sessionId) -> do
81+ conn <- getConn sState
82+ handleRetrieveRelationVariableSummary ti sessionId conn),
83+ RequestHandler (\sState (RetrieveAtomFunctionSummary sessionId) -> do
84+ conn <- getConn sState
85+ handleRetrieveAtomFunctionSummary ti sessionId conn),
86+ RequestHandler (\sState (RetrieveDatabaseContextFunctionSummary sessionId) -> do
87+ conn <- getConn sState
88+ handleRetrieveDatabaseContextFunctionSummary ti sessionId conn), RequestHandler (\sState (RetrieveCurrentSchemaName sessionId) -> do
89+ conn <- getConn sState
90+ handleRetrieveCurrentSchemaName ti sessionId conn),
91+ RequestHandler (\sState (ExecuteSchemaExpr sessionId schemaExpr) -> do
92+ conn <- getConn sState
93+ handleExecuteSchemaExpr ti sessionId conn schemaExpr),
94+ RequestHandler (\sState (RetrieveSessionIsDirty sessionId) -> do
95+ conn <- getConn sState
96+ handleRetrieveSessionIsDirty ti sessionId conn),
97+ RequestHandler (\sState (ExecuteAutoMergeToHead sessionId strat headName') -> do
98+ conn <- getConn sState
99+ handleExecuteAutoMergeToHead ti sessionId conn strat headName'),
100+ RequestHandler (\sState (RetrieveTypeConstructorMapping sessionId) -> do
101+ conn <- getConn sState
102+ handleRetrieveTypeConstructorMapping ti sessionId conn),
103+ RequestHandler (\sState (ExecuteValidateMerkleHashes sessionId) -> do
104+ conn <- getConn sState
105+ handleValidateMerkleHashes ti sessionId conn)
106+ ] ++ if testFlag then testModeHandlers ti else []
107+
108+getConn :: ConnectionState ServerState -> IO Connection
109+getConn connState = do
110+ let sock = lockless (connectionSocket connState)
111+ sState = connectionServerState connState
112+ mConn <- connectionForClient sock sState
113+ case mConn of
114+ Nothing -> error "failed to find socket in client map"
115+ Just conn -> pure conn
116+
117+testModeHandlers :: Maybe Timeout -> RequestHandlers ServerState
118+testModeHandlers ti = [RequestHandler (\sState (TestTimeout sessionId) -> do
119+ conn <- getConn sState
120+ handleTestTimeout ti sessionId conn)]
121+
122+
80123-- | A notification callback which logs the notification to stderr and does nothing else.
81124loggingNotificationCallback :: NotificationCallback
82125loggingNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received \"" ++ show notName ++ "\": " ++ show evaldNot
@@ -101,9 +144,47 @@ checkFSType performCheck strat =
101144checkFSErrorMsg :: String
102145checkFSErrorMsg = "The filesystem does not support journaling so writes may not be crash-safe. Use --disable-fscheck to disable this fatal error."
103146
147+-- Sockets do not implement hashable, so we just use their string values as keys
148+type SocketString = String
149+
150+data ServerState =
151+ ServerState {
152+ --map available databases to local database configurations
153+ stateDBMap :: StmMap.Map DatabaseName Connection,
154+ --map clients to database names- after logging in, clients are afixed to specific database names
155+ stateClientMap :: StmMap.Map SocketString DatabaseName
156+ }
157+
158+-- add a client socket to the database mapping
159+addClientLogin :: DatabaseName -> ConnectionState ServerState -> IO ()
160+addClientLogin dbName cState = do
161+ let clientMap = stateClientMap (connectionServerState cState)
162+ sock = lockless (connectionSocket cState)
163+ atomically $ do
164+ mVal <- StmMap.lookup (show sock) clientMap
165+ case mVal of
166+ Nothing -> StmMap.insert dbName (show sock) clientMap
167+ Just _ -> pure () --TODO: throw exception- user already logged in
168+
169+connectionForClient :: Socket -> ServerState -> IO (Maybe Connection)
170+connectionForClient sock sState =
171+ atomically $ do
172+ mdbname <- StmMap.lookup (show sock) (stateClientMap sState)
173+ case mdbname of
174+ Nothing -> pure Nothing
175+ Just dbname ->
176+ StmMap.lookup dbname (stateDBMap sState)
177+
178+initialServerState :: DatabaseName -> Connection -> IO ServerState
179+initialServerState dbName conn =
180+ atomically $ do
181+ dbmap <- StmMap.new
182+ clientMap <- StmMap.new
183+ StmMap.insert conn dbName dbmap
184+ pure (ServerState { stateDBMap = dbmap, stateClientMap = clientMap })
104185-- | A synchronous function to start the project-m36 daemon given an appropriate 'ServerConfig'. Note that this function only returns if the server exits. Returns False if the daemon exited due to an error. If the second argument is not Nothing, the port is put after the server is ready to service the port.
105−launchServer :: ServerConfig -> Maybe (MVar EndPointAddress) -> IO Bool
106−launchServer daemonConfig mAddressMVar = do
186+launchServer :: ServerConfig -> Maybe (MVar SockAddr) -> IO Bool
187+launchServer daemonConfig mAddr = do
107188 checkFSResult <- checkFSType (checkFS daemonConfig) (persistenceStrategy daemonConfig)
108189 if not checkFSResult then do
109190 hPutStrLn stderr checkFSErrorMsg
@@ -116,26 +197,21 @@ launchServer daemonConfig mAddressMVar = do
116197 pure False
117198 Right conn -> do
118199 let hostname = bindHost daemonConfig
119− port = bindPort daemonConfig
120−#if MIN_VERSION_network_transport_tcp(0,7,0)
121− etransport <- createTransport (defaultTCPAddr hostname (show port)) defaultTCPParameters
122−#elif MIN_VERSION_network_transport_tcp(0,6,0)
123− etransport <- createTransport hostname (show port) (\nam -> (hostname, nam)) defaultTCPParameters
124−#else
125− etransport <- createTransport hostname (show port) defaultTCPParameters
126−#endif
127− case etransport of
128− Left err -> error ("failed to create transport: " ++ show err)
129− Right transport -> do
130− eEndpoint <- newEndPoint transport
131− case eEndpoint of
132− Left err -> hPutStrLn stderr ("Failed to create transport: " ++ show err) >> pure False
133− Right endpoint -> do
134− localTCPNode <- newLocalNode transport initRemoteTable
135− --traceShowM ("newLocalNode in Server " ++ show (localNodeId localTCPNode))
136− runProcess localTCPNode $ do
137− let testBool = testMode daemonConfig
138− reqTimeout = perRequestTimeout daemonConfig
139− serve (conn, databaseName daemonConfig, mAddressMVar, address endpoint) initServer (serverDefinition testBool reqTimeout)
140− liftIO $ putStrLn "serve returned"
141− pure True
200+ port = fromIntegral (bindPort daemonConfig)
201+
202+
203+ --curryer only supports IPv4 for now
204+ let addrHints = defaultHints { addrSocketType = Stream, addrFamily = AF_INET }
205+ hostAddrs <- getAddrInfo (Just addrHints) (Just hostname) Nothing
206+ case hostAddrs of
207+ [] -> hPutStrLn stderr ("Failed to resolve: " <> hostname) >> pure False
208+ (AddrInfo _ _ _ _ (SockAddrInet _ addr32) _):_ -> do
209+ let hostAddr = hostAddressToTuple addr32
210+ mTimeout = fromIntegral <$> case perRequestTimeout daemonConfig of
211+ 0 -> Nothing
212+ v -> Just v
213+
214+ sState <- initialServerState (databaseName daemonConfig) conn
215+ serve (requestHandlers (testMode daemonConfig) mTimeout) sState hostAddr port mAddr
216+ _ -> error "unsupported socket addressing mode (IPv4 only currently)"
217+
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+125−153
@@ -3,172 +3,144 @@ module ProjectM36.Server.EntryPoints where
33import ProjectM36.Base hiding (inclusionDependencies)
44import ProjectM36.IsomorphicSchema
55import ProjectM36.Client as C
6−import ProjectM36.Error
7−import Control.Distributed.Process (Process, ProcessId)
8−import Control.Distributed.Process.ManagedProcess (ProcessReply)
9−import Control.Distributed.Process.ManagedProcess.Server (reply)
10−import Control.Distributed.Process.Async (async, task, waitCancelTimeout, AsyncResult(..))
11−import Control.Monad.IO.Class (liftIO)
126import Data.Map
137import Control.Concurrent (threadDelay)
14−import Data.Typeable
15−import Data.Binary
8+import Network.RPC.Curryer.Server
9+import System.Timeout hiding (Timeout)
10+import Network.Socket
11+import Control.Exception
1612
17−timeoutOrDie :: (Binary a, Typeable a) => Timeout -> IO a -> Process (Either ServerError a)
18−timeoutOrDie micros act =
19− if micros == 0 then
20− liftIO act >>= \x -> pure (Right x)
21− else do
22− asyncUnit <- async (task (liftIO act))
23− asyncRes <- waitCancelTimeout micros asyncUnit
24− case asyncRes of
25− AsyncDone x -> pure (Right x)
26− AsyncCancelled -> pure (Left RequestTimeoutError)
27− AsyncFailed reason -> pure (Left (ProcessDiedError (show reason)))
28− AsyncLinkFailed reason -> pure (Left (ProcessDiedError (show reason)))
29− AsyncPending -> pure (Left (ProcessDiedError "process pending"))
30−
31−type Timeout = Int
32−
33−type Reply a = Process (ProcessReply (Either ServerError a) Connection)
34−
35−handleExecuteRelationalExpr :: Timeout -> SessionId -> Connection -> RelationalExpr -> Reply (Either RelationalError Relation)
36−handleExecuteRelationalExpr ti sessionId conn expr = do
37− ret <- timeoutOrDie ti (executeRelationalExpr sessionId conn expr)
38− reply ret conn
13+timeoutOrDie :: Maybe Timeout -> IO a -> IO (Maybe a)
14+timeoutOrDie mMicros act =
15+ case mMicros of
16+ Nothing -> Just <$> act
17+ Just micros ->
18+ timeout (fromIntegral micros) act
3919
40−handleExecuteDataFrameExpr :: Timeout -> SessionId -> Connection -> DataFrameExpr -> Reply (Either RelationalError DataFrame)
41−handleExecuteDataFrameExpr ti sessionId conn expr = do
42− ret <- timeoutOrDie ti (executeDataFrameExpr sessionId conn expr)
43− reply ret conn
44−
45−handleExecuteDatabaseContextExpr :: Timeout -> SessionId -> Connection -> DatabaseContextExpr -> Reply (Either RelationalError ())
46−handleExecuteDatabaseContextExpr ti sessionId conn dbexpr = do
47− ret <- timeoutOrDie ti (executeDatabaseContextExpr sessionId conn dbexpr)
48− reply ret conn
49−
50−handleExecuteDatabaseContextIOExpr :: Timeout -> SessionId -> Connection -> DatabaseContextIOExpr -> Reply (Either RelationalError ())
51−handleExecuteDatabaseContextIOExpr ti sessionId conn dbexpr = do
52− ret <- timeoutOrDie ti (executeDatabaseContextIOExpr sessionId conn dbexpr)
53− reply ret conn
54−
55−handleExecuteHeadName :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError HeadName)
56−handleExecuteHeadName ti sessionId conn = do
57− ret <- timeoutOrDie ti (headName sessionId conn)
58− reply ret conn
59−
60−handleLogin :: Timeout -> Connection -> ProcessId -> Reply Bool
61−handleLogin ti conn newClientProcessId = do
62− ret <- timeoutOrDie ti (addClientNode conn newClientProcessId)
20+timeoutRelErr :: Maybe Timeout -> IO (Either RelationalError a) -> IO (Either RelationalError a)
21+timeoutRelErr mMicros act = do
22+ ret <- timeoutOrDie mMicros act
6323 case ret of
64− Right () -> reply (Right True) conn
65− Left err -> reply (Left err) conn
66−
67−handleExecuteGraphExpr :: Timeout -> SessionId -> Connection -> TransactionGraphOperator -> Reply (Either RelationalError ())
68−handleExecuteGraphExpr ti sessionId conn graphExpr = do
69− ret <- timeoutOrDie ti (executeGraphExpr sessionId conn graphExpr)
70− reply ret conn
71−
72−handleExecuteTransGraphRelationalExpr :: Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> Reply (Either RelationalError Relation)
73−handleExecuteTransGraphRelationalExpr ti sessionId conn graphExpr = do
74− ret <- timeoutOrDie ti (executeTransGraphRelationalExpr sessionId conn graphExpr)
75− reply ret conn
24+ Nothing -> throw TimeoutException
25+ Just v -> pure v
26+
7627
77−handleExecuteTypeForRelationalExpr :: Timeout -> SessionId -> Connection -> RelationalExpr -> Reply (Either RelationalError Relation)
78−handleExecuteTypeForRelationalExpr ti sessionId conn relExpr = do
79− ret <- timeoutOrDie ti (typeForRelationalExpr sessionId conn relExpr)
80− reply ret conn
81−
82−handleRetrieveInclusionDependencies :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError (Map IncDepName InclusionDependency))
83−handleRetrieveInclusionDependencies ti sessionId conn = do
84− ret <- timeoutOrDie ti (inclusionDependencies sessionId conn)
85− reply ret conn
86−
87−handleRetrievePlanForDatabaseContextExpr :: Timeout -> SessionId -> Connection -> DatabaseContextExpr -> Reply (Either RelationalError GraphRefDatabaseContextExpr)
88−handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr = do
89− ret <- timeoutOrDie ti (planForDatabaseContextExpr sessionId conn dbExpr)
90− reply ret conn
91−
92−handleRetrieveTransactionGraph :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)
93−handleRetrieveTransactionGraph ti sessionId conn = do
94− ret <- timeoutOrDie ti (transactionGraphAsRelation sessionId conn)
95− reply ret conn
96−
97−handleRetrieveHeadTransactionId :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError TransactionId)
98−handleRetrieveHeadTransactionId ti sessionId conn = do
99− ret <- timeoutOrDie ti (headTransactionId sessionId conn)
100− reply ret conn
101−
102−handleCreateSessionAtCommit :: Timeout -> Connection -> TransactionId -> Reply (Either RelationalError SessionId)
103−handleCreateSessionAtCommit ti conn commitId = do
104− ret <- timeoutOrDie ti (createSessionAtCommit conn commitId)
105− reply ret conn
106−
107−handleCreateSessionAtHead :: Timeout -> Connection -> HeadName -> Reply (Either RelationalError SessionId)
108−handleCreateSessionAtHead ti conn headn = do
109− ret <- timeoutOrDie ti (createSessionAtHead conn headn)
110− reply ret conn
111−
112−handleCloseSession :: Timeout -> SessionId -> Connection -> Reply ()
113−handleCloseSession ti sessionId conn = do
114− ret <- timeoutOrDie ti (closeSession sessionId conn)
115− case ret of
116− Right () -> reply (Right ()) conn
117− Left err -> reply (Left err) conn
28+handleExecuteRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)
29+handleExecuteRelationalExpr ti sessionId conn expr =
30+ timeoutRelErr ti (executeRelationalExpr sessionId conn expr)
31+
32+handleExecuteDataFrameExpr :: Maybe Timeout -> SessionId -> Connection -> DataFrameExpr -> IO (Either RelationalError DataFrame)
33+handleExecuteDataFrameExpr ti sessionId conn expr =
34+ timeoutRelErr ti (executeDataFrameExpr sessionId conn expr)
35+
36+handleExecuteDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())
37+handleExecuteDatabaseContextExpr ti sessionId conn dbexpr =
38+ timeoutRelErr ti (executeDatabaseContextExpr sessionId conn dbexpr)
39+
40+handleExecuteDatabaseContextIOExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextIOExpr -> IO (Either RelationalError ())
41+handleExecuteDatabaseContextIOExpr ti sessionId conn dbexpr =
42+ timeoutRelErr ti (executeDatabaseContextIOExpr sessionId conn dbexpr)
43+
44+handleExecuteHeadName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError HeadName)
45+handleExecuteHeadName ti sessionId conn =
46+ timeoutRelErr ti (headName sessionId conn)
47+
48+handleLogin :: Connection -> Locking Socket -> IO Bool
49+handleLogin conn lockSock = do
50+ addClientNode conn lockSock
51+ pure True
52+
53+handleExecuteGraphExpr :: Maybe Timeout -> SessionId -> Connection -> TransactionGraphOperator -> IO (Either RelationalError ())
54+handleExecuteGraphExpr ti sessionId conn graphExpr =
55+ timeoutRelErr ti (executeGraphExpr sessionId conn graphExpr)
56+
57+handleExecuteTransGraphRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)
58+handleExecuteTransGraphRelationalExpr ti sessionId conn graphExpr =
59+ timeoutRelErr ti (executeTransGraphRelationalExpr sessionId conn graphExpr)
60+
61+handleExecuteTypeForRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)
62+handleExecuteTypeForRelationalExpr ti sessionId conn relExpr =
63+ timeoutRelErr ti (typeForRelationalExpr sessionId conn relExpr)
64+
65+handleRetrieveInclusionDependencies :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError (Map IncDepName InclusionDependency))
66+handleRetrieveInclusionDependencies ti sessionId conn =
67+ timeoutRelErr ti (inclusionDependencies sessionId conn)
68+
69+handleRetrievePlanForDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)
70+handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr =
71+ timeoutRelErr ti (planForDatabaseContextExpr sessionId conn dbExpr)
72+
73+handleRetrieveTransactionGraph :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)
74+handleRetrieveTransactionGraph ti sessionId conn =
75+ timeoutRelErr ti (transactionGraphAsRelation sessionId conn)
76+
77+handleRetrieveHeadTransactionId :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TransactionId)
78+handleRetrieveHeadTransactionId ti sessionId conn =
79+ timeoutRelErr ti (headTransactionId sessionId conn)
11880
119−handleRetrieveAtomTypesAsRelation :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)
120−handleRetrieveAtomTypesAsRelation ti sessionId conn = do
121− ret <- timeoutOrDie ti (atomTypesAsRelation sessionId conn)
122− reply ret conn
81+handleCreateSessionAtCommit :: Maybe Timeout -> Connection -> TransactionId -> IO (Either RelationalError SessionId)
82+handleCreateSessionAtCommit ti conn commitId =
83+ timeoutRelErr ti (createSessionAtCommit conn commitId)
84+
85+handleCreateSessionAtHead :: Maybe Timeout -> Connection -> HeadName -> IO (Either RelationalError SessionId)
86+handleCreateSessionAtHead ti conn headn =
87+ timeoutRelErr ti (createSessionAtHead conn headn)
88+
89+handleCloseSession :: SessionId -> Connection -> IO ()
90+handleCloseSession =
91+ closeSession
92+
93+handleRetrieveAtomTypesAsRelation :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)
94+handleRetrieveAtomTypesAsRelation ti sessionId conn =
95+ timeoutRelErr ti (atomTypesAsRelation sessionId conn)
12396
12497-- | Returns a relation which lists the names of relvars in the current session as well as its types.
125−handleRetrieveRelationVariableSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)
126−handleRetrieveRelationVariableSummary ti sessionId conn = do
127− ret <- timeoutOrDie ti (relationVariablesAsRelation sessionId conn)
128− reply ret conn
129−
130−handleRetrieveAtomFunctionSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)
131−handleRetrieveAtomFunctionSummary ti sessionId conn = do
132− ret <- timeoutOrDie ti (atomFunctionsAsRelation sessionId conn)
133− reply ret conn
134−
135−handleRetrieveDatabaseContextFunctionSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)
136−handleRetrieveDatabaseContextFunctionSummary ti sessionId conn = do
137− ret <- timeoutOrDie ti (databaseContextFunctionsAsRelation sessionId conn)
138− reply ret conn
139−
140−handleRetrieveCurrentSchemaName :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError SchemaName)
141−handleRetrieveCurrentSchemaName ti sessionId conn = do
142− ret <- timeoutOrDie ti (currentSchemaName sessionId conn)
143− reply ret conn
98+handleRetrieveRelationVariableSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)
99+handleRetrieveRelationVariableSummary ti sessionId conn =
100+ timeoutRelErr ti (relationVariablesAsRelation sessionId conn)
101+
102+handleRetrieveAtomFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)
103+handleRetrieveAtomFunctionSummary ti sessionId conn =
104+ timeoutRelErr ti (atomFunctionsAsRelation sessionId conn)
105+
106+handleRetrieveDatabaseContextFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)
107+handleRetrieveDatabaseContextFunctionSummary ti sessionId conn =
108+ timeoutRelErr ti (databaseContextFunctionsAsRelation sessionId conn)
109+
110+handleRetrieveCurrentSchemaName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError SchemaName)
111+handleRetrieveCurrentSchemaName ti sessionId conn =
112+ timeoutRelErr ti (currentSchemaName sessionId conn)
144113
145−handleExecuteSchemaExpr :: Timeout -> SessionId -> Connection -> SchemaExpr -> Reply (Either RelationalError ())
146−handleExecuteSchemaExpr ti sessionId conn schemaExpr = do
147− ret <- timeoutOrDie ti (executeSchemaExpr sessionId conn schemaExpr)
148− reply ret conn
114+handleExecuteSchemaExpr :: Maybe Timeout -> SessionId -> Connection -> SchemaExpr -> IO (Either RelationalError ())
115+handleExecuteSchemaExpr ti sessionId conn schemaExpr =
116+ timeoutRelErr ti (executeSchemaExpr sessionId conn schemaExpr)
149117
150−handleLogout :: Timeout -> Connection -> Reply Bool
151−handleLogout _ =
118+handleLogout :: Maybe Timeout -> Connection -> IO Bool
119+handleLogout _ _ =
152120 --liftIO $ closeRemote_ conn
153− reply (pure True)
121+ pure True
154122
155−handleTestTimeout :: Timeout -> SessionId -> Connection -> Reply Bool
156−handleTestTimeout ti _ conn = do
157− ret <- timeoutOrDie ti (threadDelay 100000 >> pure True)
158− reply ret conn
123+handleTestTimeout :: Maybe Timeout -> SessionId -> Connection -> IO Bool
124+handleTestTimeout ti _ _ = do
125+ ret <- timeoutRelErr ti (threadDelay 100000 >> pure (Right ()))
126+ case ret of
127+ Right () -> pure True
128+ Left _ -> pure False
159129
160−handleRetrieveSessionIsDirty :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Bool)
161−handleRetrieveSessionIsDirty ti sessionId conn = do
162− ret <- timeoutOrDie ti (disconnectedTransactionIsDirty sessionId conn)
163− reply ret conn
164−
165−handleExecuteAutoMergeToHead :: Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> Reply (Either RelationalError ())
166−handleExecuteAutoMergeToHead ti sessionId conn strat headName' = do
167− ret <- timeoutOrDie ti (autoMergeToHead sessionId conn strat headName')
168− reply ret conn
130+
131+
132+handleRetrieveSessionIsDirty :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Bool)
133+handleRetrieveSessionIsDirty ti sessionId conn =
134+ timeoutRelErr ti (disconnectedTransactionIsDirty sessionId conn)
135+
136+handleExecuteAutoMergeToHead :: Maybe Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())
137+handleExecuteAutoMergeToHead ti sessionId conn strat headName' =
138+ timeoutRelErr ti (autoMergeToHead sessionId conn strat headName')
169139
170−handleRetrieveTypeConstructorMapping :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError TypeConstructorMapping)
171−handleRetrieveTypeConstructorMapping ti sessionId conn = do
172− ret <- timeoutOrDie ti (C.typeConstructorMapping sessionId conn)
173− reply ret conn
140+handleRetrieveTypeConstructorMapping :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)
141+handleRetrieveTypeConstructorMapping ti sessionId conn =
142+ timeoutRelErr ti (C.typeConstructorMapping sessionId conn)
174143
144+handleValidateMerkleHashes :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError ())
145+handleValidateMerkleHashes ti sessionId conn =
146+ timeoutRelErr ti (C.validateMerkleHashes sessionId conn)
src/lib/ProjectM36/Server/ParseArgs.hs+38−15
@@ -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,46 +34,69 @@ parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>
3434
3535parseTestMode :: Parser Bool
3636parseTestMode = flag True False (long "test-mode" <> hidden)
37−
38−parseCheckFS :: Parser Bool
37+
38+parseCheckFS :: Parser Bool
3939parseCheckFS = flag True False (long "disable-fscheck" <>
4040 help "Disable filesystem check for journaling.")
41−
41+
4242parseDatabaseName :: Parser DatabaseName
4343parseDatabaseName = strOption (short 'n' <>
4444 long "database" <>
4545 metavar "DATABASE_NAME")
4646
47−parseHostname :: Hostname -> Parser Hostname
47+parseHostname :: Hostname -> Parser Hostname
4848parseHostname defHostname = strOption (short 'h' <>
4949 long "hostname" <>
5050 metavar "HOST_NAME" <>
5151 value defHostname)
52−
53−parsePort :: Port -> Parser Port
52+
53+parsePort :: Port -> Parser Port
5454parsePort defPort = option auto (short 'p' <>
5555 long "port" <>
5656 metavar "PORT_NUMBER" <>
5757 value defPort)
58−
58+
5959parseGhcPkgPath :: Parser String
6060parseGhcPkgPath = strOption (long "ghc-pkg-dir" <>
6161 metavar "GHC_PACKAGE_DIRECTORY")
62−
63−parseTimeout :: Int -> Parser Int
62+
63+parseTimeout :: Int -> Parser Int
6464parseTimeout defTimeout = option auto (long "timeout" <>
6565 metavar "MICROSECONDS" <>
6666 value defTimeout)
6767
6868parseConfig :: IO ServerConfig
6969parseConfig = parseConfigWithDefaults defaultServerConfig
70−
70+
7171parseConfigWithDefaults :: ServerConfig -> IO ServerConfig
7272parseConfigWithDefaults defaults = execParser (info (parseArgsWithDefaults defaults <**> helpOption) idm)
7373
74+parseWSConfigWithDefaults :: ServerConfig -> IO WebsocketServerConfig
75+parseWSConfigWithDefaults defaults = execParser (info (parseWSArgsWithDefaults defaults <**> helpOption) idm)
76+
77+parseWSArgsWithDefaults :: ServerConfig -> Parser WebsocketServerConfig
78+parseWSArgsWithDefaults defaults = WebsocketServerConfig <$>
79+ parseArgsWithDefaults defaults <*>
80+ parseTlsCertificatePath <*>
81+ parseTlsKeyPath
82+
83+
84+parseTlsCertificatePath :: Parser (Maybe String)
85+parseTlsCertificatePath = optional $ strOption (long "tls-certificate-path" <>
86+ metavar "TLS_CERTIFICATE_PATH")
87+
88+parseTlsKeyPath :: Parser (Maybe String)
89+parseTlsKeyPath = optional $ strOption (long "tls-key-path" <>
90+ metavar "TLS_KEY_PATH")
7491
7592helpOption :: Parser (a -> a)
76−helpOption = abortOption ShowHelpText $ mconcat
93+helpOption = abortOption helpText $ mconcat
7794 [ long "help"
7895 , help "Show this help text"
7996 , hidden ]
97+ where
98+#if MIN_VERSION_optparse_applicative(0,16,0)
99+ helpText = ShowHelpText Nothing
100+#else
101+ helpText = ShowHelpText
102+#endif
src/lib/ProjectM36/Server/RemoteCallTypes.hs+67−35
@@ -1,4 +1,4 @@
1−{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}
1+{-# LANGUAGE DeriveGeneric, DerivingVia, CPP #-}
22module ProjectM36.Server.RemoteCallTypes where
33import ProjectM36.Base
44import ProjectM36.IsomorphicSchema
@@ -6,66 +6,98 @@ import ProjectM36.TransactionGraph
66import ProjectM36.DataFrame
77import ProjectM36.TransGraphRelationalExpression
88import ProjectM36.Session
9+import ProjectM36.Serialise.DataFrame ()
10+import ProjectM36.Serialise.IsomorphicSchema ()
911import GHC.Generics
10−import Data.Binary
11−import Control.Distributed.Process (ProcessId)
12+import Codec.Winery
13+
14+#define RPCData(typeName) deriving Generic \
15+ deriving Serialise via WineryVariant typeName
1216
1317{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}
1418-- | The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.
15−data Login = Login ProcessId
16− deriving (Binary, Generic)
19+data Login = Login DatabaseName
20+ RPCData(Login)
1721
1822data Logout = Logout
19− deriving (Binary, Generic)
20−data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr
21− deriving (Binary, Generic)
23+ RPCData(Logout)
24+
25+data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr
26+ RPCData(ExecuteRelationalExpr)
27+
2228data ExecuteDataFrameExpr = ExecuteDataFrameExpr SessionId DataFrameExpr
23− deriving (Binary, Generic)
29+ RPCData(ExecuteDataFrameExpr)
30+
2431data ExecuteDatabaseContextExpr = ExecuteDatabaseContextExpr SessionId DatabaseContextExpr
25− deriving (Binary, Generic)
32+ RPCData(ExecuteDatabaseContextExpr)
33+
2634data ExecuteDatabaseContextIOExpr = ExecuteDatabaseContextIOExpr SessionId DatabaseContextIOExpr
27− deriving (Binary, Generic)
35+ RPCData(ExecuteDatabaseContextIOExpr)
36+
2837data ExecuteGraphExpr = ExecuteGraphExpr SessionId TransactionGraphOperator
29− deriving (Binary, Generic)
38+ RPCData(ExecuteGraphExpr)
39+
3040data ExecuteTransGraphRelationalExpr = ExecuteTransGraphRelationalExpr SessionId TransGraphRelationalExpr
31− deriving (Binary, Generic)
41+ RPCData(ExecuteTransGraphRelationalExpr)
42+
3243data ExecuteHeadName = ExecuteHeadName SessionId
33− deriving (Binary, Generic)
44+ RPCData(ExecuteHeadName)
45+
3446data ExecuteTypeForRelationalExpr = ExecuteTypeForRelationalExpr SessionId RelationalExpr
35− deriving (Binary, Generic)
36−data ExecuteSchemaExpr = ExecuteSchemaExpr SessionId SchemaExpr
37− deriving (Binary, Generic)
47+ RPCData(ExecuteTypeForRelationalExpr)
48+
49+data ExecuteSchemaExpr = ExecuteSchemaExpr SessionId SchemaExpr RPCData(ExecuteSchemaExpr)
50+
3851data ExecuteSetCurrentSchema = ExecuteSetCurrentSchema SessionId SchemaName
39− deriving (Binary, Generic)
52+ RPCData(ExecuteSetCurrentSchema)
53+
4054data RetrieveInclusionDependencies = RetrieveInclusionDependencies SessionId
41− deriving (Binary, Generic)
55+ RPCData(RetrieveInclusionDependencies)
56+
4257data RetrievePlanForDatabaseContextExpr = RetrievePlanForDatabaseContextExpr SessionId DatabaseContextExpr
43− deriving (Binary, Generic)
58+ RPCData(RetrievePlanForDatabaseContextExpr)
59+
4460data RetrieveTransactionGraph = RetrieveTransactionGraph SessionId
45− deriving (Binary, Generic)
61+ RPCData(RetrieveTransactionGraph)
62+
4663data RetrieveHeadTransactionId = RetrieveHeadTransactionId SessionId
47− deriving (Binary, Generic)
64+ RPCData(RetrieveHeadTransactionId)
65+
4866data CreateSessionAtCommit = CreateSessionAtCommit TransactionId
49− deriving (Binary, Generic)
67+ RPCData(CreateSessionAtCommit)
68+
5069data CreateSessionAtHead = CreateSessionAtHead HeadName
51− deriving (Binary, Generic)
70+ RPCData(CreateSessionAtHead)
71+
5272data CloseSession = CloseSession SessionId
53− deriving (Binary, Generic)
73+ RPCData(CloseSession)
74+
5475data RetrieveAtomTypesAsRelation = RetrieveAtomTypesAsRelation SessionId
55− deriving (Binary, Generic)
76+ RPCData(RetrieveAtomTypesAsRelation)
77+
5678data RetrieveRelationVariableSummary = RetrieveRelationVariableSummary SessionId
57− deriving (Binary, Generic)
79+ RPCData(RetrieveRelationVariableSummary)
80+
5881data RetrieveAtomFunctionSummary = RetrieveAtomFunctionSummary SessionId
59− deriving (Binary, Generic)
82+ RPCData(RetrieveAtomFunctionSummary)
83+
6084data RetrieveDatabaseContextFunctionSummary = RetrieveDatabaseContextFunctionSummary SessionId
61− deriving (Binary, Generic)
85+ RPCData(RetrieveDatabaseContextFunctionSummary)
86+
6287data RetrieveCurrentSchemaName = RetrieveCurrentSchemaName SessionId
63− deriving (Binary, Generic)
88+ RPCData(RetrieveCurrentSchemaName)
89+
6490data TestTimeout = TestTimeout SessionId
65− deriving (Binary, Generic)
66−data RetrieveSessionIsDirty = RetrieveSessionIsDirty SessionId
67− deriving (Binary, Generic)
91+ RPCData(TestTimeout)
92+
93+data RetrieveSessionIsDirty = RetrieveSessionIsDirty SessionId
94+ RPCData(RetrieveSessionIsDirty)
95+
6896data ExecuteAutoMergeToHead = ExecuteAutoMergeToHead SessionId MergeStrategy HeadName
69− deriving (Binary, Generic)
97+ RPCData(ExecuteAutoMergeToHead)
98+
7099data RetrieveTypeConstructorMapping = RetrieveTypeConstructorMapping SessionId
71− deriving (Binary, Generic)
100+ RPCData(RetrieveTypeConstructorMapping)
101+
102+data ExecuteValidateMerkleHashes = ExecuteValidateMerkleHashes SessionId
103+ RPCData(ExecuteValidateMerkleHashes)
src/lib/ProjectM36/Shortcuts.hsnew file+247
@@ -0,0 +1,247 @@
1+{-# OPTIONS_GHC -fno-warn-orphans #-}
2+{-# LANGUAGE ScopedTypeVariables #-}
3+{-# LANGUAGE TypeApplications #-}
4+{-# LANGUAGE FlexibleInstances #-}
5+{-# LANGUAGE MultiParamTypeClasses #-}
6+{-# LANGUAGE TypeFamilies #-}
7+{-# LANGUAGE ExtendedDefaultRules #-}
8+{-# LANGUAGE ExistentialQuantification #-}
9+{-# LANGUAGE FlexibleContexts #-}
10+{-# LANGUAGE GADTs #-}
11+{-# LANGUAGE UndecidableInstances #-}
12+module ProjectM36.Shortcuts where
13+-- users need OverloadedLabels, OverloadedLists, and default(Int,Text) to use these shortcuts.
14+import Data.Text hiding (foldl, map)
15+import ProjectM36.Base
16+import ProjectM36.Relation
17+import ProjectM36.Atomable
18+import Prelude hiding ((!!))
19+import Data.Proxy
20+import GHC.OverloadedLabels
21+import GHC.TypeLits hiding (Text)
22+import qualified Data.Text as T
23+import qualified Data.Map as M
24+import qualified Data.Set as S
25+import GHC.Exts (IsList(..))
26+import Data.Convertible
27+
28+default (Text)
29+
30+instance IsList (AttributeNamesBase ()) where
31+ type Item (AttributeNamesBase ()) = AttributeName
32+ fromList = AttributeNames . S.fromList
33+ toList (AttributeNames ns) = S.toList ns
34+ toList _ = error "needs AttributeNames"
35+
36+instance IsList (TupleExprsBase ()) where
37+ type Item TupleExprs = TupleExpr
38+ fromList ts = TupleExprs () ts
39+ toList (TupleExprs _ ts) = ts
40+
41+instance IsList TupleExpr where
42+ type Item TupleExpr = (AttributeName, AtomExpr)
43+ fromList attributeValues = TupleExpr (M.fromList attributeValues)
44+ toList (TupleExpr attributeValues) = M.toList attributeValues
45+
46+
47+-- #xxx :: Text
48+instance KnownSymbol x => IsLabel x Text where
49+ fromLabel = T.pack $ symbolVal @x Proxy
50+
51+-- #relvarName :: RelationalExpr
52+instance KnownSymbol x => IsLabel x RelationalExpr where
53+ fromLabel = RelationVariable (T.pack $ symbolVal @x Proxy) ()
54+
55+-- *Main> #a Int :: AttributeExpr
56+-- NakedAttributeExpr (Attribute "a" IntAtomType)
57+-- *Main> #a (Attr @[Int]) :: AttributeExpr
58+-- NakedAttributeExpr (Attribute "a" (ConstructedAtomType "List" (fromList [("a",IntAtomType)])))
59+-- can't offer a Relation atomtype -- don't know how to express a Relation type in haskell type. Maybe something a HList of (Text, a) ?
60+--
61+-- ps. I don't understand the usage of "AttributeAndTypeNameExpr AttributeName TypeConstructor a"
62+instance (KnownSymbol x, Atomable a)=> IsLabel x (HaskAtomType a -> AttributeExpr) where
63+ fromLabel = (NakedAttributeExpr . Attribute name) . toAtomType''
64+ where name = T.pack $ symbolVal @x Proxy
65+
66+-- (#a 1) :: ExtendTupleExpr
67+-- no need for :=
68+instance (Convertible a AtomExpr, KnownSymbol x) => IsLabel x (a -> ExtendTupleExpr) where
69+ fromLabel x = AttributeExtendTupleExpr name (convert x)
70+ where name = T.pack $ symbolVal @x Proxy
71+
72+-- #name AtomExpr
73+-- ex. tuple [ #name 3 ]
74+-- default(Text) is needed in client code to avoid `no Atomable Char`
75+instance (Convertible a AtomExpr, KnownSymbol x) => IsLabel x (a -> (AttributeName, AtomExpr)) where
76+ fromLabel = \x -> (name, convert x)
77+ where name = T.pack $ symbolVal @x Proxy
78+
79+-- *Main> #a [1] :: AtomExpr
80+-- FunctionAtomExpr "a" [NakedAtomExpr (IntegerAtom 1)] ()
81+--
82+-- This usage is not working in RestrictionPredicateExpr and AttributeExtendTupleExpr. Use f "a" [1] instead.
83+instance (KnownSymbol x, Convertible a AtomExpr) => IsLabel x ([a] -> AtomExpr) where
84+ fromLabel = \as' -> FunctionAtomExpr name (map convert as') ()
85+ where name = T.pack $ symbolVal @x Proxy
86+
87+instance (KnownSymbol x) => IsLabel x AtomExpr where
88+ fromLabel = AttributeAtomExpr name
89+ where name = T.pack $ symbolVal @x Proxy
90+
91+
92+data HaskAtomType a where
93+ Int :: HaskAtomType Int
94+ Integer :: HaskAtomType Integer
95+ Double :: HaskAtomType Double
96+ Text :: HaskAtomType Text
97+-- Day :: HaskAtomType Day
98+-- DateTime :: HaskAtomType DateTime
99+-- ByteString :: HaskAtomType ByteString
100+ Bool :: HaskAtomType Bool
101+ Attr :: Atomable a => HaskAtomType a -- a Proxy-like value for type application.
102+
103+toAtomType'' :: Atomable a => HaskAtomType a -> AtomType
104+toAtomType'' (_ :: HaskAtomType a) = toAtomType (Proxy @a)
105+
106+-- usage: relation [tuple [#a 1, #b "b"], tuple [#a 2, #b "b"]]
107+relation :: [TupleExpr] -> RelationalExpr
108+relation ts = MakeRelationFromExprs Nothing (TupleExprs () ts)
109+
110+relation' :: [AttributeExprBase ()] -> [TupleExpr] -> RelationalExpr
111+relation' as' ts = MakeRelationFromExprs (Just as') (TupleExprs () ts)
112+
113+-- usage: tuple [#name "Mike",#age 6]
114+tuple :: [(AttributeName, AtomExpr)] -> TupleExprBase ()
115+tuple as' = TupleExpr (M.fromList as')
116+
117+-- #a rename [#b `as` #c]
118+rename :: RelationalExpr -> [(AttributeName,AttributeName)] -> RelationalExpr
119+rename relExpr renameList = case renameList of
120+ [] -> Restrict TruePredicate relExpr
121+ renames ->
122+ foldl (\acc (old,new) -> Rename old new acc) relExpr renames
123+
124+--project !!
125+-- #a !! [#b,#c]
126+infix 9 !!
127+(!!) :: RelationalExpr -> AttributeNames -> RelationalExpr
128+relExpr !! xs = Project xs relExpr
129+
130+--join ><
131+-- #a >< #b
132+(><) :: RelationalExpr -> RelationalExpr -> RelationalExpr
133+a >< b = Join a b
134+
135+allBut :: AttributeNames -> AttributeNames
136+allBut (AttributeNames ns) = InvertedAttributeNames ns
137+allBut _ = error "give allBut something other than attribute names."
138+
139+allFrom :: RelationalExpr -> AttributeNames
140+allFrom = RelationalExprAttributeNames
141+
142+as :: AttributeNames -> AttributeName -> (AttributeNames, AttributeName)
143+as = (,)
144+
145+-- #a `group` ([#b,#c] `as` #d)
146+group :: RelationalExpr -> (AttributeNames, AttributeName) -> RelationalExpr
147+group relExpr (aNames, aName) = Group aNames aName relExpr
148+
149+-- #a `ungroup` #b
150+ungroup :: RelationalExpr -> AttributeName -> RelationalExpr
151+ungroup relExpr aName = Ungroup aName relExpr
152+
153+-- *Main> #a #:= true #: ( #b (f "count" [1,2]))
154+-- Assign "a" (Extend (AttributeExtendTupleExpr "b" (FunctionAtomExpr "count" [NakedAtomExpr (IntegerAtom 1),NakedAtomExpr (IntegerAtom 2)] ())) (ExistingRelation (Relation attributesFromList [] (RelationTupleSet {asList = [RelationTuple attributesFromList [] []]}))))
155+(#:) :: RelationalExpr -> ExtendTupleExpr -> RelationalExpr
156+a #: b = Extend b a
157+infix 8 #:
158+
159+instance Convertible AtomExpr AtomExpr where
160+ safeConvert n = Right n
161+
162+instance Convertible RelVarName AtomExpr where
163+ safeConvert n = Right $ RelationAtomExpr (RelationVariable n ())
164+
165+instance Convertible RelationalExpr AtomExpr where
166+ safeConvert relExpr = Right $ RelationAtomExpr relExpr
167+
168+instance Convertible RelVarName RelationalExpr where
169+ safeConvert n = Right $ RelationVariable n ()
170+
171+-- @ in tutd
172+-- (@@) "aaa"
173+(@@) :: AttributeName -> AtomExpr
174+(@@) = AttributeAtomExpr
175+
176+-- works in RestrictedPredicateExpr and AttributeExtendTupleExpr
177+-- usage: f "gte" [1]
178+f :: Convertible a AtomExpr => AtomFunctionName -> [a] -> AtomExpr
179+f n as' = FunctionAtomExpr n (map convert as') ()
180+
181+-- DatabaseContextExpr
182+-- define
183+(#::) :: RelVarName -> [AttributeExpr] -> DatabaseContextExpr
184+s #:: xs = Define s xs
185+infix 5 #::
186+
187+-- assign
188+(#:=) :: RelVarName -> RelationalExpr -> DatabaseContextExpr
189+s #:= r = Assign s r
190+infix 5 #:=
191+
192+class Boolean a b where
193+ (&&&) :: a -> b -> RestrictionPredicateExpr
194+ infixl 6 &&&
195+ (|||) :: a -> b -> RestrictionPredicateExpr
196+ infixl 5 |||
197+
198+-- where: @~ mimics the restriction symbol in algebra
199+-- usage: true #: (#a 1) @~ #a ?= 1 &&& not' false ||| (f "gte" [1])
200+(@~) :: Convertible a RestrictionPredicateExpr => RelationalExpr -> a -> RelationalExpr
201+(@~) relExpr resPreExpr = Restrict (convert resPreExpr) relExpr
202+infix 4 @~
203+
204+true :: RelationalExpr
205+true = ExistingRelation relationTrue
206+
207+false :: RelationalExpr
208+false = ExistingRelation relationFalse
209+
210+trueP :: RestrictionPredicateExprBase a
211+trueP = TruePredicate
212+
213+falseP :: RestrictionPredicateExprBase a
214+falseP = NotPredicate TruePredicate
215+
216+(?=) :: Convertible a AtomExpr => AttributeName -> a -> RestrictionPredicateExpr
217+(?=) name a = AttributeEqualityPredicate name (convert a)
218+infix 9 ?=
219+
220+not' :: Convertible a RestrictionPredicateExpr => a -> RestrictionPredicateExpr
221+not' = NotPredicate . convert
222+
223+instance (Convertible a RestrictionPredicateExpr, Convertible b RestrictionPredicateExpr) => Boolean a b where
224+ a &&& b = AndPredicate (convert a) (convert b)
225+ a ||| b = OrPredicate (convert a) (convert b)
226+
227+instance {-# Incoherent #-} Atomable a => Convertible a RestrictionPredicateExpr where
228+ safeConvert n = Right $ AtomExprPredicate $ toAtomExpr . toAtom $ n
229+
230+instance {-# Incoherent #-} Convertible RelationalExpr RestrictionPredicateExpr where
231+ safeConvert a = Right $ RelationalExprPredicate a
232+
233+instance {-# Incoherent #-} Convertible AtomExpr RestrictionPredicateExpr where
234+ safeConvert a = Right $ AtomExprPredicate a
235+
236+instance {-# Incoherent #-} Convertible RestrictionPredicateExpr RestrictionPredicateExpr where
237+ safeConvert a = Right a
238+
239+instance {-# Incoherent #-} Atomable a => Convertible a AtomExpr where
240+ safeConvert n = Right $ toAtomExpr . toAtom $ n
241+
242+toAtomExpr :: Atom -> AtomExpr
243+toAtomExpr (ConstructedAtom n _ xs) = ConstructedAtomExpr n (toAtomExpr <$> xs) ()
244+toAtomExpr a = NakedAtomExpr a
245+
246+
247+
src/lib/ProjectM36/StaticOptimizer.hs+18−20
@@ -1,4 +1,3 @@
1−{-# LANGUAGE TypeSynonymInstances #-}
21{-# LANGUAGE FlexibleInstances #-}
32{-# LANGUAGE FlexibleContexts #-}
43module ProjectM36.StaticOptimizer where
@@ -23,8 +22,6 @@ import qualified Data.Set as S
2322
2423-- the static optimizer performs optimizations which need not take any specific-relation statistics into account
2524
26−--import Debug.Trace
27−
2825data GraphRefSOptRelationalExprEnv =
2926 GraphRefSOptRelationalExprEnv
3027 {
@@ -59,22 +56,22 @@ class Monad m => AskGraphContext m where
5956 askContext :: m DatabaseContext
6057
6158instance AskGraphContext (ReaderT GraphRefSOptDatabaseContextExprEnv (ExceptT RelationalError Identity)) where
62− askGraph = odce_graph <$> ask
63− askContext = odce_context <$> ask
59+ askGraph = asks odce_graph
60+ askContext = asks odce_context
6461
6562instance AskGraphContext (ReaderT GraphRefSOptRelationalExprEnv (ExceptT RelationalError Identity)) where
66− askGraph = ore_graph <$> ask
63+ askGraph = asks ore_graph
6764 askContext = do
68− mctx <- ore_mcontext <$> ask
65+ mctx <- asks ore_mcontext
6966 case mctx of
7067 Nothing -> throwError NoUncommittedContextInEvalError
7168 Just ctx -> pure ctx
7269
7370askTransId :: GraphRefSOptDatabaseContextExprM TransactionId
74−askTransId = odce_transId <$> ask
71+askTransId = asks odce_transId
7572
7673askMaybeContext :: GraphRefSOptRelationalExprM (Maybe DatabaseContext)
77−askMaybeContext = ore_mcontext <$> ask
74+askMaybeContext = asks ore_mcontext
7875
7976optimizeDatabaseContextExpr :: DatabaseContextExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextExpr
8077optimizeDatabaseContextExpr expr = do
@@ -83,8 +80,8 @@ optimizeDatabaseContextExpr expr = do
8380
8481optimizeAndEvalDatabaseContextExpr :: Bool -> DatabaseContextExpr -> DatabaseContextEvalMonad ()
8582optimizeAndEvalDatabaseContextExpr optimize expr = do
86− graph <- dce_graph <$> ask
87− transId <- dce_transId <$> ask
83+ graph <- asks dce_graph
84+ transId <- asks dce_transId
8885 context <- getStateContext
8986 let gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextExpr expr)
9087 eOptExpr = if optimize then
@@ -105,9 +102,9 @@ optimizeAndEvalTransGraphRelationalExpr graph tgExpr = do
105102
106103optimizeAndEvalDatabaseContextIOExpr :: DatabaseContextIOExpr -> DatabaseContextIOEvalMonad (Either RelationalError ())
107104optimizeAndEvalDatabaseContextIOExpr expr = do
108− transId <- dbcio_transId <$> ask
105+ transId <- asks dbcio_transId
109106 ctx <- getDBCIOContext
110− graph <- dbcio_graph <$> ask
107+ graph <- asks dbcio_graph
111108 let gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextIOExpr expr)
112109 eOptExpr = runGraphRefSOptDatabaseContextExprM transId ctx graph (optimizeDatabaseContextIOExpr gfExpr)
113110 case eOptExpr of
@@ -164,8 +161,8 @@ optimizeGraphRefRelationalExpr' mctx graph expr =
164161-- | optimize relational expression within database context expr monad
165162liftGraphRefRelExpr :: GraphRefSOptRelationalExprM a -> GraphRefSOptDatabaseContextExprM a
166163liftGraphRefRelExpr m = do
167− context <- odce_context <$> ask
168− graph <- odce_graph <$> ask
164+ context <- asks odce_context
165+ graph <- asks odce_graph
169166 lift $ except $ runGraphRefSOptRelationalExprM (Just context) graph m
170167
171168fullOptimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr
@@ -180,7 +177,7 @@ fullOptimizeGraphRefRelationalExpr expr = do
180177optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr
181178optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e
182179
183−optimizeGraphRefRelationalExpr e@(MakeRelationFromExprs _ _) = pure e
180+optimizeGraphRefRelationalExpr e@MakeRelationFromExprs{} = pure e
184181
185182optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e
186183
@@ -210,6 +207,8 @@ optimizeGraphRefRelationalExpr (Union exprA exprB) = do
210207 case (optExprA, optExprB) of
211208 (Restrict predA (RelationVariable nameA sA),
212209 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'
213212 _ -> if optExprA == optExprB then
214213 pure optExprA
215214 else
@@ -358,10 +357,8 @@ applyStaticPredicateOptimization predi = do
358357 OrPredicate pred1 pred2 -> do
359358 optPredA <- applyStaticPredicateOptimization pred1
360359 optPredB <- applyStaticPredicateOptimization pred2
361− if optPredA == optPredB then
360+ if (optPredA == optPredB) || isTrueExpr optPredA then
362361 pure optPredA
363− else if isTrueExpr optPredA then
364− pure optPredA -- True or x -> True
365362 else if isTrueExpr optPredB then
366363 pure optPredB
367364 else
@@ -577,4 +574,5 @@ applyStaticRestrictionPushdown expr = case expr of
577574
578575-- no optimizations available
579576optimizeDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextIOExpr
580−optimizeDatabaseContextIOExpr x = pure x
577+optimizeDatabaseContextIOExpr = pure
578+
src/lib/ProjectM36/TransGraphPlanExpr.hsdeleted−5
@@ -1,5 +0,0 @@
1−module ProjectM36.TransGraphPlanExpr where
2−import ProjectM36.Base
3−-- used to create an execution plan which can potentially read from the query cache
4−
5−data TransGraphPlanExpr = ExecuteTransGraphRelationalExprPlan TransGraphRelationalExpr
src/lib/ProjectM36/TransGraphRelationalExpression.hs+2−19
@@ -10,44 +10,27 @@ import Control.Monad.Trans.Reader
1010import Control.Monad.Trans.Class
1111import Control.Monad.Trans.Except
1212import Data.Functor.Identity
13−import Data.Binary
1413
1514-- | The TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time).
1615type TransGraphRelationalExpr = RelationalExprBase TransactionIdLookup
1716
18−instance Binary TransGraphRelationalExpr
19−
2017type TransGraphAttributeNames = AttributeNamesBase TransactionIdLookup
2118
22−instance Binary TransGraphAttributeNames
23−
2419type TransGraphExtendTupleExpr = ExtendTupleExprBase TransactionIdLookup
2520
26−instance Binary TransGraphExtendTupleExpr
27−
2821type TransGraphTupleExpr = TupleExprBase TransactionIdLookup
2922
30−instance Binary TransGraphTupleExpr
31−
3223type TransGraphTupleExprs = TupleExprsBase TransactionIdLookup
3324
34−instance Binary TransGraphTupleExprs
35−
3625type TransGraphRestrictionPredicateExpr = RestrictionPredicateExprBase TransactionIdLookup
3726
38−instance Binary TransGraphRestrictionPredicateExpr
39−
4027type TransGraphAtomExpr = AtomExprBase TransactionIdLookup
4128
42−instance Binary TransGraphAtomExpr
43−
4429type TransGraphAttributeExpr = AttributeExprBase TransactionIdLookup
4530
4631type TransGraphWithNameExpr = WithNameExprBase TransactionIdLookup
4732
48−instance Binary TransGraphWithNameExpr
49−
50−data TransGraphEvalEnv = TransGraphEvalEnv {
33+newtype TransGraphEvalEnv = TransGraphEvalEnv {
5134 tge_graph :: TransactionGraph
5235 }
5336
@@ -169,7 +152,7 @@ evalTransGraphRestrictionPredicateExpr (AttributeEqualityPredicate attrName expr
169152 AttributeEqualityPredicate attrName <$> expr'
170153
171154processTransGraphExtendTupleExpr :: TransGraphExtendTupleExpr -> TransGraphEvalMonad GraphRefExtendTupleExpr
172−processTransGraphExtendTupleExpr (AttributeExtendTupleExpr attrName expr) = do
155+processTransGraphExtendTupleExpr (AttributeExtendTupleExpr attrName expr) =
173156 AttributeExtendTupleExpr attrName <$> processTransGraphAtomExpr expr
174157
175158processTransGraphAttributeExpr :: TransGraphAttributeExpr -> TransGraphEvalMonad GraphRefAttributeExpr
src/lib/ProjectM36/Transaction.hs+10−5
@@ -17,11 +17,10 @@ singleParent tid = tid NE.:| []
1717-- | Return the same transaction but referencing only the specific child transactions. This is useful when traversing a graph and returning a subgraph. This doesn't filter parent transactions because it assumes a head-to-root traversal.
1818filterTransactionInfoTransactions :: S.Set TransactionId -> TransactionInfo -> TransactionInfo
1919filterTransactionInfoTransactions filterIds tinfo =
20− TransactionInfo { parents = case
21− NE.filter (\parent -> S.member parent filterIds) (parents tinfo) of
20+ tinfo { parents = case
21+ NE.filter (`S.member` filterIds) (parents tinfo) of
2222 [] -> rootParent
23− xs -> NE.fromList xs,
24− stamp = stamp tinfo }
23+ xs -> NE.fromList xs}
2524
2625filterParent :: TransactionId -> S.Set TransactionId -> TransactionId
2726filterParent parentId validIds = if S.member parentId validIds then parentId else U.nil
@@ -43,7 +42,13 @@ subschemas :: Transaction -> Subschemas
4342subschemas (Transaction _ _ (Schemas _ sschemas)) = sschemas
4443
4544fresh :: TransactionId -> UTCTime -> Schemas -> Transaction
46−fresh freshId stamp' newSchemas = Transaction freshId (TransactionInfo rootParent stamp') newSchemas
45+fresh freshId stamp' = Transaction freshId tinfo
46+ where
47+ tinfo = TransactionInfo {parents = rootParent,
48+ stamp = stamp',
49+ merkleHash = mempty
50+ }
4751
4852timestamp :: Transaction -> UTCTime
4953timestamp (Transaction _ tinfo _) = stamp tinfo
54+
src/lib/ProjectM36/Transaction/Persist.hs+17−17
@@ -8,13 +8,13 @@ import ProjectM36.AtomFunction
88import ProjectM36.Persist (writeBSFileSync, DiskSync, renameSync)
99import qualified Data.Map as M
1010import qualified Data.HashSet as HS
11−import qualified Data.Binary as B
1211import System.FilePath
1312import System.Directory
1413import qualified Data.Text as T
1514import Control.Monad
1615import ProjectM36.ScriptSession
1716import ProjectM36.AtomFunctions.Basic (precompiledAtomFunctions)
17+import Codec.Winery
1818
1919#ifdef PM36_HASKELL_SCRIPTING
2020import GHC
@@ -62,7 +62,7 @@ readTransaction dbdir transId mScriptSession = do
6262 return $ Left $ MissingTransactionError transId
6363 else do
6464 relvars <- readRelVars transDir
65− transInfo <- B.decodeFile (transactionInfoPath transDir)
65+ transInfo <- readFileDeserialise (transactionInfoPath transDir)
6666 incDeps <- readIncDeps transDir
6767 typeCons <- readTypeConstructorMapping transDir
6868 sschemas <- readSubschemas transDir
@@ -92,28 +92,28 @@ writeTransaction sync dbdir trans = do
9292 writeDBCFuncs sync tempTransDir (dbcFunctions context)
9393 writeTypeConstructorMapping sync tempTransDir (typeConstructorMapping context)
9494 writeSubschemas sync tempTransDir (subschemas trans)
95− B.encodeFile (transactionInfoPath tempTransDir) (transactionInfo trans)
95+ writeFileSerialise (transactionInfoPath tempTransDir) (transactionInfo trans)
9696 --move the temp directory to final location
9797 renameSync sync tempTransDir finalTransDir
9898
9999writeRelVars :: DiskSync -> FilePath -> RelationVariables -> IO ()
100100writeRelVars sync transDir relvars = do
101101 let path = relvarsPath transDir
102− writeBSFileSync sync path (B.encode relvars)
102+ writeBSFileSync sync path (serialise relvars)
103103
104104readRelVars :: FilePath -> IO RelationVariables
105−readRelVars transDir = do
106− B.decodeFile (relvarsPath transDir)
105+readRelVars transDir =
106+ readFileDeserialise (relvarsPath transDir)
107107
108108writeAtomFuncs :: DiskSync -> FilePath -> AtomFunctions -> IO ()
109109writeAtomFuncs sync transDir funcs = do
110110 let atomFuncPath = atomFuncsPath transDir
111− writeBSFileSync sync atomFuncPath (B.encode $ map (\f -> (atomFuncType f, atomFuncName f, atomFunctionScript f)) (HS.toList funcs))
111+ writeBSFileSync sync atomFuncPath (serialise $ map (\f -> (atomFuncType f, atomFuncName f, atomFunctionScript f)) (HS.toList funcs))
112112
113113--all the atom functions are in one file
114114readAtomFuncs :: FilePath -> Maybe ScriptSession -> IO AtomFunctions
115115readAtomFuncs transDir mScriptSession = do
116− atomFuncsList <- B.decodeFile (atomFuncsPath transDir)
116+ atomFuncsList <- readFileDeserialise (atomFuncsPath transDir)
117117 --only Haskell script functions can be serialized
118118 --we always return the pre-compiled functions
119119 funcs <- mapM (\(funcType, funcName, mFuncScript) -> loadAtomFunc precompiledAtomFunctions mScriptSession funcName funcType mFuncScript) atomFuncsList
@@ -153,7 +153,7 @@ readAtomFunc _ _ _ _ = error "Haskell scripting is disabled"
153153#else
154154readAtomFunc transDir funcName mScriptSession precompiledFuncs = do
155155 let atomFuncPath = atomFuncsPath transDir
156− (funcType, mFuncScript) <- B.decodeFile @([AtomType],Maybe T.Text) atomFuncPath
156+ (funcType, mFuncScript) <- readFileDeserialise @([AtomType],Maybe T.Text) atomFuncPath
157157 case mFuncScript of
158158 --handle pre-compiled case- pull it from the precompiled list
159159 Nothing -> case atomFunctionForName funcName precompiledFuncs of
@@ -184,7 +184,7 @@ writeDBCFuncs sync transDir funcs = mapM_ (writeDBCFunc sync transDir) (HS.toLis
184184writeDBCFunc :: DiskSync -> FilePath -> DatabaseContextFunction -> IO ()
185185writeDBCFunc sync transDir func = do
186186 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack (dbcFuncName func)
187− writeBSFileSync sync dbcFuncPath (B.encode (dbcFuncType func, databaseContextFunctionScript func))
187+ writeBSFileSync sync dbcFuncPath (serialise (dbcFuncType func, databaseContextFunctionScript func))
188188
189189readDBCFuncs :: FilePath -> Maybe ScriptSession -> IO DatabaseContextFunctions
190190readDBCFuncs transDir mScriptSession = do
@@ -201,7 +201,7 @@ readDBCFunc transDir funcName _ precompiledFuncs = do
201201readDBCFunc transDir funcName mScriptSession precompiledFuncs = do
202202#endif
203203 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack funcName
204− (_funcType, mFuncScript) <- B.decodeFile @([AtomType], Maybe T.Text) dbcFuncPath
204+ (_funcType, mFuncScript) <- readFileDeserialise @([AtomType], Maybe T.Text) dbcFuncPath
205205 case mFuncScript of
206206 Nothing -> case databaseContextFunctionForName funcName precompiledFuncs of
207207 Left _ -> error ("expected precompiled dbc function: " ++ T.unpack funcName)
@@ -225,7 +225,7 @@ readDBCFunc transDir funcName mScriptSession precompiledFuncs = do
225225
226226writeIncDep :: DiskSync -> FilePath -> (IncDepName, InclusionDependency) -> IO ()
227227writeIncDep sync transDir (incDepName, incDep) =
228− writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ B.encode incDep
228+ writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ serialise incDep
229229
230230writeIncDeps :: DiskSync -> FilePath -> M.Map IncDepName InclusionDependency -> IO ()
231231writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toList incdeps
@@ -233,7 +233,7 @@ writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toLis
233233readIncDep :: FilePath -> IncDepName -> IO (IncDepName, InclusionDependency)
234234readIncDep transDir incdepName = do
235235 let incDepPath = incDepsDir transDir </> T.unpack incdepName
236− incDepData <- B.decodeFile incDepPath
236+ incDepData <- readFileDeserialise incDepPath
237237 pure (incdepName, incDepData)
238238
239239readIncDeps :: FilePath -> IO (M.Map IncDepName InclusionDependency)
@@ -245,20 +245,20 @@ readIncDeps transDir = do
245245readSubschemas :: FilePath -> IO Subschemas
246246readSubschemas transDir = do
247247 let sschemasPath = subschemasPath transDir
248− B.decodeFile sschemasPath
248+ readFileDeserialise sschemasPath
249249
250250writeSubschemas :: DiskSync -> FilePath -> Subschemas -> IO ()
251251writeSubschemas sync transDir sschemas = do
252252 let sschemasPath = subschemasPath transDir
253− writeBSFileSync sync sschemasPath (B.encode sschemas)
253+ writeBSFileSync sync sschemasPath (serialise sschemas)
254254
255255writeTypeConstructorMapping :: DiskSync -> FilePath -> TypeConstructorMapping -> IO ()
256256writeTypeConstructorMapping sync path types = let atPath = typeConsPath path in
257− writeBSFileSync sync atPath $ B.encode types
257+ writeBSFileSync sync atPath $ serialise types
258258
259259readTypeConstructorMapping :: FilePath -> IO TypeConstructorMapping
260260readTypeConstructorMapping path = do
261261 let atPath = typeConsPath path
262− B.decodeFile atPath
262+ readFileDeserialise atPath
263263
264264
src/lib/ProjectM36/TransactionGraph.hs+83−27
@@ -1,4 +1,4 @@
1−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, CPP, FlexibleContexts #-}
1+{-# LANGUAGE DeriveGeneric, CPP, FlexibleContexts, DerivingVia #-}
22module ProjectM36.TransactionGraph where
33import ProjectM36.Base
44import ProjectM36.Error
@@ -9,9 +9,11 @@ import ProjectM36.TupleSet
99import ProjectM36.Tuple
1010import ProjectM36.RelationalExpression
1111import ProjectM36.TransactionGraph.Merge
12+import ProjectM36.MerkleHash
1213import qualified ProjectM36.DisconnectedTransaction as Discon
1314import qualified ProjectM36.Attribute as A
1415
16+import Codec.Winery
1517import Control.Monad.Except hiding (join)
1618import Control.Monad.Reader hiding (join)
1719import qualified Data.Vector as V
@@ -22,7 +24,6 @@ import qualified Data.List.NonEmpty as NE
2224import Data.Time.Clock
2325import qualified Data.Text as T
2426import GHC.Generics
25−import Data.Binary
2627import Data.Either (lefts, rights, isRight)
2728#if __GLASGOW_HASKELL__ < 804
2829import Data.Monoid
@@ -30,22 +31,22 @@ import Data.Monoid
3031import Control.Arrow
3132import Data.Maybe
3233import Data.UUID.V4
33−#if __GLASGOW_HASKELL__ <= 802
34−import Data.Monoid
35−#endif
36−
37−--import Debug.Trace
34+import qualified Data.ByteString.Lazy as BL
35+import ProjectM36.DatabaseContext as DBC
36+import Crypto.Hash.SHA256
3837
3938-- | Record a lookup for a specific transaction in the graph.
4039data TransactionIdLookup = TransactionIdLookup TransactionId |
4140 TransactionIdHeadNameLookup HeadName [TransactionIdHeadBacktrack]
42− deriving (Show, Eq, Binary, Generic)
41+ deriving (Show, Eq, Generic)
42+ deriving Serialise via WineryVariant TransactionIdLookup
4343
4444-- | Used for git-style head backtracking such as topic~3^2.
45−data TransactionIdHeadBacktrack = TransactionIdHeadParentBacktrack Int | -- ^ git equivalent of ~: walk back n parents, arbitrarily choosing a parent when a choice must be made
45+data TransactionIdHeadBacktrack = TransactionIdHeadParentBacktrack Int | -- ^ git equivalent of ~v: walk back n parents, arbitrarily choosing a parent when a choice must be made
4646 TransactionIdHeadBranchBacktrack Int | -- ^ git equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent
4747 TransactionStampHeadBacktrack UTCTime -- ^ git equivalent of 'git-rev-list -n 1 --before X' find the first transaction which was created before the timestamp
48− deriving (Show, Eq, Binary, Generic)
48+ deriving (Show, Eq, Generic)
49+ deriving Serialise via WineryVariant TransactionIdHeadBacktrack
4950
5051
5152-- | Operators which manipulate a transaction graph and which transaction the current 'Session' is based upon.
@@ -57,13 +58,14 @@ data TransactionGraphOperator = JumpToHead HeadName |
5758 MergeTransactions MergeStrategy HeadName HeadName |
5859 Commit |
5960 Rollback
60− deriving (Eq, Show, Binary, Generic)
61+ deriving (Eq, Show, Generic)
62+ deriving Serialise via WineryVariant TransactionGraphOperator
6163
6264isCommit :: TransactionGraphOperator -> Bool
6365isCommit Commit = True
6466isCommit _ = False
6567
66−data ROTransactionGraphOperator = ShowGraph
68+data ROTransactionGraphOperator = ShowGraph | ValidateMerkleHashes
6769 deriving Show
6870
6971bootstrapTransactionGraph :: UTCTime -> TransactionId -> DatabaseContext -> TransactionGraph
@@ -72,14 +74,15 @@ bootstrapTransactionGraph stamp' freshId context = TransactionGraph bootstrapHea
7274 bootstrapHeads = M.singleton "master" freshTransaction
7375 newSchemas = Schemas context M.empty
7476 freshTransaction = fresh freshId stamp' newSchemas
75− bootstrapTransactions = S.singleton freshTransaction
77+ hashedTransaction = Transaction freshId ((transactionInfo freshTransaction) { merkleHash = calculateMerkleHash freshTransaction emptyTransactionGraph }) newSchemas
78+ bootstrapTransactions = S.singleton hashedTransaction
7679
7780-- | Create a transaction graph from a context.
7881freshTransactionGraph :: DatabaseContext -> IO (TransactionGraph, TransactionId)
7982freshTransactionGraph ctx = do
8083 now <- getCurrentTime
8184 freshId <- nextRandom
82− pure $ (bootstrapTransactionGraph now freshId ctx, freshId)
85+ pure (bootstrapTransactionGraph now freshId ctx, freshId)
8386
8487
8588emptyTransactionGraph :: TransactionGraph
@@ -112,7 +115,7 @@ rootTransactions graph = S.filter isRootTransaction (transactionsForGraph graph)
112115
113116-- the first transaction has no parent - all other do have parents- merges have two parents
114117parentTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)
115−parentTransactions trans graph = transactionsForIds (parentIds trans) graph
118+parentTransactions trans = transactionsForIds (parentIds trans)
116119
117120childTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)
118121childTransactions trans graph = transactionsForIds childIds graph
@@ -130,10 +133,13 @@ addBranch stamp' newId newBranchName branchPointId graph = do
130133
131134--adds a disconnected transaction to a transaction graph at some head
132135addDisconnectedTransaction :: UTCTime -> TransactionId -> HeadName -> DisconnectedTransaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)
133−addDisconnectedTransaction stamp' newId headName (DisconnectedTransaction parentId schemas' _) = addTransactionToGraph headName newTrans
136+addDisconnectedTransaction stamp' newId headName (DisconnectedTransaction parentId schemas' _) graph = addTransactionToGraph headName newTrans' graph
134137 where
135− newTrans = Transaction newId (TI.singleParent parentId stamp') schemas'
136−
138+ newTrans = Transaction newId newTInfo schemas'
139+ newTInfo = TI.singleParent parentId stamp'
140+ newTrans' = Transaction newId (newTInfo { merkleHash = newHash }) schemas'
141+ newHash = calculateMerkleHash newTrans graph--lookup parents in graph to calculate
142+--LOOP
137143addTransactionToGraph :: HeadName -> Transaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)
138144addTransactionToGraph headName newTrans graph = do
139145 let parentIds' = parentIds newTrans
@@ -300,6 +306,7 @@ graphAsRelation (DisconnectedTransaction parentId _ _) graph@(TransactionGraph _
300306 mkRelationFromList attrs tupleMatrix
301307 where
302308 attrs = A.attributesFromList [Attribute "id" TextAtomType,
309+ Attribute "hash" ByteStringAtomType,
303310 Attribute "stamp" DateTimeAtomType,
304311 Attribute "parents" (RelationAtomType parentAttributes),
305312 Attribute "current" BoolAtomType,
@@ -309,6 +316,7 @@ graphAsRelation (DisconnectedTransaction parentId _ _) graph@(TransactionGraph _
309316 tupleGenerator transaction = case transactionParentsRelation transaction graph of
310317 Left err -> Left err
311318 Right parentTransRel -> Right [TextAtom $ T.pack $ show (transactionId transaction),
319+ ByteStringAtom $ _unMerkleHash (merkleHash (transactionInfo transaction)),
312320 DateTimeAtom (timestamp transaction),
313321 RelationAtom parentTransRel,
314322 BoolAtom $ parentId == transactionId transaction,
@@ -340,10 +348,12 @@ createMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> (Transact
340348createMergeTransaction stamp' newId (SelectedBranchMergeStrategy selectedBranch) t2@(trans1, trans2) = do
341349 graph <- gfGraph
342350 selectedTrans <- validateHeadName selectedBranch graph t2
343− pure $ Transaction newId (TransactionInfo {
344− parents = NE.fromList [transactionId trans1,
345− transactionId trans2],
346− stamp = stamp' }) (schemas selectedTrans)
351+ pure $ addMerkleHash graph $
352+ Transaction newId (TransactionInfo {
353+ parents = NE.fromList [transactionId trans1,
354+ transactionId trans2],
355+ stamp = stamp',
356+ merkleHash = mempty }) (schemas selectedTrans)
347357
348358-- merge functions, relvars, individually
349359createMergeTransaction stamp' newId strat@UnionMergeStrategy t2 =
@@ -374,7 +384,7 @@ subGraphOfFirstCommonAncestor origGraph resultHeads currentTrans' goalTrans trav
374384 else do
375385 currentTransChildren <- childTransactions currentTrans' origGraph
376386 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren
377− searchChild start = pathToTransaction origGraph start goalTrans (S.insert currentTrans' traverseSet)
387+ searchChild start' = pathToTransaction origGraph start' goalTrans (S.insert currentTrans' traverseSet)
378388 childSearches = map searchChild (S.toList searchChildren)
379389 errors = lefts childSearches
380390 pathsFound = rights childSearches
@@ -498,10 +508,12 @@ createUnionMergeTransaction stamp' newId strategy (t1,t2) = do
498508 typeConstructorMapping = types
499509 }
500510 newSchemas = Schemas newContext (subschemas t1)
501− pure (Transaction newId (TransactionInfo {
502− parents = NE.fromList [transactionId t1,
503− transactionId t2],
504− stamp = stamp'}) newSchemas)
511+ pure $ addMerkleHash graph $
512+ Transaction newId (TransactionInfo {
513+ parents = NE.fromList [transactionId t1,
514+ transactionId t2],
515+ stamp = stamp',
516+ merkleHash = mempty }) newSchemas
505517
506518lookupTransaction :: TransactionGraph -> TransactionIdLookup -> Either RelationalError Transaction
507519lookupTransaction graph (TransactionIdLookup tid) = transactionForId tid graph
@@ -577,3 +589,47 @@ autoMergeToHead stamp' (tempBranchTransId, tempCommitTransId, mergeTransId) disc
577589 pure (discon''''', graph''''')
578590
579591
592+addMerkleHash :: TransactionGraph -> Transaction -> Transaction
593+addMerkleHash graph trans = Transaction (transactionId trans) newInfo (schemas trans)
594+ where
595+ newInfo = (transactionInfo trans) { merkleHash = calculateMerkleHash trans graph }
596+
597+-- the new hash includes the parents' ids, the current id, and the hash of the context, and the merkle hashes of the parent transactions
598+calculateMerkleHash :: Transaction -> TransactionGraph -> MerkleHash
599+calculateMerkleHash trans graph = MerkleHash $ hashlazy (BL.fromChunks [transIds,
600+ schemasBytes
601+ ] <> dbcBytes <> parentMerkleHashes)
602+ where
603+ parentMerkleHashes = BL.fromChunks $ map (_unMerkleHash . getMerkleHash) parentTranses
604+ parentTranses =
605+ case transactionsForIds (parentIds trans) graph of
606+ Left RootTransactionTraversalError -> []
607+ Left e -> error ("failed to find transaction in Merkle hash construction: " ++ show e)
608+ Right t -> S.toList t
609+ getMerkleHash t = merkleHash (transactionInfo t)
610+ transIds = serialise (transactionId trans : S.toList (parentIds trans))
611+ dbcBytes = DBC.hashBytes (concreteDatabaseContext trans)
612+ schemasBytes = serialise (subschemas trans)
613+
614+validateMerkleHash :: Transaction -> TransactionGraph -> Either MerkleValidationError ()
615+validateMerkleHash trans graph =
616+ if expectedHash /= actualHash then
617+ Left (MerkleValidationError (transactionId trans) expectedHash actualHash)
618+ else
619+ pure ()
620+ where
621+ expectedHash = merkleHash (transactionInfo trans)
622+ actualHash = calculateMerkleHash trans graph
623+
624+data MerkleValidationError = MerkleValidationError TransactionId MerkleHash MerkleHash
625+ deriving (Show, Eq, Generic)
626+
627+validateMerkleHashes :: TransactionGraph -> Either [MerkleValidationError] ()
628+validateMerkleHashes graph =
629+ if null errs then pure () else Left errs
630+ where
631+ errs = S.foldr validateTrans [] (transactionsForGraph graph)
632+ validateTrans trans acc =
633+ case validateMerkleHash trans graph of
634+ Left err -> err : acc
635+ _ -> acc
src/lib/ProjectM36/TransactionGraph/Merge.hs+1−1
@@ -47,7 +47,7 @@ unionMergeRelVars prefer relvarsA relvarsB = do
4747 lookupA = findRel relvarsA
4848 lookupB = findRel relvarsB
4949 case (lookupA, lookupB) of
50− (Just relA, Just relB) -> do
50+ (Just relA, Just relB) ->
5151 unionMergeRelation prefer relA relB
5252 (Nothing, Just relB) -> pure relB
5353 (Just relA, Nothing) -> pure relA
src/lib/ProjectM36/TransactionGraph/Persist.hs−3
@@ -32,9 +32,6 @@ import Control.Arrow
3232import Data.Time.Clock
3333import Data.Text.Read
3434import System.FilePath.Glob
35−#if __GLASGOW_HASKELL__ <= 802
36−import Data.Monoid
37−#endif
3835
3936type LockFileHash = ByteString
4037
src/lib/ProjectM36/TransactionInfo.hs+5−3
@@ -1,10 +1,12 @@
11module ProjectM36.TransactionInfo where
22import ProjectM36.Base
33import Data.Time.Clock
4−import Data.List.NonEmpty
4+import qualified Data.List.NonEmpty as NE
55
66-- | Create a TransactionInfo with just one parent transaction ID.
77singleParent :: TransactionId -> UTCTime -> TransactionInfo
88singleParent tid stamp' = TransactionInfo {
9− parents = tid :| [],
10− stamp = stamp' }
9+ parents = tid NE.:| [],
10+ stamp = stamp',
11+ merkleHash = mempty }
12+
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+108−34
@@ -6,7 +6,26 @@
66{-# LANGUAGE UndecidableInstances #-}
77{-# LANGUAGE CPP #-}
88
9−module ProjectM36.Tupleable where
9+module ProjectM36.Tupleable
10+ ( toInsertExpr
11+ , toDefineExpr
12+ , tupleAssocsEqualityPredicate
13+ , partitionByAttributes
14+ , toUpdateExpr
15+ , toDeleteExpr
16+ , validateAttributes
17+ , Tupleable(..)
18+
19+ -- * Generics
20+ , genericToTuple
21+ , genericFromTuple
22+ , genericToAttributes
23+ , TupleableG(..)
24+ -- ** Options
25+ , defaultTupleableOptions
26+ , TupleableOptions()
27+ , fieldModifier
28+ ) where
1029
1130import Data.Foldable
1231import Data.List (partition)
@@ -19,16 +38,13 @@ import qualified Data.Text as T
1938import qualified Data.Vector as V
2039import GHC.Generics
2140import ProjectM36.Atomable
22−import ProjectM36.Attribute hiding (null)
41+import ProjectM36.Attribute as A hiding (null, toList)
2342import ProjectM36.Base
2443import ProjectM36.DataTypes.Primitive
2544import ProjectM36.Error
2645import ProjectM36.Tuple
2746import ProjectM36.TupleSet
2847import qualified Data.Set as S
29−#if __GLASGOW_HASKELL__ <= 802
30−import Data.Monoid
31−#endif
3248
3349{-import Data.Binary
3450import Control.DeepSeq
@@ -73,7 +89,7 @@ toInsertExpr vals rvName = do
7389
7490-- | 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'.
7591toDefineExpr :: forall a proxy. Tupleable a => proxy a -> RelVarName -> DatabaseContextExpr
76−toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList attrs))
92+toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList (attributesVec attrs)))
7793 where
7894 attrs = toAttributes (Proxy :: Proxy a)
7995
@@ -124,56 +140,110 @@ validateAttributes actualAttrs expectedAttrs val
124140 where
125141 nonMatchingAttrs = attributeNamesNotContained actualAttrs expectedAttrs
126142
127−
143+-- | Types that can be converted to and from 'RelationTuple'.
144+--
145+-- deriving without customization:
146+--
147+-- > data Example = Example
148+-- > { foo :: Integer
149+-- > , bar :: Text
150+-- > }
151+-- > deriving (Generic)
152+-- >
153+-- > instance Tupleable Example
154+--
155+-- deriving with customization using "ProjectM36.Tupleable.Deriving":
156+--
157+-- > data Example = Example
158+-- > { exampleFoo :: Integer
159+-- > , exampleBar :: Text
160+-- > }
161+-- > deriving stock (Generic)
162+-- > deriving (Tupleable)
163+-- > via Codec (Field (DropPrefix "example" >>> CamelCase)) Example
128164class Tupleable a where
129165 toTuple :: a -> RelationTuple
130166
131167 fromTuple :: RelationTuple -> Either RelationalError a
132168
133− toAttributes :: proxy a -> Attributes
169+ toAttributes :: Proxy a -> Attributes
134170
135171 default toTuple :: (Generic a, TupleableG (Rep a)) => a -> RelationTuple
136− toTuple v = toTupleG (from v)
172+ toTuple = genericToTuple defaultTupleableOptions
137173
138174 default fromTuple :: (Generic a, TupleableG (Rep a)) => RelationTuple -> Either RelationalError a
139− fromTuple tup = to <$> fromTupleG tup
175+ fromTuple = genericFromTuple defaultTupleableOptions
176+
177+ default toAttributes :: (Generic a, TupleableG (Rep a)) => Proxy a -> Attributes
178+ toAttributes = genericToAttributes defaultTupleableOptions
179+
180+-- | Options that influence deriving behavior.
181+newtype TupleableOptions = TupleableOptions {
182+ -- | A function that translates record field names into attribute names.
183+ fieldModifier :: T.Text -> T.Text
184+ }
185+
186+-- | The default options for deriving Tupleable instances.
187+--
188+-- These options can be customized by using record update syntax. For example,
189+--
190+-- > defaultTupleableOptions
191+-- > { fieldModifier = \fieldName ->
192+-- > case Data.Text.stripPrefix "example" fieldName of
193+-- > Nothing -> fieldName
194+-- > Just attributeName -> attributeName
195+-- > }
196+--
197+-- will result in record field names being translated into attribute names by
198+-- removing the prefix "example" from the field names.
199+defaultTupleableOptions :: TupleableOptions
200+defaultTupleableOptions = TupleableOptions {
201+ fieldModifier = id
202+ }
203+
204+genericToTuple :: (Generic a, TupleableG (Rep a)) => TupleableOptions -> a -> RelationTuple
205+genericToTuple opts v = toTupleG opts (from v)
206+
207+genericFromTuple :: (Generic a, TupleableG (Rep a)) => TupleableOptions -> RelationTuple -> Either RelationalError a
208+genericFromTuple opts tup = to <$> fromTupleG opts tup
140209
141− default toAttributes :: (Generic a, TupleableG (Rep a)) => proxy a -> Attributes
142− toAttributes _ = toAttributesG (from (undefined :: a))
210+genericToAttributes :: forall a. (Generic a, TupleableG (Rep a)) => TupleableOptions -> Proxy a -> Attributes
211+genericToAttributes opts _ = toAttributesG opts (from (undefined :: a))
143212
144213class TupleableG g where
145− toTupleG :: g a -> RelationTuple
146− toAttributesG :: g a -> Attributes
147− fromTupleG :: RelationTuple -> Either RelationalError (g a)
214+ toTupleG :: TupleableOptions -> g a -> RelationTuple
215+ toAttributesG :: TupleableOptions -> g a -> Attributes
216+ fromTupleG :: TupleableOptions -> RelationTuple -> Either RelationalError (g a)
148217 isRecordTypeG :: g a -> Bool
149218
150219--data type metadata
151220instance (Datatype c, TupleableG a) => TupleableG (M1 D c a) where
152− toTupleG (M1 v) = toTupleG v
153− toAttributesG (M1 v) = toAttributesG v
154− fromTupleG v = M1 <$> fromTupleG v
221+ toTupleG opts (M1 v) = toTupleG opts v
222+ toAttributesG opts (M1 v) = toAttributesG opts v
223+ fromTupleG opts v = M1 <$> fromTupleG opts v
155224 isRecordTypeG (M1 v) = isRecordTypeG v
156225
157226--constructor metadata
158227instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) where
159− toTupleG (M1 v) = RelationTuple attrs atoms
228+ toTupleG opts (M1 v) = RelationTuple attrs atoms
160229 where
161− attrsToCheck = toAttributesG v
162− counter = V.generate (V.length attrsToCheck) id
163− attrs = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then
230+ attrsToCheck = toAttributesG opts v
231+ counter = V.generate (arity attrsToCheck) id
232+ attrs = attributesFromList (V.toList attrsV)
233+ attrsV = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then
164234 Attribute ("attr" <> T.pack (show (num + 1))) typ
165235 else
166− attr) counter attrsToCheck
236+ attr) counter (attributesVec attrsToCheck)
167237 atoms = V.fromList (toAtomsG v)
168− toAttributesG (M1 v) = toAttributesG v
169− fromTupleG tup = M1 <$> fromTupleG tup
238+ toAttributesG opts (M1 v) = toAttributesG opts v
239+ fromTupleG opts tup = M1 <$> fromTupleG opts tup
170240 isRecordTypeG (M1 v) = isRecordTypeG v
171241
172242-- product types
173243instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where
174244 toTupleG = error "toTupleG"
175− toAttributesG ~(x :*: y) = toAttributesG x V.++ toAttributesG y --a bit of extra laziness prevents whnf so that we can use toAttributes (undefined :: Test2T Int Int) without throwing an exception
176− fromTupleG tup = (:*:) <$> fromTupleG tup <*> fromTupleG processedTuple
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
246+ fromTupleG opts tup = (:*:) <$> fromTupleG opts tup <*> fromTupleG opts processedTuple
177247 where
178248 processedTuple = if isRecordTypeG (undefined :: a x) then
179249 tup
@@ -184,18 +254,22 @@ instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where
184254--selector/record
185255instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where
186256 toTupleG = error "toTupleG"
187− toAttributesG m@(M1 v) = V.singleton (Attribute name aType)
257+ toAttributesG opts m@(M1 v) = A.singleton (Attribute modifiedName aType)
188258 where
189259 name = T.pack (selName m)
260+ modifiedName = if T.null name then
261+ name
262+ else
263+ fieldModifier opts name
190264 aType = toAtomTypeG v
191− fromTupleG tup = if null name then -- non-record type, just pull off the first tuple item
265+ fromTupleG opts tup = if null name then -- non-record type, just pull off the first tuple item
192266 M1 <$> atomv (V.head (tupleAtoms tup))
193267 else do
194− atom <- atomForAttributeName (T.pack name) tup
268+ atom <- atomForAttributeName (fieldModifier opts (T.pack name)) tup
195269 val <- atomv atom
196270 pure (M1 val)
197271 where
198− expectedAtomType = atomType (V.head (toAttributesG (undefined :: M1 S c a x)))
272+ expectedAtomType = atomType (V.head (attributesVec (toAttributesG opts (undefined :: M1 S c a x))))
199273 atomv atom = maybe (Left (AtomTypeMismatchError
200274 expectedAtomType
201275 (atomTypeForAtom atom)
@@ -206,8 +280,8 @@ instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where
206280--constructors with no arguments
207281--basically useless but orthoganal to relationTrue
208282instance TupleableG U1 where
209− toTupleG _= emptyTuple
210− toAttributesG _ = emptyAttributes
211− fromTupleG _ = pure U1
283+ toTupleG _ _ = emptyTuple
284+ toAttributesG _ _ = emptyAttributes
285+ fromTupleG _ _ = pure U1
212286 isRecordTypeG _ = False
213287
src/lib/ProjectM36/Tupleable/Deriving.hsnew file+229
@@ -0,0 +1,229 @@
1+{-# LANGUAGE ScopedTypeVariables #-}
2+{-# LANGUAGE TypeOperators #-}
3+{-# LANGUAGE KindSignatures #-}
4+{-# LANGUAGE DataKinds #-}
5+{-# LANGUAGE FlexibleContexts #-}
6+{-# LANGUAGE UndecidableInstances #-}
7+
8+-- | Newtypes for deriving Tupleable instances with customization using
9+-- @DerivingVia@.
10+--
11+-- Inspired by
12+-- [Dhall.Deriving](https://hackage.haskell.org/package/dhall-1.33.1/docs/Dhall-Deriving.html)
13+-- which in turn was inspired by Matt Parson's blog post
14+-- [Mirror Mirror: Reflection and Encoding Via](https://www.parsonsmatt.org/2020/02/04/mirror_mirror.html).
15+--
16+-- required extensions:
17+--
18+-- * DerivingVia
19+-- * DeriveGenerics
20+-- * TypeOperators (for @('<<<')@ and @('>>>')@)
21+-- * DataKinds (for types that take a string argument)
22+
23+module ProjectM36.Tupleable.Deriving
24+ ( -- * DerivingVia Newtype
25+ Codec(..)
26+
27+ -- * Type-level Options
28+ , ModifyOptions(..)
29+ , Field
30+
31+ -- * Type-level 'T.Text' -> 'T.Text' Functions
32+ , ModifyText(..)
33+ , AddPrefix
34+ , DropPrefix
35+ , AddSuffix
36+ , DropSuffix
37+ , UpperCase
38+ , LowerCase
39+ , TitleCase
40+ , CamelCase
41+ , PascalCase
42+ , SnakeCase
43+ , SpinalCase
44+ , TrainCase
45+
46+ -- * Composition
47+ , AsIs
48+ , type (<<<)
49+ , type (>>>)
50+
51+ -- * Re-Exports
52+ , Generic
53+ , module ProjectM36.Tupleable
54+ ) where
55+import Data.Maybe (fromMaybe)
56+import Data.Proxy
57+import qualified Data.Text as T
58+import Data.Text.Manipulate
59+import GHC.TypeLits
60+import GHC.Generics (Generic, Rep)
61+import ProjectM36.Tupleable
62+
63+
64+-- | A newtype wrapper to allow for easier deriving of 'Tupleable' instances
65+-- with customization.
66+--
67+-- The @tag@ type variable can be used to specify options for converting the
68+-- datatype to and from a 'RelationTuple'. For example,
69+--
70+-- > data Example = Example
71+-- > { exampleFoo :: Int
72+-- > , exampleBar :: Int
73+-- > }
74+-- > deriving stock (Generic)
75+-- > deriving (Tupleable)
76+-- > via Codec (Field (DropPrefix "example" >>> CamelCase)) Example
77+--
78+-- will derive an instance of 'Tupleable' where field names are translated into
79+-- attribute names by dropping the prefix @"example"@ and then converting the
80+-- result to camelCase. So @"exampleFoo"@ becomes @"foo"@ and @"exampleBar"@
81+-- becomes @"bar"@.
82+--
83+-- Requires the @DerivingGeneric@ and @DerivingVia@ extensions to be enabled.
84+newtype Codec tag a = Codec { unCodec :: a }
85+
86+instance (ModifyOptions tag, Generic a, TupleableG (Rep a)) => Tupleable (Codec tag a) where
87+ toTuple v = genericToTuple opts (unCodec v)
88+ where
89+ opts = modifyOptions (Proxy :: Proxy tag) defaultTupleableOptions
90+
91+ fromTuple tup = Codec <$> genericFromTuple opts tup
92+ where
93+ opts = modifyOptions (Proxy :: Proxy tag) defaultTupleableOptions
94+
95+ toAttributes _ = genericToAttributes opts (Proxy :: Proxy a)
96+ where
97+ opts = modifyOptions (Proxy :: Proxy tag) defaultTupleableOptions
98+
99+-- | Types that can be used as tags for 'Codec'.
100+class ModifyOptions a where
101+ modifyOptions :: proxy a -> TupleableOptions -> TupleableOptions
102+
103+-- | Change how record field names are translated into attribute names. For
104+-- example,
105+--
106+-- > Field SnakeCase
107+--
108+-- will translate the field name @fooBar@ into the attribute name @foo_bar@.
109+data Field a
110+
111+instance ModifyText a => ModifyOptions (Field a) where
112+ modifyOptions _ opts = opts { fieldModifier = newFieldModifier }
113+ where
114+ newFieldModifier = modifyText (Proxy :: Proxy a) . fieldModifier opts
115+
116+-- | Types that can be used in options that modify 'T.Text' such as in 'Field'.
117+class ModifyText a where
118+ modifyText :: proxy a -> T.Text -> T.Text
119+
120+-- | Add a prefix. @AddPrefix "foo"@ will transform @"bar"@ into @"foobar"@.
121+data AddPrefix (prefix :: Symbol)
122+
123+instance KnownSymbol prefix => ModifyText (AddPrefix prefix) where
124+ modifyText _ oldText = prefixText <> oldText
125+ where
126+ prefixText = T.pack (symbolVal (Proxy :: Proxy prefix))
127+
128+-- | Drop a prefix. @DropPrefix "bar"@ will transform @"foobar"@ into @"foo"@.
129+data DropPrefix (prefix :: Symbol)
130+
131+instance KnownSymbol prefix => ModifyText (DropPrefix prefix) where
132+ modifyText _ oldText = fromMaybe oldText (T.stripPrefix prefixText oldText)
133+ where
134+ prefixText = T.pack (symbolVal (Proxy :: Proxy prefix))
135+
136+-- | Add a suffix. @AddSuffix "bar"@ will transform @"foo"@ into @"foobar"@.
137+data AddSuffix (suffix :: Symbol)
138+
139+instance KnownSymbol suffix => ModifyText (AddSuffix suffix) where
140+ modifyText _ oldText = oldText <> suffixText
141+ where
142+ suffixText = T.pack (symbolVal (Proxy :: Proxy suffix))
143+
144+-- | Drop a suffix. @DropSuffix "bar"@ will transform @"foobar"@ into @"foo"@.
145+data DropSuffix (suffix :: Symbol)
146+
147+instance KnownSymbol suffix => ModifyText (DropSuffix suffix) where
148+ modifyText _ oldText = fromMaybe oldText (T.stripSuffix suffixText oldText)
149+ where
150+ suffixText = T.pack (symbolVal (Proxy :: Proxy suffix))
151+
152+-- | Convert to UPPERCASE. Will transform @"foobar"@ into @\"FOOBAR\"@.
153+data UpperCase
154+
155+instance ModifyText UpperCase where
156+ modifyText _ = T.toUpper
157+
158+-- | Convert to lowercase. Will transform @\"FOOBAR\"@ into @"foobar"@.
159+data LowerCase
160+
161+instance ModifyText LowerCase where
162+ modifyText _ = T.toLower
163+
164+-- | Convert to Title Case. Will transform @"fooBar"@ into @\"Foo Bar\"@.
165+data TitleCase
166+
167+instance ModifyText TitleCase where
168+ modifyText _ = toTitle
169+
170+-- | Convert to camelCase. Will transform @"foo_bar"@ into @"fooBar"@.
171+data CamelCase
172+
173+instance ModifyText CamelCase where
174+ modifyText _ = toCamel
175+
176+-- | Convert to PascalCase. Will transform @"foo_bar"@ into @\"FooBar\"@.
177+data PascalCase
178+
179+instance ModifyText PascalCase where
180+ modifyText _ = toPascal
181+
182+-- | Convert to snake_case. Will transform @"fooBar"@ into @"foo_bar"@.
183+data SnakeCase
184+
185+instance ModifyText SnakeCase where
186+ modifyText _ = toSnake
187+
188+-- | Convert to spinal-case. will transform @"fooBar"@ into @"foo-bar"@.
189+data SpinalCase
190+
191+instance ModifyText SpinalCase where
192+ modifyText _ = toSpinal
193+
194+-- | Convert to Train-Case. Will transform @"fooBar"@ into @\"Foo-Bar\"@.
195+data TrainCase
196+
197+instance ModifyText TrainCase where
198+ modifyText _ = toTrain
199+
200+-- | Identity option.
201+type AsIs = ()
202+
203+instance ModifyOptions () where
204+ modifyOptions _ = id
205+
206+instance ModifyText () where
207+ modifyText _ = id
208+
209+-- | Right to left composition.
210+--
211+-- Requires the @TypeOperators@ extension to be enabled.
212+data a <<< b
213+
214+instance (ModifyOptions a, ModifyOptions b) => ModifyOptions (a <<< b) where
215+ modifyOptions _ = modifyOptions (Proxy :: Proxy a) . modifyOptions (Proxy :: Proxy b)
216+
217+instance (ModifyText a, ModifyText b) => ModifyText (a <<< b) where
218+ modifyText _ = modifyText (Proxy :: Proxy a) . modifyText (Proxy :: Proxy b)
219+
220+-- | Left to right composition.
221+--
222+-- Requires the @TypeOperators@ extension to be enabled.
223+data a >>> b
224+
225+instance (ModifyOptions a, ModifyOptions b) => ModifyOptions (a >>> b) where
226+ modifyOptions _ = modifyOptions (Proxy :: Proxy b) . modifyOptions (Proxy :: Proxy a)
227+
228+instance (ModifyText a, ModifyText b) => ModifyText (a >>> b) where
229+ modifyText _ = modifyText (Proxy :: Proxy b) . modifyText (Proxy :: Proxy a)
src/lib/ProjectM36/WithNameExpr.hs+5−3
@@ -17,7 +17,7 @@ substituteWithNameMacros macros e@(RelationVariable rvname tid) =
1717 macroFilt (WithNameExpr macroName macroTid, _) = rvname == macroName && tid== macroTid in
1818 case filter macroFilt macros of
1919 [] -> e
20− (_,replacement):[] -> replacement
20+ [(_,replacement)] -> replacement
2121 _ -> error "more than one macro matched!"
2222substituteWithNameMacros macros (Project attrs expr) =
2323 Project attrs (substituteWithNameMacros macros expr)
@@ -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−50
@@ -1,50 +0,0 @@
1−# This file was automatically generated by stack init
2−# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/
3−
4−# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)
5−resolver: lts-8.5
6−
7−# Local packages, usually specified by relative directory name
8−packages:
9−- '.'
10−# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
11−extra-deps:
12−- data-accessor-transformers-0.2.1.7
13−- data-interval-1.2.0
14−- extended-reals-0.2.1.0
15−- gnuplot-0.5.4.1
16−- text-1.2.2.1
17−- aeson-1.2.1.00
18−- distributed-process-0.6.6
19−- distributed-process-async-0.2.4
20−- distributed-process-client-server-0.2.3
21−- distributed-process-extras-0.3.2
22−- deferred-folds-0.6.12
23−- rset-1.0.0
24−
25−# Override default flag values for local packages and extra-deps
26−flags: {}
27−
28−# Extra package databases containing global packages
29−extra-package-dbs: []
30−
31−# Control whether we use the GHC we find on the path
32−# system-ghc: true
33−
34−# Require a specific version of stack, using version ranges
35−# require-stack-version: -any # Default
36−# require-stack-version: >= 1.0.0
37−
38−# Override the architecture used by stack, especially useful on Windows
39−# arch: i386
40−# arch: x86_64
41−
42−# Extra directories used by stack for building
43−# extra-include-dirs: [/path/to/dir]
44−# extra-lib-dirs: [/path/to/dir]
45−
46−# Allow a newer minor version of GHC than the snapshot specifies
47−# compiler-check: newer-minor
48−
49−allow-newer: true
50−
stack.ghc8.10.yamlnew file+19
@@ -0,0 +1,19 @@
1+resolver: lts-17.13
2+packages:
3+ - "."
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−51
@@ -1,51 +0,0 @@
1−# This file was automatically generated by stack init
2−# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/
3−
4−# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)
5−resolver: lts-11.20
6−
7−# Local packages, usually specified by relative directory name
8−packages:
9−- '.'
10−# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
11−extra-deps:
12−- data-accessor-transformers-0.2.1.7
13−- data-interval-1.2.0
14−- extended-reals-0.2.1.0
15−- gnuplot-0.5.4.1
16−- text-1.2.2.1
17−- aeson-1.2.1.00
18−- distributed-process-0.7.3
19−- distributed-process-async-0.2.4.1
20−- distributed-process-client-server-0.2.3
21−- distributed-process-extras-0.3.2
22−- rset-1.0.0
23−
24−# Override default flag values for local packages and extra-deps
25−flags:
26− project-m36:
27− stack: true
28−
29−# Extra package databases containing global packages
30−extra-package-dbs: []
31−
32−# Control whether we use the GHC we find on the path
33−# system-ghc: true
34−
35−# Require a specific version of stack, using version ranges
36−# require-stack-version: -any # Default
37−# require-stack-version: >= 1.0.0
38−
39−# Override the architecture used by stack, especially useful on Windows
40−# arch: i386
41−# arch: x86_64
42−
43−# Extra directories used by stack for building
44−# extra-include-dirs: [/path/to/dir]
45−# extra-lib-dirs: [/path/to/dir]
46−
47−# Allow a newer minor version of GHC than the snapshot specifies
48−# compiler-check: newer-minor
49−
50−allow-newer: true
51−
stack.ghc8.4.yamldeleted−48
@@ -1,48 +0,0 @@
1−# This file was automatically generated by stack init
2−# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/
3−
4−# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)
5−resolver: lts-12.26
6−
7−# Local packages, usually specified by relative directory name
8−packages:
9−- '.'
10−# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
11−extra-deps:
12−- data-interval-1.3.0
13−- extended-reals-0.2.3.0
14−- distributed-process-0.7.4
15−- distributed-process-async-0.2.6
16−- distributed-process-client-server-0.2.5.1
17−- distributed-process-extras-0.3.5
18−- rset-1.0.0
19−- hashable-time-0.2.0.2
20−- network-transport-tcp-0.6.0
21−
22−# Override default flag values for local packages and extra-deps
23−flags:
24− project-m36:
25− stack: true
26−
27−# Extra package databases containing global packages
28−extra-package-dbs: []
29−
30−# Control whether we use the GHC we find on the path
31−# system-ghc: true
32−
33−# Require a specific version of stack, using version ranges
34−# require-stack-version: -any # Default
35−# require-stack-version: >= 1.0.0
36−
37−# Override the architecture used by stack, especially useful on Windows
38−# arch: i386
39−# arch: x86_64
40−
41−# Extra directories used by stack for building
42−# extra-include-dirs: [/path/to/dir]
43−# extra-lib-dirs: [/path/to/dir]
44−
45−# Allow a newer minor version of GHC than the snapshot specifies
46−# compiler-check: newer-minor
47−
48−allow-newer: true
stack.ghc8.6.yaml+25−16
@@ -2,27 +2,36 @@
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/haskell-distributed/distributed-process.git
13− commit: 660d554f6acd2dba8b605c84e8fa69e45708bc14
14−- extended-reals-0.2.3.0
15−- data-interval-2.0.1
16−- stm-containers-1.1.0.4
17−- distributed-static-0.3.9
18−- stm-hamt-1.2.0.4
19−- distributed-process-async-0.2.6
20−- distributed-process-client-server-0.2.5.1
21−- distributed-process-extras-0.3.5
22−- rset-1.0.0
23−- hashable-time-0.2.0.2
24−- network-transport-tcp-0.6.0
25−- megaparsec-7.0.5
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
2635
2736# Override default flag values for local packages and extra-deps
2837flags:
stack.ghc8.8.yaml+25−17
@@ -2,28 +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-15.11
5+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/distributed-process.git
13− commit: 688a5b96d4b7b36d90c3db676230b2c943604288
14−- extended-reals-0.2.3.0
15−- data-interval-2.0.1
16−- stm-containers-1.1.0.4
17−- distributed-static-0.3.9
18−- stm-hamt-1.2.0.4
19−- distributed-process-async-0.2.6
20−- distributed-process-client-server-0.2.5.1
21−- distributed-process-extras-0.3.5
22−- rset-1.0.0
23−- hashable-time-0.2.0.2
24−- network-transport-tcp-0.7.0
25−- megaparsec-7.0.5
26−- network-2.8.0.1
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
2735
2836# Override default flag values for local packages and extra-deps
2937flags:
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/Atomable.hs+28−15
@@ -1,8 +1,7 @@
11--Test Atomable typeclass which allows users to use existing Haskell datatypes to marshal them to and from the database as ConstructedAtoms.
2−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings, TypeApplications #-}
2+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings, TypeApplications, DerivingVia #-}
33import Test.HUnit
44import ProjectM36.Client
5−import Data.Binary
65import Control.DeepSeq
76import System.Exit
87import TutorialD.Interpreter.TestBase
@@ -13,52 +12,65 @@ import Data.Time.Calendar (fromGregorian)
1312import Data.Text
1413import qualified Data.Map as M
1514import Data.Proxy
15+import Codec.Winery
1616
1717{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}
1818data Test1T = Test1C Integer
19− deriving (Generic, Show, Eq, Binary, NFData, Atomable)
19+ deriving (Generic, Show, Eq, NFData, Atomable)
20+ deriving Serialise via WineryVariant Test1T
2021
2122data Test2T x = Test2C x
22− deriving (Show, Generic, Eq, Binary, NFData, Atomable)
23+ deriving (Show, Generic, Eq, NFData, Atomable)
24+ deriving Serialise via WineryVariant (Test2T x)
2325
2426data Test3T = Test3C Integer Integer
25− deriving (Show, Generic, Eq, Binary, NFData, Atomable)
27+ deriving (Show, Generic, Eq, NFData, Atomable)
28+ deriving Serialise via WineryVariant Test3T
2629
2730data Test4T = Test4Ca Integer |
2831 Test4Cb Integer
29− deriving (Show, Generic, Eq, Binary, NFData, Atomable)
32+ deriving (Show, Generic, Eq, NFData, Atomable)
33+ deriving Serialise via WineryVariant Test4T
3034
3135data TestListT = TestListC [Integer]
32− deriving (Show, Generic, Eq, Binary, NFData, Atomable)
36+ deriving (Show, Generic, Eq, NFData, Atomable)
37+ deriving Serialise via WineryVariant TestListT
3338
3439data TestNonEmptyT = TestNonEmptyC [Integer]
35− deriving (Show, Generic, Eq, Binary, NFData, Atomable)
40+ deriving (Show, Generic, Eq, NFData, Atomable)
41+ deriving Serialise via WineryVariant TestNonEmptyT
3642
3743data Test5T = Test5C {
3844 con1 :: Integer,
3945 con2 :: Integer
40− } deriving (Show, Generic, Eq, Binary, NFData, Atomable)
46+ } deriving (Show, Generic, Eq, NFData, Atomable)
47+ deriving Serialise via WineryRecord Test5T
4148
4249data Test6T = Test6C (Maybe Integer)
43− deriving (Show, Generic, Eq, Binary, NFData, Atomable)
50+ deriving (Show, Generic, Eq, NFData, Atomable)
51+ deriving Serialise via WineryVariant Test6T
4452
4553data Test7T = Test7C (Either Integer Integer)
46− deriving (Show, Generic, Eq, Binary, NFData, Atomable)
54+ deriving (Show, Generic, Eq, NFData, Atomable)
55+ deriving Serialise via WineryVariant Test7T
4756
4857data Test8T = Test8C Test1T
49− deriving (Show, Generic, Eq, Binary, NFData, Atomable)
58+ deriving (Show, Generic, Eq, NFData, Atomable)
59+ deriving Serialise via WineryVariant Test8T
5060
5161data User = User
5262 { userFirstName :: Text
5363 , userLastName :: Text
54− } deriving (Eq, Ord, Show, Generic, NFData, Binary, Atomable)
64+ } deriving (Eq, Ord, Show, Generic, NFData, Atomable)
65+ deriving Serialise via WineryRecord User
5566
5667data Test9_4T = Test9_4C {
5768 f9_41 :: Int,
5869 f9_42 :: Int,
5970 f9_43 :: Int,
6071 f9_44 :: Int }
61− deriving (Show, Generic, Eq, Binary, NFData, Atomable)
72+ deriving (Show, Generic, Eq, NFData, Atomable)
73+ deriving Serialise via WineryRecord Test9_4T
6274
6375data Test9_5T = Test9_5C {
6476 f9_51 :: Int,
@@ -67,7 +79,8 @@ data Test9_5T = Test9_5C {
6779 f9_54 :: Int,
6880 f9_55 :: Int
6981 }
70− deriving (Show, Generic, Eq, Binary, NFData, Atomable)
82+ deriving (Show, Generic, Eq, NFData, Atomable)
83+ deriving Serialise via WineryRecord Test9_5T
7184
7285main :: IO ()
7386main = do
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+187−9
@@ -1,19 +1,29 @@
1−{-# LANGUAGE DeriveGeneric, FlexibleInstances, FlexibleContexts, DeriveAnyClass #-}
1+{-# LANGUAGE
2+ DeriveGeneric
3+ , FlexibleInstances
4+ , FlexibleContexts
5+ , DeriveAnyClass
6+ , ScopedTypeVariables
7+ , TypeApplications
8+ , DataKinds
9+ , TypeOperators
10+ , AllowAmbiguousTypes
11+ , DerivingVia
12+ #-}
213import Test.HUnit
3−import ProjectM36.Tupleable
14+import ProjectM36.Tupleable.Deriving
415import ProjectM36.Atomable
5−import ProjectM36.Attribute
16+import ProjectM36.Attribute as A
617import ProjectM36.Error
7−import Data.Binary
818import ProjectM36.Base
919import Control.DeepSeq (NFData)
10−import GHC.Generics
1120import qualified Data.Vector as V
1221import qualified Data.Map as M
1322import qualified Data.Text as T
1423import qualified Data.Set as S
1524import System.Exit
1625import Data.Proxy
26+import Codec.Winery
1727
1828{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}
1929
@@ -21,35 +31,43 @@ data Test1T = Test1C {
2131 attrA :: Integer
2232 }
2333 deriving (Generic, Eq, Show)
34+ deriving Serialise via WineryRecord Test1T
2435
2536data Test2T = Test2C {
2637 attrB :: Integer,
2738 attrC :: Integer
2839 }
2940 deriving (Generic, Eq, Show)
41+ deriving Serialise via WineryRecord Test2T
3042
3143data Test3T = Test3C Integer
3244 deriving (Generic, Eq, Show)
45+ deriving Serialise via WineryVariant Test3T
3346
3447data Test4T = Test4C
3548 deriving (Generic, Eq, Show)
49+ deriving Serialise via WineryVariant Test4T
3650
3751data Test5T = Test5C1 Integer |
3852 Test5C2 Integer
3953 deriving (Generic, Eq, Show)
54+ deriving Serialise via WineryVariant Test5T
4055
4156data Test6T = Test6C T.Text Integer Double
4257 deriving (Generic, Eq, Show)
4358
4459data Test7A = Test7AC Integer
45− deriving (Generic, Show, Eq, Binary, NFData, Atomable)
60+ deriving (Generic, Show, Eq, NFData, Atomable)
61+ deriving Serialise via WineryVariant Test7A
4662
4763
4864data Test7T = Test7C Test7A
4965 deriving (Generic, Show, Eq)
66+ deriving Serialise via WineryVariant Test7T
5067
5168data Test8T = Test8C
5269 deriving (Generic, Show, Eq)
70+ deriving Serialise via WineryVariant Test8T
5371
5472data Test9T = Test9C
5573 {
@@ -58,6 +76,15 @@ data Test9T = Test9C
5876 attr9C :: Double
5977 }
6078 deriving (Generic, Show, Eq)
79+ deriving Serialise via WineryRecord Test9T
80+
81+data Test10T = Test10C {
82+ longAttrNameA10 :: Integer,
83+ long_attr_name_b10 :: Integer,
84+ longMixed_attr_NameC10 :: Integer
85+ }
86+ deriving (Generic, Show, Eq)
87+ deriving Serialise via WineryRecord Test10T
6188
6289instance Tupleable Test1T
6390
@@ -83,7 +110,7 @@ main = do
83110 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
84111
85112testList :: Test
86−testList = TestList [testADT1, testADT2, testADT3, testADT4, testADT6, testADT7, testADT8, testInsertExpr, testDefineExpr, testUpdateExpr, testUpdateExprEmptyAttrs, testDeleteExpr, testUpdateExprWrongAttr, testReorderedTuple]
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]
87114
88115testADT1 :: Test
89116testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))
@@ -121,7 +148,7 @@ testADT7 :: Test
121148testADT7 = TestCase $ do
122149 let example = Test7C (Test7AC 3)
123150 assertEqual "atom type" (Right example) (fromTuple (toTuple example))
124− let expectedAttrs = V.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))
151+ let expectedAttrs = A.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))
125152 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))
126153
127154testADT8 :: Test
@@ -195,8 +222,159 @@ testDeleteExpr = TestCase $ do
195222testReorderedTuple :: Test
196223testReorderedTuple = TestCase $ do
197224 let tupleRev :: RelationTuple -> RelationTuple
198− 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))
199227 expected = Test2C {attrB = 3,
200228 attrC = 4}
201229 actual = fromTuple . tupleRev . toTuple $ expected
202230 assertEqual "reordered tuple" (Right expected) actual
231+
232+testCodec :: forall tag. ModifyOptions tag => String -> [AttributeName] -> Test
233+testCodec msg expected = TestCase $
234+ assertEqual msg (S.fromList expected) actual
235+ where
236+ actual = attributeNameSet $ toAttributes (Proxy :: Proxy (Codec tag Test10T))
237+
238+testAddPrefixField :: Test
239+testAddPrefixField = testCodec
240+ @(Field (AddPrefix "prefix_"))
241+ "codec field add prefix attributes"
242+ ["prefix_longAttrNameA10",
243+ "prefix_long_attr_name_b10",
244+ "prefix_longMixed_attr_NameC10"]
245+
246+testDropPrefixField :: Test
247+testDropPrefixField = testCodec
248+ @(Field (DropPrefix "long"))
249+ "codec field drop prefix"
250+ ["AttrNameA10",
251+ "_attr_name_b10",
252+ "Mixed_attr_NameC10"]
253+
254+testAddSuffixField :: Test
255+testAddSuffixField = testCodec
256+ @(Field (AddSuffix "_suffix"))
257+ "codec field add suffix"
258+ ["longAttrNameA10_suffix",
259+ "long_attr_name_b10_suffix",
260+ "longMixed_attr_NameC10_suffix"]
261+
262+testDropSuffixField :: Test
263+testDropSuffixField = testCodec
264+ @(Field (DropSuffix "10"))
265+ "codec field drop suffix"
266+ ["longAttrNameA",
267+ "long_attr_name_b",
268+ "longMixed_attr_NameC"]
269+
270+testUpperCaseField :: Test
271+testUpperCaseField = testCodec
272+ @(Field UpperCase)
273+ "codec field uppercase"
274+ ["LONGATTRNAMEA10",
275+ "LONG_ATTR_NAME_B10",
276+ "LONGMIXED_ATTR_NAMEC10"]
277+
278+testLowerCaseField :: Test
279+testLowerCaseField = testCodec
280+ @(Field LowerCase)
281+ "codec field lowercase"
282+ ["longattrnamea10",
283+ "long_attr_name_b10",
284+ "longmixed_attr_namec10"]
285+
286+testTitleCaseField :: Test
287+testTitleCaseField = testCodec
288+ @(Field TitleCase)
289+ "codec field title case"
290+ ["Long Attr Name A10",
291+ "Long Attr Name B10",
292+ "Long Mixed Attr Name C10"]
293+
294+testCamelCaseField :: Test
295+testCamelCaseField = testCodec
296+ @(Field CamelCase)
297+ "codec field camel case"
298+ ["longAttrNameA10",
299+ "longAttrNameB10",
300+ "longMixedAttrNameC10"]
301+
302+testPascalCaseField :: Test
303+testPascalCaseField = testCodec
304+ @(Field PascalCase)
305+ "codec field pascal case"
306+ ["LongAttrNameA10",
307+ "LongAttrNameB10",
308+ "LongMixedAttrNameC10"]
309+
310+testSnakeCaseField :: Test
311+testSnakeCaseField = testCodec
312+ @(Field SnakeCase)
313+ "codec field snake case"
314+ ["long_attr_name_a10",
315+ "long_attr_name_b10",
316+ "long_mixed_attr_name_c10"]
317+
318+testSpinalCaseField :: Test
319+testSpinalCaseField = testCodec
320+ @(Field SpinalCase)
321+ "codec field spinal case"
322+ ["long-attr-name-a10",
323+ "long-attr-name-b10",
324+ "long-mixed-attr-name-c10"]
325+
326+testTrainCaseField :: Test
327+testTrainCaseField = testCodec
328+ @(Field TrainCase)
329+ "codec field train case"
330+ ["Long-Attr-Name-A10",
331+ "Long-Attr-Name-B10",
332+ "Long-Mixed-Attr-Name-C10"]
333+
334+testAsIsCodec :: Test
335+testAsIsCodec = testCodec
336+ @AsIs
337+ "codec as is"
338+ ["longAttrNameA10",
339+ "long_attr_name_b10",
340+ "longMixed_attr_NameC10"]
341+
342+testAsIsField :: Test
343+testAsIsField = testCodec
344+ @(Field AsIs)
345+ "codec field as is"
346+ ["longAttrNameA10",
347+ "long_attr_name_b10",
348+ "longMixed_attr_NameC10"]
349+
350+testComposeRLCodec :: Test
351+testComposeRLCodec = testCodec
352+ @(Field UpperCase <<< Field (DropPrefix "long"))
353+ "codec (<<<)"
354+ ["ATTRNAMEA10",
355+ "_ATTR_NAME_B10",
356+ "MIXED_ATTR_NAMEC10"]
357+
358+testComposeRLField :: Test
359+testComposeRLField = testCodec
360+ @(Field (UpperCase <<< DropPrefix "long"))
361+ "codec field (<<<)"
362+ ["ATTRNAMEA10",
363+ "_ATTR_NAME_B10",
364+ "MIXED_ATTR_NAMEC10"]
365+
366+testComposeLRCodec :: Test
367+testComposeLRCodec = testCodec
368+ @(Field (DropPrefix "long") >>> Field UpperCase)
369+ "codec (>>>)"
370+ ["ATTRNAMEA10",
371+ "_ATTR_NAME_B10",
372+ "MIXED_ATTR_NAMEC10"]
373+
374+testComposeLRField :: Test
375+testComposeLRField = testCodec
376+ @(Field (DropPrefix "long" >>> UpperCase))
377+ "codec field (>>>)"
378+ ["ATTRNAMEA10",
379+ "_ATTR_NAME_B10",
380+ "MIXED_ATTR_NAMEC10"]
test/Server/Main.hs+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/TransactionGraph/Merge.hs+25−15
@@ -4,6 +4,7 @@ import ProjectM36.Base
44import ProjectM36.Attribute
55import ProjectM36.Relation
66import ProjectM36.Transaction
7+import ProjectM36.TransactionInfo as TI
78import ProjectM36.TransactionGraph
89import ProjectM36.Error
910import ProjectM36.Key
@@ -14,6 +15,17 @@ import ProjectM36.StaticOptimizer
1415
1516import qualified Data.ByteString.Lazy as BS
1617import System.Exit
18+
19+
20+
21+
22+
23+
24+
25+
26+
27+
28+
1729import Data.Word
1830import qualified Data.UUID as U
1931import qualified Data.Set as S
@@ -21,7 +33,6 @@ import qualified Data.Map as M
2133import Data.Maybe
2234import Data.Time.Clock
2335import Data.Time.Calendar
24−import qualified Data.List.NonEmpty as NE
2536
2637{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
2738
@@ -61,10 +72,9 @@ basicTransactionGraph = do
6172 uuidA = fakeUUID 10
6273 uuidB = fakeUUID 11
6374 uuidRoot = fakeUUID 1
64− parents' = uuidRoot NE.:| []
6575 rootContext = concreteDatabaseContext rootTrans
66− (_, bsGraph') <- addTransaction "branchA" (createTrans uuidA (TransactionInfo parents' testTime) rootContext) bsGraph
67− (_, bsGraph'') <- addTransaction "branchB" (createTrans uuidB (TransactionInfo parents' testTime) rootContext) bsGraph'
76+ (_, bsGraph') <- addTransaction "branchA" (createTrans uuidA (TI.singleParent uuidRoot testTime) rootContext) bsGraph
77+ (_, bsGraph'') <- addTransaction "branchB" (createTrans uuidB (TI.singleParent uuidRoot testTime) rootContext) bsGraph'
6878 pure bsGraph''
6979
7080addTransaction :: HeadName -> Transaction -> TransactionGraph -> IO (Transaction, TransactionGraph)
@@ -108,7 +118,7 @@ testSubGraphToFirstAncestorSnipBranch = TestCase $ do
108118 baseGraph <- basicTransactionGraph
109119 transA <- assertMaybe (transactionForHead "branchA" baseGraph) "failed to get branchA"
110120 transB <- assertMaybe (transactionForHead "branchB" baseGraph) "failed to get branchB"
111− (_, graph) <- addTransaction "branchC" (createTrans (fakeUUID 12) (TransactionInfo (fakeUUID 1 NE.:| []) testTime) (concreteDatabaseContext transA)) baseGraph
121+ (_, graph) <- addTransaction "branchC" (createTrans (fakeUUID 12) (TI.singleParent (fakeUUID 1) testTime) (concreteDatabaseContext transA)) baseGraph
112122 subgraph <- assertEither $ subGraphOfFirstCommonAncestor graph (transactionHeadsForGraph baseGraph) transA transB S.empty
113123 assertGraph subgraph
114124 let graphEq graphArg = S.map transactionId (transactionsForGraph graphArg)
@@ -127,13 +137,13 @@ testSubGraphToFirstAncestorMoreTransactions = TestCase $ do
127137 updatedBranchBContext <- case runDatabaseContextEvalMonad branchBContext env (optimizeAndEvalDatabaseContextExpr True (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) of
128138 Left err -> assertFailure (show err) >> undefined
129139 Right st -> pure $ dbc_context st
130− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans NE.:| []) testTime) updatedBranchBContext) graph
140+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) updatedBranchBContext) graph
131141 branchBTrans' <- assertMaybe (transactionForHead "branchB" graph') "failed to get branchB head"
132142 assertEqual "branchB id 3" (fakeUUID 3) (transactionId branchBTrans')
133143
134144 -- add another transaction to branchA
135145 branchATrans <- assertMaybe (transactionForHead "branchA" graph) "failed to get branchA head"
136− (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchATrans NE.:| []) testTime) (concreteDatabaseContext branchATrans)) graph'
146+ (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchATrans) testTime) (concreteDatabaseContext branchATrans)) graph'
137147 branchATrans' <- assertMaybe (transactionForHead "branchA" graph'') "failed to get branchA head"
138148 assertEqual "branchA id 4" (fakeUUID 4) (transactionId branchATrans')
139149
@@ -156,7 +166,7 @@ testSelectedBranchMerge = TestCase $ do
156166 updatedBranchBContext <- case runDatabaseContextEvalMonad branchBContext env (optimizeAndEvalDatabaseContextExpr True (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) of
157167 Left err -> assertFailure (show err) >> undefined
158168 Right st -> pure (dbc_context st)
159− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans NE.:| []) testTime) updatedBranchBContext) graph
169+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) updatedBranchBContext) graph
160170 --create the merge transaction in the graph
161171 let eGraph' = runGraphRefRelationalExprM gfEnv $ mergeTransactions testTime (fakeUUID 4) (fakeUUID 10) (SelectedBranchMergeStrategy "branchA") ("branchA", "branchB")
162172 gfEnv = freshGraphRefRelationalExprEnv Nothing graph'
@@ -185,8 +195,8 @@ testUnionPreferMergeStrategy = TestCase $ do
185195 branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.insert conflictRelVarName (ExistingRelation branchBRelVar) (relationVariables (concreteDatabaseContext branchBTrans))}
186196 conflictRelVarName = "conflictRelVar"
187197
188− (_, graph') <- addTransaction "branchA" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchATrans NE.:| []) testTime) branchAContext) graph
189− (_, graph'') <- addTransaction "branchB" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchBTrans NE.:| []) testTime) branchBContext) graph'
198+ (_, graph') <- addTransaction "branchA" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchATrans) testTime) branchAContext) graph
199+ (_, graph'') <- addTransaction "branchB" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchBTrans) testTime) branchBContext) graph'
190200 -- validate that the conflict is hidden because we preferred a branch
191201 let merged = runGraphRefRelationalExprM env $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) (UnionPreferMergeStrategy "branchB") ("branchA", "branchB")
192202 env = freshGraphRefRelationalExprEnv Nothing graph''
@@ -215,7 +225,7 @@ testUnionMergeStrategy = TestCase $ do
215225 branchAOnlyIncDepName = "branchAOnlyIncDep"
216226 branchBOnlyRelVarName = "branchBOnlyRelVar"
217227 branchAOnlyIncDep = InclusionDependency (ExistingRelation relationTrue) (ExistingRelation relationTrue)
218− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans NE.:| []) testTime) updatedBranchBContext) graph
228+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) updatedBranchBContext) graph
219229 let env = freshGraphRefRelationalExprEnv Nothing graph'
220230 (discon, _) <- assertEither $ runGraphRefRelationalExprM env $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 10) UnionMergeStrategy ("branchA", "branchB")
221231 let Just rvExpr = M.lookup branchBOnlyRelVarName (relationVariables (Discon.concreteDatabaseContext discon))
@@ -223,7 +233,7 @@ testUnionMergeStrategy = TestCase $ do
223233 reEnv = freshGraphRefRelationalExprEnv (Just (Discon.concreteDatabaseContext discon)) graph
224234
225235 assertEqual "branchBOnlyRelVar should appear in the merge" relationTrue rvRel
226− (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchATrans NE.:| []) testTime) updatedBranchAContext) graph'
236+ (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchATrans) testTime) updatedBranchAContext) graph'
227237 let eMergeGraph = runGraphRefRelationalExprM gfEnv $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB")
228238 gfEnv = freshGraphRefRelationalExprEnv Nothing graph''
229239 case eMergeGraph of
@@ -243,7 +253,7 @@ testUnionMergeStrategy = TestCase $ do
243253 conflictRelVar <- assertEither $ mkRelationFromList (attributesFromList [Attribute "conflict" IntAtomType]) []
244254 let conflictContextA = updatedBranchAContext {relationVariables = M.insert branchBOnlyRelVarName (ExistingRelation conflictRelVar) (relationVariables updatedBranchAContext) }
245255 conflictBranchATrans <- assertMaybe (transactionForHead "branchA" graph'') "retrieving head transaction for expected conflict"
246− (_, graph''') <- addTransaction "branchA" (createTrans (fakeUUID 6) (TransactionInfo (transactionId conflictBranchATrans NE.:| []) testTime) conflictContextA) graph''
256+ (_, graph''') <- addTransaction "branchA" (createTrans (fakeUUID 6) (TI.singleParent (transactionId conflictBranchATrans) testTime) conflictContextA) graph''
247257 let failingMerge = runGraphRefRelationalExprM gfEnv' $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB")
248258 gfEnv' = freshGraphRefRelationalExprEnv Nothing graph'''
249259 case failingMerge of
@@ -272,9 +282,9 @@ testUnionMergeIncDepViolation = TestCase $ do
272282
273283
274284 --add the rv in new commits to both branches
275− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans NE.:| []) testTime) branchBContext) graph
285+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) branchBContext) graph
276286
277− (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchATrans NE.:| []) testTime) branchAContext) graph'
287+ (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchATrans) testTime) branchAContext) graph'
278288
279289 --check that the union merge fails due to a violated constraint
280290 let eMerge = runGraphRefRelationalExprM env $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB")
test/TransactionGraph/Persist.hs+64−7
@@ -3,11 +3,12 @@ import Test.HUnit
33import ProjectM36.Base
44import ProjectM36.Persist (DiskSync(NoDiskSync))
55import ProjectM36.TransactionGraph.Persist
6−import ProjectM36.TransactionGraph
6+import ProjectM36.TransactionGraph as TG
77import ProjectM36.Transaction
88import ProjectM36.DateExamples
99import System.IO.Temp
1010import System.Exit
11+import System.Directory
1112import Data.Either
1213import Data.UUID.V4 (nextRandom)
1314import System.FilePath
@@ -16,10 +17,9 @@ import qualified Data.Map as M
1617import qualified Data.Set as S
1718import Data.Time.Clock
1819import Data.Time.Calendar
19−#ifdef PM36_HASKELL_SCRIPTING
20−import ProjectM36.Client
20+import ProjectM36.Client as C
2121import ProjectM36.Relation
22−#endif
22+import ProjectM36.Transaction.Persist
2323
2424main :: IO ()
2525main = do
@@ -29,7 +29,8 @@ main = do
2929testList :: Test
3030testList = TestList [testBootstrapDB,
3131 testDBSimplePersistence,
32− testFunctionPersistence]
32+ testFunctionPersistence,
33+ testMerkleHashValidation]
3334
3435
3536stamp' :: UTCTime
@@ -74,7 +75,62 @@ testDBSimplePersistence = TestCase $ withSystemTempDirectory "m36testdb" $ \temp
7475 case graphErr of
7576 Left err -> assertFailure (show err)
7677 Right graph'' -> assertBool "graph equality" (mapEq graph'' == mapEq graph')
77−
78+
79+testMerkleHashValidation :: Test
80+testMerkleHashValidation = TestCase $
81+ -- add a commit and validate the hashes successfully
82+ withSystemTempDirectory "m36testdb" $ \tempdir -> do
83+ let dbdir = tempdir </> "dbdir"
84+ connInfo = InProcessConnectionInfo (MinimalPersistence dbdir) emptyNotificationCallback []
85+ conn <- assertIOEither $ connectProjectM36 connInfo
86+ sess <- assertIOEither $ createSessionAtHead conn "master"
87+ Right _ <- executeDatabaseContextExpr sess conn (Assign "x" (ExistingRelation relationTrue))
88+ Right _ <- commit sess conn
89+ val <- C.validateMerkleHashes sess conn
90+ assertEqual "merkle success" (Right ()) val
91+
92+ --read graph from disk
93+ conn' <- assertIOEither $ connectProjectM36 connInfo
94+ sess' <- assertIOEither $ createSessionAtHead conn' "master"
95+
96+ val' <- C.validateMerkleHashes sess' conn'
97+ assertEqual "merkle read again success" (Right ()) val'
98+
99+ --alter the on-disk representation and check that the hash validation fails
100+ eGraph <- transactionGraphLoad dbdir emptyTransactionGraph Nothing
101+ case eGraph of
102+ Left err -> assertFailure $ "failed to load graph" ++ show err
103+ Right graph -> do
104+ let trans = transactionHeadsForGraph graph M.! "master"
105+ updatedTrans = Transaction (transactionId trans) (transactionInfo trans) updatedSchemas
106+ transactionDir' = dbdir </> show (transactionId trans)
107+ updatedSchemas =
108+ case schemas trans of
109+ Schemas ctx sschemas ->
110+ let updatedContext = ctx {
111+ relationVariables = M.insert "malicious" (ExistingRelation relationFalse) (relationVariables ctx)
112+ } in
113+ Schemas updatedContext sschemas
114+ maliciousGraph = TransactionGraph malHeads malTransSet
115+ malHeads = M.insert "master" updatedTrans (transactionHeadsForGraph graph)
116+ malTransSet = S.insert updatedTrans (transactionsForGraph graph)
117+ malMerkleHash = calculateMerkleHash updatedTrans maliciousGraph
118+ regMerkleHash = merkleHash (transactionInfo trans)
119+ --validate and fail
120+ let val'' = TG.validateMerkleHashes maliciousGraph
121+ assertEqual "loaded graph merkle hashes" (Left [MerkleValidationError (transactionId trans) regMerkleHash malMerkleHash]) val''
122+ --delete existing transaction directory
123+ removeDirectoryRecursive transactionDir'
124+ writeTransaction NoDiskSync dbdir updatedTrans
125+
126+ --read graph from disk
127+ eConnFail <- connectProjectM36 connInfo
128+ case eConnFail of
129+ Left err ->
130+ assertEqual "open connection merkle validation" (DatabaseValidationError [MerkleValidationError (transactionId trans) regMerkleHash malMerkleHash]) err
131+ Right _ -> assertFailure "open connection validation"
132+
133+
78134
79135--only Haskell-scripted dbc and atom functions can be serialized
80136testFunctionPersistence :: Test
@@ -103,10 +159,11 @@ testFunctionPersistence = TestCase $
103159 let expectedRel = mkRelationFromList (attributesFromList [Attribute "a" IntAtomType]) [[IntAtom 3]]
104160 assertEqual "testdisk dbc function run" expectedRel res
105161
162+#endif
163+
106164assertIOEither :: (Show a) => IO (Either a b) -> IO b
107165assertIOEither x = do
108166 ret <- x
109167 case ret of
110168 Left err -> assertFailure (show err) >> undefined
111169 Right val -> pure val
112−#endif
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+48−9
@@ -78,13 +78,17 @@ main = do
7878 testAtomFunctionArgumentMismatch,
7979 testInvalidDataConstructor,
8080 testBasicList,
81− testRelationDeclarationMismatch
81+ testRelationDeclarationMismatch,
82+ testInvalidTuples,
83+ testSelfReferencingUncommittedContext,
84+ testUnionAndIntersectionAttributeExprs
8285 ]
8386
8487simpleRelTests :: Test
8588simpleRelTests = TestCase $ do
8689 (graph, transId) <- freshTransactionGraph dateExamples
87− mapM_ (\(tutd, expected) -> assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups
90+ mapM_ (\(tutd, expected) ->
91+ assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups
8892 where
8993 testTups = [("x:=true", Right relationTrue),
9094 ("x:=false", Right relationFalse),
@@ -119,7 +123,8 @@ simpleRelTests = TestCase $ do
119123 ("x:=relation{tuple{a 5}} : {b:=6}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 6])]),
120124 ("x:=relation{tuple{a 5}} : {b:=add(@a,5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 10])]),
121125 ("x:=relation{tuple{a 5}} : {b:=add(@a,\"spam\")}", Left (AtomFunctionTypeError "add" 2 IntegerAtomType TextAtomType)),
122− ("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 [])
123128 ]
124129 simpleAAttributes = A.attributesFromList [Attribute "a" IntegerAtomType]
125130 simpleBAttributes = A.attributesFromList [Attribute "d" IntegerAtomType]
@@ -131,7 +136,8 @@ simpleRelTests = TestCase $ do
131136dateExampleRelTests :: Test
132137dateExampleRelTests = TestCase $ do
133138 (graph, transId) <- freshTransactionGraph dateExamples
134− mapM_ (\(tutd, expected) -> assertTutdEqual dateExamples transId graph expected tutd) testTups
139+ mapM_ (\(tutd, expected) ->
140+ assertTutdEqual dateExamples transId graph expected tutd) testTups
135141 where
136142 simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]
137143 maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)
@@ -149,7 +155,7 @@ dateExampleRelTests = TestCase $ do
149155 else Right tuple) suppliersRel
150156 extendTestAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" $ RelationAtomType (R.attributes suppliersRel)]
151157 testTups = [("x:=s where true", Right suppliersRel),
152− ("x:=s where city = \"London\"", restrict (\tuple -> pure $ atomForAttributeName "city" tuple == (Right $ TextAtom "London")) suppliersRel),
158+ ("x:=s where city = \"London\"", restrict (\tuple -> pure $ atomForAttributeName "city" tuple == Right (TextAtom "London")) suppliersRel),
153159 ("x:=s where false", Right $ Relation (R.attributes suppliersRel) emptyTupleSet),
154160 ("x:=p where color=\"Blue\" and city=\"Paris\"", mkRelationFromList (R.attributes productsRel) [[TextAtom "P5", TextAtom "Cam", TextAtom "Blue", IntegerAtom 12, TextAtom "Paris"]]),
155161 ("a:=s; update a (status:=50); x:=a{status}", mkRelation (A.attributesFromList [Attribute "status" IntegerAtomType]) (RelationTupleSet [mkRelationTuple (A.attributesFromList [Attribute "status" IntegerAtomType]) (V.fromList [IntegerAtom 50])])),
@@ -157,7 +163,7 @@ dateExampleRelTests = TestCase $ do
157163 --atom function tests
158164 ("x:=((s : {status2 := add(10,@status)}) where status2=add(10,@status)){city,s#,sname,status}", Right suppliersRel),
159165 ("x:=relation{tuple{a 5}} : {b:=s}", mkRelation extendTestAttributes (RelationTupleSet [mkRelationTuple extendTestAttributes (V.fromList [IntegerAtom 5, RelationAtom suppliersRel])])),
160− ("x:=s; update x where sname=\"Blake\" (city:=\"Boston\")", relMap (\tuple -> if atomForAttributeName "sname" tuple == (Right $ TextAtom "Blake") then Right $ updateTupleWithAtoms (M.singleton "city" (TextAtom "Boston")) tuple else Right tuple) suppliersRel),
166+ ("x:=s; update x where sname=\"Blake\" (city:=\"Boston\")", relMap (\tuple -> if atomForAttributeName "sname" tuple == Right (TextAtom "Blake") then Right $ updateTupleWithAtoms (M.singleton "city" (TextAtom "Boston")) tuple else Right tuple) suppliersRel),
161167 ("x:=s; update x where city=\"Paris\" (status:=add(@status,10))", updateParisPlus10),
162168 --relatom function tests
163169 ("x:=((s group ({city} as y)):{z:=count(@y)}){z}", mkRelation groupCountAttrs (RelationTupleSet [mkRelationTuple groupCountAttrs (V.singleton $ IntegerAtom 1)])),
@@ -229,7 +235,7 @@ transactionGraphAddCommitTest = TestCase $ do
229235 commit sessionId dbconn >>= eitherFail
230236 discon <- disconnectedTransaction_ sessionId dbconn
231237 let context = Discon.concreteDatabaseContext discon
232− 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))
233239
234240transactionRollbackTest :: Test
235241transactionRollbackTest = TestCase $ do
@@ -356,7 +362,7 @@ testComments :: Test
356362testComments = TestCase $ do
357363 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
358364 mapM_ (executeTutorialD sessionId dbconn) [
359− ":branch testbranch --test comment\n",
365+ ":branch testbranch --test comment",
360366 ":jumphead {- test comment -} master"]
361367
362368-- create a graph and query from two disparate contexts
@@ -539,7 +545,7 @@ testListConstructedAtom = TestCase $ do
539545testTypeChecker :: Test
540546testTypeChecker = TestCase $ do
541547 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
542− let err1 = "AtomFunctionTypeError \"max\" 1 (RelationAtomType [Attribute \"_\" IntegerAtomType]) IntegerAtomType"
548+ let err1 = "AtomFunctionTypeError \"max\" 1"
543549 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"
544550
545551--exercise expression parser
@@ -659,6 +665,10 @@ testWithClause = TestCase $ do
659665 executeTutorialD sessionId dbconn "x:=with (x as s) x"
660666 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())
661667 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
662672
663673 let err1 = "RelVarAlreadyDefinedError"
664674 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"
@@ -691,3 +701,32 @@ testRelationDeclarationMismatch :: Test
691701testRelationDeclarationMismatch = TestCase $ do
692702 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
693703 expectTutorialDErr sessionId dbconn (T.isPrefixOf "AtomTypeMismatchError") "data A a = A a | B | C; a := relation{a A Integer}{tuple{a A \"1\"}}"
704+
705+--generate errors when the tuples in a new relation don't match
706+testInvalidTuples :: Test
707+testInvalidTuples = TestCase $ do
708+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
709+ expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{b 2}}"
710+ expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{a 2, b 3}}"
711+-- expectTutorialDErr sessionId dbconn (T.isPrefixOf "ParseErrorBundle") ":showexpr relation{tuple{a 2, a 3}}" --parse failure can't be validated with this function
712+
713+testSelfReferencingUncommittedContext :: Test
714+testSelfReferencingUncommittedContext = TestCase $ do
715+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
716+ executeTutorialD sessionId dbconn "s:=s union s"
717+ eS <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())
718+ _ <- rollback sessionId dbconn
719+ eSorig <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())
720+ assertEqual "s=s'" eSorig eS
721+
722+testUnionAndIntersectionAttributeExprs :: Test
723+testUnionAndIntersectionAttributeExprs = TestCase $ do
724+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
725+ executeTutorialD sessionId dbconn "x:=s{intersection of {all but sname} {sname}}"
726+ xRel <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())
727+ assertEqual "intersection attrs" (Right relationTrue) xRel
728+
729+ executeTutorialD sessionId dbconn "y:=s{union of {all but sname} {sname}}"
730+ yRel <- executeRelationalExpr sessionId dbconn (RelationVariable "y" ())
731+ assertEqual "union attrs" (Right suppliersRel) yRel
732+
test/TutorialD/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 ()