git.iko.soy/project-m36
on 1046167 help sign in
44feeff
swap
0 ahead, 241 behind
150 files changed+2628−5696
since splitsnapshots
unifiedsplit
.appveyor.yml+3−2 .github/workflows/ci.yaml−69 .gitignore+1−3 .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−33 README.markdown+3−12 cabal.project+2−9 default.nix−1 docker.nix−18 docs/15_minute_tutorial.markdown+68−65 docs/commits_in_constant_time.markdown−134 docs/data_independence.markdown−109 docs/filesystem-persistence.markdown+1−1 docs/import_export_csv.markdown+2−2 docs/introduction_to_projectm36.markdown+9−28 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/server_mode.markdown+1−1 docs/transaction_graph_operators.markdown+4−6 docs/tupleable.markdown−19 docs/tutd_cheatsheet.markdown−99 docs/tutd_tutorial.markdown+2−56 docs/websocket_server.markdown+2−2 examples/DerivingCustomTupleable.hs−54 examples/Plantfarm.hs−446 examples/SimpleClient.hs+1−1 examples/blog.hs+4−5 examples/hair.hs+6−9 examples/out_of_the_tarpit.hs+7−11 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+160−168 release.nix−36 scripts/DateExamples.tutd+2−2 scripts/multiline.tutd−2 shell.nix−1 src/bin/ProjectM36/Client/Json.hs+1−4 src/bin/ProjectM36/Server/RemoteCallTypes/Json.hs+2−33 src/bin/ProjectM36/Server/WebSocket.hs+21−33 src/bin/ProjectM36/Server/WebSocket/websocket-client.html+1−1 src/bin/ProjectM36/Server/WebSocket/websocket-server.hs+18−48 src/bin/TutorialD/Interpreter.hs+28−30 src/bin/TutorialD/Interpreter/Base.hs+38−66 src/bin/TutorialD/Interpreter/DatabaseContextExpr.hs+13−16 src/bin/TutorialD/Interpreter/Export/Base.hs+1−1 src/bin/TutorialD/Interpreter/Import/Base.hs+4−9 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+17−70 src/bin/TutorialD/Interpreter/RODatabaseContextOperator.hs+16−33 src/bin/TutorialD/Interpreter/RelationalExpr.hs+44−77 src/bin/TutorialD/Interpreter/SchemaOperator.hs+3−3 src/bin/TutorialD/Interpreter/TransactionGraphOperator.hs+3−12 src/bin/TutorialD/Interpreter/Types.hs+4−10 src/bin/TutorialD/Printer.hs−165 src/bin/TutorialD/tutd.hs+19−15 src/bin/benchmark/Handles.hs+14−25 src/bin/benchmark/bigrel.hs+7−8 src/lib/ProjectM36/Arbitrary.hs+1−6 src/lib/ProjectM36/Atom.hs+1−2 src/lib/ProjectM36/AtomFunction.hs+2−19 src/lib/ProjectM36/AtomFunctionError.hs+2−1 src/lib/ProjectM36/AtomType.hs+14−86 src/lib/ProjectM36/Atomable.hs+49−33 src/lib/ProjectM36/Attribute.hs+29−148 src/lib/ProjectM36/Base.hs+107−113 src/lib/ProjectM36/Client.hs+309−195 src/lib/ProjectM36/DataFrame.hs+15−23 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+2−17 src/lib/ProjectM36/DatabaseContextFunction.hs+1−17 src/lib/ProjectM36/DatabaseContextFunctionError.hs+2−1 src/lib/ProjectM36/DisconnectedTransaction.hs+6−2 src/lib/ProjectM36/Error.hs+14−20 src/lib/ProjectM36/FileLock.hs+1−1 src/lib/ProjectM36/GraphRefRelationalExpr.hs+25−24 src/lib/ProjectM36/InclusionDependency.hs+6−5 src/lib/ProjectM36/IsomorphicSchema.hs+6−3 src/lib/ProjectM36/Key.hs+1−1 src/lib/ProjectM36/MerkleHash.hs−9 src/lib/ProjectM36/NormalizeExpr.hs+2−7 src/lib/ProjectM36/Persist.hs+4−3 src/lib/ProjectM36/Relation.hs+22−17 src/lib/ProjectM36/Relation/Parse/CSV.hs+3−7 src/lib/ProjectM36/Relation/Show/CSV.hs+5−5 src/lib/ProjectM36/Relation/Show/HTML.hs+3−4 src/lib/ProjectM36/Relation/Show/Term.hs+1−4 src/lib/ProjectM36/RelationalExpression.hs+369−289 src/lib/ProjectM36/ScriptSession.hs+44−72 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+99−166 src/lib/ProjectM36/Server/Config.hs−6 src/lib/ProjectM36/Server/EntryPoints.hs+153−126 src/lib/ProjectM36/Server/ParseArgs.hs+16−39 src/lib/ProjectM36/Server/RemoteCallTypes.hs+35−67 src/lib/ProjectM36/Sessions.hs+3−3 src/lib/ProjectM36/Shortcuts.hs−247 src/lib/ProjectM36/StaticOptimizer.hs+19−19 src/lib/ProjectM36/TransGraphPlanExpr.hs+5 src/lib/ProjectM36/TransGraphRelationalExpression.hs+18−9 src/lib/ProjectM36/Transaction.hs+5−10 src/lib/ProjectM36/Transaction/Persist.hs+31−51 src/lib/ProjectM36/TransactionGraph.hs+77−166 src/lib/ProjectM36/TransactionGraph/Merge.hs+15−19 src/lib/ProjectM36/TransactionGraph/Persist.hs+3−3 src/lib/ProjectM36/TransactionInfo.hs+3−5 src/lib/ProjectM36/Tuple.hs+33−47 src/lib/ProjectM36/TupleSet.hs−7 src/lib/ProjectM36/Tupleable.hs+36−113 src/lib/ProjectM36/Tupleable/Deriving.hs−229 src/lib/ProjectM36/WithNameExpr.hs+3−5 stack.ghc8.0.yaml+50 stack.ghc8.10.yaml−19 stack.ghc8.8.yaml → stack.ghc8.2.yaml+15−26 stack.ghc8.6.yaml → stack.ghc8.4.yaml+17−26 test/Client/Simple.hs+2−1 test/IsomorphicSchema.hs+3−1 test/Relation/Atomable.hs+20−52 test/Relation/Basic.hs+14−15 test/Relation/Export/CSV.hs+18−23 test/Relation/Tupleable.hs+9−187 test/Server/Main.hs+23−24 test/Server/WebSocket.hs+12−8 test/TransactionGraph/Merge.hs+39−70 test/TransactionGraph/Persist.hs+15−79 test/TutorialD/InterpreterTest.hs → test/TutorialD/Interpreter.hs+13−78 test/TutorialD/Interpreter/AtomFunctionScript.hs+17−25 test/TutorialD/Interpreter/DatabaseContextFunctionScript.hs+6−13 test/TutorialD/Interpreter/Import/ImportTest.hs−47 test/TutorialD/Interpreter/Import/TutorialD.hs+29 test/TutorialD/Interpreter/Import/httpimporttest.tutd−2 test/TutorialD/Interpreter/TestBase.hs+8−8 test/TutorialD/PrinterTest.hs−47 test/scripts.hs+2−5
.appveyor.yml+3−2
@@ -17,7 +17,8 @@ environment:
1717 global:
1818 STACK_ROOT: "c:\\sr"
1919 matrix:
20− - YAML: "stack.ghc8.6.yaml"
20+ - YAML: "stack.ghc8.2.yaml"
21+ - YAML: "stack.ghc8.4.yaml"
2122
2223platform:
2324 - x64
@@ -36,4 +37,4 @@ test_script:
3637
3738#artifacts:
3839# - path: project-m36.7z
39−# name: project-m36.7z
40+# name: project-m36.7z
.github/workflows/ci.yamldeleted−69
@@ -1,69 +0,0 @@
1−name: "CI"
2−on:
3− pull_request:
4− push:
5−jobs:
6− dockerimage:
7− runs-on: ubuntu-latest
8− steps:
9− - uses: actions/checkout@v2.3.1
10− - uses: cachix/install-nix-action@v12
11− with:
12− nix_path: nixpkgs=channel:nixos-unstable
13− - uses: cachix/cachix-action@v8
14− with:
15− name: project-m36
16− signingKey: "${{ secrets.CACHIX_SIGNING_KEY }}"
17− - run: cachix use iohk
18− - name: docker load
19− run: docker load < $(nix-build docker.nix)
20− - name: docker login
21− if: ${{ github.ref == 'refs/heads/master' }}
22− run: echo ${{secrets.DOCKERHUB_PASSWORD}} | docker login --username ${{secrets.DOCKERHUB_USER}} --password-stdin
23− - name: docker tag with version
24− run: docker tag project-m36:latest projectm36/project-m36:$(awk '/^Version:/ {print $2}' project-m36.cabal)
25− if: ${{ github.ref == 'refs/heads/master' }}
26− - name: docker tag latest
27− run: docker tag project-m36:latest projectm36/project-m36:latest
28− if: ${{ github.ref == 'refs/heads/master' }}
29− - run: docker push projectm36/project-m36
30− if: ${{ github.ref == 'refs/heads/master' }}
31−
32− stack-build:
33− runs-on: ${{ matrix.os }}
34− strategy:
35− matrix:
36− os: [ubuntu-latest]
37− ghc:
38− - ghc8.10
39− - ghc8.8
40− - ghc8.6
41− include:
42− - os: macos-latest
43− ghc: ghc8.10
44− env:
45− STACK_YAML: stack.${{ matrix.ghc }}.yaml
46− steps:
47− - uses: actions/checkout@v2
48− - name: Cache
49− uses: actions/cache@v1
50− with:
51− path: ~/.stack
52− key: ${{ runner.os }}-build-stack-${{ matrix.ghc }}-${{ hashFiles(env.STACK_YAML) }}-${{ hashFiles('**/*.cabal') }}
53− restore-keys: |
54− ${{ runner.os }}-build-stack-${{ matrix.ghc }}-${{ hashFiles(env.STACK_YAML) }}
55− ${{ runner.os }}-build-stack-${{ matrix.ghc }}
56− - name: Fix macOS cache bug
57− run: rm -rf ~/.stack/setup-exe-cache
58− - name: Build
59− run: stack build --ghc-options -O2 --local-bin-path out --copy-bins
60− - name: Test
61− run: stack test --stack-yaml=${{ env.STACK_YAML }}
62− - name: HLint
63− run: curl -sSL https://raw.github.com/ndmitchell/hlint/master/misc/run.sh | sh -s .
64− - name: Haddock
65− run: stack --no-install-ghc --system-ghc --no-haddock-deps haddock
66− - uses: actions/upload-artifact@v2
67− with:
68− name: project-m36-${{ matrix.os }}-${{ matrix.ghc }}
69− path: out/
.gitignore+1−3
@@ -18,6 +18,4 @@ persistence-notes
1818jupyter/itutd.egg-info
1919jupyter/build
2020juyter/dist
21−.ipynb_checkpoints
22−project-m36.nix
23−stack.yaml
21+.ipynb_checkpoints
.travis.ymlnew file+60
@@ -0,0 +1,60 @@
1+# For more information, see https://github.com/ChrisPenner/haskell-stack-travis-ci
2+language: c
3+sudo: false
4+
5+git:
6+ submodules: false # whether to recursively clone submodules
7+
8+cache:
9+ directories:
10+ - $HOME/.ghc
11+ - $HOME/.cabal
12+ - $HOME/.stack
13+ - .stack-work
14+ timeout: 1000
15+
16+matrix:
17+ fast_finish: true
18+ include:
19+ - env: CACHE_NAME=8.2.2 STACK_YAML=stack.ghc8.2.yaml
20+ compiler: ": #stack 8.2.2"
21+
22+ - env: CACHE_NAME=osx-8.2.2 STACK_YAML=stack.ghc8.2.yaml
23+ os: osx
24+ os_image: xcode7.3
25+ compiler: ": #stack 8.2.2"
26+
27+ - env: CACHE_NAME=8.4.3 STACK_YAML=stack.ghc8.4.yaml
28+ compiler: ": #stack 8.4.3"
29+
30+before_script:
31+ - unset CC
32+ - export PATH=$HOME/.local/bin:/opt/ghc/$GHC_VERSION/bin:$PATH
33+ - ./.travis/install-ghr.sh
34+ - ./.travis/install-stack.sh
35+
36+# Here starts the actual work to be performed for the package under test;
37+# any command which exits with a non-zero exit code causes the build to fail.
38+script:
39+ - |
40+ # Run tests
41+ set -e
42+ ./.travis/install-dependencies.sh
43+ stack --no-terminal --jobs=2 --system-ghc test
44+ - |
45+ #Run HLint
46+ if [[ "$(uname)" = "Linux" ]]; then
47+ curl -sL https://raw.github.com/ndmitchell/hlint/master/misc/travis.sh | sh -s lint src test examples --cpp-define VERSION_project_m36=HLINT
48+ fi
49+ - |
50+ #Run Haddock
51+ if [[ "$(uname)" = "Linux" ]]; then
52+ stack --no-install-ghc --system-ghc --no-haddock-deps haddock
53+ fi
54+
55+after_success:
56+ - |
57+ # Build and ship binary
58+ #./.travis/attach-binary.sh
59+
60+# EOF
.travis/attach-binary.shnew file+25
@@ -0,0 +1,25 @@
1+#!/bin/sh
2+set -o errexit -o verbose
3+
4+if test ! "$BUILD_BINARY" || test ! "$TRAVIS_TAG"
5+then
6+ echo 'This is not a release build.'
7+elif test ! "$GITHUB_TOKEN"
8+then
9+ echo 'The GITHUB_TOKEN environment variable is not set!'
10+ exit 1
11+else
12+ echo "Building binary for $TRAVIS_OS_NAME to $TRAVIS_TAG..."
13+ stack build --ghc-options -O2 --pedantic
14+ echo "Attaching binary for $TRAVIS_OS_NAME to $TRAVIS_TAG..."
15+ OWNER="$(echo "$TRAVIS_REPO_SLUG" | cut -f1 -d/)"
16+ REPO="$(echo "$TRAVIS_REPO_SLUG" | cut -f2 -d/)"
17+ BIN="$(stack path --local-install-root)/bin/$REPO"
18+ BUNDLE_NAME="$REPO-$TRAVIS_TAG-$TRAVIS_OS_NAME.tar.gz"
19+ cp "$BIN" "./$REPO"
20+ chmod +x "./$REPO"
21+ tar -czf "$BUNDLE_NAME" "$REPO"
22+ echo "SHA256:"
23+ shasum -a 256 "$BUNDLE_NAME"
24+ ghr -t "$GITHUB_TOKEN" -u "$OWNER" -r "$REPO" --replace "$(git describe --tags)" "$BUNDLE_NAME"
25+fi
.travis/install-dependencies.shnew file+22
@@ -0,0 +1,22 @@
1+# Run tests
2+if [[ "$(uname)" = "Darwin" ]]; then
3+ timeout_cmd="gtimeout"
4+else
5+ timeout_cmd="timeout"
6+fi
7+$timeout_cmd 40m stack --no-terminal --jobs=2 --install-ghc --system-ghc build --only-dependencies --fast
8+ret=$?
9+case "$ret" in
10+ 0)
11+ # continue
12+ ;;
13+ 124)
14+ echo "Timed out while installing dependencies."
15+ echo "Try building again by pushing a new commit."
16+ exit 1
17+ ;;
18+ *)
19+ echo "Failed to install dependencies; stack exited with $ret"
20+ exit "$ret"
21+ ;;
22+esac
.travis/install-ghc.shnew file+16
@@ -0,0 +1,16 @@
1+#!/bin/sh
2+set -eux
3+#assume stack is installed
4+STACK=~/.local/bin/stack
5+
6+fetch_ghc_osx() {
7+ echo "Using stack to install GHC $GHC_VERSION"
8+ $STACK setup $GHC_VERSION
9+}
10+
11+if [ "$(uname)" = "Darwin" ]; then
12+ fetch_ghc_osx
13+else
14+ #installed by apt
15+ echo "Linux GHC $GHC_VERSION via APT already installed."
16+fi
.travis/install-ghr.shnew file+21
@@ -0,0 +1,21 @@
1+#!/bin/sh
2+set -o errexit -o verbose
3+
4+if test ! "$BUILD_BINARY" || test ! "$TRAVIS_TAG"
5+then
6+ echo 'This is not a release build.'
7+else
8+ if [ "$TRAVIS_OS_NAME" = "linux" ]
9+ then
10+ ARCH="linux"
11+ else
12+ ARCH="darwin"
13+ fi
14+ echo "Installing ghr"
15+ URL="https://github.com/tcnksm/ghr/releases/download/v0.5.4/ghr_v0.5.4_${ARCH}_386.zip"
16+ curl -L ${URL} > ghr.zip
17+ mkdir -p "$HOME/bin"
18+ export PATH="$HOME/bin:$PATH"
19+ unzip ghr.zip -d "$HOME/bin"
20+ rm ghr.zip
21+fi
.travis/install-stack.shnew file+27
@@ -0,0 +1,27 @@
1+#!/bin/sh
2+
3+# Adapted from https://github.com/commercialhaskell/stack
4+
5+set -eux
6+
7+travis_retry() {
8+ cmd=$*
9+ $cmd || (sleep 2 && $cmd) || (sleep 10 && $cmd)
10+}
11+
12+fetch_stack_osx() {
13+ curl -skL https://www.stackage.org/stack/osx-x86_64 | tar xz --strip-components=1 --include '*/stack' -C ~/.local/bin;
14+}
15+
16+fetch_stack_linux() {
17+ curl -sL https://www.stackage.org/stack/linux-x86_64 | tar xz --wildcards --strip-components=1 -C ~/.local/bin '*/stack';
18+}
19+
20+# We need stack to generate cabal files with precise bounds, even for cabal
21+# builds.
22+mkdir -p ~/.local/bin;
23+if [ "$(uname)" = "Darwin" ]; then
24+ travis_retry fetch_stack_osx
25+else
26+ travis_retry fetch_stack_linux
27+fi
Changelog.markdown−33
@@ -1,36 +1,3 @@
1−# 2021-04-01 (v0.9.3)
2−
3−* add new ":importtutd <URI> <SHA256 hash>" feature to import TutorialD from a local file or a HTTP/HTTPS URI
4−
5−# 2020-12-27 (v0.9.0)
6−
7−* replace unmaintained distributed-process-client-server RPC package with new curryer RPC package
8−* drop support for GHC 8.2 and GHC 8.4 due to dependency on DerivingVia extension
9−
10−# 2020-11-21 (v0.8.2)
11−
12−* support multiple extend expressions in TutorialD
13−* fix parsing of Bool atoms in TutorialD
14−* fix database context expressions which include self-references such as `s:=s union s`
15−* show constraints as TutorialD when using tutd console
16−* add `RelationalExprAtom` data type useful for storing `RelationalExpr` within the database
17−
18−# 2020-10-05 (v0.8.1)
19−
20−* support GHC 8.10
21−
22−# 2020-05-25 (v0.8)
23−
24−* refactor backend to maximize laziness: [An Architecture for Data Independence](docs/data_independence.markdown)
25−
26−# 2019-09-07 (v0.7)
27−
28−* fix case sensitivity issue with relation variables in tutd
29−* fix multibyte escaping in data frames
30−* fix broken instances of `Atomable [a]`
31−* fix `TypeConstructor` validation of argument count
32−* add help option to executables
33−
341# 2019-01-08 (v0.6)
352
363* fix atom type parsing to support more complex data types
README.markdown+3−12
@@ -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)
78[![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,12 +14,6 @@
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−
2317## Description
2418
2519Unlike most database management systems (DBMS), Project:M36 is opinionated software which adheres strictly to the mathematics of the relational algebra. The purpose of this adherence is to prove that software which implements mathematically-sound design principles reaps benefits in the form of code clarity, consistency, performance, and future-proofing.
@@ -44,7 +38,7 @@ Project:M36 supports multiple frontends which target different audiences.
4438
4539* [Developer's Blog](https://agentm.github.io/project-m36/)
4640* [Mailing List/Discussion Group](https://groups.google.com/d/forum/project-m36)
47−* IRC Channel: irc.libera.chat #project-m36 -- [Chat via Web Client](http://kiwiirc.com/nextclient/irc.libera.chat:+6697/#project-m36)
41+* IRC Channel: chat.freenode.net #project-m36
4842* [Hackage](https://hackage.haskell.org/package/project-m36)
4943* [Diogo Biazus' Project:M36 Video Tutorial](https://www.youtube.com/watch?v=_GC_lxlVEnE)
5044
@@ -54,7 +48,6 @@ Project:M36 supports multiple frontends which target different audiences.
5448
55491. [Installation and Introduction to Project:M36](docs/introduction_to_projectm36.markdown)
56501. [Introduction to the Relational Algebra](docs/introduction_to_the_relational_algebra.markdown)
57−1. [TutorialD Cheatsheet](docs/tutd_cheatsheet.markdown)
58511. [TutorialD via Jupyter Notebook Walkthrough](jupyter/TutorialD%20Notebook%20Walkthrough.ipynb)
59521. [TutorialD Tutorial](docs/tutd_tutorial.markdown)
60531. [15 Minute Tutorial](docs/15_minute_tutorial.markdown)
@@ -67,7 +60,6 @@ Project:M36 supports multiple frontends which target different audiences.
67601. [ACID Database Properties](docs/acid_assessment.markdown)
68611. [On NULL (in SQL)](docs/on_null.markdown)
69621. [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)
7163
7264### Advanced Features
7365
@@ -84,7 +76,6 @@ Project:M36 supports multiple frontends which target different audiences.
84761. [Isomorphic Schemas](docs/isomorphic_schemas.markdown)
85771. [Replication](docs/replication.markdown)
86781. [Basic Operator Benchmarks](https://rawgit.com/agentm/project-m36/master/docs/basic_benchmarks.html)
87−1. [Merkle Transaction Hashes](docs/merkle_transaction_graph.markdown)
8879
8980### Integrations
9081
@@ -94,7 +85,7 @@ Project:M36 supports multiple frontends which target different audiences.
9485
9586## Development
9687
97−Project:M36 is developed in Haskell and compiled with GHC 8.6 or later.
88+Project:M36 is developed in Haskell and compiled with GHC 8.0.2 or later.
9889
9990## Related Projects
10091
cabal.project+2−9
@@ -1,10 +1,3 @@
1+-- this is needed for GHC8 until distributed-process-extras is updated on Hackage with increased upper bounds
12packages: project-m36.cabal
2−
3−package *
4− split-sections: True
5−
6−--high-performance streaming library
7−source-repository-package
8− type: git
9− location: https://github.com/composewell/streamly.git
10− tag: ac3af8749194f1788704dda8667d0b3807075cc2
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
default.nixdeleted−1
@@ -1 +0,0 @@
1−(import ./release.nix { }).project
docker.nixdeleted−18
@@ -1,18 +0,0 @@
1−{ compiler ? "ghc8104"
2−, sources ? import ./nix/sources.nix
3−, pkgs ? import sources.nixpkgs { }
4−}:
5−let
6− release = import ./release.nix { inherit pkgs compiler sources; };
7− static-project-m36 = pkgs.haskell.lib.dontCheck (pkgs.haskell.lib.justStaticExecutables release.project);
8−in
9−pkgs.dockerTools.buildImage {
10− name = "project-m36";
11− tag = "latest";
12− contents = [ static-project-m36 ];
13− # expose default project-m36 and websocket server ports
14− config = {
15− Env = [ "LC_ALL=en_US.UTF-8" ];
16− ExposedPorts = { "6543/tcp" = { }; "8000/tcp" = { }; };
17− };
18−}
docs/15_minute_tutorial.markdown+68−65
@@ -4,34 +4,40 @@ Thank you for evaluating Project:M36, a new relational algebra engine written in
44
55## Prerequisites
66
7−* any Linux, MacOS, or Windows computer with Docker installed
7+* any Linux
8+* GHC 7.10 or later version (Haskell compiler)
9+* cabal (package downloader) installed
810
911## Download and Install
1012
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−
1713```bash
1814git clone https://github.com/agentm/project-m36.git
19−cabal new-run tutd
15+cabal sandbox init
16+cabal install --dependencies-only
17+cabal run tutd
2018```
2119
2220## Some Basic TutorialD
2321
24−When you run the ```tutd``` interpreter, you are interacting with an in-memory database using a dialect of the TutorialD language which is described in numerous books by Chris J. Date. It is a language specifically designed for human interaction with the relational algebra.
22+When you run the ```tutd``` interpreter, you are interacting with an in-memory database using a dialect of the TutorialD language which is described in numerous book by Chris J. Date. It is a language specifically designed for human interaction with the relational algebra.
2523
2624Note that TutorialD is strongly-typed- no type coercions take place automatically. For example, an integer will never be interpreted as a string or vice versa.
2725
2826### Load the Canonical Chris Date Example
2927
3028```
31−TutorialD (master/main): :importexample cjdate
29+TutorialD (master/main): :importexample date
30+```
31+
32+or
33+
34+```
35+TutorialD (master/main): :importtud "scripts/DateExamples.tutd"
3236```
3337
34−```:importexample``` (do not skip typing the preceding colon), loads a built-in example schema and executes it to change the state of the database. In this case, the relations "s" (supplier), "p" (product), and "sp" (suppliers-products) are now loaded.
38+```:importtutd``` (do not skip typing the preceding colon), loads a file which contains a script written in the TutorialD dialect used by Project:M36 and executes it to change the state of the database. In this case, the relations "s" (supplier), "p" (product), and "sp" (suppliers-products) are now loaded.
39+
40+```:importexample date``` loads the date example directly without any file I/O, so it is safe to use with the websocket server.
3541
3642### Execute Relational Expressions
3743
@@ -158,7 +164,7 @@ Database context expressions change the state of the database, much like "CREATE
158164#### Create a Relation Variable
159165
160166```
161−TutorialD (master/main): x:=relation{name Text, age Integer}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}
167+TutorialD (master/main): x:=relation{name Text, age Int}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}
162168TutorialD (master/main): :showexpr x
163169┌────────┬──────────┐
164170│age::Int│name::Text│
@@ -173,25 +179,23 @@ This is similar to SQL's "CREATE TABLE" operator.
173179#### Insert Additional Tuples
174180
175181```
176−TutorialD (master/main): x:=relation{name Text, age Integer}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}
182+TutorialD (master/main): x:=relation{name Text, age Int}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}
177183TutorialD (master/main): :showexpr x
178−┌────────────┬──────────┐
179−│age::Integer│name::Text│
180−├────────────┼──────────┤
181−│31 │"Mike" │
182−│40 │"Steve" │
183−└────────────┴──────────┘
184−
184+┌────────┬──────────┐
185+│age::Int│name::Text│
186+├────────┼──────────┤
187+│40 │"Steve" │
188+│31 │"Mike" │
189+└────────┴──────────┘
185190TutorialD (master/main): insert x relation{tuple{name "Bob", age 24}}
186191TutorialD (master/main): :showexpr x
187−┌────────────┬──────────┐
188−│age::Integer│name::Text│
189−├────────────┼──────────┤
190−│31 │"Mike" │
191−│40 │"Steve" │
192−│24 │"Bob" │
193−└────────────┴──────────┘
194−
192+┌────────┬──────────┐
193+│age::Int│name::Text│
194+├────────┼──────────┤
195+│40 │"Steve" │
196+│24 │"Bob" │
197+│31 │"Mike" │
198+└────────┴──────────┘
195199```
196200
197201Note that the relational insertion is identical to "x:=x union relation{...}".
@@ -200,51 +204,50 @@ Note that the relational insertion is identical to "x:=x union relation{...}".
200204
201205```
202206TutorialD (master/main): :showexpr s
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−└──────────┴────────┴───────────┴───────────────┘
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+└──────────┴────────┴───────────┴───────────┘
212216TutorialD (master/main): update s where city="London" (status:=35)
213217TutorialD (master/main): :showexpr s
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−
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+└──────────┴────────┴───────────┴───────────┘
224227```
225228#### Deleting Tuples from a Relation Variable
226229
227230```
228231TutorialD (master/main): :showexpr s
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−└──────────┴────────┴───────────┴───────────────┘
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+└──────────┴────────┴───────────┴───────────┘
238241TutorialD (master/main): delete s where sname="Adams"
239242TutorialD (master/main): :showexpr s
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−└──────────┴────────┴───────────┴───────────────┘
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+└──────────┴────────┴───────────┴───────────┘
248251```
249252
250253### Execute Transaction Graph Expressions
@@ -267,7 +270,7 @@ TutorialD (master/main): :rollback
267270
268271```
269272TutorialD (master/main): :branch experimental
270−TutorialD (experimental): employee:=relation{name Text, salary Integer}
273+TutorialD (experimental): employee:=relation{name Text, salary Int}
271274TutorialD (experimental): :commit
272275```
273276
docs/commits_in_constant_time.markdowndeleted−134
@@ -1,134 +0,0 @@
1−# Transactional Database Commits in O(1)
2−
3−A.M.
4−
5−[Project:M36](https://github.com/agentm/project-m36)
6−
7−## Synopsis
8−
9−Common relational database management systems operate in an imperative manner by executing statements immediately. This naive strategy quickly becomes an IO-bound bottleneck. By applying Haskell's laziness-in-evaluation to database updates, new doors for optimizations based on what is queried make themselves apparent. Furthermore, by serializing thunks representing idempotent database updates, the database can commit transactions in constant time with regards to the tuple count since the tuples themselves need not be serialized. This optimization, combined with *fsync*-coalescing, can allow databases to commit to disk faster than tuples updates can be processed.
10−
11−Using this deferred execution technique, database updates can be processed in the background or, in the case when the tuples are never requested, never.
12−
13−These database update thunks and other interesting optimizations are implemented in [Project:M36](https://github.com/agentm/project-m36): an experimental, clean-room, purely Haskell implementation of an RDBMS engine based on the mathematical principles of the relational algebra.
14−
15−## Rationale
16−
17−A typical SQL RDBMS such as PostgreSQL executes a list of commands serially against a serializable representation of the database state without concern to whether or not the commands are effectively necessary to service subsequent requests. A database update which affects *n* tuples will necessitate disk writes of *O(n)* plus *O(n\*log(n))* writes for each affected index.
18−
19−By validating and serializing thunks of validated commands, Project:M36 commits can be independent of the tuple write cost. The thunks, which are flushed to non-volatile storage to complete the transaction commit, allow the DBMS to defer execution in preference to commit time.
20−
21−The deferral is, however, not required, and could be left as a option to the user or application.
22−
23−The final cost of committing in Project:M36 relates to the size of the update expression. If the update expression is, for example, a insertion of a large number of rows, then the commit cost will be *O(t)* where *t* is the number of tuples expressed in the update, but still independent of the cost of the existing tuples in the database.
24−
25−## Example and Comparison to PostgreSQL
26−
27−Let us walk through a specific example using SQL. While Project:M36 does not support SQL (and for [good reasons](https://github.com/agentm/project-m36/blob/master/docs/on_null.markdown)), comparing both databases with a common language is useful for illustrative purposes.
28−
29−Let us consider an existing database with a table/relation named "BigTable" which has 10 billion rows/tuples (an arbitrarily large number) of which one column is named "x" and represents a randomly-assigned integer. Next, assume that the user of the database will execute an update which will update every row/tuple, commit the changes, then query a subset of the resultant updated rows/tuples.
30−
31−
32−### The Update Expression
33−
34−Consider the following database update:
35−
36−```
37−UPDATE "BigTable" SET x = x + 1;
38−```
39−In PostgreSQL, the cost of executing this expression is incurred immediately upon execution. New tuples are laid down to disk (if the dataset is larger than *shared_buffers*), duplicating the entirety of the existing table/relation in storage (due to MVCC) for a cost of *O(n)* where *n* is the number of existing rows/tuples in "BigTable". If *x* is indexed, then the index writes incur an additional cost of *O(n\*log(n))* writes. Furthermore, PostgreSQL will write all changes to its write-ahead log, so the cost is multiplied by some factor.
40−
41−In Project:M36, the same expression can first be statically validated to adhere to the database constraints. The only constraint affected here is for the column/attribute *x* which requires an integer. Since adding one to any integer retains the integer type, the constraint can be determined to be unviolated without evaluating the expression, thus at a cost of *O(1)*. Project:M36 uses a novel WORM (write-once, read-many) strategy over journaled filesystems to avoid the need for a separate journal.
42−
43−*For the purpose of this example, assume that integer overflow is not a concern.*
44−
45−### The Commit
46−
47−```
48−COMMIT;
49−```
50−
51−In PostgreSQL, the write-ahead log mentioned above containing all tuples changes must now be flushed to non-volatile storage, creating a bottleneck to the slowest form of storage. A necessary checkpoint (which is configurable) could incur further writes as the tuples are flushed to disk as well.
52−
53−In Project:M36, the update expression must also be flushed to disk, but the expression is a mere few bytes appended to the transaction graph.
54−
55−### The Subsequent Query
56−
57−Finally, the user queries a subset of the updated table/relation.
58−
59−```
60−SELECT a, b, c, x FROM "BigTable" WHERE x > 10000;
61−```
62−
63−In PostgreSQL, considering that the column/attribute has an index, *O(log(n))* reads are needed to identify on which pages in the table's on-disk storage the proper values can be found. Considering that the value *x* was previously described as random, despite the restriction, in the worst case, every page of the on-disk table may need to be read because each page could contain one value matching the restriction. This would necessitate reading *O(n)* tuples previously written to disk. After reading the tuples, the tuples must be filtered by the restriction to service the query.
64−
65−In Project:M36, the state of the database is determined to be the difference of the previous state *S* (before the *x+1* update above) and *S'* (after the update). The serialized update expression can be deserialized and merged into the rewritten query:
66−
67−```
68−SELECT orig.a, orig.b, orig.c, x_orig + 1 AS x FROM (SELECT a, b, c, x AS x_orig FROM "BigTable"@S) AS orig WHERE x > 10000;
69−```
70−
71−where the *@* symbol references the state of "BigTable" at transaction state *S* in the past. The rewrite process can occur in constant time regarding the tuple count, but the execution does require reading the previous state *S* of "BigTable", filtering it as expected. The tuple read cost is equivalent to that of the same statement at *S'*: *O(log(n))* utilizing a b-tree index.
72−
73−### Summary
74−
75−| | PostgreSQL | Project:M36 |
76−|-|------------|-------------|
77−| UPDATE x+1 | *O(nlog(n))* | *O(1)* |
78−| COMMIT | flush *n* tuples to disk | flush expression to disk |
79−| SELECT x>10000 | *Ω(log(n))*, *O(n)* worst case | *O(log(n))* |
80−
81−Even if the user were to query all the tuples back, the actual IO cost in Project:M36 would be lower since the updates are only "executed" on the fly and not necessarily written to disk. However, a clever cacheing strategy could note that state *S* is queried often enough to warrant a cached version. The table's data on disk, however, is not required to answer the query.
82−
83−## Constraint Oracles
84−
85−To be able to perform an update and commit in constant or less than *O(n)* time does have some preconditions:
86−
87− * constraints must be able to be statically validated in linear or logarithmic time
88−
89−However, even if constraints lack a proper oracle such as an index or a static means of validation and, thus, cannot be validated in constant time, the user may still benefit from serialization of the database update expression since writing the validated tuples to disk can be deferred beyond commit time and could go directly into an on-disk cache.
90−
91−## Worst Case Behavior
92−
93−Every database constraint can be represented as an inclusion dependency whereby the evaluation of a relational expression `sub` must be a subset of the evaluation of relational expression `super` (`sub ⊆ super`) for the constraint to validate. Therefore, the worst case time to validate any constraint, assuming that the constraint has an ideal oracle, is O(n) in the tuple count. However, as mentioned above, there are many constraints that can be validated in constant or less-than-linear time. Furthermore, the validated tuples need not be written to disk once the constraint is found to hold.
94−
95−Since there is great variation in constraint validation cost, the RDBMS could pre-analyze and report on associated constraints costs or make use of data independence to guide storage to optimize queries needed to service the constraint checker.
96−
97−## Caveats
98−
99−Certain types of updates still take a similar amount of time to commit in Project:M36 in comparison to PostgreSQL. Specifically, any update which relies on data outside the database's purview will necessitate flushing the tuple data since the update expression contains new tuple data not based on existing tuples. For example, the equivalent of:
100−
101−```
102−INSERT INTO "BigTable"(a, b, c, x) VALUES (1,5,10,10),(20,20,21,30),.... #many tuples
103−```
104−will still necessitate a *O(n)* tuple writes to disk in both databases. Though the asymptotic costs are equivalent, the number of writes are cut in half in Project:M36 since it does not require a write-ahead log.
105−
106−While PostgreSQL makes use of MVCC (multi-version concurrency control) which marks which tuples belong to a linear progression of transaction states, Project:M36 stores a full history of database state using a transaction graph (a directed acyclic graph similar to the commit-based graph of `git`). The graph allows named branches to be created and merged which also reduce contention around a singular graph head.
107−
108−## Applying Laziness to SQL RDBMSes
109−
110−Would it be possible to apply transaction-based laziness to an SQL-based RDBMS? Certainly, with sufficient shoe-horning, it could work, but SQL includes a few malfeatures which would make it difficult, if not impossible:
111−
112− * Non-idempotent server-side functions prevent laziness because of side effects. PostgreSQL can mark functions as idempotent, but does not validate or enforce the idempotence, Project:M36, via Safe Haskell, can validate pure functions.
113− * The lack of "time travel", the ability to query database state in the past prevents reliance on previous states, prevents direct referencing of previous database states on which the state differences can be built.
114− * Tightly-coupled table-to-storage management prevents alternative data models. Indexing and constraint checking need to be statically verifiable and deferrable.
115−
116−These hurdles are not insurmountable, just perhaps not a good fit for SQL databases with a lot of historical and implementation baggage.
117−
118−## Benchmarks
119−
120−Forthcoming.
121−
122−## Conclusion
123−
124−Transactional time-to-commit is critical in ensuring that business decisions can make it to non-volatile storage as quickly as possible. By introducing Haskell-like, lazy evaluation to update expressions and serializing the resultant thunk, commits can be serialized in constant time, disregarding the number of tuples modified in the expression.
125−
126−This serialization strategy turns modern RDBMS architecture on its head since the table/relation-to-file mapping is broken, resulting in true data independence. Any on-disk representation of a relation at a specific transaction state therefore merely becomes a cached and purgeable entity, drastically shrinking on-disk cacheing requirements while expanding the scope in which said strategies can operate. Hopefully, a truly data independent architecture will result in new optimization discoveries.
127−
128−Project:M36 implements a transaction graph which can represent the entirety of database state, leaving room for any number of alternative representations, even for a single relation or relation across transaction states. A simple example could include storing two different orderings of tuples of the same relation in order to optimally serve different join queries. Common RDBMSes offer only two on-disk representations: the set of fully-evaluated tuples and indexes to those tuples, preventing data independence. Data independence paves the way towards the elimination of implementation-specific, gatekeeper roles such as database administrators.
129−
130−The promise of the relational algebra has always been the liberation of data from its data structure representation in order to be able to answer arbitrary queries. Modern DBMSes which typically map tables directly to one or more files on disk fail to live up to this promise. Project:M36 sets out to rectify this failure.
131−
132−In a greater context, applying laziness to an architecture to make use of more interesting optimizations is hardly new. The OpenGL API views its "immediate" mode as effectively deprecated. Filesystems take advantage of laziness using copy-on-write semantics. High-level programming languages can make greater, more interesting inferences about how a computation must be execute. A computer can always consider many more possible solution paths than a human can.
133−
134−The adherence to mathematical priniciples in Project:M36 results in features and optimization opportunities which have not yet been discovered. In contrast to RDBMSes designed around specific optimizations (such as indexes, specific disk layouts, or key-value lookups), Project:M36 sets out to demonstrate practically that future optimizations can only be discovered when operating within a mathematically-coherent architecture.
docs/data_independence.markdowndeleted−109
@@ -1,109 +0,0 @@
1−# Project:M36: Towards an Architecture for Data Independence
2−
3−## Introduction
4−
5−The Project:M36 relational algebra architecture sets itself apart from typical DBMSes by ensuring strict transactional isolation, a branchable/mergeable (rather than linear) transaction graph, and storage of relational expressions (rather than storage of tuples). Let's look at how these architectural features work together to make Project:M36 the first relational algebra engine to implement true data independence.
6−
7−## What is Data Independence?
8−
9−C.J. Date writes:
10−
11−`Certainly most SQL products have failed to live up to the [relational] model's full potential...in those products, what the user sees and what is physically stored are essentially the same thing... In particular, it accounts for the argument, so often heard, to the effect that we have to "denormalize for performance."`
12−
13−`In principle, logical design has absolutely nothing to do with performance at all.`
14−
15−(Date, C.J. "Database In Depth: Relational Theory for Practitioners". O'Reilly Media. 2005. pages 156-157.)
16−
17−Data independence is therefore defined as the separation of the database user's experience from the database's means of in-memory or on-disk representation. As Date points out, virtually all database products implement a one-to-one mapping of relations to files in storage.
18−
19−One advantage of high-level abstractions in programming languages is to leverage advanced algorithms which can choose optimization paths on behalf of the user which a human may never be able to discover. While the promise of ever higher-level abstractions is realized by progamming languages such as Haskell, DBMS implementors have been resistant to data independence. This is due to several legacy factors such as companies pushing one-trick-pony database technologies and middlemen such as DBAs required to play gatekeeper against "bad" schema changes. The result is customers forced to run multiple disparate databases such as one for realtime transaction processing and another for analytics and another for audit logging. This recalcitrance has also led to the rise of databases such as "document" JSON databases with weak mathematical underpinnings in the name of performance as users become frustrated when hitting performance walls and dealing with arbitrary database limitations.
20−
21−Implementations which closely tie the user interface to backend representation close the door on interesting alternative representations and optimizations. For example, SQL databases typically store a single relation as a list of tuples on disk with supplementary indexes stored in separate files. There is no reason that the same relation couldn't be on disk or in memory in any number of formats. Such a table might be useful in various formats ideal for servicing different types of queries. Data independence grants the DBMS the permission to create any number of representations- including none at all- as long as the correct answer is provided to the user. "Column-store" databases may try to slice the tuples in a different axis, but those databases simply shift the performance problems elsewhere. Only implementation details prevent a database from offering both column-oriented *and* tuple-oriented representation while allowing the database to choose.
22−
23−That is why it is critical for the user's interface to the database *not* to include features such as "query hints" which would force a specific implementation in the backend. The user's interface must be declarative (describing the state change or query rather than *how* to execute it) and sufficiently high level. Any implementation detail leakage to the user's interface is a lost potential algorithmic optimization. While the topic of providing high-level interfaces is not specific to database design, we will continue to explore the ramifications of data independence in databases.
24−
25−
26−## Transactional Isolation
27−
28−While other databases offer various transaction isolation levels with differing levels of implementation-specific surprises, Project:M36 solely suppports the maximum transaction isolation level. Instead of relying on details of [MVCC](https://www.postgresql.org/docs/current/mvcc-intro.html) which marks each tuple in a relation with a monotonically-increasing number identifying from which transaction the tuple was added or deleted, Project:M36 includes no singular backing store for tuples, instead storing a stream of state change requests. Because the transaction graph supports branching and merging (similar to version control such as git), transactions can be committed without contention at a singular head of the graph. Committing to disk can be implemented as writing a file to represent the transaction's state and
29−
30−## The Transaction Graph
31−
32−These state changes are, in fact, the idempotent relational update expressions that the user has submitted. For example, given a transaction which includes a single relation `s`:
33−
34−```
35−┌──────────┬────────┬───────────┬───────────┐
36−│city::Text│s#::Text│sname::Text│status::Int│
37−├──────────┼────────┼───────────┼───────────┤
38−│"Paris" │"S2" │"Jones" │10 │
39−└──────────┴────────┴───────────┴───────────┘
40−```
41−
42−if the user commits a transaction with an insert such as:
43−
44−```
45−insert x relation{tuple{city "Boston", s# "S3", sname "Smith", status 400}}
46−```
47−
48−then a typical database will find the file representing the relation, find some free space in it and save the new tuple along with the MVCC transaction identifier. Subsequent transactions will find the tuple and compare it to their own transaction id in order to determine its "visibility". Project:M36, on the other hand, after validating that all relational constraints (such as primary and foreign keys) still hold, will simply serialize and append the expression to the transaction graph log. By default, there is no file representing the relation.
49−
50−For those familiar with Haskell, note how serializing the update expression is similar to being able to serialize a thunk or deferred execution.
51−
52−The transaction graph also allows users to travel back to previously-committed transactions. This may be useful for audit logging or alternative schemas.
53−
54−## Storage Representations
55−
56−Given the ever-growing transaction graph based on state changes, let's examine how Project:M36 services subsequent queries.
57−
58−## Benefits
59−
60−The primary goal of a database should be to ensure data integrity. Project:M36 takes no shortcuts in achieving this goal, but choosing a backend architecture which minimizes the time which it takes to get the transaction to non-volatile storage (disk) by storing update expressions rather than attempting to shuffle tuples on disk. This architecture open the door to many optimization techniques, many of which are new to databases.
61−
62−### Multiple On-Disk Representations
63−
64−The promise of data independence allows database backends to store relations as they see fit. That can include any number of on-disk representations including none at all. For example, for a table accessed by multiple projections, the database may choose to materialize the relation in those projections. The representations are therefore created in service to the queries submitted or anticipated instead of being based on past update expressions. Because on-disk storage is obviously limited, the database must decide what is valuable to keep around for future queries. This could open a new area of research into the appropriate machine learning algorithms, but, fundamentally, this set of materialized query responses is effectively a cache which can always be refreshed.
65−
66−The alternative representations need not be a direct answer to queries- for example, a materialized relation from a transaction could be used to service a query from a later transaction if the updates since that transaction are applied.
67−
68−The database could also anticipate, for example, scheduled queries and actually materialize relations before the query is executed. On-disk cache could represent "denormalized" tuple sets while the user-facing interface shows a properly normalized schema, thereby supporting data independence.
69−
70−More research in determining just what should be in the cache is needed.
71−
72−### Transactional Commits in O(1) Time
73−
74−Because the Project:M36 backend need not save tuples into a specific file representing a relation, the backend can drastically reduce the amount of time needed to commit a transaction to disk. Specifically, following constraint validation (which can often be done in constant or logarithmic time relative to the tuple count), the fastest means of committing the transaction is to save the update expression itself. Since the previous state has already been presumably committed, any idempotent operation can be saved for deferred execution. This means that transactions can be committed to disk relative to the size of the update expression rather than the number of the tuples affected- committing can occur at a rate relative to that of update expression size (typically a few kilobytes) rather than relative to the number of tuples that the update expression happened to alter.
75−
76−This technique gets transactions to disk faster, thus drastically increasing the rate transactions can be committed overall. Note that the execution of the update expression may be deferred by this process, so the cost to evaluate it may occur later, but this processing may be performed in the background after the transaction is committed. When the data is never requested, for example, for a defunct transaction graph branch, the actual execution could be deferred indefinitely, incurring zero cost to calculate the consquence of the update.
77−
78−### Less Disk Usage
79−
80−Because Project:M36 stores a stream of update expressions rather than tuples themselves, the minimum storage requirements for a given database may be reduced. For example, if a relation with an attribute `x` of type `Integer` has 1,000,000 tuples, a subsequent update to increment all 1,000,000 values by one may be cheaper to evaluate on-demand rather than immediately generating 1,000,000 new tuples and saving them to disk. If the new tuples are requested, the database can determine that the tuples are not materialized, calculate them, and return them, all without ever having the tuples on disk. Furthermore, if only a subset of the tuples are ever requested, for example, due to a query restriction, then some of the tuples may never need to be calculated or materialized.
81−
82−### Audit Logging
83−
84−Typical databases implement various strategies for audit logging, including:
85−
86−* exposing MVCC-like values such as tuple "created at" and "created by" to the user and forcing all tables to be insert-only
87−* shuttling audit logs to a secondary database
88−
89−Project:M36, through its inherent ability to travel the append-only transaction graph, enables audit-logging by allowing users to checkout previous transaction states. Committed transaction states are immutable, so no relation pollution or secondary database is necessary.
90−
91−### Selective Caching
92−
93−Typical databases materialize entire tuple sets representing each named relation (relation variable), but there is nothing special about relations that happen to be named. Data independence allows us to cache answers to common or even anticipated queries- this allows the schema to be normalized and unmaterialized while the *denormalized* query results are materialized cached. This flexibility saves disk space and allows the cache to be much more dynamic than in a typical DBMS.
94−
95−### Never-Materialized Tuples Replace Partitions
96−
97−Queries on very large relations often very often restricted (filtered by tuple) to generate subsets which are often partitioned, for example, by an event's date. Instead of requiring DBMS users to manually partition and slice their data in one, fixed, particular way, Project:M36's cacheing system will only cache those tuples that serve the interests of the queries. With something like an LRU cache, a data independent architecture will naturally cache "partitions" of the full relation without manual intervention.
98−
99−### Elimination of DBA role
100−
101−Databases essential to a business function are often guarded by a human database administrator (DBA) whose role it is to monitor database performance and to play gatekeeper to database schema changes as the database grows. This role is necessary because database tuning can be an arcane skill, rife with pitfalls for those who don't know the database software inside-and-out. This is a direct cause of data dependence, forcing DBAs to manually enforce data partitioning and shuffling data to different servers, configuring database replicas, and making Faustian bargains to "denormalize" tables for analytical workloads.
102−
103−A data independent architecture eliminates this role by allowing the database to make the optimal choices itself. This means that the database can respond to schema changes immediately, without manual repartitioning or denormalization steps.
104−
105−## Conclusion
106−
107−Project:M36's backend architecture enables new optimizations and features that are sorely lacking in existing DBMSes. By leveraging its novel transaction graph and deferred evaluation, Project:M36 handles more DBMS use-cases.
108−
109−Project:M36's novel architecture opens the door for further database and algorithmic research.
docs/filesystem-persistence.markdown+1−1
@@ -1,4 +1,4 @@
1−# Project-M36 Filesystem Persistence (Change Proposal)
1+# Project-M36 Filesystem Persistence
22
33## Introduction
44
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 cjdate
12+TutorialD (master/main): :importexample date
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 cjdate
40+TutorialD (master/main): :importexample date
4141TutorialD (master/main): :showexpr s
4242┌──────────┬────────┬───────────┬───────────────┐
4343│city::Text│s#::Text│sname::Text│status::Integer│
docs/introduction_to_projectm36.markdown+9−28
@@ -15,35 +15,16 @@ The relational algebra is the mathematical model underpinning Project:M36. When
1515
1616## Binary Releases
1717
18−The quickest and preferred method of installation is via docker, which works on Linux, macOS, and Windows. Docker downloads and runs preconfigured software in secure, sandboxed containers, preventing third-party software from altering the host system without your permission.
18+### Windows
19+Project:M36 now provides binary installations for Windows. Check the (releases page)[https://github.com/agentm/project-m36/releases] for downloads.
1920
20−### Install Docker:
21+### MacOS X
2122
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)
23+Binary releases are not yet available for MacOS X, but compiling from source is easy.
2524
26−### Run TutorialD from Docker Image
25+### Linux
2726
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−```
27+The currently-preferred method of installation is from source. A future enhancement would be installation from deb or rpm.
4728
4829## Source Installation
4930
@@ -51,7 +32,7 @@ Requirements:
5132
5233To build with stack:
5334
54−* [GHC 8.6.5 or greater](https://www.haskell.org/downloads)
35+* [GHC 8.2.2 or greater](https://www.haskell.org/downloads)
5536* [Haskell stack](https://docs.haskellstack.org/en/stable/README/)
5637* Linux, macOS, or Microsoft Windows
5738
@@ -59,11 +40,11 @@ Compilation steps:
5940
6041* ```git clone https://github.com/agentm/project-m36```
6142* ```cd project-m36```
62−* ```stack --stack-yaml stack.ghc8.6.yaml build```
43+* ```stack --stack-yaml stack.ghc8.2.yaml build```
6344
6445At this point, the TutorialD interactive interpreter can be run using ```stack exec tutd```.
6546
66−Alternative building with GHC 8.6.5 or greater:
47+Alternative building with GHC 8.0.2 or greater:
6748
6849* ```cabal new-build```
6950
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 Name, Instructor Name Type)|(Course Room Number, Room Number Type)|
205+|(Course Name, Course Name Type)|(Instructor, Instructor Name Type)|(Course Room Number, Room Number Type)|
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 which the aggregate was derived.
381+In the relational algebra, The aggregate value can be placed alongside the relation value from whic the aggregate was derived.
382382
383383Example:
384384
docs/merkle_transaction_graph.markdowndeleted−33
@@ -1,33 +0,0 @@
1−# Project:M36: Merkle Hashing for Transaction Graph
2−
3−## Introduction
4−
5−Project:M36 supports an append-only transaction graph model (similar to git) whereby new transactions can be added to the graph but not removed. As with any graph, each node can contain a Merkle hash which ensures not only that it's state since being added to the graph has not changed but also that none of its parent nodes all the way to the root node (initial state) have not been modified. This validation has a number of use cases.
6−
7−## Usage
8−
9−Project:M36 automatically adds Merkle hashes to every transaction. All data which represents the database state at that transaction is included in the hash including (but not limited to) relation variable definitions, atom and database context functions, constraints, and types.
10−
11−Project:M36 validates all merkle hashes at database startup. For users who need validation after the database is started, the user can issue `:validatemerklehashes` at the `tutd` command line.
12−
13−### Audit Logging
14−
15−Project:M36 supports audit logging by allowing users to travel to transactions in the past and recreate the database state at that past point-in-time. To ensure that those past states cannot be modified either by malicious on-disk or in-memory changes, each transaction is protected by its own Merkle hash. If the calculated hash does not match the stored hash, Project:M36 can immediately report which transaction triggered the tamper-proof log.
16−
17−### Reproducibility
18−
19−Since a Merkle tree is effectively immutable except to add more nodes, it can be used to save and restore a whole database with very high confidence in the results. This feature could also be used to restore a database partially; for example, to duplicate just the latest database state on a second machine for OLAP analysis.
20−
21−### High-Availability
22−
23−Merkle tree hashes can be used to assert database integrity across high-availibility or database replication. Since the hash covers all database state, it can be used to validate log-shipping-based replication. Corrupted cache tuple data can be easily detected and flushed.
24−
25−## Merkle Hashes in Other DBMSes
26−
27−While Merkle hashes have become prevalent in blockchain-style databases, they have not made many appearances in typical SQL databases. This is likely due to the fact that such databases consider any additional operations against the large tuple stores as prohibitively expensive. Project:M36 is able to skirt this cost by only hashing database update expressions rather than the result of these executed expressions. This also means that the Merkle hash can be computed against transactions which have been created but never executed.
28−
29−## Conclusion
30−
31−Merkle hashes are an obvious improvement to any graph-based transaction log and are a low-cost method of ensuring data integrity.
32−
33−A further improvement could allow users to specify an initial key provided by an admin user to salt the hash used to create the database. Additionally, a multi-user system could allow individual users to sign their committed transactions. The signature would then be included in the Merkle hash.
docs/reaching_out_of_the_tarpit.markdown+1−1
@@ -57,7 +57,7 @@ Project:M36 implements multiple interfaces:
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 cjdate
60+TutorialD (master/main): :importexample date
6161TutorialD (master/main): :showexpr p
6262┌───────────────────┬────────────┬───────────────────┬────────────┬────────────┐
6363│address::Address │agent::Agent│dateRegistered::Day│photo::Text │price::Price│
docs/server_mode.markdown+1−1
@@ -8,7 +8,7 @@ While Project:M36 is easy-to-use as an interactive, in-process database manageme
88
99To start the Project:M36 server to serve the local host with a database named "mydbname", run ```cabal run project-m36-server -- --database mydbname --hostname 127.0.0.1``` in the project-m36 source directory. The double-dash indicates that the arguments should be passed to ```project-m36-server``` instead of ```cabal```. Under normal conditions, this command will print nothing and block indefinitely to serve incoming requests on the default port 6543.
1010
11−Note that the above invocation will serve an in-memory, transient "mydbname" database. The database is deleted when the server exits. To serve a database with filesystem persistence, invoke ```cabal run project-m36-server -- --database mydbname --hostname 127.0.0.1 --database-directory /path/to/dbdirectory --fsync```.
11+Note that the above invocation will serve and in-memory, transient "mydbname" database. The database is deleted when the server exits. To serve a database with filesystem persistence, invoke ```cabal run project-m36-server -- --database mydbname --hostname 127.0.0.1 --database-directory /path/to/dbdirectory --fsync```.
1212
1313## Connecting an Interactive Client
1414
docs/transaction_graph_operators.markdown+4−6
@@ -43,17 +43,15 @@ 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−┌─────────────┬────────────────────────────────────────────┬──────────┬──────────────────────────────────────┬────────────────────────────────────────┬─────────────────────────────────┐
47−│current::Bool│hash::ByteString │head::Text│id::Text │parents::relation {id::Text} │stamp::DateTime │
48−├─────────────┼────────────────────────────────────────────┼──────────┼──────────────────────────────────────┼────────────────────────────────────────┼─────────────────────────────────┤
49−
46+TutorialD (master/main): :showgraph
47+┌─────────────┬──────────┬──────────────────────────────────────┬────────────────────────────┬──────────────────────────────┐
48+│current::Bool│head::Text│id::Text │parents::relation {id::Text}│stamp::DateTime │
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−
5755The "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.
5856
5957The "id" attribute is the UUID needed in order to navigate the graph.
docs/tupleable.markdown−19
@@ -23,25 +23,6 @@ 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−
4526## Usage
4627
4728The ```Tupleable``` module includes the following functions:
docs/tutd_cheatsheet.markdowndeleted−99
@@ -1,99 +0,0 @@
1−# Tutorial D Cheatsheet
2−
3−The following tables list examples of expressions for `tutd`, Project:M36's "Tutorial D" implementation.
4−
5−## Relational Expressions
6−
7−Relational expressions query database state without being able to change it.
8−
9−|Relational Expression |Description |
10−|------------------------------------------------------|---------------------------------------|
11−|`:showexpr p`|Display the relation variable `p`|
12−|`:showexpr s rename {city as town}`|Display the result after renaming a relational attribute|
13−|`:showexpr p{color,city}`|Display the result of the projection on the `color` and `city` attributes|
14−|`:showexpr p{all but city}`|Display the result of the projection of all attribute of `p` except `city`|
15−|`:showexpr p join sp`|Display the result of the relational expression `p` joined against `sp` (equivalent to `NATURAL JOIN` in SQL)|
16−|`:showexpr (s join sp){all from s}`|Display the result of a join but only include attributes from `s`|
17−|`:showexpr s semijoin sp`|Equivalent to `(s join sp){all from s}`|
18−|`:showexpr s antijoin sp`|Display the result of all tuples in `s` which do not match appear in the result of `s semijoin sp`|
19−|`:showexpr s union s`| Display the result of `s` unioned with itself (which is equivalent to `s`)|
20−|`:showexpr s:{status2:=add(10,@status)}`| Display the result of extending the `s` relation variable with a new attribute which adds 10 to each `status` attribute|
21−|`:showexpr s group ({sname,status,s#} as subrel)`| Display the result of grouping the `sname`, `status`, and `s#` into a subrel for each tuple in the `s` relation where the `city` attribute (not mentioned) is the grouping criteria|
22−|`:showexpr (s group ({sname,status,s#} as subrel)) ungroup subrel`| Display the result of unwrapping a subrelation to create one new tuple for each subrelation tuple in the result|
23−|`:showexpr s minus s`|Display the result after removing all tuples that match the second argument. `x minus x` is equivalent to `x where false`|
24−|`:showexpr relation{tuple{name "Mike",age 6},tuple{name "Sam",age 10}}`|Display an unnamed relation using manually constructed tuples|
25−|`:showexpr relation{a Integer, b Text}`|Display an empty-tupled relation of a specified type|
26−|`:showexpr relation{a Integer, b Text}{tuple{a 4, b "four"}}`|Display a relation bound by the specified types and containing one or more tuples|
27−|`:showexpr s group ({s#,sname,status} as subrel):{citycount:=count(@subrel)}`|Display a result which groups `s` by `city` and extends the relation by a count for each city.|
28−|`:showrelvars`|Display a list of relation variables in the current context along with their types (attributes)|
29−
30−## Built-In Types
31−
32−|Example Value Expression |Type |Explanation|
33−|------------------------------------------------------|---------------------------------------|-----------|
34−|`"abc"`|Text|UTF-8 string|
35−|`123`|Integer|an integer of limitless size (using gmp)|
36−|`int(456)`|Int|machine-word-based integer|
37−|`12.56`|Double|64-bit IEEE 754 floating point number|
38−|`dateTimeFromEpochSeconds(1502304846)`|DateTime||
39−|`fromGregorian(2017,05,30)`|Date||
40−|`t`|Bool|`t` or `f`|
41−|`bytestring("dGVzdGRhdGE=")`|Bytestring|base-64-encoded string of bytes|
42−|`interval(3,5,f,f)`|Interval(Integer)|the constructor function includes two bounds and two boolean flags for inclusiveness|
43−
44−## Database Context Expressions
45−
46−Database context expressions take the current database context as input and alter it to create a new
47−
48−|Database Context Expression |Description |
49−|------------------------------------------------------|---------------------------------------|
50−|`:importexample cjdate`|Imports a precooked schema from Chris Date's books resulting in relvars `s`, `sp`, and `p`|
51−|`:importtutd "file:///home/agentm/project-m36/scripts/emp.tutd"`|Imports TutorialD from file URI|
52−|`:importtutd "https://raw.githubusercontent.com/agentm/project-m36/master/scripts/emp.tutd" "effe32b247586dc3ac0079fc241b9618d41d189afcaeb7907edbe5a8b45992a4"`| Imports TutorialD from HTTP or HTTPS URI|
53−|`newrelvar:=relation{tuple{age 3}}`|Assign a new relation variable named `newrelvar`|
54−|`undefine s`|Remove a relation variable|
55−|`insert s relation{tuple{city "Boston",s# "S10",sname "Gonzalez",status 10}}`| Append to an existing relation variable with another relational expression|
56−|`update s where status=20 (sname:="Mr. Twenty")`|Replace one or more values in matching tuples with a new value|
57−|`delete sp where s#="S4"`|Remove tuples matching the criteria|
58−|`key s_key_constraint {s#} s`|Add a constraint named `s_key_constraint` on relation variable `s` ensuring that `s#` is unique|
59−|`foreign key s#_in_sp sp{s#} in s{s#}`|Add a foreign key constraint that ensures that `sp`'s `s#` attribute always references a `s#` value in `s`|
60−|`constraint s_status_less_than_50 (s where ^lt(50,@status)){} in false`|Add a constraint that stipulates that the `status` values in `s` are less than 50|
61−|`createarbitraryrelation employee {name Text, empid Int, hired DateTime} 3-100`|Create a relation variable with random values with between 3-100 tuples- useful for testing|
62−|`notify steve_change person where name="Steve" true (person where name="Steve"){address}`|Notify the current connection with an asynchronous event if any committed tuples matching `person where name="Steve"` with `true` for the pre-change state and `person where name="Steve"){address}` for the post-change state- these states will be sent along with the notification|
63−|`data Hair = Bald | Brown | Blond | OtherColor Text`|Create a new algebraic data type for use with values inside tuples|
64−|`undata Hair`|Delete the `Hair` custom type|
65−
66−
67−## Transaction Graph Expressions
68−
69−Transaction graph expressions alter the state of the transaction graph by append new states.
70−
71−|Transaction Graph Expression |Description |
72−|------------------------------------------------------|---------------------------------------|
73−|`:commit`|Save the current database context to a new transaction and add it to the transaction graph|
74−|`:rollback`|Return the database context to the state before any alterations were made|
75−|`:branch experimental`|Create a new branch from the existing branch and switch the current context to be able to commit to the new branch|
76−|`:jumphead master`|Discard any changes in the current context and jump to the head of a different branch|
77−|`:jump 11b601c9-f46b-42b0-a2ce-cf18ced31b7f`|Jump to the specific transaction by UUID- useful for introspecting past states|
78−|`:showgraph`|Display a representation of the transaction graph|
79−|`:walkbacktotime "2017-08-10 16:44:00"`|Walk back in time from the current branch until a transaction less than or equal to the time is found and switch the current context to that past transaction- useful for auditing|
80−
81−## Data Frame Expressions
82−
83−In contrast to relational expressions, data frame expressions generate ordered tuples.
84−
85−|Data Frame Expression |Description |
86−|------------------------------------------------------|---------------------------------------|
87−|`:showdataframe s orderby {status}`|Display a data frame result for the relational expression `s` and sort the tuples by `status`|
88−|`:showdataframe s{status} orderby {status descending} offset 1 limit 3`|Display a data frame result for `s{status}` but ordered by `status` values descending, skip the first tuple, and return no more than 3 tuples|
89−
90−## Trans-Graph Relational Expressions
91−
92−Trans-graph relational expressions allow queries spanning multiple transactions.
93−
94−|Trans-Graph Relational Expressions |Description |
95−|------------------------------------------------------|---------------------------------------|
96−|`:showtransgraphexpr s@master join sp@master`|Display a result for joining `s` and `sp` on the branch `master`|
97−|`:showtransgraphexpr s@master~ join sp@master`|Display a result for joining `s` on the parent transaction of `master`'s current head and `sp` on master|
98−|`:showtransgraphexpr s@master~^2`|Display a result for `s` two parents previous to the parent of the current `master`'s head|
99−
docs/tutd_tutorial.markdown+2−56
@@ -19,7 +19,7 @@ TutorialD (master/main):
1919The examples in this tutorial can be executed after loading Chris Date's sample relations using:
2020
2121```
22−:importexample cjdate
22+:importexample date
2323```
2424
2525Each section assumes a fresh instance of the Date examples. The relation variables created in the script are:
@@ -30,24 +30,6 @@ Each section assumes a fresh instance of the Date examples. The relation variabl
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−
5133### Types
5234
5335TutorialD is strongly-typed. The basic built-in types are:
@@ -215,7 +197,7 @@ TutorialD (master/main): :showexpr s{all but city}
215197└────────┴───────────┴───────────────┘
216198```
217199
218−Projection attributes can be derived from a relational expression using `all from`:
200+Projection attributes can also be derived from a relational expression using `all from`:
219201
220202```
221203TutorialD (master/main): :showexpr (s join sp){all from s}
@@ -231,42 +213,6 @@ TutorialD (master/main): :showexpr (s join sp){all from s}
231213
232214Above, we join `s` and `sp` but project the result back onto the attributes of `s`.
233215
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−
270216#### Restriction
271217
272218Restriction is applied using a "where" clause, much like in SQL.
docs/websocket_server.markdown+2−2
@@ -16,8 +16,8 @@ except that the websocket server is now listening for websocket connections on p
1616
1717## Client Connection
1818
19−A [simple JavaScript library](/src/bin/ProjectM36/Server/WebSocket/project-m36.js) to manage the WebSocket connection is available.
19+A [simple JavaScript library](/ProjectM36/Server/WebSocket/project-m36.js) to manage the WebSocket connection is available.
2020
2121## Sample Application
2222
23−The [WebSocket example application](/src/bin/ProjectM36/Server/WebSocket/websocket-client.html) can be used to learn TutorialD and for remote database access from the web browser.
23+The [WebSocket example application](/ProjectM36/Server/WebSocket/websocket-client.html) can be used to learn TutorialD and for remote database access from the web browser.
examples/DerivingCustomTupleable.hsdeleted−54
@@ -1,54 +0,0 @@
1−{-# LANGUAGE DeriveGeneric, DerivingVia, GeneralizedNewtypeDeriving, TypeOperators, DataKinds, OverloadedStrings #-}
2−
3−import ProjectM36.Tupleable.Deriving
4−import ProjectM36.Atomable (Atomable)
5−import Control.DeepSeq (NFData)
6−import Data.Text (Text)
7−import GHC.Generics (Generic)
8−import Codec.Winery
9−
10−newtype BlogId = BlogId { getBlogId :: Int }
11− deriving stock (Eq, Ord, Show, Generic)
12− deriving newtype (Num)
13− deriving Serialise via WineryRecord BlogId
14−
15−instance NFData BlogId
16−instance Atomable BlogId
17−
18−data Blog = Blog
19− { blogId :: BlogId
20− , blogTitle :: Text
21− , blogAuthorName :: Text
22− }
23− deriving stock (Show, Generic)
24− deriving (Tupleable)
25− via Codec (Field (DropPrefix "blog" >>> CamelCase)) Blog
26− deriving Serialise via WineryRecord Blog
27−
28−data Comment = Comment
29− { commentAuthorName :: Text
30− , commentComment :: Text
31− , commentFor :: BlogId
32− }
33− deriving stock (Show, Generic)
34− deriving (Tupleable)
35− via Codec (Field (DropPrefix "comment" >>> CamelCase)) Comment
36− deriving Serialise via WineryRecord Comment
37−
38−main :: IO ()
39−main = do
40− let exampleBlog = Blog
41− { blogId = 0
42− , blogTitle = "Cat Pics"
43− , blogAuthorName = "Alice"
44− }
45− exampleComment = Comment
46− { commentAuthorName = "Bob"
47− , commentComment = "great"
48− , commentFor = 0
49− }
50− print exampleBlog
51− print (toTuple exampleBlog)
52− putStrLn ""
53− print exampleComment
54− print (toTuple exampleComment)
examples/Plantfarm.hsdeleted−446
@@ -1,446 +0,0 @@
1−{-# LANGUAGE DeriveGeneric #-}
2−
3−{-# LANGUAGE OverloadedStrings #-}
4−
5−{-# LANGUAGE DeriveAnyClass #-}
6−
7−{-# LANGUAGE DerivingVia #-}
8−
9−
10−import Codec.Winery (Serialise, WineryVariant(WineryVariant))
11−import Control.DeepSeq (NFData)
12−import Data.Aeson (FromJSON, ToJSON(toEncoding, toJSON))
13−import Data.Data (Proxy(Proxy))
14−import Data.Either (lefts, rights)
15−import Data.Functor (($>))
16−import Data.Text as T (Text)
17−import qualified Data.Text.Lazy as TL (pack)
18−import GHC.Generics (Generic)
19−import qualified ProjectM36.Base as Base
20−import ProjectM36.Client
21− ( AtomExprBase(NakedAtomExpr)
22− , Atomable(toAddTypeExpr, toAtom)
23− , AttributeName
24− , Connection
25− , ConnectionInfo(InProcessConnectionInfo)
26− , DatabaseContextExpr
27− , DatabaseContextExprBase(Delete)
28− , PersistenceStrategy(NoPersistence)
29− , RelationalError
30− , RelationalExprBase(RelationVariable, Restrict)
31− , RestrictionPredicateExprBase(AttributeEqualityPredicate)
32− , SessionId
33− , close
34− , commit
35− , connectProjectM36
36− , createSessionAtHead
37− , databaseContextExprForUniqueKey
38− , defaultHeadName
39− , emptyNotificationCallback
40− , executeDatabaseContextExpr
41− , executeRelationalExpr
42− , withTransaction
43− )
44−import qualified ProjectM36.Relation as Relation
45−import ProjectM36.Tupleable
46− ( Tupleable(fromTuple)
47− , toDefineExpr
48− , toDeleteExpr
49− , toInsertExpr
50− , toUpdateExpr
51− )
52−import qualified System.Random as R
53−
54−
55−import Control.Monad.IO.Class (MonadIO(liftIO))
56−import qualified Web.Scotty as S
57−
58−-- | This is an example showcasing the updating of data
59−-- with the help of plants. \\
60−-- This is a very simple example and of course not how
61−-- plants grow in nature. \\
62−-- The main goal of this example is to showcase the updating
63−-- of data and the different options of persistence.
64−-- You can just pipe the output from curl into jq:
65−--
66−-- curl -X POST -H 'Accept: application/json' http://localhost:8001/plant/water/angu | jq -r '.stage'
67−
68−
69−data Stage = Seed | Sprout | Seedling | Adult | Dead
70− deriving (Show, Eq, Ord, Generic, NFData, Atomable)
71− deriving Serialise via WineryVariant Stage
72−
73−
74−instance ToJSON Stage where -- The where can be removed and the implementation commented out
75− -- if the ascii values are not wanted
76− toJSON s = toJSON $ show s <> "\nascii only provided for visualisation:\n" <> stagetoAscii s
77−
78− toEncoding s = toEncoding $ show s <> "\nascii only provided for visualisation:\n" <> stagetoAscii s
79−
80−instance FromJSON Stage
81−
82−instance S.Parsable Stage where
83− parseParam t
84− | t == "seed" || t == "Seed" = Right Seed
85− | t == "sprout" || t == "Sprout" = Right Sprout
86− | t == "seedling" || t == "Seedling" = Right Seedling
87− | t == "adult" || t == "Adult" = Right Adult
88− | t == "dead" || t == "Dead" = Right Dead
89− | otherwise = Left t
90−
91−
92−-- Just for ToJSON for ilustration of stage
93−type ASCIIStage = String
94−
95−seedStr :: ASCIIStage
96−seedStr = "<>\n\
97− \'''\n"
98−sproutStr :: ASCIIStage
99−sproutStr = " ..\n\
100− \<|>\n\
101− \''''\n"
102−seedlingStr :: ASCIIStage
103−seedlingStr = " `\\⁄o \n\
104− \ v|/\n\
105− \'´;'''\n"
106−adultStr :: ASCIIStage
107−adultStr = "*~(#)~\n\
108− \ \\,Y,e\n\
109− \ \\|/\n\
110− \''+'\\''\n"
111−deadStr :: ASCIIStage
112−deadStr = " ,__:<\n\
113− \'/'''''\n"
114−
115−-- Just used for ToJSON illustration of stages
116−stagetoAscii :: Stage -> ASCIIStage
117−stagetoAscii Seed = seedStr
118−stagetoAscii Sprout = sproutStr
119−stagetoAscii Seedling = seedlingStr
120−stagetoAscii Adult = adultStr
121−stagetoAscii Dead = deadStr
122−
123−-- used for update stage
124−next :: Stage -> Stage
125−next Seed = Sprout
126−next Sprout = Seedling
127−next Seedling = Adult
128−next s = s
129−
130−data Plant = Plant { name :: Text, species :: Text, stage :: Stage, waterings:: Integer } deriving (Show, Generic)
131−instance Tupleable Plant
132−instance ToJSON Plant
133−instance FromJSON Plant
134−
135−
136−main :: IO ()
137−main = do
138− putStrLn "Connecting to plant farm"
139− c <- dbConnection
140− _ <- createSchema c
141− putStrLn "Planting some plants"
142− _ <- insertSampleData c
143− let port = 8001
144− putStrLn $ "Started Plant farm at " <> show port
145− S.scotty port $ do
146−
147− -- retrieve a plant by name
148− S.get "/plant/:name" $ do
149− n <- S.param "name"
150− e <- liftIO $ getPlant c n
151− p <- handleWebError e
152− S.json p
153−
154−
155− -- save a plant providing it as json data
156− S.post "/plant" $ do
157− pl <- S.jsonData :: S.ActionM Plant
158− e <- liftIO $ savePlant c [pl]
159− p <- handleWebError e
160− S.json p
161−
162− -- updating a plant providing it as json data
163− S.put "/plant" $ do
164− pl <- S.jsonData :: S.ActionM Plant
165− e <- liftIO $ updatePlantFst c pl
166− p <- handleWebError e
167− S.json p
168−
169− -- watering the plant having the provided name.
170− -- This will water the plant and might let it progress to the next stage. It might also die.
171− S.post "/plant/water/:name" $ do
172− n <- S.param "name"
173− e <- liftIO $ waterPlant c n
174− p <- handleWebError e
175− S.json p
176−
177− -- retriving all the plants as json data
178− S.get "/plants" $ do
179− e <- liftIO $ getAllPlants c
180− ps <- handleWebErrors e
181− S.json ps
182−
183− -- saving many plants at the same time
184− S.post "/plants" $ do
185− pl <- S.jsonData :: S.ActionM [Plant]
186− e <- liftIO $ savePlant c pl
187− p <- handleWebError e
188− S.json p
189−
190− -- deleting all plants at a specific stage
191− S.delete "/plants?stage=:stage" $ do
192− s <- S.param "stage"
193− e <- liftIO $ deletePlantsByStage c s
194− p <- handleWebError e
195− S.json p
196−
197− -- deleting all plants at a specific stage
198− S.delete "/plants" $ do
199− s <- S.param "name"
200− e <- liftIO $ deletePlantByName c s
201− p <- handleWebError e
202− S.json p
203−
204− -- deleting all dead plants
205− S.delete "/plants/clear" $ do
206− e <- liftIO $ clearDeadPlants c
207− ps <- handleWebErrors e
208− S.json ps
209−
210−handleWebError :: Either Err b -> S.ActionM b
211−handleWebError (Left e) = S.raise (TL.pack $ "An error occurred:\n" <> show e)
212−handleWebError (Right v) = pure v
213−
214−handleWebErrors :: [Either Err b] -> S.ActionM [b]
215−handleWebErrors e = do
216− case lefts e of
217− [] -> pure (rights e)
218− l -> S.raise (TL.pack $ "Errors occurred:\n" <> concatMap ((<>"\n") . show) l)
219−
220−
221−-- | watering a plant and thereby possibly updating its stage
222−waterPlant :: DBConnection -> Text -> IO (Either Err Plant)
223−waterPlant db n = do
224− p <- getPlant db n
225− case p of
226− Left e -> pure $ Left e
227− Right v -> updateStage db $ v { waterings = waterings v + 1 }
228−
229−-- | used by 'waterPlant' updates the stage depending on random numbers
230−updateStage :: DBConnection -> Plant -> IO (Either Err Plant)
231−updateStage db p@(Plant _ _ Dead _ ) = do
232− tmp <- updatePlantFst db p
233− case tmp of
234− Left e -> pure $ Left e
235− Right _ -> pure $ Right p
236−updateStage db p = do
237− res <- calculateStage p
238− tmp <- updatePlantFst db res
239− case tmp of
240− Left e -> pure $ Left e
241− Right _ -> pure $ Right res
242− where calculateStage p' = do
243− r1 <- R.randomRIO (1, 10) :: IO Integer
244− let np = if r1 < waterings p' then p' { stage = next $ stage p', waterings = 0 } else p'
245− r2 <- R.randomRIO (1, 20)
246− pure $ if r2 < waterings np then np { stage = Dead, waterings = 0 } else np
247−
248−-- | deletes all plants with Stage = Dead
249−clearDeadPlants :: DBConnection -> IO [Either Err Plant]
250−clearDeadPlants db = do
251− _ <- deletePlantsByStage db Dead
252− getAllPlants db
253−
254−
255−-- ****************************
256−-- | *Database functions* :
257−-- ****************************
258−
259−
260−-- | Error type for passing. It is not very specific.
261−-- Just minimal and non optimal for this example.
262−data Err = NotSpecified | NotFound deriving (Show ,Generic)
263−
264−instance ToJSON Err
265−
266−-- | Just for convinience for passing around the SessionId
267−-- and the Connection
268−data DBConnection = DB SessionId Connection
269−
270−
271−-- | Getting plants by their name.\
272−-- Because plant has name as primary key \
273−-- we can assume will get at most one result. \
274−-- Alternatively we could return a list.
275−getPlant :: DBConnection -> Text -> IO (Either Err Plant)
276−getPlant db n = defaultHead (Left NotFound) <$> (
277− get db
278− ( Restrict -- Restrict can be thought of as similar to "WITH" in SQL
279− (AttributeEqualityPredicate "name" (NakedAtomExpr (toAtom n))) -- This is the Predicate we are "restricting" our RelationalExprBase with
280− (RelationVariable "plants" ())
281− )
282− :: IO [Either Err Plant] -- this is needed because our 'get' function is
283− )
284−
285−defaultHead :: a -> [a] -> a
286−defaultHead d [] = d
287−defaultHead _ (x:_) = x
288−
289−-- | Getting all the plants
290−getAllPlants :: DBConnection -> IO [Either Err Plant]
291−getAllPlants db = get db (RelationVariable "plants" ())
292−
293−-- | Getting all the plants that satisfy the restrictions
294−getAllPlantsWith :: DBConnection -> Base.RestrictionPredicateExpr -> IO [Either Err Plant]
295−getAllPlantsWith db ex = get db (Restrict ex (RelationVariable "plants" ()))
296−
297−
298−-- | Saving a plant
299−savePlant :: (Traversable t) => DBConnection -> t Plant -> IO (Either Err ())
300−savePlant db sps = insert db sps "plants"
301−
302−-- | An alternative to update alone because due to updates
303−-- not being cached yet \
304−-- they have to be calculated every update. \
305−-- This seems like an alternative until caching is implemented.
306−updatePlantFst :: DBConnection -> Plant -> IO (Either Err ())
307−updatePlantFst db pln = do
308− _ <- delete db pln ["name"] "plants"
309− savePlant db [pln]
310−
311−-- | Updating a plant. Due to the way project 36 works, \
312−-- updates have to be executed every time.\
313−-- This is slow but won't be an issue soon because they will
314−-- be cached.\
315−-- But because of this project 36 can provide O(1) commits.
316−updatePlant :: DBConnection -> Plant -> IO (Either Err ())
317−updatePlant db sps = update
318− db -- db connection
319− sps -- plant value
320− ["name"] -- the attributes to be updated by (in case of unique key)
321− "plants" -- the relation we want to update on
322−
323−
324−-- | deleting all plants that have given name.
325−deletePlantByName :: DBConnection -> Text -> IO (Either Err ())
326−deletePlantByName db s = executeWithTransaction db $ Right $ Delete "plants" $ AttributeEqualityPredicate "name" (NakedAtomExpr (toAtom s))
327−
328−-- | deleting all plants that have given stage.
329−deletePlantsByStage :: DBConnection -> Stage -> IO (Either Err ())
330−deletePlantsByStage db s = executeWithTransaction db $ Right $ Delete "plants" $ AttributeEqualityPredicate "stage" (NakedAtomExpr (toAtom s))
331−
332−
333−-- | Inserting the schema into the DB
334−createSchema :: DBConnection -> IO ()
335−createSchema (DB sessionId conn) = do
336− _ <- handleIOErrorsAndQuit $ mapM (executeDatabaseContextExpr sessionId conn) [
337− toAddTypeExpr (Proxy :: Proxy Stage) -- Adds the Type Stage as data to the DB
338− , toDefineExpr (Proxy :: Proxy Plant) "plants" -- Creates the plants relation
339− , databaseContextExprForUniqueKey "plants" ["name"] -- Makes name of the plants relation a uniqe Key,
340− -- Foreign Key restrictions are available too
341− ]
342− pure ()
343−
344−
345−-- | inserting some sample data
346−insertSampleData :: DBConnection -> IO (Either Err ())
347−insertSampleData (DB sid conn) = do
348− insert (DB sid conn) [
349− Plant "angu" "Caladenia angustata" Seed 0
350− , Plant "thely" "Thelymitra alcockiae" Seed 0
351− , Plant "monstera" "Araceae" Seed 0
352− ] "plants"
353−
354−dbConnection :: IO DBConnection
355−dbConnection = do
356− -- connect to the database
357− let connInfo = InProcessConnectionInfo NoPersistence emptyNotificationCallback []
358− -- The code below persists the data in a DB with the name "base". \\
359−-- let connInfo = InProcessConnectionInfo (CrashSafePersistence "base") emptyNotificationCallback [] \\
360− -- In addition minimal persistance is available. \\
361−-- let connInfo = InProcessConnectionInfo (MinimalPersistence "base") emptyNotificationCallback []
362− conn <- handleIOErrorAndQuit $ connectProjectM36 connInfo
363− --create a database session at the default branch of the database
364− sessionId <- handleIOErrorAndQuit $ createSessionAtHead conn defaultHeadName
365− pure (DB sessionId conn)
366−
367−
368−-- | A polymorphic function to insert data (a traversable of data) into the DB
369−insert :: (Tupleable a, Traversable t) => DBConnection -> t a -> Base.RelVarName -> IO (Either Err ())
370−insert db rlv rlvName = executeWithTransaction db $ toInsertExpr rlv rlvName
371−
372−-- | A polymorphic function to update data in the DB.
373−-- An update in one funtion would take:
374−--
375−-- - SessionId
376−-- - Connection
377−-- - Tuplable a -- the Tuplable you want to update
378−-- - [AttributeName] -- the Attributes of the Tuplable you want to update those are of StringType
379−-- - RelVarName -- the name of the relation
380−--
381−-- With that you can via 'toUpdateExpr' create a 'DatabaseContextExpr' to be executed. \\
382−-- For inserting its very similarly done with 'toInsertExpr'.
383−update :: (Tupleable a) => DBConnection -> a -> [AttributeName]-> Base.RelVarName -> IO (Either Err ())
384−update db rlv attr rlvName = executeWithTransaction db $ toUpdateExpr rlvName attr rlv
385−
386−-- | A polymorphic function to delete data in the DB
387−delete :: (Tupleable a) => DBConnection -> a -> [AttributeName]-> Base.RelVarName -> IO (Either Err ())
388−delete db rlv attr rlvName = executeWithTransaction db $ toDeleteExpr rlvName attr rlv
389−
390−-- | A convenience function to make executing DBContextExpr with commiting simpler. \\
391−-- In particular for expr that just insert, delete and update.
392−-- Therefor ultimately return Either _ ()
393−executeWithTransaction :: DBConnection -> Either RelationalError DatabaseContextExpr -> IO (Either Err ())
394−executeWithTransaction (DB sid conn) expr = do
395− iEx <- handleError expr
396− case iEx of
397− Left e -> pure $ Left e
398− Right v -> handleIOError $ withTransaction sid conn (executeDatabaseContextExpr sid conn v) (commit sid conn)
399−
400−-- | A polymorphic function to get data (a list of data and possibly errors) from the DB
401−get :: Tupleable b => DBConnection -> Base.RelationalExpr -> IO [Either Err b]
402−get (DB sessionId conn) q = do
403− eRel <- executeRelationalExpr sessionId conn q
404− e <- handleError eRel
405− case e of
406− Left err -> pure [Left err]
407− Right pRel -> do
408− ws <- Relation.toList pRel
409− mapM (handleError . fromTuple) ws
410−
411−-- | for closing the DB connection.
412−-- Not really needed when using in-memory DB
413−closeConn :: DBConnection -> IO ()
414−closeConn (DB _ conn) = close conn
415−
416−
417−-- | Error handling is heavily inspired by 'blog.hs' the blog example \\
418−-- by (agentm)[https://github.com/agentm] (https://github.com/agentm/project-m36, commit: f8432522adaafeae7c32bc2b8b6cb09c00396fc6). \\
419−-- As stated there, your application should have proper error handling.
420−handleIOErrorAndQuit :: Show e => IO (Either e a) -> IO a
421−handleIOErrorAndQuit m = do
422− v <- m
423− handleErrorAndQuit v
424−
425−handleError :: Show e => Either e a -> IO (Either Err a)
426−handleError eErr = case eErr of
427− Left err -> print err $> Left NotSpecified
428− Right v -> pure $ Right v
429−
430−handleIOError :: Show e => IO (Either e a) -> IO (Either Err a)
431−handleIOError m = do
432− v <- m
433− handleError v
434−
435−handleErrorAndQuit :: Show e => Either e a -> IO a
436−handleErrorAndQuit eErr = case eErr of
437− Left err -> print err >> error "Quit."
438− Right v -> pure v
439−
440−handleIOErrorsAndQuit :: Show e => IO [Either e a] -> IO [a]
441−handleIOErrorsAndQuit m = do
442− eErrs <- m
443− case lefts eErrs of
444− [] -> pure (rights eErrs)
445− err:_ -> handleErrorAndQuit (Left err)
446−
examples/SimpleClient.hs+1−1
@@ -6,7 +6,7 @@ import Data.Text.IO as TIO
66main :: IO ()
77main = do
88 -- 1. create a ConnectionInfo
9− let connInfo = RemoteConnectionInfo "mytestdb" "127.0.0.1" (show defaultServerPort) emptyNotificationCallback
9+ let connInfo = RemoteProcessConnectionInfo "mytestdb" (createNodeId "127.0.0.1" defaultServerPort) emptyNotificationCallback
1010 -- 2. conncted to the remote database
1111 eConn <- connectProjectM36 connInfo
1212 case eConn of
examples/blog.hs+4−5
@@ -1,5 +1,5 @@
11-- a simple example of a blog schema
2−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings, CPP, DerivingVia #-}
2+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings, CPP #-}
33
44import ProjectM36.Client
55import ProjectM36.Base
@@ -10,18 +10,18 @@ import ProjectM36.Tuple (atomForAttributeName)
1010
1111import Data.Either
1212import GHC.Generics
13+import Data.Binary
1314import qualified Data.Text as T
1415import qualified Data.Text.Lazy as TL
1516import Data.Time.Clock
1617import Data.Time.Calendar
1718import Control.DeepSeq
1819import Data.Proxy
19−#if __GLASGOW_HASKELL__ < 804
20+#if __GLASGOW_HASKELL__ <= 802
2021import Data.Monoid
2122#endif
2223import Data.List
2324import 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,8 +52,7 @@ 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, 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
55+ deriving (Atomable, Eq, Show, NFData, Binary, Generic) -- derive Atomable so that values of this type can be stored as a database value
5756
5857-- add some short-hand error handling- your application should have proper handling
5958handleIOError :: Show e => IO (Either e a) -> IO a
examples/hair.hs+6−9
@@ -1,17 +1,16 @@
1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings, DerivingVia #-}
1+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings #-}
22import ProjectM36.Client
33import ProjectM36.Relation.Show.Term
44import GHC.Generics
55import Data.Text
6+import Data.Binary
67import Control.DeepSeq
78import qualified Data.Map as M
89import qualified Data.Text.IO as TIO
910import Data.Proxy
10−import Codec.Winery
1111
1212data Hair = Bald | Brown | Blond | OtherColor Text
13− deriving (Generic, Show, Eq, NFData, Atomable)
14− deriving Serialise via WineryVariant Hair
13+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)
1514
1615main :: IO ()
1716main = do
@@ -32,13 +31,11 @@ main = do
3231
3332 --create a relation with the new Hair AtomType
3433 let blond = NakedAtomExpr (toAtom Blond)
35− eCheck $ executeDatabaseContextExpr sessionId conn
36− (Assign "people"
37− (MakeRelationFromExprs Nothing $ TupleExprs () [
38− TupleExpr (M.fromList [("hair", blond), ("name", NakedAtomExpr (TextAtom "Colin"))])]))
34+ eCheck $ executeDatabaseContextExpr sessionId conn (Assign "people" (MakeRelationFromExprs Nothing [
35+ TupleExpr (M.fromList [("hair", blond), ("name", NakedAtomExpr (TextAtom "Colin"))])]))
3936
4037 let restrictionPredicate = AttributeEqualityPredicate "hair" blond
4138 peopleRel <- eCheck $ executeRelationalExpr sessionId conn (Restrict restrictionPredicate (RelationVariable "people" ()))
4239
4340 TIO.putStrLn (showRelation peopleRel)
44−
41+
examples/out_of_the_tarpit.hs+7−11
@@ -1,5 +1,5 @@
11-- the Out-of-the-Tarpit example in Haskell and Project:M36
2−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings, DerivingVia #-}
2+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings #-}
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
1011import Control.DeepSeq
1112import qualified Data.Text as T
1213import Data.Time.Calendar
1314import Data.Proxy
14−import Codec.Winery
1515
1616--create various database value (atom) types
1717type Price = Double
@@ -21,20 +21,16 @@ type Name = T.Text
2121type Address = T.Text
2222
2323data RoomType = Kitchen | Bathroom | LivingRoom
24− deriving (Generic, Atomable, Eq, Show, NFData)
25− deriving Serialise via WineryVariant RoomType
24+ deriving (Generic, Atomable, Eq, Show, Binary, NFData)
2625
2726data PriceBand = Low | Medium | High | Premium
28− deriving (Generic, Atomable, Eq, Show, NFData)
29− deriving Serialise via WineryVariant PriceBand
27+ deriving (Generic, Atomable, Eq, Show, Binary, NFData)
3028
3129data AreaCode = City | Suburban | Rural
32− deriving (Generic, Atomable, Eq, Show, NFData)
33− deriving Serialise via WineryVariant AreaCode
30+ deriving (Generic, Atomable, Eq, Show, Binary, NFData)
3431
3532data SpeedBand = VeryFastBand | FastBand | MediumBand | SlowBand
36− deriving (Generic, Atomable, Eq, Show, NFData)
37− deriving Serialise via WineryVariant SpeedBand
33+ deriving (Generic, Atomable, Eq, Show, Binary, NFData)
3834
3935main :: IO ()
4036main = do
@@ -261,4 +257,4 @@ handleIOErrors m = do
261257 [] -> pure (rights eErrs)
262258 errs -> handleError (Left (someErrors errs))
263259
264−
260+
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 Integer --dollars
6+data Price = Price Double
77data RoomType = Kitchen | Bathroom | LivingRoom
8−data PriceBand = Low | Med | High | Premium
8+data PriceBand = Low | Medium | 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(@price,Price 2000)) minus ((property join decision){address,agent,dateRegistered,photo,price})) group ({} as x) : {z:=gt(count(@x),50)}) {z}){} equals false
60+constraint noMoreThan50PremiumProperties ((((property where ^gt(offerPrice,2000.0)) minus ((property join decision){address,agent,dateRegistered,photo,price})) group ({} as x) : {z:=gt(count(@x),50)}) {z}){} equals false
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 cjdate"
41+ ":importexample date"
4242 ]
4343 },
4444 {
nix/sources.jsondeleted−50
@@ -1,50 +0,0 @@
1−{
2− "curryer": {
3− "branch": "master",
4− "description": "Fast Haskell RPC",
5− "homepage": null,
6− "owner": "agentm",
7− "repo": "curryer",
8− "rev": "74ecaac619ad1165a4517d5c0f4e530493bda130",
9− "sha256": "1izdvzj00k0y76ixm7dfgvq2fzphb8h4nzqgwkl3p0bg0806rsn1",
10− "type": "tarball",
11− "url": "https://github.com/agentm/curryer/archive/74ecaac619ad1165a4517d5c0f4e530493bda130.tar.gz",
12− "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
13− },
14− "niv": {
15− "branch": "master",
16− "description": "Easy dependency management for Nix projects",
17− "homepage": "https://github.com/nmattia/niv",
18− "owner": "nmattia",
19− "repo": "niv",
20− "rev": "1819632b5823e0527da28ad82fecd6be5136c1e9",
21− "sha256": "08jz17756qchq0zrqmapcm33nr4ms9f630mycc06i6zkfwl5yh5i",
22− "type": "tarball",
23− "url": "https://github.com/nmattia/niv/archive/1819632b5823e0527da28ad82fecd6be5136c1e9.tar.gz",
24− "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
25− },
26− "nixpkgs": {
27− "branch": "master",
28− "description": "Nix Packages collection",
29− "homepage": "",
30− "owner": "NixOS",
31− "repo": "nixpkgs",
32− "rev": "429c23aad0fce9ef38b0e60d55d7459c19d53ddc",
33− "sha256": "1nj8sh1fnxp07jdlvjkijwfd1pnsi2zj0ivy7a0dhx02g63byhg3",
34− "type": "tarball",
35− "url": "https://github.com/NixOS/nixpkgs/archive/429c23aad0fce9ef38b0e60d55d7459c19d53ddc.tar.gz",
36− "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
37− },
38− "streamly": {
39− "branch": "ac3af8749194f1788704dda8667d0b3807075cc2",
40− "description": "Beautiful Streaming, Concurrent and Reactive Composition (Haskell)",
41− "homepage": "https://hackage.haskell.org/package/streamly",
42− "owner": "composewell",
43− "repo": "streamly",
44− "rev": "ac3af8749194f1788704dda8667d0b3807075cc2",
45− "sha256": "04d8fk654vawdfs0dfidmq2awwgwi8x44iv8r7vqz70zkcsd5fij",
46− "type": "tarball",
47− "url": "https://github.com/composewell/streamly/archive/ac3af8749194f1788704dda8667d0b3807075cc2.tar.gz",
48− "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
49− }
50−}
nix/sources.nixdeleted−171
@@ -1,171 +0,0 @@
1−# This file has been generated by Niv.
2−
3−let
4−
5− #
6− # The fetchers. fetch_<type> fetches specs of type <type>.
7− #
8−
9− fetch_file = pkgs: name: spec:
10− let
11− name' = sanitizeName name + "-src";
12− in
13− if spec.builtin or true then
14− builtins_fetchurl { inherit (spec) url sha256; name = name'; }
15− else
16− pkgs.fetchurl { inherit (spec) url sha256; name = name'; };
17−
18− fetch_tarball = pkgs: name: spec:
19− let
20− name' = sanitizeName name + "-src";
21− in
22− if spec.builtin or true then
23− builtins_fetchTarball { name = name'; inherit (spec) url sha256; }
24− else
25− pkgs.fetchzip { name = name'; inherit (spec) url sha256; };
26−
27− fetch_git = name: spec:
28− let
29− ref =
30− if spec ? ref then spec.ref else
31− if spec ? branch then "refs/heads/${spec.branch}" else
32− if spec ? tag then "refs/tags/${spec.tag}" else
33− abort "In git source '${name}': Please specify `ref`, `tag` or `branch`!";
34− in
35− builtins.fetchGit { url = spec.repo; inherit (spec) rev; inherit ref; };
36−
37− fetch_local = spec: spec.path;
38−
39− fetch_builtin-tarball = name: throw
40− ''[${name}] The niv type "builtin-tarball" is deprecated. You should instead use `builtin = true`.
41− $ niv modify ${name} -a type=tarball -a builtin=true'';
42−
43− fetch_builtin-url = name: throw
44− ''[${name}] The niv type "builtin-url" will soon be deprecated. You should instead use `builtin = true`.
45− $ niv modify ${name} -a type=file -a builtin=true'';
46−
47− #
48− # Various helpers
49− #
50−
51− # https://github.com/NixOS/nixpkgs/pull/83241/files#diff-c6f540a4f3bfa4b0e8b6bafd4cd54e8bR695
52− sanitizeName = name:
53− (
54− concatMapStrings (s: if builtins.isList s then "-" else s)
55− (
56− builtins.split "[^[:alnum:]+._?=-]+"
57− ((x: builtins.elemAt (builtins.match "\\.*(.*)" x) 0) name)
58− )
59− );
60−
61− # The set of packages used when specs are fetched using non-builtins.
62− mkPkgs = sources: system:
63− let
64− sourcesNixpkgs =
65− import (builtins_fetchTarball { inherit (sources.nixpkgs) url sha256; }) { inherit system; };
66− hasNixpkgsPath = builtins.any (x: x.prefix == "nixpkgs") builtins.nixPath;
67− hasThisAsNixpkgsPath = <nixpkgs> == ./.;
68− in
69− if builtins.hasAttr "nixpkgs" sources
70− then sourcesNixpkgs
71− else if hasNixpkgsPath && ! hasThisAsNixpkgsPath then
72− import <nixpkgs> {}
73− else
74− abort
75− ''
76− Please specify either <nixpkgs> (through -I or NIX_PATH=nixpkgs=...) or
77− add a package called "nixpkgs" to your sources.json.
78− '';
79−
80− # The actual fetching function.
81− fetch = pkgs: name: spec:
82−
83− if ! builtins.hasAttr "type" spec then
84− abort "ERROR: niv spec ${name} does not have a 'type' attribute"
85− else if spec.type == "file" then fetch_file pkgs name spec
86− else if spec.type == "tarball" then fetch_tarball pkgs name spec
87− else if spec.type == "git" then fetch_git name spec
88− else if spec.type == "local" then fetch_local spec
89− else if spec.type == "builtin-tarball" then fetch_builtin-tarball name
90− else if spec.type == "builtin-url" then fetch_builtin-url name
91− else
92− abort "ERROR: niv spec ${name} has unknown type ${builtins.toJSON spec.type}";
93−
94− # If the environment variable NIV_OVERRIDE_${name} is set, then use
95− # the path directly as opposed to the fetched source.
96− replace = name: drv:
97− let
98− saneName = stringAsChars (c: if isNull (builtins.match "[a-zA-Z0-9]" c) then "_" else c) name;
99− ersatz = builtins.getEnv "NIV_OVERRIDE_${saneName}";
100− in
101− if ersatz == "" then drv else ersatz;
102−
103− # Ports of functions for older nix versions
104−
105− # a Nix version of mapAttrs if the built-in doesn't exist
106− mapAttrs = builtins.mapAttrs or (
107− f: set: with builtins;
108− listToAttrs (map (attr: { name = attr; value = f attr set.${attr}; }) (attrNames set))
109− );
110−
111− # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/lists.nix#L295
112− range = first: last: if first > last then [] else builtins.genList (n: first + n) (last - first + 1);
113−
114− # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L257
115− stringToCharacters = s: map (p: builtins.substring p 1 s) (range 0 (builtins.stringLength s - 1));
116−
117− # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L269
118− stringAsChars = f: s: concatStrings (map f (stringToCharacters s));
119− concatMapStrings = f: list: concatStrings (map f list);
120− concatStrings = builtins.concatStringsSep "";
121−
122− # https://github.com/NixOS/nixpkgs/blob/8a9f58a375c401b96da862d969f66429def1d118/lib/attrsets.nix#L331
123− optionalAttrs = cond: as: if cond then as else {};
124−
125− # fetchTarball version that is compatible between all the versions of Nix
126− builtins_fetchTarball = { url, name ? null, sha256 }@attrs:
127− let
128− inherit (builtins) lessThan nixVersion fetchTarball;
129− in
130− if lessThan nixVersion "1.12" then
131− fetchTarball ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))
132− else
133− fetchTarball attrs;
134−
135− # fetchurl version that is compatible between all the versions of Nix
136− builtins_fetchurl = { url, name ? null, sha256 }@attrs:
137− let
138− inherit (builtins) lessThan nixVersion fetchurl;
139− in
140− if lessThan nixVersion "1.12" then
141− fetchurl ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))
142− else
143− fetchurl attrs;
144−
145− # Create the final "sources" from the config
146− mkSources = config:
147− mapAttrs (
148− name: spec:
149− if builtins.hasAttr "outPath" spec
150− then abort
151− "The values in sources.json should not have an 'outPath' attribute"
152− else
153− spec // { outPath = replace name (fetch config.pkgs name spec); }
154− ) config.sources;
155−
156− # The "config" used by the fetchers
157− mkConfig =
158− { sourcesFile ? if builtins.pathExists ./sources.json then ./sources.json else null
159− , sources ? if isNull sourcesFile then {} else builtins.fromJSON (builtins.readFile sourcesFile)
160− , system ? builtins.currentSystem
161− , pkgs ? mkPkgs sources system
162− }: rec {
163− # The sources, i.e. the attribute set of spec name to spec
164− inherit sources;
165−
166− # The "pkgs" (evaluated nixpkgs) to use for e.g. non-builtin fetchers
167− inherit pkgs;
168− };
169−
170−in
171−mkSources (mkConfig {}) // { __functor = _: settings: mkSources (mkConfig settings); }
project-m36.cabal+160−168
@@ -1,8 +1,6 @@
1−Cabal-Version: 2.2
21Name: project-m36
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
2+Version: 0.6
3+License: PublicDomain
64Build-Type: Simple
75Homepage: https://github.com/agentm/project-m36
86Bug-Reports: https://github.com/agentm/project-m36/issues
@@ -10,6 +8,7 @@ Author: AgentM
108Stability: experimental
119Category: Relational Algebra
1210Maintainer: agentm@themactionfaction.com
11+Cabal-Version: >= 1.10
1312Synopsis: Relational Algebra Engine
1413Description: A relational algebra engine which can be used to persist and query Haskell data types.
1514Extra-Source-Files: Changelog.markdown README.markdown
@@ -29,21 +28,8 @@ Flag stack
2928 Manual: True
3029 Default: False
3130
32−Flag haskell-scripting
33− Description: enables Haskell scripting which links against GHC as a library
34− Manual: True
35− Default: True
36−
3731Library
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
39− if flag(haskell-scripting)
40− Build-Depends: ghc >= 8.2 && < 8.11
41− CPP-Options: -DPM36_HASKELL_SCRIPTING
42− if impl(ghc>= 8) && flag(haskell-scripting)
43− build-depends:
44− ghc-boot, ghci
45− if impl(ghc>= 8.6)
46− Build-Depends: deferred-folds
32+ Build-Depends: base>=4.8 && < 4.12, ghc >= 7.8 && < 8.5, ghc-paths, mtl, containers, unordered-containers, hashable, haskeline, directory, MonadRandom, random-shuffle, uuid >= 1.3.12, cassava >= 0.4.5.1 && < 0.6, text, bytestring, deepseq, deepseq-generics, vector, parallel, monad-parallel, exceptions, transformers, gnuplot, binary, filepath, zlib, directory, vector-binary-instances, temporary, stm, time, hashable-time, old-locale, rset, attoparsec, either, base64-bytestring, data-interval, extended-reals, network-transport, aeson >= 1.1, path-pieces, conduit, resourcet, http-api-data, semigroups, QuickCheck, quickcheck-instances, distributed-process-client-server >= 0.2.3, distributed-process >= 0.7.4, distributed-process-extras >= 0.3.2, distributed-process-async >= 0.2.4.1, network-transport-tcp >= 0.6.0, network-transport, list-t, stm-containers >= 0.2.15, foldl, optparse-applicative, Glob, cryptohash-sha256
4733 Exposed-Modules: ProjectM36.Error,
4834 ProjectM36.Transaction,
4935 ProjectM36.TransactionGraph,
@@ -52,8 +38,6 @@ Library
5238 ProjectM36.TransactionGraph.Merge,
5339 ProjectM36.TransGraphRelationalExpression,
5440 ProjectM36.Base,
55− ProjectM36.Serialise.Base,
56− ProjectM36.Serialise.Error,
5741 ProjectM36.DataFrame,
5842 ProjectM36.Attribute,
5943 ProjectM36.AttributeNames,
@@ -63,7 +47,6 @@ Library
6347 ProjectM36.AtomFunction,
6448 ProjectM36.AtomFunctionError,
6549 ProjectM36.ScriptSession,
66− ProjectM36.Shortcuts,
6750 ProjectM36.DatabaseContextFunction,
6851 ProjectM36.DatabaseContextFunctionError,
6952 ProjectM36.DatabaseContextFunctionUtils,
@@ -83,7 +66,6 @@ Library
8366 ProjectM36.Relation.Parse.CSV,
8467 ProjectM36.IsomorphicSchema,
8568 ProjectM36.InclusionDependency,
86− ProjectM36.MerkleHash,
8769 ProjectM36.Client,
8870 ProjectM36.Client.Simple,
8971 ProjectM36.Persist,
@@ -93,7 +75,6 @@ Library
9375 ProjectM36.AtomFunctions.Primitive,
9476 ProjectM36.Atomable,
9577 ProjectM36.Tupleable,
96− ProjectM36.Tupleable.Deriving,
9778 ProjectM36.DataConstructorDef,
9879 ProjectM36.DataTypes.Basic,
9980 ProjectM36.DataTypes.Sorting,
@@ -114,10 +95,6 @@ Library
11495 ProjectM36.Server.EntryPoints,
11596 ProjectM36.Server.ParseArgs,
11697 ProjectM36.Server.RemoteCallTypes,
117− ProjectM36.Serialise.AtomFunctionError,
118− ProjectM36.Serialise.DataFrame,
119− ProjectM36.Serialise.DatabaseContextFunctionError,
120− ProjectM36.Serialise.IsomorphicSchema,
12198 ProjectM36.Session,
12299 ProjectM36.Sessions,
123100 ProjectM36.Transaction.Persist,
@@ -136,20 +113,22 @@ Library
136113 Other-Modules: ProjectM36.Win32Handle
137114 else
138115 --219- too many exported symbols under Windows and GHC 8.4
139− GHC-Options: -rdynamic -fexternal-interpreter
116+ GHC-Options: -rdynamic
140117 C-sources: cbits/DirectoryFsync.c, cbits/darwin_statfs.c
141118 Build-Depends: unix
142− CC-Options: -fPIC
119+ CC-Options: -fPIC
143120 Hs-Source-Dirs: ./src/lib
144121 Default-Language: Haskell2010
145122 Default-Extensions: OverloadedStrings, CPP
146− if !flag(stack)
123+ if impl(ghc>= 8)
124+ build-depends:
125+ ghc-boot, ghci
126+ if !flag(stack)
147127 Build-Depends: deferred-folds
148128
149129Executable tutd
150− if flag(haskell-scripting)
151− Build-Depends: ghc >= 8.2 && < 8.11
152130 Build-Depends: base >=4.8 && <5.0,
131+ ghc >= 7.8 && < 8.5,
153132 ghc-paths,
154133 project-m36,
155134 containers,
@@ -163,11 +142,13 @@ Executable tutd
163142 MonadRandom, MonadRandom,
164143 vector,
165144 text,
145+ vector-binary-instances,
166146 time,
167147 hashable-time,
168148 bytestring,
169149 stm,
170150 deepseq,
151+ binary,
171152 data-interval,
172153 parallel,
173154 cassava,
@@ -175,23 +156,14 @@ Executable tutd
175156 directory,
176157 filepath,
177158 temporary,
178− megaparsec >= 5.2.0 && < 10,
159+ megaparsec >= 5.2.0 && < 7,
179160 haskeline,
180161 random, MonadRandom,
181162 base64-bytestring,
182163 optparse-applicative,
183164 attoparsec,
184165 stm-containers >= 1.0.0,
185− list-t,
186− parser-combinators,
187− curryer-rpc,
188− prettyprinter,
189− cryptohash-sha256,
190− --due to decode signature change
191− base16-bytestring >= 1.0.0.0,
192− http-conduit,
193− modern-uri,
194− http-types
166+ list-t
195167 Other-Modules: TutorialD.Interpreter,
196168 TutorialD.Interpreter.Base,
197169 TutorialD.Interpreter.DatabaseContextExpr,
@@ -210,7 +182,6 @@ Executable tutd
210182 TutorialD.Interpreter.SchemaOperator,
211183 TutorialD.Interpreter.TransGraphRelationalOperator,
212184 TutorialD.Interpreter.SchemaOperator
213− TutorialD.Printer
214185 main-is: TutorialD/tutd.hs
215186 CC-Options: -fPIC
216187 GHC-Options: -Wall -threaded
@@ -219,12 +190,12 @@ Executable tutd
219190 Default-Extensions: OverloadedStrings
220191
221192Executable project-m36-server
222− if flag(haskell-scripting)
223− Build-Depends: ghc >= 8.2 && < 8.11
224193 Build-Depends: base,
194+ ghc >= 7.8 && < 8.5,
225195 ghc-paths,
226− transformers,
227196 project-m36,
197+ binary,
198+ transformers,
228199 temporary,
229200 data-interval,
230201 deepseq,
@@ -237,6 +208,7 @@ Executable project-m36-server
237208 optparse-applicative,
238209 hashable-time,
239210 time,
211+ vector-binary-instances,
240212 text,
241213 deepseq-generics,
242214 mtl,
@@ -249,32 +221,11 @@ Executable project-m36-server
249221 list-t,
250222 base64-bytestring
251223 Main-Is: ./src/bin/ProjectM36/Server/project-m36-server.hs
252− GHC-Options: -Wall -threaded -rtsopts
253− if flag(profiler)
254− GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
255− Default-Language: Haskell2010
256− Default-Extensions: OverloadedStrings
257−
258−Executable bigrel
259− Default-Language: Haskell2010
260− Default-Extensions: OverloadedStrings
261− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups, parser-combinators
262− Other-Modules: TutorialD.Interpreter.Base,
263− TutorialD.Interpreter.DatabaseContextExpr,
264− TutorialD.Interpreter.RelationalExpr,
265− TutorialD.Interpreter.Types
266− main-is: benchmark/bigrel.hs
267− GHC-Options: -Wall -threaded -rtsopts
268− HS-Source-Dirs: ./src/bin
224+ GHC-Options: -Wall -threaded -rtsopts
269225 if flag(profiler)
270226 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
271−
272−Common commontest
273227 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
275228 Default-Extensions: OverloadedStrings
276− GHC-Options: -Wall -threaded
277− Hs-Source-Dirs: test, src/bin
278229
279230Benchmark basic-benchmark
280231 Default-Language: Haskell2010
@@ -287,202 +238,240 @@ Benchmark basic-benchmark
287238 if flag(profiler)
288239 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
289240
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−
302241Test-Suite test-tutoriald
303− import: commontest
242+ Default-Language: Haskell2010
243+ Default-Extensions: OverloadedStrings
304244 type: exitcode-stdio-1.0
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
245+ main-is: test/TutorialD/Interpreter.hs
246+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, list-t, project-m36, random, MonadRandom, semigroups
247+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator
248+ GHC-Options: -Wall -threaded
249+ Hs-Source-Dirs: ./src/bin, ., test
308250
309251Test-Suite test-tutoriald-atomfunctionscript
310− import: commontest
252+ Default-Language: Haskell2010
253+ Default-Extensions: OverloadedStrings
311254 type: exitcode-stdio-1.0
312− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer
313− main-is: TutorialD/Interpreter/AtomFunctionScript.hs
255+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator
256+ main-is: test/TutorialD/Interpreter/AtomFunctionScript.hs
257+ Build-Depends: base, HUnit, project-m36, uuid, containers, megaparsec, text, vector, directory, bytestring, mtl, haskeline, random, MonadRandom, semigroups, time
258+ GHC-Options: -Wall -threaded
259+ Hs-Source-Dirs: ./src/bin, ./test, .
314260
315261Test-Suite test-tutoriald-databasecontextfunctionscript
316− import: commontest
262+ Default-Language: Haskell2010
263+ Default-Extensions: OverloadedStrings
317264 type: exitcode-stdio-1.0
318− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer
319− main-is: TutorialD/Interpreter/DatabaseContextFunctionScript.hs
265+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator
266+ main-is: test/TutorialD/Interpreter/DatabaseContextFunctionScript.hs
267+ Build-Depends: base, HUnit, project-m36, uuid, containers, megaparsec, text, vector, directory, bytestring, mtl, haskeline, random, MonadRandom, semigroups, time
268+ GHC-Options: -Wall -threaded
269+ Hs-Source-Dirs: ./src/bin, ./test, .
320270
321271Test-Suite test-relation
322− import: commontest
272+ Default-Language: Haskell2010
273+ Default-Extensions: OverloadedStrings
323274 type: exitcode-stdio-1.0
324− main-is: Relation/Basic.hs
275+ main-is: test/Relation/Basic.hs
276+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, transformers
277+ GHC-Options: -Wall -threaded
325278
326279Test-Suite test-static-optimizer
327− import: commontest
280+ Default-Language: Haskell2010
281+ Default-Extensions: OverloadedStrings
328282 type: exitcode-stdio-1.0
329− main-is: Relation/StaticOptimizer.hs
283+ main-is: test/Relation/StaticOptimizer.hs
284+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, transformers
285+ GHC-Options: -Wall -threaded
330286
331287Test-Suite test-transactiongraph-persist
332− import: commontest
288+ Default-Language: Haskell2010
289+ Default-Extensions: OverloadedStrings
333290 type: exitcode-stdio-1.0
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
291+ main-is: test/TransactionGraph/Persist.hs
292+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, random, MonadRandom, semigroups
293+ Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples
294+ Hs-Source-Dirs: ., ./src/bin
295+ GHC-Options: -Wall -threaded
336296
337297Test-Suite test-relation-import-csv
338− import: commontest
298+ Default-Language: Haskell2010
299+ Default-Extensions: OverloadedStrings
339300 type: exitcode-stdio-1.0
340− main-is: Relation/Import/CSV.hs
301+ main-is: test/Relation/Import/CSV.hs
302+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36
303+ GHC-Options: -Wall -threaded
341304
342305Test-Suite test-tutoriald-import-tutoriald
343− import: commontest
306+ Default-Language: Haskell2010
307+ Default-Extensions: OverloadedStrings
344308 type: exitcode-stdio-1.0
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
309+ main-is: test/TutorialD/Interpreter/Import/TutorialD.hs
310+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, random, MonadRandom, semigroups
311+ Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples
312+ GHC-Options: -Wall -threaded
313+ Hs-Source-Dirs: ., ./src/bin
347314
348315Test-Suite test-relation-export-csv
349− import: commontest
316+ Default-Language: Haskell2010
317+ Default-Extensions: OverloadedStrings
350318 type: exitcode-stdio-1.0
351− main-is: Relation/Export/CSV.hs
319+ main-is: test/Relation/Export/CSV.hs
320+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36
321+ GHC-Options: -Wall -threaded
352322
353323Test-Suite test-transactiongraph-merge
354− import: commontest
355− type: exitcode-stdio-1.0
356− main-is: TransactionGraph/Merge.hs
357−
358−
359−Test-Suite test-prettyprinter
360− import: commontest
324+ Default-Language: Haskell2010
325+ Default-Extensions: OverloadedStrings
361326 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
327+ main-is: test/TransactionGraph/Merge.hs
328+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, template-haskell, transformers, aeson, conduit, either, path-pieces, http-api-data, stm-containers, list-t, project-m36
329+ GHC-Options: -Wall -threaded
364330
365331benchmark bench
366− import: commontest
332+ Default-Language: Haskell2010
333+ Default-Extensions: OverloadedStrings
367334 type: exitcode-stdio-1.0
368335 main-is: benchmark/Relation.hs
336+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, criterion, stm-containers, project-m36
337+ GHC-Options: -Wall -rtsopts -threaded
338+ Hs-Source-Dirs: ./src/bin
369339
370340Test-Suite test-server
371− import: commontest
341+ Default-Language: Haskell2010
342+ Default-Extensions: OverloadedStrings
372343 type: exitcode-stdio-1.0
373− main-is: Server/Main.hs
374−
344+ main-is: test/Server/Main.hs
345+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, project-m36, network-transport, semigroups
346+ HS-Source-Dirs: ., ./src/bin
347+ GHC-Options: -Wall -threaded
375348
376349Executable Example-SimpleClient
377350 Default-Language: Haskell2010
378351 Default-Extensions: OverloadedStrings
379− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, ghc, ghc-paths, project-m36, random, MonadRandom
352+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, ghc, ghc-paths, project-m36, random, MonadRandom
380353 Main-Is: examples/SimpleClient.hs
381354 GHC-Options: -Wall -threaded
382355
383356Executable Example-OutOfTheTarpit
384357 Default-Language: Haskell2010
385358 Default-Extensions: OverloadedStrings
386− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery
359+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36
387360 Main-Is: examples/out_of_the_tarpit.hs
388361 GHC-Options: -Wall -threaded
389362
390363Executable Example-Blog
391364 Default-Language: Haskell2010
392365 Default-Extensions: OverloadedStrings
393− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, scotty, blaze-html, http-types, winery
366+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, scotty, blaze-html, http-types
394367 Main-Is: examples/blog.hs
395368 GHC-Options: -Wall -threaded
396369
370+
397371Executable Example-Hair
398372 Default-Language: Haskell2010
399373 Default-Extensions: OverloadedStrings
400− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery
374+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36
401375 Main-Is: examples/hair.hs
402376 GHC-Options: -Wall -threaded
403377
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−
411378Executable Example-CustomTupleable
412379 Default-Language: Haskell2010
413380 Default-Extensions: OverloadedStrings
414− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery
381+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36
415382 Main-Is: examples/CustomTupleable.hs
416383 GHC-Options: -Wall -threaded
417384
418−Executable Example-DerivingCustomTupleable
419− if impl(ghc>=8.6)
420− Buildable: True
421− else
422− Buildable: False
423− Default-Language: Haskell2010
424− Build-Depends: base, text, deepseq, project-m36, winery
425− Main-Is: examples/DerivingCustomTupleable.hs
426− GHC-Options: -Wall -threaded
427−
428385Test-Suite test-scripts
429− import: commontest
386+ Default-Language: Haskell2010
387+ Default-Extensions: OverloadedStrings
430388 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
389+ main-is: test/scripts.hs
390+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, project-m36, random, MonadRandom, semigroups
391+ Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.Import.BasicExamples
392+ GHC-Options: -Wall -threaded
393+ Hs-Source-Dirs: ., ./src/bin
433394
434395Executable project-m36-websocket-server
435396 Default-Language: Haskell2010
436− Build-Depends: base, aeson, path-pieces, either, conduit, http-api-data, template-haskell, websockets, aeson, optparse-applicative, project-m36, containers, bytestring, text, vector, uuid, megaparsec, haskeline, mtl, directory, base64-bytestring, random, MonadRandom, time, semigroups, attoparsec, parser-combinators, prettyprinter, network, modern-uri, http-conduit, base16-bytestring, http-types, cryptohash-sha256, wai, wai-websockets, warp, warp-tls
397+ Build-Depends: base, aeson, path-pieces, either, conduit, http-api-data, template-haskell, websockets, aeson, optparse-applicative, project-m36, containers, bytestring, text, vector, uuid, megaparsec, haskeline, mtl, directory, base64-bytestring, random, MonadRandom, time, network-transport-tcp, semigroups, attoparsec
437398 Main-Is: ProjectM36/Server/WebSocket/websocket-server.hs
438− Other-Modules: ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer
399+ Other-Modules: ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator
439400 GHC-Options: -Wall -threaded
440401 Hs-Source-Dirs: ./src/bin
441402 Default-Extensions: OverloadedStrings
442403
443404Test-Suite test-websocket-server
444− import: commontest
405+ Default-Language: Haskell2010
445406 type: exitcode-stdio-1.0
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
407+ main-is: test/Server/WebSocket.hs
408+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, network-transport-tcp, semigroups
409+ Other-Modules: TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.TransactionGraphOperator, ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator
410+ Default-Extensions: OverloadedStrings
411+ GHC-Options: -Wall -threaded
412+ Hs-Source-Dirs: ./src/bin, .
448413
449414Test-Suite test-isomorphic-schemas
450− import: commontest
415+ Default-Language: Haskell2010
451416 type: exitcode-stdio-1.0
452− main-is: IsomorphicSchema.hs
417+ main-is: test/IsomorphicSchema.hs
418+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36
419+ Default-Extensions: OverloadedStrings
420+ GHC-Options: -Wall -threaded
421+ Hs-Source-Dirs: ./src/bin, .
453422
454423Test-Suite test-atomable
455− import: commontest
424+ Default-Language: Haskell2010
456425 type: exitcode-stdio-1.0
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
426+ main-is: test/Relation/Atomable.hs
427+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups
428+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types
429+ Default-Extensions: OverloadedStrings
430+ GHC-Options: -Wall -threaded
431+ Hs-Source-Dirs: ./src/bin, ., test/
459432
460433Test-Suite test-multiprocess-access
461− import: commontest
434+ Default-Language: Haskell2010
462435 type: exitcode-stdio-1.0
463− main-is: MultiProcessDatabaseAccess.hs
436+ main-is: test/MultiProcessDatabaseAccess.hs
437+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom
438+ Default-Extensions: OverloadedStrings
439+ GHC-Options: -Wall -threaded
440+ Hs-Source-Dirs: ./src/bin, ., test/
464441
465442Test-Suite test-transactiongraph-automerge
466− import: commontest
443+ Default-Language: Haskell2010
467444 type: exitcode-stdio-1.0
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
445+ main-is: test/TransactionGraph/Automerge.hs
446+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups
447+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types
448+ Default-Extensions: OverloadedStrings
449+ GHC-Options: -Wall -threaded
450+ Hs-Source-Dirs: ./src/bin, ., test/
470451
471452Test-Suite test-tupleable
472− import: commontest
453+ Default-Language: Haskell2010
473454 type: exitcode-stdio-1.0
474− main-is: Relation/Tupleable.hs
455+ main-is: test/Relation/Tupleable.hs
456+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups
457+ Default-Extensions: OverloadedStrings
458+ GHC-Options: -Wall -threaded
459+ Hs-Source-Dirs: ./src/bin, ., test/
475460
476461Test-Suite test-client-simple
477− import: commontest
478− Main-Is: Client/Simple.hs
462+ Default-Language: Haskell2010
463+ Main-Is: test/Client/Simple.hs
479464 type: exitcode-stdio-1.0
465+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups
466+ Default-Extensions: OverloadedStrings
467+ GHC-Options: -Wall -threaded
468+ Hs-Source-Dirs: ./src/bin, ., test/
480469
481470-- test for file handle leaks
482471Executable handles
483472 Default-Language: Haskell2010
484473 Default-Extensions: OverloadedStrings
485− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups, parser-combinators, prettyprinter, modern-uri, http-types, http-conduit, base16-bytestring, cryptohash-sha256
474+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups
486475 main-is: benchmark/Handles.hs
487476 Other-Modules: TutorialD.Interpreter,
488477 TutorialD.Interpreter.Base,
@@ -501,14 +490,17 @@ Executable handles
501490 TutorialD.Interpreter.TransGraphRelationalOperator,
502491 TutorialD.Interpreter.TransactionGraphOperator,
503492 TutorialD.Interpreter.Types
504− TutorialD.Printer
505493 GHC-Options: -Wall -threaded -rtsopts
506494 HS-Source-Dirs: ./src/bin
507495 if flag(profiler)
508496 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
509−
497+
510498Test-Suite test-dataframe
511− import: commontest
499+ Default-Language: Haskell2010
500+ Main-Is: test/DataFrame.hs
512501 type: exitcode-stdio-1.0
513− Main-Is: DataFrame.hs
514− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Printer
502+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types
503+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups
504+ Default-Extensions: OverloadedStrings
505+ GHC-Options: -Wall -threaded
506+ Hs-Source-Dirs: ./src/bin, ., test/
release.nixdeleted−36
@@ -1,36 +0,0 @@
1−{ compiler ? "ghc8104"
2−, sources ? import ./nix/sources.nix
3−, pkgs ? import sources.nixpkgs { }
4−}:
5−let
6− doJailbreak = pkgs.haskell.lib.doJailbreak;
7− needsCocoa = drv:
8− if pkgs.stdenv.isDarwin
9− then drv.overrideDerivation (old:
10− { buildInputs = [ pkgs.darwin.apple_sdk.frameworks.Cocoa ] ++ old.buildInputs; }
11− )
12− else drv;
13−
14− haskellPackages = pkgs.haskell.packages.${compiler}.override {
15− overrides = self: super: {
16− curryer-rpc = self.callCabal2nix "curryer-rpc" sources.curryer { };
17− streamly = doJailbreak (needsCocoa (self.callCabal2nix "streamly" sources.streamly { }));
18− project-m36 = ((self.callCabal2nixWithOptions "project-m36" ./. "-f-haskell-scripting" { }));
19− };
20− };
21−in
22−{
23− project = haskellPackages.project-m36;
24−
25− shell = haskellPackages.shellFor {
26− packages = p: [
27− p.project-m36
28− ];
29− buildInputs = [
30− haskellPackages.ghcid
31− haskellPackages.hlint
32− pkgs.docker
33− ];
34− withHoogle = true;
35− };
36−}
scripts/DateExamples.tutd+2−2
@@ -20,7 +20,7 @@ sp := relation{tuple{s# "S1",p# "P1",qty 300},
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.tutddeleted−2
@@ -1,2 +0,0 @@
1−x:=relation{
2−tuple{ x 2}} -- nice
shell.nixdeleted−1
@@ -1 +0,0 @@
1−(import ./release.nix { }).shell
src/bin/ProjectM36/Client/Json.hs+1−4
@@ -3,7 +3,6 @@ module ProjectM36.Client.Json where
33import Data.Aeson
44import ProjectM36.Server.RemoteCallTypes.Json ()
55import ProjectM36.Client
6−import ProjectM36.TransactionGraph
76import Control.Exception (IOException)
87
98instance ToJSON EvaluatedNotification
@@ -12,6 +11,4 @@ instance FromJSON EvaluatedNotification
1211instance ToJSON ConnectionError
1312
1413instance ToJSON IOException where
15− toJSON err = object ["IOException" .= show err]
16−
17−instance ToJSON MerkleValidationError
14+ toJSON err = object ["IOException" .= show err]
src/bin/ProjectM36/Server/RemoteCallTypes/Json.hs+2−33
@@ -10,8 +10,6 @@ import ProjectM36.DataTypes.Primitive
1010import ProjectM36.Error
1111import ProjectM36.IsomorphicSchema
1212import ProjectM36.Server.RemoteCallTypes
13−import ProjectM36.MerkleHash
14−import ProjectM36.Attribute as A
1513
1614import Data.Aeson
1715import Data.ByteString.Base64 as B64
@@ -24,9 +22,6 @@ instance FromJSON RelationalExpr
2422instance ToJSON TupleExpr
2523instance FromJSON TupleExpr
2624
27−instance ToJSON TupleExprs
28−instance FromJSON TupleExprs
29−
3025instance ToJSON RestrictionPredicateExpr
3126instance FromJSON RestrictionPredicateExpr
3227
@@ -45,11 +40,8 @@ instance FromJSON ExecuteRelationalExpr
4540instance ToJSON Relation
4641instance FromJSON Relation
4742
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"
43+instance ToJSON Attribute
44+instance FromJSON Attribute
5345
5446instance ToJSON ExtendTupleExpr
5547instance FromJSON ExtendTupleExpr
@@ -103,8 +95,6 @@ instance ToJSON Atom where
10395 "val" .= i ]
10496 toJSON atom@(RelationAtom i) = object [ "type" .= atomTypeForAtom atom,
10597 "val" .= i ]
106− toJSON atom@(RelationalExprAtom i) = object [ "type" .= atomTypeForAtom atom,
107− "val" .= i ]
10898 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [
10999 "dataconstructorname" .= dConsName,
110100 "type" .= toJSON atomtype,
@@ -132,7 +122,6 @@ instance FromJSON Atom where
132122 Left err -> fail ("Failed to parse base64-encoded ByteString: " ++ err)
133123 Right bs -> pure (ByteStringAtom bs)
134124 BoolAtomType -> BoolAtom <$> o .: "val"
135− RelationalExprAtomType -> RelationalExprAtom <$> o .: "val"
136125
137126instance ToJSON Notification
138127instance FromJSON Notification
@@ -140,21 +129,6 @@ instance FromJSON Notification
140129instance ToJSON ScriptCompilationError
141130instance FromJSON ScriptCompilationError
142131
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−
158132instance ToJSON RelationalError
159133instance FromJSON RelationalError
160134
@@ -164,9 +138,6 @@ instance FromJSON SchemaError
164138instance ToJSON MergeError
165139instance FromJSON MergeError
166140
167−instance ToJSON ImportError'
168−instance FromJSON ImportError'
169−
170141instance ToJSON DatabaseContextFunctionError
171142instance FromJSON DatabaseContextFunctionError
172143
@@ -181,5 +152,3 @@ instance FromJSON AtomFunctionError
181152
182153instance ToJSON WithNameExpr
183154instance FromJSON WithNameExpr
184−
185−
src/bin/ProjectM36/Server/WebSocket.hs+21−33
@@ -1,4 +1,4 @@
1−{-# LANGUAGE LambdaCase, CPP #-}
1+{-# LANGUAGE LambdaCase #-}
22module ProjectM36.Server.WebSocket where
33-- while the tutd client performs TutorialD parsing on the client, the websocket server will pass tutd to be parsed and executed on the server- otherwise I have to pull in ghcjs as a dependency to allow client-side parsing- that's not appealing because then the frontend is not language-agnostic, but this could change in the future, perhaps by sending different messages over the websocket
44-- ideally, the wire protocol should not be exposed to a straight string-based API ala SQL, so we could make perhaps a javascript DSL which compiles to the necessary JSON- anaylyze tradeoffs
@@ -22,14 +22,9 @@ import Data.Attoparsec.Text
2222import Control.Applicative
2323import Text.Megaparsec.Error
2424import Data.Functor
25−import Data.Either (fromRight)
26−
27−#if MIN_VERSION_megaparsec(7,0,0)
28−import Data.List.NonEmpty as NE
29−#endif
3025
3126websocketProxyServer :: Port -> Hostname -> WS.ServerApp
32−websocketProxyServer port host pending = do
27+websocketProxyServer port host pending = do
3328 conn <- WS.acceptRequest pending
3429 let unexpectedMsg = WS.sendTextData conn ("messagenotexpected" :: T.Text)
3530 --phase 1- accept database name for connection
@@ -38,10 +33,10 @@ websocketProxyServer port host pending = do
3833 if not (connectdbmsg `T.isPrefixOf` dbmsg) then unexpectedMsg >> WS.sendClose conn ("" :: T.Text)
3934 else do
4035 let dbname = T.unpack $ T.drop (T.length connectdbmsg) dbmsg
41− bracket (createConnection conn dbname port host)
36+ bracket (createConnection conn dbname port host)
4237 (\case
4338 Right dbconn -> close dbconn
44− Left _ -> pure ()) $ \case
39+ Left _ -> pure ()) $ \case
4540 Left err -> sendError conn err
4641 Right dbconn -> do
4742 eSessionId <- createSessionAtHead dbconn "master"
@@ -52,41 +47,34 @@ websocketProxyServer port host pending = do
5247 _ <- forever $ do
5348 pInfo <- promptInfo sessionId dbconn
5449 --figure out why sending three times during startup is necessary
55− sendPromptInfo pInfo conn
50+ sendPromptInfo pInfo conn
5651 sendPromptInfo pInfo conn
5752 msg <- WS.receiveData conn :: IO T.Text
5853 case parseOnly parseExecuteMessage msg of
5954 Left _ -> unexpectedMsg
6055 Right (presentation, tutdString) ->
6156 case parseTutorialD tutdString of
62− Left err -> handleOpResult conn dbconn presentation
63−#if MIN_VERSION_megaparsec(7,0,0)
64− (DisplayErrorResult
65− ("parse error: " `T.append` T.pack
66− (parseErrorPretty . NE.head . bundleErrors $ err)))
67−#else
68− (DisplayErrorResult ("parse error: " `T.append` T.pack (parseErrorPretty err)))
69−#endif
57+ Left err -> handleOpResult conn dbconn presentation (DisplayErrorResult ("parse error: " `T.append` T.pack (parseErrorPretty err)))
7058 Right parsed -> do
71− let timeoutFilter exc = if exc == RequestTimeoutException
72− then Just exc
59+ let timeoutFilter exc = if exc == RequestTimeoutException
60+ then Just exc
7361 else Nothing
7462 responseHandler = do
7563 result <- evalTutorialD sessionId dbconn SafeEvaluation parsed
7664 pInfo' <- promptInfo sessionId dbconn
77− sendPromptInfo pInfo' conn
65+ sendPromptInfo pInfo' conn
7866 handleOpResult conn dbconn presentation result
7967 catchJust timeoutFilter responseHandler (\_ -> handleOpResult conn dbconn presentation (DisplayErrorResult "Request Timed Out."))
8068 pure ()
81−
82−notificationCallback :: WS.Connection -> NotificationCallback
69+
70+notificationCallback :: WS.Connection -> NotificationCallback
8371notificationCallback conn notifName evaldNotif = WS.sendTextData conn (encode (object ["notificationname" .= notifName,
8472 "evaldnotification" .= evaldNotif
8573 ]))
86−
74+
8775--this creates a new database for each connection- perhaps not what we want (?)
8876createConnection :: WS.Connection -> DatabaseName -> Port -> Hostname -> IO (Either ConnectionError Connection)
89−createConnection wsconn dbname port host = connectProjectM36 (RemoteConnectionInfo dbname host (show port) (notificationCallback wsconn))
77+createConnection wsconn dbname port host = connectProjectM36 (RemoteProcessConnectionInfo dbname (createNodeId host port) (notificationCallback wsconn))
9078
9179sendError :: (ToJSON a) => WS.Connection -> a -> IO ()
9280sendError conn err = WS.sendTextData conn (encode (object ["displayerror" .= err]))
@@ -112,32 +100,32 @@ handleOpResult conn _ presentation (DisplayDataFrameResult df) = do
112100 texto = ["text" .= showDataFrame df | textPresentation presentation]
113101 htmlo = ["html" .= dataFrameAsHTML df | htmlPresentation presentation]
114102 WS.sendTextData conn (encode (object ["displaydataframe" .= object (jsono ++ texto ++ htmlo)]))
115−
103+
116104-- get current schema and head name for client
117105promptInfo :: SessionId -> Connection -> IO (HeadName, SchemaName)
118106promptInfo sessionId conn = do
119− eHeadName <- headName sessionId conn
107+ eHeadName <- headName sessionId conn
120108 eSchemaName <- currentSchemaName sessionId conn
121− pure (fromRight "<unknown>" eHeadName, fromRight "<no schema>" eSchemaName)
122−
109+ pure (either (const "<unknown>") id eHeadName, either (const "<no schema>") id eSchemaName)
110+
123111sendPromptInfo :: (HeadName, SchemaName) -> WS.Connection -> IO ()
124112sendPromptInfo (hName, sName) conn = WS.sendTextData conn (encode (object ["promptInfo" .= object ["headname" .= hName, "schemaname" .= sName]]))
125113
126114--a returning relation can be returned as JSON, Text (for consoles), or HTML
127115data Presentation = Presentation {
128− jsonPresentation :: Bool,
116+ jsonPresentation :: Bool,
129117 textPresentation :: Bool,
130118 htmlPresentation :: Bool }
131−
119+
132120data PresentationFlag = JSONFlag | TextFlag | HTMLFlag
133−
121+
134122parseExecuteMessage :: Parser (Presentation, T.Text)
135123parseExecuteMessage = do
136124 _ <- string "executetutd/"
137125 flags <- sepBy ((string "json" $> JSONFlag) <|>
138126 (string "text" $> TextFlag) <|>
139127 (string "html" $> HTMLFlag)) "+"
140− let presentation = foldr (\flag acc -> case flag of
128+ let presentation = foldr (\flag acc -> case flag of
141129 JSONFlag -> acc {jsonPresentation = True}
142130 TextFlag -> acc {textPresentation = True}
143131 HTMLFlag -> acc {htmlPresentation = True}) (Presentation False False False) flags
src/bin/ProjectM36/Server/WebSocket/websocket-client.html+1−1
@@ -126,7 +126,7 @@ margin-bottom: 5pt;
126126 <li>:showrelvars</li>
127127 <li>:showexpr true</li>
128128 <li>:showexpr false</li>
129− <li>:importexample cjdate</li>
129+ <li>:importexample date</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+18−48
@@ -1,63 +1,33 @@
11{-# LANGUAGE CPP #-}
2−
3−import Control.Concurrent
4−import Control.Exception
5−import Control.Monad (when)
6−import Data.Maybe (isJust)
7−import Data.String (fromString)
8−import Network.HTTP.Types (status400)
9−import Network.Socket
10−import Network.Wai (Application, responseLBS)
11−import Network.Wai.Handler.Warp
12−import Network.Wai.Handler.WarpTLS (runTLS, tlsSettings)
13−import qualified Network.Wai.Handler.WebSockets as WS
14−import Network.WebSockets (defaultConnectionOptions)
15−import ProjectM36.Server
2+import ProjectM36.Server.WebSocket
163import ProjectM36.Server.Config
174import ProjectM36.Server.ParseArgs
18−import ProjectM36.Server.WebSocket
5+import ProjectM36.Server
6+import Control.Concurrent
7+import qualified Network.WebSockets as WS
8+
9+#if MIN_VERSION_network_transport_tcp(0,6,0)
10+import Network.Transport.TCP.Internal (decodeEndPointAddress)
11+#else
12+import Network.Transport.TCP (decodeEndPointAddress)
13+#endif
14+
15+import Control.Exception
1916
2017main :: IO ()
2118main = do
2219 -- launch normal project-m36-server
2320 addressMVar <- newEmptyMVar
24− wsConfig <- parseWSConfigWithDefaults (defaultServerConfig {bindPort = 8000, bindHost = "127.0.0.1"})
25−
21+ serverConfig <- parseConfigWithDefaults (defaultServerConfig { bindPort = 8000, bindHost = "127.0.0.1" })
2622 --usurp the serverConfig for our websocket server and make the proxied server run locally
27− let serverConfig = wsServerConfig wsConfig
28− wsHost = bindHost serverConfig
23+ let wsHost = bindHost serverConfig
2924 wsPort = bindPort serverConfig
3025 serverHost = "127.0.0.1"
3126 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−
3827 _ <- forkFinally (launchServer serverConfig' (Just addressMVar) >> pure ()) (either throwIO pure)
3928 --wait for server to be listening
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"
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)
5533
56−warpSettings :: HostName -> Port -> Settings
57−warpSettings host port =
58− setHost (fromString host)
59− . setPort port
60− . setServerName "project-m36"
61− . setTimeout 3600
62− . setGracefulShutdownTimeout (Just 5)
63− $ defaultSettings
src/bin/TutorialD/Interpreter.hs+28−30
@@ -28,13 +28,12 @@ import System.Console.Haskeline
2828import System.Directory (getHomeDirectory)
2929import qualified Data.Text as T
3030import System.IO (hPutStrLn, stderr)
31−#if __GLASGOW_HASKELL__ < 804
31+#if __GLASGOW_HASKELL__ <= 802
3232import Data.Monoid
3333#endif
3434import Data.List (isPrefixOf)
3535import Control.Exception
3636import System.Exit
37−import Data.Either (fromRight)
3837
3938{-
4039context ops are read-only operations which only operate on the database context (relvars and constraints)
@@ -62,7 +61,7 @@ interpreterParserP = safeInterpreterParserP <|>
6261 fmap ImportDBContextOp (tutdImportP <* eof) <|>
6362 fmap RelVarExportOp (exportCSVP <* eof) <|>
6463 fmap DatabaseContextIOExprOp (dbContextIOExprP <* eof)
65−
64+
6665-- the safe interpreter never reads or writes the file system
6766safeInterpreterParserP :: Parser ParsedOperation
6867safeInterpreterParserP = fmap RODatabaseContextOp (roDatabaseContextOperatorP <* eof) <|>
@@ -78,8 +77,8 @@ safeInterpreterParserP = fmap RODatabaseContextOp (roDatabaseContextOperatorP <*
7877promptText :: Either RelationalError HeadName -> Either RelationalError SchemaName -> StringType
7978promptText eHeadName eSchemaName = "TutorialD (" <> transInfo <> "): "
8079 where
81− transInfo = fromRight "<unknown>" eHeadName <> "/" <> fromRight "<no schema>" eSchemaName
82−
80+ transInfo = either (const "<unknown>") id eHeadName <> "/" <> either (const "<no schema>") id eSchemaName
81+
8382parseTutorialD :: T.Text -> Either ParserError ParsedOperation
8483parseTutorialD = parse interpreterParserP ""
8584
@@ -107,20 +106,20 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of
107106 else
108107 pure res
109108 _ -> pure res
110−
111− (DatabaseContextExprOp execOp) ->
112− eHandler $ C.executeDatabaseContextExpr sessionId conn execOp
113−
114− (DatabaseContextIOExprOp execOp) ->
109+
110+ (DatabaseContextExprOp execOp) ->
111+ eHandler $ C.executeDatabaseContextExpr sessionId conn execOp
112+
113+ (DatabaseContextIOExprOp execOp) ->
115114 if needsSafe then
116115 unsafeError
117116 else
118117 eHandler $ C.executeDatabaseContextIOExpr sessionId conn execOp
119−
118+
120119 (GraphOp execOp) -> do
121120 -- warn if the graph op could cause uncommited changes to be discarded
122121 eIsDirty <- C.disconnectedTransactionIsDirty sessionId conn
123− let runGraphOp = eHandler $ C.executeGraphExpr sessionId conn execOp
122+ let runGraphOp = eHandler $ C.executeGraphExpr sessionId conn execOp
124123 settings = Settings {complete = noCompletion,
125124 historyFile = Nothing,
126125 autoAddHistory = False}
@@ -144,20 +143,20 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of
144143 pure (DisplayErrorResult "Graph operation cancelled.")
145144 else
146145 runGraphOp
147−
146+
148147 (ConvenienceGraphOp execOp) ->
149148 eHandler $ evalConvenienceGraphOp sessionId conn execOp
150149
151150 (ROGraphOp execOp) -> do
152151 opResult <- evalROGraphOp sessionId conn execOp
153− case opResult of
152+ case opResult of
154153 Left err -> barf err
155154 Right rel -> pure (DisplayRelationResult rel)
156−
155+
157156 (SchemaOp execOp) ->
158157 eHandler $ evalSchemaOperator sessionId conn execOp
159−
160− (ImportRelVarOp execOp@(RelVarDataImportOperator relVarName _ _)) ->
158+
159+ (ImportRelVarOp execOp@(RelVarDataImportOperator relVarName _ _)) ->
161160 if needsSafe then
162161 unsafeError
163162 else do
@@ -175,8 +174,8 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of
175174 case exprErr of
176175 Left err -> barf err
177176 Right dbexpr -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexpr)
178−
179− (ImportDBContextOp execOp) ->
177+
178+ (ImportDBContextOp execOp) ->
180179 if needsSafe then
181180 unsafeError
182181 else do
@@ -184,15 +183,15 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of
184183 case eErr of
185184 Left err -> barf err
186185 Right dbexprs -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexprs)
187−
188− (InfoOp execOp) ->
186+
187+ (InfoOp execOp) ->
189188 if needsSafe then
190189 unsafeError
191190 else
192191 case evalInformationOperator execOp of
193192 Left err -> pure (DisplayErrorResult err)
194193 Right info -> pure (DisplayResult info)
195−
194+
196195 (RelVarExportOp execOp@(RelVarDataExportOperator relExpr _ _)) ->
197196 --eval relexpr to relation and pass to export function
198197 if needsSafe then
@@ -216,20 +215,19 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of
216215 unsafeError = pure $ DisplayErrorResult "File I/O operation prohibited."
217216 barf :: RelationalError -> IO TutorialDOperatorResult
218217 barf (ScriptError (OtherScriptCompilationError errStr)) = pure (DisplayErrorResult (T.pack errStr))
219− barf (ParseError err) = pure (DisplayErrorResult err)
220218 barf err = return $ DisplayErrorResult (T.pack (show err))
221219 eHandler io = do
222220 eErr <- io
223221 case eErr of
224222 Left err -> barf err
225223 Right () -> return QuietSuccessResult
226−
227−type GhcPkgPath = String
224+
225+type GhcPkgPath = String
228226type TutorialDExec = String
229227type CheckFS = Bool
230−
228+
231229data InterpreterConfig = LocalInterpreterConfig PersistenceStrategy HeadName (Maybe TutorialDExec) [GhcPkgPath] CheckFS |
232− RemoteInterpreterConfig C.Hostname C.Port C.DatabaseName HeadName (Maybe TutorialDExec) CheckFS
230+ RemoteInterpreterConfig C.NodeId C.DatabaseName HeadName (Maybe TutorialDExec) CheckFS
233231
234232outputNotificationCallback :: C.NotificationCallback
235233outputNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received " ++ show notName ++ ":\n" ++ "\n" ++ prettyEvaluatedNotification evaldNot
@@ -258,12 +256,12 @@ reprLoop config sessionId conn = do
258256 Just line -> do
259257 runTutorialD sessionId conn (Just (T.length prompt)) (T.pack line)
260258 reprLoop config sessionId conn
261−
259+
262260
263261runTutorialD :: C.SessionId -> C.Connection -> Maybe PromptLength -> T.Text -> IO ()
264−runTutorialD sessionId conn mPromptLength tutd =
262+runTutorialD sessionId conn mPromptLength tutd =
265263 case parseTutorialD tutd of
266− Left err ->
264+ Left err ->
267265 displayOpResult $ DisplayParseErrorResult mPromptLength err
268266 Right parsed ->
269267 catchJust (\exc -> if exc == C.RequestTimeoutException then Just exc else Nothing) (do
src/bin/TutorialD/Interpreter/Base.hs+38−66
@@ -1,8 +1,8 @@
11{-# LANGUAGE DeriveGeneric, CPP #-}
22module TutorialD.Interpreter.Base (
3− module TutorialD.Interpreter.Base,
3+ module TutorialD.Interpreter.Base,
44 module Text.Megaparsec,
5−#if MIN_VERSION_megaparsec(6,0,0)
5+#if MIN_VERSION_megaparsec(6,0,0)
66 module Text.Megaparsec.Char,
77 module Control.Applicative
88#else
@@ -12,12 +12,11 @@ module TutorialD.Interpreter.Base (
1212 where
1313import ProjectM36.Base
1414import ProjectM36.AtomType
15−import ProjectM36.Attribute as A
1615import ProjectM36.Relation
1716import ProjectM36.DataFrame
1817
1918#if MIN_VERSION_megaparsec(6,0,0)
20−import Text.Megaparsec.Char
19+import Text.Megaparsec.Char
2120import qualified Text.Megaparsec.Char.Lexer as Lex
2221import Text.Megaparsec
2322import Data.Void
@@ -31,11 +30,12 @@ import Data.Text hiding (count)
3130import System.Random
3231import qualified Data.Text as T
3332import 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
3737import GHC.Generics
38−#if __GLASGOW_HASKELL__ < 804
38+#if __GLASGOW_HASKELL__ <= 802
3939import Data.Monoid
4040#endif
4141import qualified Data.UUID as U
@@ -44,18 +44,12 @@ import Data.List.NonEmpty as NE
4444import Data.Time.Clock
4545import Data.Time.Format
4646import Control.Monad (void)
47−import Data.Char
48−
49−#if !MIN_VERSION_megaparsec(7,0,0)
50−anySingle :: Parsec Void Text (Token Text)
51−anySingle = anyChar
52−#endif
5347
5448displayOpResult :: TutorialDOperatorResult -> IO ()
5549displayOpResult QuitResult = return ()
5650displayOpResult (DisplayResult out) = TIO.putStrLn out
5751displayOpResult (DisplayIOResult ioout) = ioout
58−displayOpResult (DisplayErrorResult err) = let outputf = if T.length err > 0 && T.last err /= '\n' then TIO.hPutStrLn else TIO.hPutStr in
52+displayOpResult (DisplayErrorResult err) = let outputf = if T.length err > 0 && T.last err /= '\n' then TIO.hPutStrLn else TIO.hPutStr in
5953 outputf stderr ("ERR: " <> err)
6054displayOpResult QuietSuccessResult = return ()
6155displayOpResult (DisplayRelationResult rel) = do
@@ -63,13 +57,8 @@ displayOpResult (DisplayRelationResult rel) = do
6357 let randomlySortedRel = evalRand (randomizeTupleOrder rel) gen
6458 TIO.putStrLn (showRelation randomlySortedRel)
6559displayOpResult (DisplayParseErrorResult mPromptLength err) = do
66−#if MIN_VERSION_megaparsec(7,0,0)
67− let errorIndent = errorOffset . NE.head . bundleErrors $ err
68− errString = T.pack (parseErrorPretty . NE.head . bundleErrors $ err)
69−#else
70− let errorIndent = unPos (sourceColumn (NE.head (errorPos err)))
71− errString = T.pack (parseErrorPretty err)
72−#endif
60+ let errString = T.pack (parseErrorPretty err)
61+ errorIndent = unPos (sourceColumn (NE.head (errorPos err)))
7362 pointyString len = T.justifyRight (len + fromIntegral errorIndent) '_' "^"
7463 maybe (pure ()) (TIO.putStrLn . pointyString) mPromptLength
7564 TIO.putStr ("ERR:" <> errString)
@@ -82,10 +71,9 @@ type ParseStr = Text
8271type ParseStr = String
8372#endif
8473
85−-- consumes only horizontal spaces
8674spaceConsumer :: Parser ()
87−spaceConsumer = Lex.space space1 (Lex.skipLineComment "--") (Lex.skipBlockComment "{-" "-}")
88−
75+spaceConsumer = Lex.space (void spaceChar) (Lex.skipLineComment "--") (Lex.skipBlockComment "{-" "-}")
76+
8977opChar :: Parser Char
9078opChar = oneOf (":!#$%&*+./<=>?\\^|-~" :: String)-- remove "@" so it can be used as attribute marker without spaces
9179
@@ -104,13 +92,9 @@ braces = between (symbol "{") (symbol "}")
10492identifier :: Parser Text
10593identifier = do
10694 istart <- letterChar <|> char '_'
107− identifierRemainder istart
108−
109−identifierRemainder :: Char -> Parser Text
110−identifierRemainder c = do
111− rest <- many (alphaNumChar <|> char '_' <|> char '#')
95+ irest <- many (alphaNumChar <|> char '_' <|> char '#')
11296 spaceConsumer
113− pure (pack (c:rest))
97+ pure (pack (istart:irest))
11498
11599symbol :: ParseStr -> Parser Text
116100#if MIN_VERSION_megaparsec(6,0,0)
@@ -137,14 +121,11 @@ arrow = symbol "->"
137121semi :: Parser Text
138122semi = symbol ";"
139123
140−nline :: Parser Text
141−nline = (T.singleton <$> newline) <|> crlf
142−
143124integer :: Parser Integer
144125#if MIN_VERSION_megaparsec(6,0,0)
145−integer = Lex.signed (pure ()) Lex.decimal <* spaceConsumer
126+integer = Lex.signed spaceConsumer Lex.decimal
146127#else
147−integer = Lex.signed (pure ()) Lex.integer <* spaceConsumer
128+integer = Lex.signed spaceConsumer Lex.integer
148129#endif
149130
150131natural :: Parser Integer
@@ -155,30 +136,36 @@ natural = Lex.integer <* spaceConsumer
155136#endif
156137
157138float :: Parser Double
158−float = Lex.float <* spaceConsumer
139+float = Lex.float
159140
160141capitalizedIdentifier :: Parser Text
161−capitalizedIdentifier =
162− upperChar >>= identifierRemainder
163−
142+capitalizedIdentifier = do
143+ fletter <- upperChar
144+ restOfIdentifier_ fletter
145+
146+restOfIdentifier_ :: Char -> Parser Text
147+restOfIdentifier_ fletter = do
148+ rest <- option "" identifier
149+ spaceConsumer
150+ pure (T.cons fletter rest)
151+
164152uncapitalizedIdentifier :: Parser Text
165−uncapitalizedIdentifier =
166− lowerChar >>= identifierRemainder
153+uncapitalizedIdentifier = do
154+ fletter <- lowerChar
155+ restOfIdentifier_ fletter
167156
168157showRelationAttributes :: Attributes -> Text
169158showRelationAttributes attrs = "{" <> T.concat (L.intersperse ", " $ L.map showAttribute attrsL) <> "}"
170159 where
171− showAttribute (Attribute name atomType') = name <> " " <> prettyAtomType atomType'
172− attrsL = A.toList attrs
160+ showAttribute (Attribute name atomType) = name <> " " <> prettyAtomType atomType
161+ attrsL = V.toList attrs
173162
174−type PromptLength = Int
163+type PromptLength = Int
175164
176−#if MIN_VERSION_megaparsec(7,0,0)
177−type ParserError = ParseErrorBundle T.Text Void
178−#elif MIN_VERSION_megaparsec(6,0,0)
165+#if MIN_VERSION_megaparsec(6,0,0)
179166type ParserError = ParseError Char Void
180−#else
181−type ParserError = ParseError Char Dec
167+#else
168+type ParserError = ParseError Char Dec
182169#endif
183170
184171data TutorialDOperatorResult = QuitResult |
@@ -190,27 +177,24 @@ data TutorialDOperatorResult = QuitResult |
190177 DisplayParseErrorResult (Maybe PromptLength) ParserError | -- PromptLength refers to length of prompt text
191178 QuietSuccessResult
192179 deriving (Generic)
193−
180+
194181type TransactionGraphWasUpdated = Bool
195182
196183--allow for python-style triple quoting because guessing the correct amount of escapes in different contexts is annoying
197184tripleQuotedString :: Parser Text
198185tripleQuotedString = do
199186 _ <- tripleQuote
200− pack <$> manyTill anySingle (try (tripleQuote >> notFollowedBy quote))
201−
187+ pack <$> manyTill anyChar (try (tripleQuote >> notFollowedBy quote))
188+
202189normalQuotedString :: Parser Text
203190normalQuotedString = quote *> (T.pack <$> manyTill Lex.charLiteral quote)
204191
205192quotedString :: Parser Text
206193quotedString = try tripleQuotedString <|> normalQuotedString
207194
208−quoted :: Parser a -> Parser a
209−quoted = between quote quote
210−
211195uuidP :: Parser U.UUID
212196uuidP = do
213− uuidStart <- count 8 hexDigitChar
197+ uuidStart <- count 8 hexDigitChar
214198 _ <- char '-' -- min 28 with no dashes, maximum 4 dashes
215199 uuidMid1 <- count 4 hexDigitChar
216200 _ <- char '-'
@@ -230,16 +214,4 @@ utcTimeP = do
230214 case parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" (T.unpack timeStr) of
231215 Nothing -> fail "invalid datetime input, use \"YYYY-MM-DD HH:MM:SS\""
232216 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'))
245217
src/bin/TutorialD/Interpreter/DatabaseContextExpr.hs+13−16
@@ -12,7 +12,7 @@ import ProjectM36.Error
1212import qualified ProjectM36.RelationalExpression as RE
1313import ProjectM36.Key
1414import ProjectM36.FunctionalDependency
15−#if __GLASGOW_HASKELL__ < 804
15+#if __GLASGOW_HASKELL__ <= 802
1616import Data.Monoid
1717#endif
1818import Data.Functor
@@ -44,7 +44,7 @@ nothingP = spaceConsumer >> pure NoOperation
4444assignP :: Parser DatabaseContextExpr
4545assignP = do
4646 relVarName <- try $ do
47− relVarName <- relVarNameP
47+ relVarName <- identifier
4848 reservedOp ":="
4949 return relVarName
5050 Assign relVarName <$> relExprP
@@ -53,20 +53,19 @@ multilineSep :: Parser T.Text
5353multilineSep = newline >> pure "\n"
5454
5555multipleDatabaseContextExprP :: Parser DatabaseContextExpr
56−multipleDatabaseContextExprP = do
57− exprs <- filter (/= NoOperation) <$> sepBy1 databaseContextExprP semi
58− pure (MultipleExpr exprs)
56+multipleDatabaseContextExprP =
57+ MultipleExpr <$> sepBy1 databaseContextExprP semi
5958
6059insertP :: Parser DatabaseContextExpr
6160insertP = do
6261 reservedOp "insert"
63− relvar <- relVarNameP
62+ relvar <- identifier
6463 Insert relvar <$> relExprP
6564
6665defineP :: Parser DatabaseContextExpr
6766defineP = do
6867 relVarName <- try $ do
69− relVarName <- relVarNameP
68+ relVarName <- identifier
7069 reservedOp "::"
7170 return relVarName
7271 Define relVarName <$> makeAttributeExprsP
@@ -74,17 +73,17 @@ defineP = do
7473undefineP :: Parser DatabaseContextExpr
7574undefineP = do
7675 reservedOp "undefine"
77− Undefine <$> relVarNameP
76+ Undefine <$> identifier
7877
7978deleteP :: Parser DatabaseContextExpr
8079deleteP = do
8180 reservedOp "delete"
82− Delete <$> relVarNameP <*> option TruePredicate (reservedOp "where" *> restrictionPredicateP)
81+ Delete <$> identifier <*> option TruePredicate (reservedOp "where" *> restrictionPredicateP)
8382
8483updateP :: Parser DatabaseContextExpr
8584updateP = do
8685 reservedOp "update"
87− relVarName <- relVarNameP
86+ relVarName <- identifier
8887 predicate <- option TruePredicate (reservedOp "where" *> restrictionPredicateP <* spaceConsumer)
8988 attributeAssignments <- M.fromList <$> parens (sepBy attributeAssignmentP comma)
9089 return $ Update relVarName attributeAssignments predicate
@@ -167,7 +166,7 @@ addTypeConstructorP = do
167166removeTypeConstructorP :: Parser DatabaseContextExpr
168167removeTypeConstructorP = do
169168 reserved "undata"
170− RemoveTypeConstructor <$> typeConstructorNameP
169+ RemoveTypeConstructor <$> identifier
171170
172171removeAtomFunctionP :: Parser DatabaseContextExpr
173172removeAtomFunctionP = do
@@ -179,13 +178,10 @@ removeDatabaseContextFunctionP = do
179178 reserved "removedatabasecontextfunction"
180179 RemoveDatabaseContextFunction <$> quotedString
181180
182−functionNameP :: Parser AtomFunctionName
183−functionNameP = uncapitalizedIdentifier
184−
185181executeDatabaseContextFunctionP :: Parser DatabaseContextExpr
186182executeDatabaseContextFunctionP = do
187183 reserved "execute"
188− funcName <- functionNameP
184+ funcName <- identifier
189185 args <- parens (sepBy atomExprP comma)
190186 pure (ExecuteDatabaseContextFunction funcName args)
191187
@@ -207,7 +203,8 @@ interpretDatabaseContextExpr context transId graph tutdstring =
207203 Left err -> Left $ PM36E.ParseError (T.pack (show err))
208204 Right parsed -> do
209205 let env = RE.mkDatabaseContextEvalEnv transId graph
210− RE.dbc_context <$> RE.runDatabaseContextEvalMonad context env (optimizeAndEvalDatabaseContextExpr True parsed)
206+ x <- RE.dbc_context <$> RE.runDatabaseContextEvalMonad context env (optimizeAndEvalDatabaseContextExpr True parsed)
207+ pure x
211208
212209{-
213210--no optimization
src/bin/TutorialD/Interpreter/Export/Base.hs+1−1
@@ -2,7 +2,7 @@
22module TutorialD.Interpreter.Export.Base where
33import ProjectM36.Base
44import ProjectM36.Error
5−#if __GLASGOW_HASKELL__ < 804
5+#if __GLASGOW_HASKELL__ <= 802
66import Data.Monoid
77#endif
88
src/bin/TutorialD/Interpreter/Import/Base.hs+4−9
@@ -2,9 +2,7 @@
22module TutorialD.Interpreter.Import.Base where
33import ProjectM36.Base
44import ProjectM36.Error
5−import Text.URI (URI)
6−import Data.Text (Text)
7−#if __GLASGOW_HASKELL__ < 804
5+#if __GLASGOW_HASKELL__ <= 802
86import Data.Monoid
97#endif
108
@@ -14,14 +12,11 @@ data RelVarDataImportOperator = RelVarDataImportOperator RelVarName FilePath (Re
1412instance Show RelVarDataImportOperator where
1513 show (RelVarDataImportOperator rv path _) = "RelVarDataImportOperator " <> show rv <> " " <> path
1614
17−type HashVerification = Maybe Text
18−
1915-- | import data into a database context
20−data DatabaseContextDataImportOperator = DatabaseContextDataImportOperator URI HashVerification (URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr))
16+data DatabaseContextDataImportOperator = DatabaseContextDataImportOperator FilePath (FilePath -> IO (Either RelationalError DatabaseContextExpr))
2117
2218instance Show DatabaseContextDataImportOperator where
23− show (DatabaseContextDataImportOperator uri hash _) =
24− "DatabaseContextDataImportOperator " <> show uri <> " " <> show hash
19+ show (DatabaseContextDataImportOperator path _) = "DatabaseContextDataImportOperator " <> path
2520
2621-- perhaps create a structure to import a whole transaction graph section in the future
2722
@@ -29,4 +24,4 @@ evalRelVarDataImportOperator :: RelVarDataImportOperator -> TypeConstructorMappi
2924evalRelVarDataImportOperator (RelVarDataImportOperator relVarName path importFunc) tConsMap attrs = importFunc relVarName tConsMap attrs path
3025
3126evalDatabaseContextDataImportOperator :: DatabaseContextDataImportOperator -> IO (Either RelationalError DatabaseContextExpr)
32−evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator uri hash importFunc) = importFunc uri hash
27+evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator path importFunc) = importFunc path
src/bin/TutorialD/Interpreter/Import/BasicExamples.hs+2−2
@@ -20,8 +20,8 @@ importBasicExampleOperatorP :: Parser ImportBasicExampleOperator
2020importBasicExampleOperatorP = do
2121 reservedOp ":importexample"
2222 example <- identifier
23− if example == "cjdate" then
23+ if example == "date" 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 -> pure $ Left (ImportError (ImportFileError (T.pack (show err))))
17+ Left err -> return $ Left (ImportError $ T.pack (show err))
1818 Right csvData' -> case csvAsRelation attrs tConsMap csvData' of
19− Left err -> pure $ Left (ParseError $ T.pack (show err))
20− Right csvRel -> pure $ Right (Insert relVarName (ExistingRelation csvRel))
19+ Left err -> return $ Left (ParseError $ T.pack (show err))
20+ Right csvRel -> return $ Right (Insert relVarName (ExistingRelation csvRel))
2121
2222importCSVP :: Parser RelVarDataImportOperator
2323importCSVP = do
src/bin/TutorialD/Interpreter/Import/TutorialD.hs+17−70
@@ -9,78 +9,25 @@ import qualified Data.Text as T
99import Control.Exception
1010import qualified Data.ByteString as BS
1111import qualified Data.Text.Encoding as TE
12−import qualified Text.URI as URI
13−import Text.URI (URI)
14−import Crypto.Hash.SHA256
15−import Data.ByteString.Base16 as B16
16−import Network.HTTP.Simple
17−import Network.HTTP.Types
18−--import a file containing TutorialD database context expressions via local files or HTTP/HTTPS
12+--import a file containing TutorialD database context expressions
1913
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−
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+
7528tutdImportP :: Parser DatabaseContextDataImportOperator
7629tutdImportP = do
7730 reserved ":importtutd"
78− uri <- quoted URI.parser
31+ path <- quotedString
7932 spaceConsumer
80− mhash <- optional (quoted hex)
81− handler <- case URI.unRText <$> URI.uriScheme uri of
82− Nothing -> fail "URI scheme missing"
83− Just "file" -> pure importTutorialDFromFile
84− Just scheme | scheme `elem` ["http", "https"] -> pure importTutorialDViaHTTP
85− | otherwise -> fail ( "unsupported URI scheme: " <> show scheme)
86− pure $ DatabaseContextDataImportOperator uri mhash handler
33+ return $ DatabaseContextDataImportOperator (T.unpack path) importTutorialD
src/bin/TutorialD/Interpreter/RODatabaseContextOperator.hs+16−33
@@ -1,16 +1,13 @@
11{-# LANGUAGE GADTs #-}
22module TutorialD.Interpreter.RODatabaseContextOperator where
33import ProjectM36.Base
4−import ProjectM36.Relation
54import qualified ProjectM36.DataFrame as DF
65import ProjectM36.Error
7−import ProjectM36.Tuple
86import ProjectM36.InclusionDependency
97import qualified ProjectM36.Client as C
108import TutorialD.Interpreter.Base
119import TutorialD.Interpreter.RelationalExpr
1210import TutorialD.Interpreter.DatabaseContextExpr
13−import TutorialD.Printer
1411import Control.Monad.State
1512import qualified Data.Text as T
1613import ProjectM36.Relation.Show.Gnuplot
@@ -22,7 +19,7 @@ data RODatabaseContextOperator where
2219 ShowRelation :: RelationalExpr -> RODatabaseContextOperator
2320 PlotRelation :: RelationalExpr -> RODatabaseContextOperator
2421 ShowRelationType :: RelationalExpr -> RODatabaseContextOperator
25− ShowConstraints :: StringType -> RODatabaseContextOperator
22+ ShowConstraint :: StringType -> RODatabaseContextOperator
2623 ShowPlan :: DatabaseContextExpr -> RODatabaseContextOperator
2724 ShowTypes :: RODatabaseContextOperator
2825 ShowRelationVariables :: RODatabaseContextOperator
@@ -34,44 +31,44 @@ data RODatabaseContextOperator where
3431
3532typeP :: Parser RODatabaseContextOperator
3633typeP = do
37− colonOp ":type"
34+ reservedOp ":type"
3835 ShowRelationType <$> relExprP
3936
4037showRelP :: Parser RODatabaseContextOperator
4138showRelP = do
42− colonOp ":showexpr"
39+ reservedOp ":showexpr"
4340 ShowRelation <$> relExprP
4441
4542showPlanP :: Parser RODatabaseContextOperator
4643showPlanP = do
47− colonOp ":showplan"
44+ reservedOp ":showplan"
4845 ShowPlan <$> databaseContextExprP
4946
5047showTypesP :: Parser RODatabaseContextOperator
51−showTypesP = colonOp ":showtypes" >> pure ShowTypes
48+showTypesP = reserved ":showtypes" >> pure ShowTypes
5249
5350showRelationVariables :: Parser RODatabaseContextOperator
54−showRelationVariables = colonOp ":showrelvars" >> pure ShowRelationVariables
51+showRelationVariables = reserved ":showrelvars" >> pure ShowRelationVariables
5552
5653showAtomFunctionsP :: Parser RODatabaseContextOperator
57−showAtomFunctionsP = colonOp ":showatomfunctions" >> pure ShowAtomFunctions
54+showAtomFunctionsP = reserved ":showatomfunctions" >> pure ShowAtomFunctions
5855
5956showDatabaseContextFunctionsP :: Parser RODatabaseContextOperator
60−showDatabaseContextFunctionsP = colonOp ":showdatabasecontextfunctions" >> pure ShowDatabaseContextFunctions
57+showDatabaseContextFunctionsP = reserved ":showdatabasecontextfunctions" >> pure ShowDatabaseContextFunctions
6158
6259quitP :: Parser RODatabaseContextOperator
6360quitP = do
64− colonOp ":quit"
61+ reservedOp ":quit"
6562 return Quit
6663
6764showConstraintsP :: Parser RODatabaseContextOperator
6865showConstraintsP = do
69− colonOp ":constraints"
70− ShowConstraints <$> option "" identifier
66+ reservedOp ":constraints"
67+ ShowConstraint <$> option "" identifier
7168
7269plotRelExprP :: Parser RODatabaseContextOperator
7370plotRelExprP = do
74− colonOp ":plotexpr"
71+ reserved ":plotexpr"
7572 PlotRelation <$> relExprP
7673
7774roDatabaseContextOperatorP :: Parser RODatabaseContextOperator
@@ -109,16 +106,15 @@ evalRODatabaseContextOp sessionId conn (PlotRelation expr) = do
109106 err <- plotRelation rel
110107 when (isJust err) $ print err
111108
112−evalRODatabaseContextOp sessionId conn (ShowConstraints name) = do
109+evalRODatabaseContextOp sessionId conn (ShowConstraint name) = do
113110 eIncDeps <- C.inclusionDependencies sessionId conn
114111 let val = case eIncDeps of
115112 Left err -> Left err
116113 Right incDeps -> case name of
117− "" -> inclusionDependenciesAsRelation incDeps >>= renderRelExprsInIncDeps
114+ "" -> inclusionDependenciesAsRelation incDeps
118115 depName -> case M.lookup depName incDeps of
119116 Nothing -> Left (InclusionDependencyNameNotInUseError depName)
120− Just dep ->
121− inclusionDependenciesAsRelation (M.singleton depName dep) >>= renderRelExprsInIncDeps
117+ Just dep -> inclusionDependenciesAsRelation (M.singleton depName dep)
122118 pure $ case val of
123119 Left err -> DisplayErrorResult (T.pack (show err))
124120 Right rel -> DisplayRelationResult rel
@@ -168,7 +164,7 @@ interpretRODatabaseContextOp sessionId conn tutdstring = case parse roDatabaseCo
168164
169165showDataFrameP :: Parser RODatabaseContextOperator
170166showDataFrameP = do
171− colonOp ":showdataframe"
167+ reservedOp ":showdataframe"
172168 relExpr <- relExprP
173169 reservedOp "orderby"
174170 attrOrdersExpr <- attrOrdersExprP
@@ -195,16 +191,3 @@ attrOrderExprP = DF.AttributeOrderExpr <$> identifier <*> orderP
195191
196192orderP :: Parser DF.Order
197193orderP = try (reservedOp "ascending" >> pure DF.AscendingOrder) <|> try (reservedOp "descending" >> pure DF.DescendingOrder) <|> pure DF.AscendingOrder
198−
199−-- render RelationalExprAtoms as TutorialD
200−renderRelExprsInIncDeps :: Relation -> Either RelationalError Relation
201−renderRelExprsInIncDeps = relMogrify tupMapper attrs
202− where
203− tupMapper tup = pure $ mkRelationTupleFromMap (M.map mapper (tupleToMap tup))
204− mapper (RelationalExprAtom expr) = TextAtom (T.pack (show (prettyRelationalExpr expr)))
205− mapper atom = atom
206− attrs = C.attributesFromList [Attribute "name" TextAtomType,
207− Attribute "sub" TextAtomType,
208− Attribute "super" TextAtomType
209− ]
210−
src/bin/TutorialD/Interpreter/RelationalExpr.hs+44−77
@@ -1,11 +1,6 @@
1−{-# LANGUAGE CPP #-}
21module TutorialD.Interpreter.RelationalExpr where
32import Text.Megaparsec
4−#if MIN_VERSION_megaparsec(7,0,0)
5−import Control.Monad.Combinators.Expr
6−#else
73import Text.Megaparsec.Expr
8−#endif
94import ProjectM36.Base
105import TutorialD.Interpreter.Base
116import TutorialD.Interpreter.Types
@@ -17,36 +12,26 @@ import ProjectM36.MiscUtils
1712
1813--used in projection
1914attributeListP :: RelationalMarkerExpr a => Parser (AttributeNamesBase a)
20−attributeListP =
15+attributeListP =
2116 (reservedOp "all but" >>
22− InvertedAttributeNames . S.fromList <$> sepBy attributeNameP comma) <|>
23−
17+ InvertedAttributeNames . S.fromList <$> sepBy identifier comma) <|>
2418 (reservedOp "all from" >>
2519 RelationalExprAttributeNames <$> relExprP) <|>
26−
27− (reservedOp "union of" >>
28− UnionAttributeNames <$> braces attributeListP <*> braces attributeListP) <|>
29−
30− (reservedOp "intersection of" >>
31− IntersectAttributeNames <$> braces attributeListP <*> braces attributeListP) <|>
32−
33− (AttributeNames . S.fromList <$> sepBy attributeNameP comma)
34−
20+ (AttributeNames . S.fromList <$> sepBy identifier comma)
3521
3622makeRelationP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)
3723makeRelationP = do
3824 reserved "relation"
3925 attrExprs <- try (fmap Just makeAttributeExprsP) <|> pure Nothing
4026 tupleExprs <- braces (sepBy tupleExprP comma) <|> pure []
41− marker <- parseMarkerP
42− pure $ MakeRelationFromExprs attrExprs (TupleExprs marker tupleExprs)
43−
27+ pure $ MakeRelationFromExprs attrExprs tupleExprs
4428
29+
4530--abstract data type parser- in this context, the type constructor must not include any type arguments
4631--Either Text Int
4732adTypeConstructorP :: Parser TypeConstructor
4833adTypeConstructorP = do
49− tConsName <- typeConstructorNameP
34+ tConsName <- capitalizedIdentifier
5035 tConsArgs <- many typeConstructorP
5136 pure $ ADTypeConstructor tConsName tConsArgs
5237
@@ -56,25 +41,25 @@ tupleExprP = do
5641 attrAssocs <- braces (sepBy tupleAtomExprP comma)
5742 --detect duplicate attribute names
5843 let dupAttrNames = dupes (sort (map fst attrAssocs))
59− if not (null dupAttrNames) then
44+ if not (null dupAttrNames) then
6045 fail ("Attribute names duplicated: " ++ show dupAttrNames)
6146 else
6247 pure (TupleExpr (M.fromList attrAssocs))
6348
6449tupleAtomExprP :: RelationalMarkerExpr a => Parser (AttributeName, AtomExprBase a)
6550tupleAtomExprP = do
66− attributeName <- attributeNameP
51+ attributeName <- identifier
6752 atomExpr <- atomExprP
6853 pure (attributeName, atomExpr)
69−
54+
7055projectP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)
7156projectP = Project <$> braces attributeListP
7257
7358renameClauseP :: Parser (T.Text, T.Text)
7459renameClauseP = do
75− oldAttr <- attributeNameP
60+ oldAttr <- identifier
7661 reservedOp "as"
77− newAttr <- attributeNameP
62+ newAttr <- identifier
7863 pure (oldAttr, newAttr)
7964
8065renameP :: Parser (RelationalExprBase a -> RelationalExprBase a)
@@ -83,7 +68,7 @@ renameP = do
8368 renameList <- braces (sepBy renameClauseP comma)
8469 case renameList of
8570 [] -> pure (Restrict TruePredicate) --no-op when rename list is empty
86− renames ->
71+ renames ->
8772 pure $ \expr -> foldl (\acc (oldAttr, newAttr) -> Rename oldAttr newAttr acc) expr renames
8873
8974whereClauseP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)
@@ -93,7 +78,7 @@ groupClauseP :: RelationalMarkerExpr a => Parser (AttributeNamesBase a, T.Text)
9378groupClauseP = do
9479 attrs <- braces attributeListP
9580 reservedOp "as"
96− newAttrName <- attributeNameP
81+ newAttrName <- identifier
9782 pure (attrs, newAttrName)
9883
9984groupP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)
@@ -106,30 +91,26 @@ groupP = do
10691ungroupP :: Parser (RelationalExprBase a -> RelationalExprBase a)
10792ungroupP = do
10893 reservedOp "ungroup"
109− Ungroup <$> attributeNameP
94+ Ungroup <$> identifier
11095
11196extendP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)
11297extendP = do
11398 reservedOp ":"
114− extends <- braces (sepBy extendTupleExpressionP comma)
115− case extends of
116− [] -> pure (Restrict TruePredicate)
117− extends' ->
118− pure $ \expr -> foldl (flip Extend) expr extends'
119−
99+ Extend <$> braces extendTupleExpressionP
100+
120101semijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)
121102semijoinP = do
122103 reservedOp "semijoin" <|> reservedOp "matching"
123− pure (\exprA exprB ->
104+ pure (\exprA exprB ->
124105 Project (RelationalExprAttributeNames exprA) (Join exprA exprB))
125−
126−antijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)
106+
107+antijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)
127108antijoinP = do
128109 reservedOp "not matching" <|> reservedOp "antijoin"
129110 pure (\exprA exprB ->
130111 Difference exprA (
131112 Project (RelationalExprAttributeNames exprA) (Join exprA exprB)))
132−
113+
133114relOperators :: RelationalMarkerExpr a => [[Operator Parser (RelationalExprBase a)]]
134115relOperators = [
135116 [Postfix projectP],
@@ -142,23 +123,15 @@ relOperators = [
142123 [InfixL antijoinP],
143124 [InfixL (reservedOp "union" >> return Union)],
144125 [InfixL (reservedOp "minus" >> return Difference)],
145− [InfixN (reservedOp "=" >> return Equals),
146− InfixN (reservedOp "/=" >> return NotEquals)],
126+ [InfixN (reservedOp "=" >> return Equals)],
147127 [Postfix extendP]
148128 ]
149129
150130relExprP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)
151131relExprP = try withMacroExprP <|> makeExprParser relTerm relOperators
152132
153−--allow for additional characters
154−attributeNameP :: Parser AttributeName
155−attributeNameP = uncapitalizedIdentifier
156−
157−relVarNameP :: Parser RelVarName
158−relVarNameP = uncapitalizedIdentifier
159−
160133relVarP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)
161−relVarP = RelationVariable <$> relVarNameP <*> parseMarkerP
134+relVarP = RelationVariable <$> identifier <*> parseMarkerP
162135
163136relTerm :: RelationalMarkerExpr a => Parser (RelationalExprBase a)
164137relTerm = parens relExprP
@@ -179,13 +152,13 @@ restrictionPredicateP = makeExprParser predicateTerm predicateOperators
179152 <|> relationalBooleanExprP
180153
181154relationalBooleanExprP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)
182−relationalBooleanExprP =
155+relationalBooleanExprP =
183156 --we can't actually detect if the type is relational boolean, so we just pass it to the next phase
184157 RelationalExprPredicate <$> (parens relExprP <|> relTerm)
185−
158+
186159restrictionAttributeEqualityP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)
187160restrictionAttributeEqualityP = do
188− attributeName <- attributeNameP
161+ attributeName <- identifier
189162 reservedOp "="
190163 AttributeEqualityPredicate attributeName <$> atomExprP
191164
@@ -202,7 +175,7 @@ extendTupleExpressionP = attributeExtendTupleExpressionP
202175
203176attributeExtendTupleExpressionP :: RelationalMarkerExpr a => Parser (ExtendTupleExprBase a)
204177attributeExtendTupleExpressionP = do
205− newAttr <- attributeNameP
178+ newAttr <- identifier
206179 reservedOp ":="
207180 AttributeExtendTupleExpr newAttr <$> atomExprP
208181
@@ -214,34 +187,33 @@ consumeAtomExprP consume = try functionAtomExprP <|>
214187 try (parens (constructedAtomExprP True)) <|>
215188 constructedAtomExprP consume <|>
216189 attributeAtomExprP <|>
217− try nakedAtomExprP <|>
190+ nakedAtomExprP <|>
218191 relationalAtomExprP
219−
220192
221193attributeAtomExprP :: Parser (AtomExprBase a)
222194attributeAtomExprP = do
223195 _ <- string "@"
224− AttributeAtomExpr <$> attributeNameP
196+ AttributeAtomExpr <$> identifier
225197
226198nakedAtomExprP :: Parser (AtomExprBase a)
227199nakedAtomExprP = NakedAtomExpr <$> atomP
228200
229201constructedAtomExprP :: RelationalMarkerExpr a => Bool -> Parser (AtomExprBase a)
230202constructedAtomExprP consume = do
231− dConsName <- dataConstructorNameP
203+ dConsName <- capitalizedIdentifier
232204 dConsArgs <- if consume then sepBy (consumeAtomExprP False) spaceConsumer else pure []
233205 ConstructedAtomExpr dConsName dConsArgs <$> parseMarkerP
234−
206+
235207-- used only for primitive type parsing ?
236208atomP :: Parser Atom
237−atomP = stringAtomP <|>
238− try doubleAtomP <|>
239− integerAtomP <|>
209+atomP = stringAtomP <|>
210+ doubleAtomP <|>
211+ integerAtomP <|>
240212 boolAtomP
241−
213+
242214functionAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)
243−functionAtomExprP =
244− FunctionAtomExpr <$> uncapitalizedIdentifier <*> parens (sepBy atomExprP comma) <*> parseMarkerP
215+functionAtomExprP =
216+ FunctionAtomExpr <$> identifier <*> parens (sepBy atomExprP comma) <*> parseMarkerP
245217
246218relationalAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)
247219relationalAtomExprP = RelationAtomExpr <$> relExprP
@@ -249,29 +221,25 @@ relationalAtomExprP = RelationAtomExpr <$> relExprP
249221stringAtomP :: Parser Atom
250222stringAtomP = TextAtom <$> quotedString
251223
252−doubleAtomP :: Parser Atom
253−doubleAtomP = DoubleAtom <$> float
224+doubleAtomP :: Parser Atom
225+doubleAtomP = DoubleAtom <$> try float
254226
255227integerAtomP :: Parser Atom
256228integerAtomP = IntegerAtom <$> integer
257229
258230boolAtomP :: Parser Atom
259231boolAtomP = do
260− v <- identifier
261− if v == "t" || v == "f" then
262− pure $ BoolAtom (v == "t")
263− else
264− fail "invalid boolAtom"
265−
266−
232+ val <- char 't' <|> char 'f'
233+ return $ BoolAtom (val == 't')
234+
267235relationAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)
268236relationAtomExprP = RelationAtomExpr <$> makeRelationP
269237
270238withMacroExprP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)
271239withMacroExprP = do
272240 reservedOp "with"
273− views <- parens (sepBy1 createMacroP comma)
274− With views <$> relExprP
241+ macros <- parens (sepBy1 createMacroP comma)
242+ With macros <$> relExprP
275243
276244createMacroP :: RelationalMarkerExpr a => Parser (WithNameExprBase a, RelationalExprBase a)
277245createMacroP = do
@@ -280,5 +248,4 @@ createMacroP = do
280248 expr <- relExprP
281249 marker <- parseMarkerP
282250 pure (WithNameExpr name marker, expr)
283−
284−
251+
src/bin/TutorialD/Interpreter/SchemaOperator.hs+3−3
@@ -42,7 +42,7 @@ isoRestrictP = do
4242 reserved "isorestrict"
4343 relVarIn <- qrelVarP
4444 relvarsOut <- isoRestrictOutRelVarsP
45− IsoRestrict relVarIn <$> restrictionPredicateP <*> pure relvarsOut
45+ IsoRestrict <$> pure relVarIn <*> restrictionPredicateP <*> pure relvarsOut
4646
4747isoRestrictOutRelVarsP :: Parser (RelVarName, RelVarName)
4848isoRestrictOutRelVarsP = (,) <$> qrelVarP <*> qrelVarP
@@ -55,7 +55,7 @@ isoUnionP = do
5555 reserved "isounion"
5656 relVarsIn <- isoUnionInRelVarsP
5757 relVarsOut <- qrelVarP
58− IsoUnion relVarsIn <$> restrictionPredicateP <*> pure relVarsOut
58+ IsoUnion <$> pure relVarsIn <*> restrictionPredicateP <*> pure relVarsOut
5959
6060isoRenameP :: Parser SchemaIsomorph
6161isoRenameP = do
@@ -74,4 +74,4 @@ isoUnionInRelVarsP = (,) <$> qrelVarP <*> qrelVarP
7474evalSchemaOperator :: SessionId -> Connection -> SchemaOperator -> IO (Either RelationalError ())
7575evalSchemaOperator sessionId conn (ModifySchemaExpr expr) = executeSchemaExpr sessionId conn expr
7676evalSchemaOperator sessionId conn (SetCurrentSchema sname) = setCurrentSchemaName sessionId conn sname
77−
77+
src/bin/TutorialD/Interpreter/TransactionGraphOperator.hs+3−12
@@ -2,9 +2,8 @@
22module TutorialD.Interpreter.TransactionGraphOperator where
33import TutorialD.Interpreter.Base
44import ProjectM36.TransactionGraph hiding (autoMergeToHead)
5−import ProjectM36.Client as C
5+import ProjectM36.Client
66import ProjectM36.Base
7−import ProjectM36.Relation (relationTrue)
87import Data.Functor
98
109data ConvenienceTransactionGraphOperator = AutoMergeToHead MergeStrategy HeadName
@@ -72,9 +71,6 @@ mergeTransactionsP = do
7271 reservedOp ":mergetrans"
7372 MergeTransactions <$> mergeTransactionStrategyP <*> identifier <*> identifier
7473
75−validateMerkleHashesP :: Parser ROTransactionGraphOperator
76−validateMerkleHashesP = reservedOp ":validatemerklehashes" $> ValidateMerkleHashes
77−
7874transactionGraphOpP :: Parser TransactionGraphOperator
7975transactionGraphOpP =
8076 jumpToHeadP
@@ -87,7 +83,7 @@ transactionGraphOpP =
8783 <|> mergeTransactionsP
8884
8985roTransactionGraphOpP :: Parser ROTransactionGraphOperator
90−roTransactionGraphOpP = showGraphP <|> validateMerkleHashesP
86+roTransactionGraphOpP = showGraphP
9187
9288
9389
@@ -105,11 +101,6 @@ interpretOps newUUID trans@(DisconnectedTransaction _ context) transGraph instri
105101
106102evalROGraphOp :: SessionId -> Connection -> ROTransactionGraphOperator -> IO (Either RelationalError Relation)
107103evalROGraphOp 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)
113104
114105evalConvenienceGraphOp :: SessionId -> Connection -> ConvenienceTransactionGraphOperator -> IO (Either RelationalError ())
115−evalConvenienceGraphOp sessionId conn (AutoMergeToHead strat head') = autoMergeToHead sessionId conn strat head'
106+evalConvenienceGraphOp sessionId conn (AutoMergeToHead strat head') = autoMergeToHead sessionId conn strat head'
src/bin/TutorialD/Interpreter/Types.hs+4−10
@@ -9,24 +9,18 @@ class RelationalMarkerExpr a where
99
1010instance RelationalMarkerExpr () where
1111 parseMarkerP = pure ()
12−
13−typeConstructorNameP :: Parser TypeConstructorName
14−typeConstructorNameP = capitalizedIdentifier
15−
16−dataConstructorNameP :: Parser DataConstructorName
17−dataConstructorNameP = capitalizedIdentifier
18−
12+
1913-- | Upper case names are type names while lower case names are polymorphic typeconstructor arguments.
2014-- data *Either a b* = Left a | Right b
2115typeConstructorDefP :: Parser TypeConstructorDef
22−typeConstructorDefP = ADTypeConstructorDef <$> typeConstructorNameP <*> typeVarNamesP
16+typeConstructorDefP = ADTypeConstructorDef <$> capitalizedIdentifier <*> typeVarNamesP
2317
2418typeVarNamesP :: Parser [TypeVarName]
2519typeVarNamesP = many uncapitalizedIdentifier
2620
2721-- data Either a b = *Left a* | *Right b*
2822dataConstructorDefP :: Parser DataConstructorDef
29−dataConstructorDefP = DataConstructorDef <$> typeConstructorNameP <*> many dataConstructorDefArgP
23+dataConstructorDefP = DataConstructorDef <$> capitalizedIdentifier <*> many dataConstructorDefArgP
3024
3125-- data *Either a b* = Left *a* | Right *b*
3226dataConstructorDefArgP :: Parser DataConstructorDefArg
@@ -53,7 +47,7 @@ typeConstructorP = relationTypeConstructorP <|>
5347 monoTypeConstructorP
5448
5549monoTypeConstructorP :: Parser TypeConstructor
56−monoTypeConstructorP = ADTypeConstructor <$> typeConstructorNameP <*> pure [] <|>
50+monoTypeConstructorP = ADTypeConstructor <$> capitalizedIdentifier <*> pure [] <|>
5751 TypeVariable <$> uncapitalizedIdentifier
5852
5953
src/bin/TutorialD/Printer.hsdeleted−165
@@ -1,165 +0,0 @@
1−{-# OPTIONS_GHC -fno-warn-orphans #-}
2−{-# LANGUAGE FlexibleInstances #-}
3−{-# LANGUAGE OverloadedStrings #-}
4−{-# LANGUAGE ScopedTypeVariables #-}
5−{-# LANGUAGE TypeApplications #-}
6−module TutorialD.Printer where
7−import ProjectM36.Base
8−import ProjectM36.Attribute as A hiding (null)
9−import Data.Text.Prettyprint.Doc
10−import qualified Data.Set as S hiding (fromList)
11−import qualified Data.Vector as V
12−import qualified Data.Map.Strict as M
13−import Data.Time.Calendar
14−import Data.Time.Clock.POSIX
15−import qualified Data.ByteString.Base64 as B64
16−import qualified Data.Text.Encoding as TE
17−
18−instance Pretty Atom where
19− pretty (IntegerAtom x) = pretty x
20− pretty (IntAtom x) = "int" <> parensList [pretty x]
21− pretty (DoubleAtom x) = pretty x
22− pretty (TextAtom x) = dquotes (pretty x)
23− pretty (DayAtom x) = "fromGregorian" <> parensList [pretty a, pretty b, pretty c]
24− where
25− (a,b,c) = toGregorian x
26− pretty (DateTimeAtom time) = "dateTimeFromEpochSeconds" <> parensList [pretty @Integer (round (utcTimeToPOSIXSeconds time))]
27− pretty (ByteStringAtom bs) = "bytestring" <> parensList [dquotes (pretty (TE.decodeUtf8 (B64.encode bs)))]
28− pretty (BoolAtom x) = if x then "t" else "f"
29− pretty (RelationAtom x) = pretty x
30− pretty (RelationalExprAtom re) = pretty re
31− pretty (ConstructedAtom n _ as) = pretty n <+> prettyList as
32−
33−instance Pretty AtomExpr where
34− pretty (AttributeAtomExpr attrName) = pretty attrName
35− pretty (NakedAtomExpr atom) = pretty atom
36− pretty (FunctionAtomExpr atomFuncName' atomExprs _) = pretty atomFuncName' <> prettyAtomExprsAsArguments atomExprs
37− pretty (RelationAtomExpr relExpr) = pretty relExpr
38− pretty (ConstructedAtomExpr dName [] _) = pretty dName
39− pretty (ConstructedAtomExpr dName atomExprs _) = pretty dName <+> hsep (map prettyAtomExpr atomExprs)
40−
41−prettyAtomExpr :: AtomExpr -> Doc ann
42−prettyAtomExpr atomExpr =
43− case atomExpr of
44− AttributeAtomExpr attrName -> "@" <> pretty attrName
45− ConstructedAtomExpr dConsName [] () -> pretty dConsName
46− ConstructedAtomExpr dConsName atomExprs () -> parens (pretty dConsName <+> hsep (map prettyAtomExpr atomExprs))
47− _ -> pretty atomExpr
48−
49−prettyAtomExprsAsArguments :: [AtomExpr] -> Doc ann
50−prettyAtomExprsAsArguments = align . parensList . map addAt
51− where addAt (atomExpr :: AtomExpr) =
52− case atomExpr of
53− AttributeAtomExpr attrName -> "@" <> pretty attrName
54− _ -> pretty atomExpr
55−
56−instance Pretty TupleExpr where
57− pretty (TupleExpr map') = "tuple" <> bracesList (Prelude.map (\(attrName,atom)-> pretty attrName <+> pretty atom) (M.toList map'))
58−
59−instance Pretty RelationTuple where
60− pretty (RelationTuple attrs atoms) = "tuple" <> bracesList (zipWith (\x y-> pretty x <+> pretty y) (V.toList (attributeNames attrs)) (V.toList atoms))
61−
62−instance Pretty Relation where
63− pretty (Relation attrs tupSet) | attrs == mempty && null (asList tupSet) = "false"
64− pretty (Relation attrs tupSet) | attrs == mempty && asList tupSet == [RelationTuple mempty mempty] = "true"
65− pretty (Relation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)
66−
67−instance Pretty Attribute where
68− pretty (Attribute n aTy) = pretty n <+> pretty (show aTy) -- workaround
69−
70−instance Pretty RelationalExpr where
71− pretty (RelationVariable n _) = pretty n
72− pretty (ExistingRelation r) = pretty r
73− pretty (NotEquals a b) = pretty' a <+> "!=" <+> pretty' b
74− pretty (Equals a b) = pretty' a <+> "==" <+> pretty' b
75− pretty (Project ns r) = pretty' (ignoreProjects r) <> pretty ns
76− pretty (Extend ext r) = collectExtends r <> pretty ext <> "}"
77− pretty (MakeRelationFromExprs Nothing (TupleExprs () tupExprs)) = "relation" <> prettyBracesList tupExprs
78− pretty (MakeRelationFromExprs (Just attrExprs) (TupleExprs () tupExprs)) = "relation" <> prettyBracesList attrExprs <> prettyBracesList tupExprs
79− pretty (MakeStaticRelation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)
80− pretty (Union a b) = parens $ pretty' a <+> "union" <+> pretty' b
81− pretty (Join a b) = parens $ pretty' a <+> "join" <+> pretty' b
82− pretty (Rename n1 n2 relExpr) = parens $ pretty relExpr <+> "rename" <+> braces (pretty n1 <+> "as" <+> pretty n2)
83− pretty (Difference a b) = parens $ pretty' a <+> "minus" <+> pretty' b
84− pretty (Group attrNames attrName relExpr) = parens $ pretty relExpr <+> "group" <+> parens (pretty attrNames <+> "as" <+> pretty attrName)
85− pretty (Ungroup attrName relExpr) = parens $ pretty' relExpr <+> "ungroup" <+> pretty attrName
86− pretty (Restrict resPreExpr relExpr) = parens $ pretty' relExpr <+> "where" <+> pretty resPreExpr
87− pretty (With pairs a) = "with" <+> parensList (map (\(name,expr)-> pretty name <+> "as" <+> pretty expr) pairs) <+> pretty' a
88−
89−-- relvar:{a:=?}:{b:=?}:... in ADTs => relvar:{a:=?, b:=?, ...} in Doc ann
90−collectExtends :: RelationalExpr -> Doc ann
91−collectExtends (Extend ext r) = collectExtends r <> pretty ext <> ", "
92−collectExtends r = pretty r <> ":{"
93−
94−--relvar{a,b,c,...}{a,b,...}..{a} => relvar{a}
95−ignoreProjects :: RelationalExpr -> RelationalExpr
96−ignoreProjects (Project _ r) = ignoreProjects r
97−ignoreProjects r = r
98−
99−prettyRelationalExpr :: RelationalExpr -> Doc n
100−prettyRelationalExpr (RelationVariable n _) = pretty n
101−prettyRelationalExpr r = parens (pretty r)
102−
103−pretty' :: RelationalExpr -> Doc n
104−pretty' = prettyRelationalExpr
105−
106−instance Pretty AttributeNames where
107− pretty (AttributeNames attrNames) = prettyBracesList (S.toList attrNames)
108− pretty (InvertedAttributeNames attrNames) = braces $ "all but" <+> concatWith (surround ", ") (map pretty (S.toList attrNames))
109− pretty (RelationalExprAttributeNames relExpr) = braces $ "all from" <+> pretty relExpr
110− pretty (UnionAttributeNames aAttrNames bAttrNames) = braces ("union of" <+> pretty aAttrNames <+> pretty bAttrNames)
111− pretty (IntersectAttributeNames aAttrNames bAttrNames) = braces ("intersection of" <+> pretty aAttrNames <+> pretty bAttrNames)
112−
113−instance Pretty AttributeExpr where
114− pretty (NakedAttributeExpr attr) = pretty attr
115− pretty (AttributeAndTypeNameExpr name typeCons _) = pretty name <+> pretty typeCons
116−
117−instance Pretty TypeConstructor where
118− pretty (ADTypeConstructor tcName []) = pretty tcName
119− pretty (ADTypeConstructor tcName tConsArgs) = pretty tcName <+> hsep (map pretty tConsArgs)
120− pretty (PrimitiveTypeConstructor tcName atomType') = pretty tcName <+> pretty atomType'
121− pretty (RelationAtomTypeConstructor attrExprs) = "relation" <> prettyBracesList attrExprs
122− pretty (TypeVariable x) = pretty x
123−
124−instance Pretty AtomType where
125− pretty IntAtomType = "Int"
126− pretty IntegerAtomType = "Integer"
127− pretty DoubleAtomType = "Double"
128− pretty TextAtomType = "Text"
129− pretty DayAtomType = "Day"
130− pretty DateTimeAtomType = "DateTime"
131− pretty ByteStringAtomType = "ByteString"
132− pretty BoolAtomType = "Bool"
133− pretty (RelationAtomType attrs) = "relation " <+> prettyBracesList (A.toList attrs)
134− pretty (ConstructedAtomType tcName tvMap) = pretty tcName <+> hsep (map pretty (M.toList tvMap)) --order matters
135− pretty RelationalExprAtomType = "RelationalExpr"
136− pretty (TypeVariableType x) = pretty x
137−
138−instance Pretty ExtendTupleExpr where
139− pretty (AttributeExtendTupleExpr attrName atomExpr) = pretty attrName <> ":=" <> pretty atomExpr
140−
141−
142−instance Pretty RestrictionPredicateExpr where
143− pretty TruePredicate = "true"
144− pretty (AndPredicate a b) = pretty a <+> "and" <+> pretty b
145− pretty (OrPredicate a b) = pretty a <+> "or" <+> pretty b
146− pretty (NotPredicate a) = "not" <+> pretty a
147− pretty (RelationalExprPredicate relExpr) = pretty relExpr
148− pretty (AtomExprPredicate atomExpr) = pretty atomExpr
149− pretty (AttributeEqualityPredicate attrName atomExpr) = pretty attrName <> "=" <> pretty atomExpr
150−
151−instance Pretty WithNameExpr where
152− pretty (WithNameExpr name _) = pretty name
153−
154−bracesList :: [Doc ann] -> Doc ann
155−bracesList = group . encloseSep (flatAlt "{ " "{") (flatAlt " }" "}") ", "
156−
157−prettyBracesList :: Pretty a => [a] -> Doc ann
158−prettyBracesList = align . bracesList . map pretty
159−
160−parensList :: [Doc ann] -> Doc ann
161−parensList = group . encloseSep (flatAlt "( " "(") (flatAlt " )" ")") ", "
162−
163−prettyParensList :: Pretty a => [a] -> Doc ann
164−prettyParensList = align . parensList . map pretty
165−
src/bin/TutorialD/tutd.hs+19−15
@@ -5,11 +5,9 @@ import ProjectM36.Client
55import ProjectM36.Server.ParseArgs
66import ProjectM36.Server
77import System.IO
8−import GHC.IO.Encoding
98import Options.Applicative
109import System.Exit
11−import Control.Monad
12−#if __GLASGOW_HASKELL__ < 804
10+#if __GLASGOW_HASKELL__ <= 802
1311import Data.Monoid
1412#endif
1513import Data.Maybe
@@ -22,7 +20,7 @@ import qualified Data.Text as T
2220
2321parseArgs :: Parser InterpreterConfig
2422parseArgs = LocalInterpreterConfig <$> parsePersistenceStrategy <*> parseHeadName <*> parseTutDExec <*> many parseGhcPkgPath <*> parseCheckFS <|>
25− RemoteInterpreterConfig <$> parseHostname "127.0.0.1" <*> parsePort defaultServerPort <*> parseDatabaseName <*> parseHeadName <*> parseTutDExec <*> parseCheckFS
23+ RemoteInterpreterConfig <$> parseNodeId <*> parseDatabaseName <*> parseHeadName <*> parseTutDExec <*> parseCheckFS
2624
2725parseHeadName :: Parser HeadName
2826parseHeadName = option auto (long "head" <>
@@ -31,6 +29,19 @@ parseHeadName = option auto (long "head" <>
3129 value "master"
3230 )
3331
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+
3445--just execute some tutd and exit
3546parseTutDExec :: Parser (Maybe TutorialDExec)
3647parseTutDExec = optional $ strOption (long "exec-tutd" <>
@@ -44,19 +55,19 @@ opts = info (parseArgs <**> helpOption) idm
4455
4556connectionInfoForConfig :: InterpreterConfig -> ConnectionInfo
4657connectionInfoForConfig (LocalInterpreterConfig pStrategy _ _ ghcPkgPaths _) = InProcessConnectionInfo pStrategy outputNotificationCallback ghcPkgPaths
47−connectionInfoForConfig (RemoteInterpreterConfig remoteHost remotePort remoteDBName _ _ _) = RemoteConnectionInfo remoteDBName remoteHost (show remotePort) outputNotificationCallback
58+connectionInfoForConfig (RemoteInterpreterConfig remoteNodeId remoteDBName _ _ _) = RemoteProcessConnectionInfo remoteDBName remoteNodeId outputNotificationCallback
4859
4960headNameForConfig :: InterpreterConfig -> HeadName
5061headNameForConfig (LocalInterpreterConfig _ headn _ _ _) = headn
51−headNameForConfig (RemoteInterpreterConfig _ _ _ headn _ _) = headn
62+headNameForConfig (RemoteInterpreterConfig _ _ headn _ _) = headn
5263
5364execTutDForConfig :: InterpreterConfig -> Maybe String
5465execTutDForConfig (LocalInterpreterConfig _ _ t _ _) = t
55−execTutDForConfig (RemoteInterpreterConfig _ _ _ _ t _) = t
66+execTutDForConfig (RemoteInterpreterConfig _ _ _ t _) = t
5667
5768checkFSForConfig :: InterpreterConfig -> Bool
5869checkFSForConfig (LocalInterpreterConfig _ _ _ _ c) = c
59−checkFSForConfig (RemoteInterpreterConfig _ _ _ _ _ c) = c
70+checkFSForConfig (RemoteInterpreterConfig _ _ _ _ c) = c
6071
6172persistenceStrategyForConfig :: InterpreterConfig -> Maybe PersistenceStrategy
6273persistenceStrategyForConfig (LocalInterpreterConfig strat _ _ _ _) = Just strat
@@ -75,15 +86,8 @@ printWelcome = do
7586 putStrLn "A full tutorial is available at:"
7687 putStrLn "https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown"
7788
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−
8489main :: IO ()
8590main = do
86− setLocaleIfNecessary
8791 interpreterConfig <- execParser opts
8892 let connInfo = connectionInfoForConfig interpreterConfig
8993 fscheck <- checkFSType (checkFSForConfig interpreterConfig) (fromMaybe NoPersistence (persistenceStrategyForConfig interpreterConfig))
src/bin/benchmark/Handles.hs+14−25
@@ -6,15 +6,13 @@ import Options.Applicative
66import TutorialD.Interpreter
77import TutorialD.Interpreter.Base hiding (Parser, option)
88import qualified Data.Text as T
9−#if __GLASGOW_HASKELL__ < 804
109import Data.Monoid
11−#endif
1210import Control.Monad
1311
1412data HandlesArgs = HandlesArgs {
1513 openCloseCount :: Int,
1614 transactionCount :: Int,
17− dbdir :: FilePath,
15+ dbdir :: FilePath,
1816 tutdSetup :: String,
1917 tutdIterate :: String
2018 }
@@ -40,13 +38,13 @@ parseTutdIterate = strOption (short 'i' <> long "iterate-tutd" <> value "update
4038main :: IO ()
4139main = do
4240 args <- execParser $ info (helper <*> parseArgs) fullDesc
43− replicateM_ (openCloseCount args) (runOpenClose
41+ replicateM_ (openCloseCount args) (runOpenClose
4442 (T.pack (tutdSetup args))
4543 (T.pack (tutdIterate args))
46− (transactionCount args)
44+ (transactionCount args)
4745 (dbdir args))
48−
49−runOpenClose :: T.Text -> T.Text -> Int -> FilePath -> IO ()
46+
47+runOpenClose :: T.Text -> T.Text -> Int -> FilePath -> IO ()
5048runOpenClose tutdSetup' tutdIterate' tCount dbdir' = do
5149 let connInfo = InProcessConnectionInfo (MinimalPersistence dbdir') emptyNotificationCallback []
5250 eConn <- connectProjectM36 connInfo
@@ -56,7 +54,7 @@ runOpenClose tutdSetup' tutdIterate' tCount dbdir' = do
5654 eSess <- createSessionAtHead conn "master"
5755 case eSess of
5856 Left err -> error (show err)
59− Right session ->
57+ Right session ->
6058 --database setup
6159 case parseTutorialD tutdSetup' of
6260 Left err -> error (show err)
@@ -64,19 +62,14 @@ runOpenClose tutdSetup' tutdIterate' tCount dbdir' = do
6462 res <- evalTutorialD session conn UnsafeEvaluation parsed
6563 case res of
6664 DisplayErrorResult err -> error (T.unpack err)
67− DisplayParseErrorResult _ err ->
68−#if MIN_VERSION_megaparsec(7,0,0)
69− error (errorBundlePretty err)
70−#else
71− error (parseErrorPretty err)
72−#endif
73− _ -> do
65+ DisplayParseErrorResult _ err -> error (parseErrorPretty err)
66+ _ -> do
7467 replicateM_ tCount (runTransaction tutdIterate' session conn)
7568 close conn
7669 printFdCount
77−
70+
7871runTransaction :: T.Text -> SessionId -> Connection -> IO ()
79−runTransaction tutdIterate' sess conn =
72+runTransaction tutdIterate' sess conn =
8073 --run tutd on every iteration
8174 case parseTutorialD tutdIterate' of
8275 Left err -> error (show err)
@@ -84,14 +77,10 @@ runTransaction tutdIterate' sess conn =
8477 res <- evalTutorialD sess conn UnsafeEvaluation parsed
8578 case res of
8679 DisplayErrorResult err -> error (T.unpack err)
87− DisplayParseErrorResult _ err ->
88−#if MIN_VERSION_megaparsec(7,0,0)
89− error (errorBundlePretty err)
90−#else
91− error (parseErrorPretty err)
92−#endif
93− _ -> do
94− eErr <- commit sess conn
80+ DisplayParseErrorResult _ err -> error (parseErrorPretty err)
81+ _ -> do
82+ eErr <- commit sess conn
9583 case eErr of
9684 Left err -> error (show err)
9785 Right _ -> printFdCount
86+
src/bin/benchmark/bigrel.hs+7−8
@@ -1,4 +1,4 @@
1−{-# LANGUAGE FlexibleInstances, CPP #-}
1+{-# LANGUAGE FlexibleInstances #-}
22{-# OPTIONS_GHC -fno-warn-orphans #-}
33import ProjectM36.Base
44import ProjectM36.Relation
@@ -9,6 +9,7 @@ import qualified ProjectM36.Attribute as A
99import qualified Data.Text as T
1010--import ProjectM36.Relation.Show.CSV
1111import ProjectM36.Relation.Show.HTML
12+import TutorialD.Interpreter.DatabaseContextExpr (interpretDatabaseContextExpr)
1213import ProjectM36.RelationalExpression
1314import ProjectM36.TransactionGraph
1415--import qualified Data.HashSet as HS
@@ -17,16 +18,16 @@ import ProjectM36.TransactionGraph
1718--import qualified Data.Hashable as Hash
1819import qualified Data.Vector as V
1920import Options.Applicative
21+import qualified Data.Map as M
2022import qualified Data.Text.IO as TIO
2123import System.IO
24+import Control.Monad.State
2225import Control.DeepSeq
2326import Data.Text hiding (map)
27+import Data.Monoid
2428import Data.Time.Clock
29+import Data.UUID
2530import Data.UUID.V4
26−#if __GLASGOW_HASKELL__ < 804
27−import Data.Monoid
28−#endif
29−
3031
3132{-
3233dumpcsv :: Relation -> IO ()
@@ -75,9 +76,7 @@ matrixRun (BigrelArgs attributeCount tupleCount tutd) =
7576 case eNewState of
7677 Right newState -> do
7778 let ctx = dbc_context newState
78− Right x = optimizeAndEvalRelationalExpr env' (RelationVariable "x" ())
79− env' = RelationalExprEnv ctx graph Nothing
80− TIO.putStrLn $ relationAsHTML x
79+ TIO.putStrLn $ relationAsHTML (relationVariables ctx M.! "x")
8180 Left err -> hPrint stderr err
8281
8382{-
src/lib/ProjectM36/Arbitrary.hs+1−6
@@ -9,7 +9,6 @@ import ProjectM36.AtomType
99import ProjectM36.Attribute (atomType)
1010import ProjectM36.DataConstructorDef as DCD
1111import ProjectM36.DataTypes.Interval
12−import ProjectM36.Relation
1312import qualified Data.Vector as V
1413import Data.Text (Text)
1514import Test.QuickCheck
@@ -49,10 +48,6 @@ arbitrary' ByteStringAtomType =
4948
5049arbitrary' BoolAtomType =
5150 Right . BoolAtom <$> lift (arbitrary :: Gen Bool)
52−
53−arbitrary' RelationalExprAtomType =
54− pure (Right (RelationalExprAtom (ExistingRelation relationTrue))) -- don't bother with arbitrary relational expressions
55−
5651arbitrary' constructedAtomType@(ConstructedAtomType tcName tvMap)
5752 --special-casing for Interval type
5853 | isIntervalAtomType constructedAtomType = createArbitraryInterval (intervalSubType constructedAtomType)
@@ -84,7 +79,7 @@ maybeToRight y Nothing = Left y
8479arbitraryRelationTuple :: Attributes -> WithTCMap Gen (Either RelationalError RelationTuple)
8580arbitraryRelationTuple attris = do
8681 tcMap <- ask
87− listOfMaybeAType <- lift $ mapM ((\aTy -> runReaderT (arbitrary' aTy) tcMap) . atomType) (V.toList (attributesVec attris))
82+ listOfMaybeAType <- lift $ mapM ((\aTy -> runReaderT (arbitrary' aTy) tcMap) . atomType) (V.toList attris)
8883 case sequence listOfMaybeAType of
8984 Left err -> pure $ Left err
9085 Right listOfAttr -> do
src/lib/ProjectM36/Atom.hs+1−2
@@ -3,7 +3,7 @@ import ProjectM36.Base
33import ProjectM36.Error
44import ProjectM36.DataTypes.Interval
55import qualified Data.Text as T
6−#if __GLASGOW_HASKELL__ < 804
6+#if __GLASGOW_HASKELL__ <= 802
77import Data.Monoid
88#endif
99
@@ -20,7 +20,6 @@ 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
2423
2524atomToText (RelationAtom i) = (T.pack . show) i
2625atomToText (ConstructedAtom dConsName typ atoms)
src/lib/ProjectM36/AtomFunction.hs+2−19
@@ -1,7 +1,5 @@
1−{-# LANGUAGE CPP #-}
21module ProjectM36.AtomFunction where
32import ProjectM36.Base
4−import ProjectM36.Serialise.Base ()
53import ProjectM36.Error
64import ProjectM36.Relation
75import ProjectM36.AtomType
@@ -10,8 +8,7 @@ import ProjectM36.ScriptSession
108import qualified ProjectM36.Attribute as A
119import qualified Data.HashSet as HS
1210import qualified Data.Text as T
13−import qualified Data.ByteString.Lazy as BL
14−import Codec.Winery
11+
1512
1613foldAtomFuncType :: AtomType -> AtomType -> [AtomType]
1714--the underscore in the attribute name means that any attributes are acceptable
@@ -75,11 +72,7 @@ createScriptedAtomFunction funcName argsType retType = AddAtomFunction funcName
7572 retType]])
7673
7774loadAtomFunctions :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError [AtomFunction])
78−#ifdef PM36_HASKELL_SCRIPTING
7975loadAtomFunctions = loadFunction
80−#else
81−loadAtomFunctions _ _ _ = pure (Left LoadSymbolError)
82−#endif
8376
8477atomFunctionsAsRelation :: AtomFunctions -> Either RelationalError Relation
8578atomFunctionsAsRelation funcs = mkRelationFromList attrs tups
@@ -88,14 +81,4 @@ atomFunctionsAsRelation funcs = mkRelationFromList attrs tups
8881 Attribute "arguments" TextAtomType]
8982 atomFuncToTuple aFunc = [TextAtom (atomFuncName aFunc),
9083 TextAtom (atomFuncTypeToText aFunc)]
91− 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
84+ atomFuncTypeToText aFunc = T.intercalate " -> " (map prettyAtomType (atomFuncType aFunc))
src/lib/ProjectM36/AtomFunctionError.hs+2−1
@@ -1,5 +1,6 @@
11{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}
22module ProjectM36.AtomFunctionError where
3+import Data.Binary
34import GHC.Generics
45import Control.DeepSeq
56import Data.Text
@@ -13,5 +14,5 @@ data AtomFunctionError = AtomFunctionUserError String |
1314 AtomTypeDoesNotSupportOrderingError Text |
1415 AtomTypeDoesNotSupportIntervalError Text |
1516 AtomFunctionBytesDecodingError String
16− deriving(Generic, Eq, Show, NFData)
17+ deriving(Generic, Eq, Show, Binary, NFData)
1718
src/lib/ProjectM36/AtomType.hs+14−86
@@ -139,37 +139,14 @@ resolveAttributeExprTypeVars (AttributeAndTypeNameExpr _ tCons _) aType tConsMap
139139
140140-- check that type vars on the right also appear on the left
141141-- check that the data constructor names are unique
142−validateTypeConstructorDef :: TypeConstructorDef -> [DataConstructorDef] -> TypeConstructorMapping -> Either RelationalError ()
143−validateTypeConstructorDef tConsDef dConsList tConsMap = do
142+validateTypeConstructorDef :: TypeConstructorDef -> [DataConstructorDef] -> [RelationalError]
143+validateTypeConstructorDef tConsDef dConsList = execWriter $ do
144144 let duplicateDConsNames = dupes (L.sort (map DCD.name dConsList))
145− unless (null duplicateDConsNames) (Left (someErrors (map DataConstructorNameInUseError duplicateDConsNames)))
145+ mapM_ tell [map DataConstructorNameInUseError duplicateDConsNames]
146146 let leftSideVars = S.fromList (TCD.typeVars tConsDef)
147147 rightSideVars = S.unions (map DCD.typeVars dConsList)
148148 varsDiff = S.difference leftSideVars rightSideVars
149− when (S.size varsDiff > 0) (Left (someErrors (map DataConstructorUsesUndeclaredTypeVariable (S.toList varsDiff))))
150− mapM_ (\dConsDef -> validateDataConstructorDef dConsDef tConsDef tConsMap) dConsList
151−
152−--check that the data constructor names are not in use (recursively)
153−validateDataConstructorDef :: DataConstructorDef -> TypeConstructorDef -> TypeConstructorMapping -> Either RelationalError ()
154−validateDataConstructorDef (DataConstructorDef dConsName dConsDefArgs) tConsDef tConsMap =
155− case findDataConstructor dConsName tConsMap of
156− Just _ -> Left (DataConstructorNameInUseError dConsName)
157− Nothing ->
158− mapM_ (\arg -> validateDataConstructorDefArg arg tConsDef tConsMap) dConsDefArgs
159−
160−
161−validateDataConstructorDefArg :: DataConstructorDefArg -> TypeConstructorDef -> TypeConstructorMapping -> Either RelationalError ()
162−validateDataConstructorDefArg (DataConstructorDefTypeConstructorArg (PrimitiveTypeConstructor _ _)) _ _ = Right ()
163−validateDataConstructorDefArg (DataConstructorDefTypeConstructorArg (TypeVariable _)) _ _ = Right ()
164−validateDataConstructorDefArg (DataConstructorDefTypeConstructorArg tCons) tConsDef tConsMap = case findTypeConstructor (TC.name tCons) tConsMap of
165− Nothing ->
166− when (TC.name tCons /= TCD.name tConsDef) (Left (NoSuchTypeConstructorName (TC.name tCons))) --allows for recursively-defined types
167− Just (ADTypeConstructorDef _ tConsArgs, _) -> do --validate that the argument count matches- type matching can occur later
168− let existingCount = length tConsArgs
169− newCount = length (TC.arguments tCons)
170− when (newCount /= existingCount) (Left (ConstructedAtomArgumentCountMismatchError existingCount newCount))
171− Just (PrimitiveTypeConstructorDef _ _, _) -> pure ()
172−validateDataConstructorDefArg (DataConstructorDefTypeVarNameArg _) _ _ = Right ()
149+ mapM_ tell [map DataConstructorUsesUndeclaredTypeVariable (S.toList varsDiff)]
173150
174151atomTypeForTypeConstructor :: TypeConstructor -> TypeConstructorMapping -> TypeVarMap -> Either RelationalError AtomType
175152atomTypeForTypeConstructor = atomTypeForTypeConstructorValidate False
@@ -211,7 +188,7 @@ isValidAtomTypeForTypeConstructor (ConstructedAtomType tConsName _) (ADTypeConst
211188
212189isValidAtomTypeForTypeConstructor (RelationAtomType attrs) (RelationAtomTypeConstructor attrExprs) tConsMap = do
213190 evaldAtomTypes <- mapM (\expr -> atomTypeForAttributeExpr expr tConsMap M.empty) attrExprs
214− mapM_ (uncurry resolveAtomType) (zip (A.atomTypesList attrs) evaldAtomTypes)
191+ mapM_ (uncurry resolveAtomType) (zip (map A.atomType (V.toList attrs)) evaldAtomTypes)
215192isValidAtomTypeForTypeConstructor aType tCons _ = Left (AtomTypeTypeConstructorReconciliationError aType (TC.name tCons))
216193
217194findTypeConstructor :: TypeConstructorName -> TypeConstructorMapping -> Maybe (TypeConstructorDef, [DataConstructorDef])
@@ -221,18 +198,10 @@ findTypeConstructor name = foldr tConsFolder Nothing
221198 Just (tCons, dConsList)
222199 else
223200 accum
224−
225−resolveAttributes :: Attribute -> Attribute -> Either RelationalError Attribute
226−resolveAttributes attrA attrB =
227− if A.attributeName attrA /= A.attributeName attrB then
228− Left $ AttributeNamesMismatchError (S.fromList (map A.attributeName [attrA, attrB]))
229− else
230− Attribute (A.attributeName attrA) <$> resolveAtomType (A.atomType attrA) (A.atomType attrB)
231−
232−--given two atom types, try to resolve type variables
201+
233202resolveAtomType :: AtomType -> AtomType -> Either RelationalError AtomType
234203resolveAtomType (ConstructedAtomType tConsName resolvedTypeVarMap) (ConstructedAtomType _ unresolvedTypeVarMap) =
235− ConstructedAtomType tConsName <$> resolveAtomTypesInTypeVarMap resolvedTypeVarMap unresolvedTypeVarMap
204+ ConstructedAtomType tConsName <$> resolveAtomTypesInTypeVarMap resolvedTypeVarMap unresolvedTypeVarMap
236205resolveAtomType typeFromRelation unresolvedType = if typeFromRelation == unresolvedType then
237206 Right typeFromRelation
238207 else
@@ -260,16 +229,12 @@ resolveAtomTypesInTypeVarMap resolvedTypeMap unresolvedTypeMap = do
260229 let resolveTypePair resKey resType =
261230 -- if the key is missing in the unresolved type map, then fill it in with the value from the resolved map
262231 case M.lookup resKey unresolvedTypeMap of
263− Just unresType -> case unresType of
232+ Just unresType -> case unresType of
264233 --do we need to recurse for RelationAtomType?
265234 subType@(ConstructedAtomType _ _) -> do
266235 resSubType <- resolveAtomType resType subType
267236 pure (resKey, resSubType)
268− TypeVariableType _ -> pure (resKey, resType)
269− typ -> if typ == resType then
270− pure (resKey, resType)
271− else
272− Left $ AtomTypeMismatchError typ resType
237+ _ -> pure (resKey, resType)
273238 Nothing ->
274239 pure (resKey, resType) --swipe the missing type var from the expected map
275240 tVarList <- mapM (uncurry resolveTypePair) (M.toList resolvedTypeMap)
@@ -295,7 +260,7 @@ resolveTypeInAtom _ atom _ = Right atom
295260-- 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.
296261resolveTypesInTuple :: Attributes -> TypeConstructorMapping -> RelationTuple -> Either RelationalError RelationTuple
297262resolveTypesInTuple resolvedAttrs tConss (RelationTuple _ tupAtoms) = do
298− newAtoms <- mapM (\(atom, resolvedType) -> resolveTypeInAtom resolvedType atom tConss) (zip (V.toList tupAtoms) $ A.atomTypesList resolvedAttrs)
263+ newAtoms <- mapM (\(atom, resolvedType) -> resolveTypeInAtom resolvedType atom tConss) (zip (V.toList tupAtoms) $ map A.atomType (V.toList resolvedAttrs))
299264 Right (RelationTuple resolvedAttrs (V.fromList newAtoms))
300265
301266-- | Validate that the type is provided with complete type variables for type constructors.
@@ -314,19 +279,10 @@ validateAtomType typ@(ConstructedAtomType tConsName tVarMap) tConss =
314279 _ -> Right ()
315280validateAtomType (RelationAtomType attrs) tConss =
316281 mapM_ (\attr ->
317− validateAtomType (A.atomType attr) tConss) (attributesVec attrs)
282+ validateAtomType (A.atomType attr) tConss) (V.toList attrs)
318283validateAtomType (TypeVariableType x) _ = Left (TypeConstructorTypeVarMissing x)
319284validateAtomType _ _ = pure ()
320285
321−validateAttributes :: TypeConstructorMapping -> Attributes -> Either RelationalError ()
322−validateAttributes tConss attrs =
323− if not (null errs) then
324− Left (someErrors errs)
325− else
326− pure ()
327− where
328− errs = lefts $ map (`validateAtomType` tConss) (A.atomTypesList attrs)
329−
330286--ensure that all type vars are fully resolved
331287validateTypeVarMap :: TypeVarMap -> TypeConstructorMapping -> Either RelationalError ()
332288validateTypeVarMap tvMap tConss = mapM_ (`validateAtomType` tConss) $ M.elems tvMap
@@ -358,7 +314,7 @@ atomTypeVerify x@(RelationAtomType attrs1) y@(RelationAtomType attrs2) = do
358314 if notElem "_" [name1, name2] && name1 /= name2 then
359315 Left $ AtomTypeMismatchError x y
360316 else
361− atomTypeVerify (A.atomType attr1) (A.atomType attr2)) $ V.toList (V.zip (attributesVec attrs1) (attributesVec attrs2))
317+ atomTypeVerify (A.atomType attr1) (A.atomType attr2)) $ V.toList (V.zip attrs1 attrs2)
362318 return x
363319atomTypeVerify x y = if x == y then
364320 Right x
@@ -367,15 +323,10 @@ atomTypeVerify x y = if x == y then
367323
368324-- | Determine if two typeVars are logically compatible.
369325typeVarMapsVerify :: TypeVarMap -> TypeVarMap -> Bool
370−typeVarMapsVerify a b = M.keysSet a == M.keysSet b && (length . rights) zipped == M.size a
371− where
372− zipped = zipWith
373− (curry (\ ((_, v1), (_, v2)) -> atomTypeVerify v1 v2))
374− (M.toAscList a)
375− (M.toAscList b)
326+typeVarMapsVerify a b = M.keysSet a == M.keysSet b && (length . rights) (map (\((_,v1),(_,v2)) -> atomTypeVerify v1 v2) (zip (M.toAscList a) (M.toAscList b))) == M.size a
376327
377328prettyAtomType :: AtomType -> T.Text
378−prettyAtomType (RelationAtomType attrs) = "relation {" `T.append` T.intercalate "," (map prettyAttribute (V.toList (attributesVec attrs))) `T.append` "}"
329+prettyAtomType (RelationAtomType attrs) = "relation {" `T.append` T.intercalate "," (map prettyAttribute (V.toList attrs)) `T.append` "}"
379330prettyAtomType (ConstructedAtomType tConsName typeVarMap) = tConsName `T.append` T.concat (map showTypeVars (M.toList typeVarMap))
380331 where
381332 showTypeVars (_, TypeVariableType x) = " " <> x
@@ -431,26 +382,3 @@ resolvedAtomTypeForDataConstructorDefArg _ tvMap (DataConstructorDefTypeVarNameA
431382 Nothing -> Left (DataConstructorUsesUndeclaredTypeVariable tvName)
432383 Just typ -> Right typ
433384
434−isResolvedType :: AtomType -> Bool
435−isResolvedType typ =
436− case typ of
437− IntAtomType -> True
438− IntegerAtomType -> True
439− DoubleAtomType -> True
440− TextAtomType -> True
441− DayAtomType -> True
442− DateTimeAtomType -> True
443− ByteStringAtomType -> True
444− BoolAtomType -> True
445− RelationalExprAtomType -> True
446− RelationAtomType attrs -> isResolvedAttributes attrs
447− ConstructedAtomType _ tvMap -> all isResolvedType (M.elems tvMap)
448− TypeVariableType _ -> False
449−
450−isResolvedAttributes :: Attributes -> Bool
451−isResolvedAttributes attrs = all isResolvedAttribute (V.toList (attributesVec attrs))
452−
453−isResolvedAttribute :: Attribute -> Bool
454−isResolvedAttribute = isResolvedType . A.atomType
455−
456−--given two AtomTypes x,y
src/lib/ProjectM36/Atomable.hs+49−33
@@ -13,16 +13,29 @@ import qualified Data.Map as M
1313import qualified Data.Text as T
1414import qualified Data.Vector as V
1515import Control.DeepSeq (NFData)
16+import Data.Binary
1617import Control.Applicative
1718import Data.Time.Calendar
1819import Data.ByteString (ByteString)
1920import Data.Time.Clock
2021import Data.Proxy
2122import 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+-}
2437-- | All database values ("atoms") adhere to the 'Atomable' typeclass. This class is derivable allowing new datatypes to be easily marshaling between Haskell values and database values.
25−class (Eq a, NFData a, Serialise a, Show a) => Atomable a where
38+class (Eq a, NFData a, Binary a, Show a) => Atomable a where
2639 toAtom :: a -> Atom
2740 default toAtom :: (Generic a, AtomableG (Rep a)) => a -> Atom
2841 toAtom v = toAtomG (from v) (toAtomTypeG (from v))
@@ -43,7 +56,7 @@ class (Eq a, NFData a, Serialise a, Show a) => Atomable a where
4356 -- | Creates DatabaseContextExpr necessary to load the type constructor and data constructor into the database.
4457 toAddTypeExpr :: proxy a -> DatabaseContextExpr
4558 default toAddTypeExpr :: (Generic a, AtomableG (Rep a)) => proxy a -> DatabaseContextExpr
46− toAddTypeExpr _ = toAddTypeExprG (from (error "insufficient laziness" :: a)) (toAtomType (Proxy :: Proxy a))
59+ toAddTypeExpr _ = toAddTypeExprG (from (undefined :: a)) (toAtomType (Proxy :: Proxy a))
4760
4861instance Atomable Integer where
4962 toAtom = IntegerAtom
@@ -135,10 +148,10 @@ instance (Atomable a, Atomable b) => Atomable (Either a b) where
135148--convert to ADT list
136149instance Atomable a => Atomable [a] where
137150 toAtom [] = ConstructedAtom "Empty" (listAtomType (toAtomType (Proxy :: Proxy a))) []
138− toAtom (x:xs) = ConstructedAtom "Cons" (listAtomType (toAtomType (Proxy :: Proxy a))) (toAtom x: [toAtom xs])
151+ toAtom (x:xs) = ConstructedAtom "Cons" (listAtomType (toAtomType (Proxy :: Proxy a))) (map toAtom (x:xs))
139152
140153 fromAtom (ConstructedAtom "Empty" _ _) = []
141− fromAtom (ConstructedAtom "Cons" _ [x,y]) = fromAtom x:fromAtom y
154+ fromAtom (ConstructedAtom "Cons" _ (x:xs)) = fromAtom x:map fromAtom xs
142155 fromAtom _ = error "improper fromAtom [a]"
143156
144157 toAtomType _ = ConstructedAtomType "List" (M.singleton "a" (toAtomType (Proxy :: Proxy a)))
@@ -152,6 +165,10 @@ instance Atomable a => Atomable (NE.NonEmpty a) where
152165 toAtomType _ = ConstructedAtomType "NonEmptyList" (M.singleton "a" (toAtomType (Proxy :: Proxy a)))
153166 toAddTypeExpr _ = NoOperation
154167
168+#if !MIN_VERSION_binary(0,8,4)
169+instance Binary a => Binary (NE.NonEmpty a)
170+#endif
171+
155172-- Generics
156173class AtomableG g where
157174 --type AtomTG g
@@ -167,17 +184,17 @@ class AtomableG g where
167184instance (Datatype c, AtomableG a) => AtomableG (M1 D c a) where
168185 toAtomG (M1 v) = toAtomG v
169186 fromAtomG atom args = M1 <$> fromAtomG atom args
170− toAtomsG = error "invalid toAtomsG in M1 D"
187+ toAtomsG = undefined
171188 toAtomTypeG _ = ConstructedAtomType (T.pack typeName) M.empty -- generics don't allow us to get the type constructor variables- alternatives?
172189 where
173190 typeName = datatypeName (undefined :: M1 D c a x)
174− toAddTypeExprG ~(M1 v) (ConstructedAtomType tcName _) = AddTypeConstructor tcDef dataConstructors
191+ toAddTypeExprG (M1 v) (ConstructedAtomType tcName _) = AddTypeConstructor tcDef dataConstructors
175192 where
176193 tcDef = ADTypeConstructorDef tcName []
177194 dataConstructors = getConstructorsG v
178195 toAddTypeExprG _ _ = NoOperation
179− getConstructorsG ~(M1 v) = getConstructorsG v
180− getConstructorArgsG = error "invalid getConstructorArgsG in M1 D"
196+ getConstructorsG (M1 v) = getConstructorsG v
197+ getConstructorArgsG = undefined
181198
182199--constructor metadata
183200instance (Constructor c, AtomableG a) => AtomableG (M1 C c a) where
@@ -192,11 +209,11 @@ instance (Constructor c, AtomableG a) => AtomableG (M1 C c a) where
192209 Nothing
193210 where
194211 dName = T.pack (conName (undefined :: M1 C c a x))
195− fromAtomG _ _ = error "invalid fromAtomG in M1 C"
196− toAtomsG = error "invalid toAtomsG in M1 C"
197− toAtomTypeG = error "invalid toAtomTypeG in M1 C"
198− toAddTypeExprG = error "invalid toAddTypeExprG in M1 C"
199− getConstructorsG ~(M1 v) = [DataConstructorDef (T.pack dName) dArgs]
212+ fromAtomG _ _ = error "unsupported generic traversal"
213+ toAtomsG = undefined
214+ toAtomTypeG = undefined
215+ toAddTypeExprG = undefined
216+ getConstructorsG (M1 v) = [DataConstructorDef (T.pack dName) dArgs]
200217 where
201218 dName = conName (undefined :: M1 C c a x)
202219 dArgs = getConstructorArgsG v
@@ -208,9 +225,9 @@ instance (Selector c, AtomableG a) => AtomableG (M1 S c a) where
208225 fromAtomG atom args = M1 <$> fromAtomG atom args
209226 toAtomsG (M1 v) = toAtomsG v
210227 toAtomTypeG (M1 v) = toAtomTypeG v
211− toAddTypeExprG = error "invalid toAddTypeExprG in M1 S"
212− getConstructorsG = error "invalid getConstructorsG in M1 S"
213− getConstructorArgsG ~(M1 v) = getConstructorArgsG v
228+ toAddTypeExprG _ _ = undefined
229+ getConstructorsG = undefined
230+ getConstructorArgsG (M1 v) = getConstructorArgsG v
214231
215232-- field data metadata
216233instance (Atomable a) => AtomableG (K1 c a) where
@@ -220,9 +237,9 @@ instance (Atomable a) => AtomableG (K1 c a) where
220237 headatom [] = error "no more atoms for constructor!"
221238 toAtomsG (K1 v) = [toAtom v]
222239 toAtomTypeG _ = toAtomType (Proxy :: Proxy a)
223− toAddTypeExprG = error "invalid toAddTypeExprG in K1"
224− getConstructorsG = error "invalid getConstructorsG in K1"
225− getConstructorArgsG ~(K1 _) = [DataConstructorDefTypeConstructorArg tCons]
240+ toAddTypeExprG _ _ = undefined
241+ getConstructorsG = undefined
242+ getConstructorArgsG (K1 _) = [DataConstructorDefTypeConstructorArg tCons]
226243 where
227244 tCons = typeToTypeConstructor $ toAtomType (Proxy :: Proxy a)
228245
@@ -235,9 +252,8 @@ typeToTypeConstructor x@DayAtomType = PrimitiveTypeConstructor "Day" x
235252typeToTypeConstructor x@DateTimeAtomType = PrimitiveTypeConstructor "DateTime" x
236253typeToTypeConstructor x@ByteStringAtomType = PrimitiveTypeConstructor "ByteString" x
237254typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x
238−typeToTypeConstructor x@RelationalExprAtomType = PrimitiveTypeConstructor "RelationalExpr" x
239255typeToTypeConstructor (RelationAtomType attrs)
240− = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList (attributesVec attrs)
256+ = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList attrs
241257 where
242258 attrToAttrExpr (Attribute n t) = AttributeAndTypeNameExpr n (typeToTypeConstructor t) ()
243259typeToTypeConstructor (ConstructedAtomType tcName tvMap)
@@ -245,12 +261,12 @@ typeToTypeConstructor (ConstructedAtomType tcName tvMap)
245261typeToTypeConstructor (TypeVariableType tvName) = TypeVariable tvName
246262
247263instance AtomableG U1 where
248− toAtomG = error "invalid toAtomG in U1"
264+ toAtomG = undefined
249265 fromAtomG _ _ = pure U1
250266 toAtomsG _ = []
251− toAtomTypeG = error "invalid toAtomTypeG in U1"
252− toAddTypeExprG = error "invalid toAddTypeExprG in U1"
253− getConstructorsG = error "invalid getConstructorsG in U1"
267+ toAtomTypeG = undefined
268+ toAddTypeExprG = undefined
269+ getConstructorsG = undefined
254270 getConstructorArgsG _ = []
255271
256272-- product types
@@ -260,23 +276,23 @@ instance (AtomableG a, AtomableG b) => AtomableG (a :*: b) where
260276 where splitargs1 = take splitpoint args
261277 splitargs2 = drop splitpoint args
262278 splitpoint = length args `div` 2
263− toAtomTypeG = error "invalid toAtomTypeG in :*:"
279+ toAtomTypeG = undefined
264280 toAtomsG (x :*: y) = toAtomsG x ++ toAtomsG y
265− toAddTypeExprG = error "invalid toAddTypeExprG in :*:"
266− getConstructorsG = error "invalid getConstructorsG in :*:"
267− getConstructorArgsG ~(x :*: y) = getConstructorArgsG x ++ getConstructorArgsG y
281+ toAddTypeExprG _ _ = undefined
282+ getConstructorsG = undefined
283+ getConstructorArgsG (x :*: y) = getConstructorArgsG x ++ getConstructorArgsG y
268284
269285-- sum types
270286instance (AtomableG a, AtomableG b) => AtomableG (a :+: b) where
271287 toAtomG (L1 x) = toAtomG x
272288 toAtomG (R1 x) = toAtomG x
273289 fromAtomG atom args = (L1 <$> fromAtomG atom args) <|> (R1 <$> fromAtomG atom args)
274− toAtomTypeG = error "invalid toAtomTypeG in :+:"
290+ toAtomTypeG = undefined
275291 toAtomsG (L1 x) = toAtomsG x
276292 toAtomsG (R1 x) = toAtomsG x
277− toAddTypeExprG = error "invalid toAddTypeExprG in :+:"
293+ toAddTypeExprG _ _ = undefined
278294 getConstructorsG _ = getConstructorsG (undefined :: a x) ++ getConstructorsG (undefined :: b x)
279− getConstructorArgsG = error "invalid getConstructorArgsG in :+:"
295+ getConstructorArgsG = undefined
280296
281297--this represents the unimplemented generics traversals which should never be called
282298{-
src/lib/ProjectM36/Attribute.hs+29−148
@@ -1,4 +1,3 @@
1−{-# OPTIONS_GHC -fno-warn-orphans #-}
21module ProjectM36.Attribute where
32import ProjectM36.Base
43import ProjectM36.Error
@@ -11,54 +10,16 @@ import qualified Data.Map as M
1110import Data.Either
1211
1312arity :: Attributes -> Int
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− }
13+arity = V.length
2714
2815emptyAttributes :: Attributes
29−emptyAttributes = mempty
16+emptyAttributes = V.empty
3017
3118null :: Attributes -> Bool
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)
19+null = V.null
4220
4321attributesFromList :: [Attribute] -> Attributes
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
22+attributesFromList = V.fromList -- . L.nub --too expensive
6223
6324attributeName :: Attribute -> AttributeName
6425attributeName (Attribute name _) = name
@@ -67,16 +28,17 @@ atomType :: Attribute -> AtomType
6728atomType (Attribute _ atype) = atype
6829
6930atomTypes :: Attributes -> V.Vector AtomType
70−atomTypes attrs = V.map atomType (attributesVec attrs)
31+atomTypes = V.map atomType
7132
7233atomTypesList :: Attributes -> [AtomType]
7334atomTypesList = V.toList . atomTypes
7435
36+--hm- no error-checking here
7537addAttribute :: Attribute -> Attributes -> Attributes
76−addAttribute attr attrs = attrs <> singleton attr
38+addAttribute attr attrs = attrs `V.snoc` attr
7739
7840--if some attribute names overlap but the types do not, then spit back an error
79−{-joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes
41+joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes
8042joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length overlappingAttributes = Left (TupleAttributeTypeMismatchError overlappingAttributes)
8143 | V.length overlappingAttrsDifferentTypes > 0 = Left (TupleAttributeTypeMismatchError overlappingAttrsDifferentTypes)
8244 | otherwise = Right $ vectorUniqueify (attrs1 V.++ attrs2)
@@ -85,52 +47,20 @@ joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length
8547 attrNames2 = V.map attributeName attrs2
8648 uniqueOverlappingAttributes = vectorUniqueify overlappingAttributes
8749 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− }
10650
10751addAttributes :: Attributes -> Attributes -> Attributes
108−addAttributes = (<>)
109−
110−member :: Attribute -> Attributes -> Bool
111−member attr attrs = HS.member attr (attributesSet attrs)
52+addAttributes = (V.++)
11253
11354deleteAttributeName :: AttributeName -> Attributes -> Attributes
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
55+deleteAttributeName attrName = V.filter (\attr -> attributeName attr /= attrName)
12356
12457renameAttribute :: AttributeName -> Attribute -> Attribute
12558renameAttribute newAttrName (Attribute _ typeo) = Attribute newAttrName typeo
12659
12760renameAttributes :: AttributeName -> AttributeName -> Attributes -> Attributes
128−renameAttributes oldAttrName newAttrName attrs = Attributes {
129− attributesVec = vec
130− }
61+renameAttributes oldAttrName newAttrName = V.map renamer
13162 where
132− vec = V.map renamer (attributesVec attrs)
133− renamer attr = if attributeName attr == oldAttrName then
63+ renamer attr = if attributeName attr == oldAttrName then
13464 renameAttribute newAttrName attr
13565 else
13666 attr
@@ -141,7 +71,7 @@ atomTypeForAttributeName attrName attrs = do
14171 return atype
14272
14373attributeForName :: AttributeName -> Attributes -> Either RelationalError Attribute
144−attributeForName attrName attrs = case V.find (\attr -> attributeName attr == attrName) (attributesVec attrs) of
74+attributeForName attrName attrs = case V.find (\attr -> attributeName attr == attrName) attrs of
14575 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))
14676 Just attr -> Right attr
14777
@@ -159,18 +89,15 @@ projectionAttributesForNames names attrsIn =
15989 missingNames = attributeNamesNotContained names (S.fromList (V.toList (attributeNames attrsIn)))
16090
16191attributesForNames :: S.Set AttributeName -> Attributes -> Attributes
162−attributesForNames attrNameSet attrs = Attributes {
163− attributesVec = vec
164− }
92+attributesForNames attrNameSet = V.filter filt
16593 where
166− vec = V.filter filt (attributesVec attrs)
16794 filt attr = S.member (attributeName attr) attrNameSet
16895
16996attributeNameSet :: Attributes -> S.Set AttributeName
170−attributeNameSet attrs = S.fromList $ V.toList $ V.map (\(Attribute name _) -> name) (attributesVec attrs)
97+attributeNameSet attrVec = S.fromList $ V.toList $ V.map (\(Attribute name _) -> name) attrVec
17198
17299attributeNames :: Attributes -> V.Vector AttributeName
173−attributeNames attrs = V.map attributeName (attributesVec attrs)
100+attributeNames = V.map attributeName
174101
175102--checks if set s1 is wholly contained in the set s2
176103attributesContained :: Attributes -> Attributes -> Bool
@@ -191,88 +118,42 @@ attributeNamesNotContained subset superset = S.filter (`S.notMember` superset) s
191118
192119-- useful for display
193120orderedAttributes :: Attributes -> [Attribute]
194−orderedAttributes attrs = L.sortBy (\a b -> attributeName a `compare` attributeName b) (V.toList (attributesVec attrs))
121+orderedAttributes attrs = L.sortBy (\a b -> attributeName a `compare` attributeName b) (V.toList attrs)
195122
196123orderedAttributeNames :: Attributes -> [AttributeName]
197124orderedAttributeNames attrs = map attributeName (orderedAttributes attrs)
198125
199126-- 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
201127attributesDifference :: Attributes -> Attributes -> Attributes
202−{-attributesDifference attrsA attrsB = V.fromList $ diff (V.toList attrsA) (V.toList attrsB)
128+attributesDifference attrsA attrsB = V.fromList $ diff (V.toList attrsA) (V.toList attrsB)
203129 where
204130 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)
219131
220132vectorUniqueify :: (Hash.Hashable a, Eq a) => V.Vector a -> V.Vector a
221133vectorUniqueify vecIn = V.fromList $ HS.toList $ HS.fromList $ V.toList vecIn
222134
223135--check that each attribute only appears once
224136verifyAttributes :: Attributes -> Either RelationalError Attributes
225−verifyAttributes attrs =
226− if vecSet == attributesSet attrs then
227− pure attrs
228− else
229− Left (TupleAttributeTypeMismatchError diffAttrs)
137+verifyAttributes attrs = if collapsedAttrs /= attrs then
138+ Left (TupleAttributeTypeMismatchError (attributesDifference collapsedAttrs attrs))
139+ else
140+ Right attrs
230141 where
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
142+ collapsedAttrs = vectorUniqueify attrs
250143
251−-- use to determine if the same attributes are contained (but ordering is irrelevant)
252144attributesEqual :: Attributes -> Attributes -> Bool
253−attributesEqual attrsA attrsB =
254− attributesVec attrsA == attributesVec attrsB ||
255− attributesSet attrsA == attributesSet attrsB
145+attributesEqual attrs1 attrs2 = V.null (attributesDifference attrs1 attrs2)
256146
257147attributesAsMap :: Attributes -> M.Map AttributeName Attribute
258−attributesAsMap attrs = V.foldr' (\attr acc -> M.insert (attributeName attr) attr acc) mempty (attributesVec attrs)
259−
148+attributesAsMap attrs = (M.fromList . V.toList) (V.map (\attr -> (attributeName attr, attr)) attrs)
260149
261150-- | Left-biased union of attributes.
262151union :: Attributes -> Attributes -> Attributes
263−union attrsA attrsB = Attributes {
264− attributesVec = vec
265− --,attributesSet = hset
266− }
152+union attrsA attrsB = V.fromList (M.elems unioned)
267153 where
268− hset = HS.union (attributesSet attrsA) (attributesSet attrsB)
269− vec = HS.foldr (flip V.snoc) mempty hset
154+ unioned = M.union (attributesAsMap attrsA) (attributesAsMap attrsB)
270155
271156intersection :: Attributes -> Attributes -> Attributes
272−intersection attrsA attrsB = Attributes {
273− attributesVec = vec
274− --,attributesSet = hset
275− }
157+intersection attrsA attrsB = V.fromList (M.elems intersected)
276158 where
277− hset = HS.intersection (attributesSet attrsA) (attributesSet attrsB)
278− vec = HS.foldr (flip V.snoc) mempty hset
159+ intersected = M.intersection (attributesAsMap attrsA) (attributesAsMap attrsB)
src/lib/ProjectM36/Base.hs+107−113
@@ -1,12 +1,10 @@
1−{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveTraversable, DerivingVia, TemplateHaskell, TypeFamilies #-}
1+{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveFoldable, DeriveFunctor, DeriveTraversable #-}
22{-# OPTIONS_GHC -fno-warn-orphans #-}
33
44module ProjectM36.Base where
55import ProjectM36.DatabaseContextFunctionError
66import ProjectM36.AtomFunctionError
7−import ProjectM36.MerkleHash
87
9−import Data.Functor.Foldable.TH
108import qualified Data.Map as M
119import qualified Data.HashSet as HS
1210import Data.Hashable (Hashable, hashWithSalt)
@@ -19,17 +17,16 @@ import GHC.Stack
1917import qualified Data.Vector as V
2018import qualified Data.List as L
2119import 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)
2325import Data.Hashable.Time ()
24−import Data.Time.Calendar (Day)
2526import Data.Typeable
2627import Data.ByteString (ByteString)
2728import qualified Data.List.NonEmpty as NE
28−import Data.Vector.Instances ()
29−
3029type StringType = Text
31−
32−type DatabaseName = String
3330
3431-- | Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.
3532data Atom = IntegerAtom Integer |
@@ -41,9 +38,8 @@ data Atom = IntegerAtom Integer |
4138 ByteStringAtom ByteString |
4239 BoolAtom Bool |
4340 RelationAtom Relation |
44− RelationalExprAtom RelationalExpr | --used for returning inc deps
4541 ConstructedAtom DataConstructorName AtomType [Atom]
46− deriving (Eq, Show, Typeable, NFData, Generic, Read)
42+ deriving (Eq, Show, Binary, Typeable, NFData, Generic)
4743
4844instance Hashable Atom where
4945 hashWithSalt salt (ConstructedAtom dConsName _ atoms) = salt `hashWithSalt` atoms
@@ -57,7 +53,16 @@ instance Hashable Atom where
5753 hashWithSalt salt (ByteStringAtom bs) = salt `hashWithSalt` bs
5854 hashWithSalt salt (BoolAtom b) = salt `hashWithSalt` b
5955 hashWithSalt salt (RelationAtom r) = salt `hashWithSalt` r
60− hashWithSalt salt (RelationalExprAtom re) = salt `hashWithSalt` re
56+
57+instance Binary UTCTime where
58+ put utc = put $ toRational (utcTimeToPOSIXSeconds utc)
59+ get = posixSecondsToUTCTime . fromRational <$> (get :: Get Rational)
60+
61+instance Binary Day where
62+ put day = put $ toGregorian day
63+ get = do
64+ (y,m,d) <- get :: Get (Integer, Int, Int)
65+ return (fromGregorian y m d)
6166
6267-- 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.
6368-- | The AtomType uniquely identifies the type of a atom.
@@ -71,15 +76,12 @@ data AtomType = IntAtomType |
7176 BoolAtomType |
7277 RelationAtomType Attributes |
7378 ConstructedAtomType TypeConstructorName TypeVarMap |
74− RelationalExprAtomType |
7579 TypeVariableType TypeVarName
7680 --wildcard used in Atom Functions and tuples for data constructors which don't provide all arguments to the type constructor
77− deriving (Eq, NFData, Generic, Show, Read, Hashable)
81+ deriving (Eq, NFData, Generic, Binary, Show)
7882
7983instance Ord AtomType where
80− compare = undefined
81−
82−-- this should probably be an ordered dictionary in order to be able to round-trip these arguments
84+ compare = undefined
8385type TypeVarMap = M.Map TypeVarName AtomType
8486
8587instance Hashable TypeVarMap where
@@ -94,37 +96,25 @@ isRelationAtomType _ = False
9496type AttributeName = StringType
9597
9698-- | A relation's type is composed of attribute names and types.
97−data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Read, Generic, NFData)
99+data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Generic, NFData, Binary)
98100
99101instance Hashable Attribute where
100102 hashWithSalt salt (Attribute attrName _) = hashWithSalt salt attrName
101103
102−type AttributesHash = Int
103−
104104-- | 'Attributes' represent the head of a relation.
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
105+type Attributes = V.Vector Attribute
122106
107+-- | Equality function for a set of attributes.
108+attributesEqual :: Attributes -> Attributes -> Bool
109+attributesEqual attrs1 attrs2 = attrsAsSet attrs1 == attrsAsSet attrs2
110+ where
111+ attrsAsSet = HS.fromList . V.toList
112+
123113sortedAttributesIndices :: Attributes -> [(Int, Attribute)]
124−sortedAttributesIndices attrs = L.sortBy (\(_, Attribute name1 _) (_,Attribute name2 _) -> compare name1 name2) $ V.toList (V.indexed (attributesVec attrs))
114+sortedAttributesIndices attrs = L.sortBy (\(_, Attribute name1 _) (_,Attribute name2 _) -> compare name1 name2) $ V.toList (V.indexed attrs)
125115
126116-- | The relation's tuple set is the body of the relation.
127−newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic, Read)
117+newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic, Binary)
128118
129119instance Read Relation where
130120 readsPrec = error "relation read not supported"
@@ -140,8 +130,8 @@ instance NFData RelationTupleSet where rnf = genericRnf
140130instance Hashable RelationTuple where
141131 --sanity check the tuple for attribute and tuple counts
142132 --this bit me when tuples were being hashed before being verified
143− hashWithSalt salt (RelationTuple attrs tupVec) = if V.length (attributesVec attrs) /= V.length tupVec then
144− error ("invalid tuple: attributes and tuple count mismatch " <> show (attributesVec attrs, tupVec))
133+ hashWithSalt salt (RelationTuple attrs tupVec) = if V.length attrs /= V.length tupVec then
134+ error "invalid tuple: attributes and tuple count mismatch"
145135 else
146136 salt `hashWithSalt`
147137 sortedAttrs `hashWithSalt`
@@ -152,23 +142,25 @@ instance Hashable RelationTuple where
152142 sortedTupVec = V.map (\(index, _) -> tupVec V.! index) $ V.fromList sortedAttrsIndices
153143
154144-- | A tuple is a set of attributes mapped to their 'Atom' values.
155−data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Read, Generic)
145+data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Generic)
146+
147+instance Binary RelationTuple
156148
157149instance Eq RelationTuple where
158− tuple1@(RelationTuple attrs1 _) == tuple2@(RelationTuple attrs2 _) =
159− attrs1 == attrs2 && atomsEqual
150+ (==) tuple1@(RelationTuple attrs1 _) tuple2@(RelationTuple attrs2 _) = attributesEqual attrs1 attrs2 && atomsEqual
160151 where
161− atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) (attributesVec attrs) of
152+ atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) attrs of
162153 Nothing -> Nothing
163154 Just index -> tupVec V.!? index
164− atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) (attributesVec attrs1)
155+ atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) attrs1
165156
166157instance NFData RelationTuple where rnf = genericRnf
167158
159+
168160data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)
169161
170162instance Eq Relation where
171− Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attrs1 == attrs2 && tupSet1 == tupSet2
163+ Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attributesEqual attrs1 attrs2 && tupSet1 == tupSet2
172164
173165instance NFData Relation where rnf = genericRnf
174166
@@ -179,6 +171,8 @@ instance Hashable Relation where
179171 where
180172 sortedAttrs = map snd (sortedAttributesIndices attrs)
181173
174+instance Binary Relation
175+
182176-- | Used to represent the number of tuples in a relation.
183177data RelationCardinality = Countable | Finite Int deriving (Eq, Show, Generic, Ord)
184178
@@ -190,7 +184,7 @@ type RelationalExpr = RelationalExprBase ()
190184-- | A relational expression represents query (read) operations on a database.
191185data RelationalExprBase a =
192186 --- | Create a relation from tuple expressions.
193− MakeRelationFromExprs (Maybe [AttributeExprBase a]) (TupleExprsBase a) |
187+ MakeRelationFromExprs (Maybe [AttributeExprBase a]) [TupleExprBase a] |
194188 --- | Create and reference a relation from attributes and a tuple set.
195189 MakeStaticRelation Attributes RelationTupleSet |
196190 --- | Reference an existing relation in Haskell-space.
@@ -223,15 +217,17 @@ data RelationalExprBase a =
223217 --Summarize :: AtomExpr -> AttributeName -> RelationalExpr -> RelationalExpr -> RelationalExpr -- a special case of Extend
224218 --Evaluate relationalExpr with scoped views
225219 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)
226− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)
220+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)
221+
222+instance Binary RelationalExpr
227223
228−instance Hashable RelationalExpr
229−
230224data WithNameExprBase a = WithNameExpr RelVarName a
231− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable, Hashable)
225+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)
232226
233227type WithNameExpr = WithNameExprBase ()
234228
229+instance Binary WithNameExpr
230+
235231type GraphRefWithNameExpr = WithNameExprBase GraphRefTransactionMarker
236232
237233type NotificationName = StringType
@@ -243,22 +239,22 @@ data Notification = Notification {
243239 reportOldExpr :: RelationalExpr, --run the expression in the pre-change context
244240 reportNewExpr :: RelationalExpr --run the expression in the post-change context
245241 }
246− deriving (Show, Eq, Generic, NFData)
242+ deriving (Show, Eq, Binary, Generic, NFData)
247243
248244type TypeVarName = StringType
249245
250246-- | Metadata definition for type constructors such as @data Either a b@.
251247data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |
252248 PrimitiveTypeConstructorDef TypeConstructorName AtomType
253− deriving (Show, Generic, Eq, NFData, Hashable, Read)
249+ deriving (Show, Generic, Binary, Eq, NFData)
254250
255251-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int
256252type TypeConstructor = TypeConstructorBase ()
257253data TypeConstructorBase a = ADTypeConstructor TypeConstructorName [TypeConstructor] |
258− PrimitiveTypeConstructor TypeConstructorName AtomType |
259− RelationAtomTypeConstructor [AttributeExprBase a] |
260− TypeVariable TypeVarName
261− deriving (Show, Generic, Eq, NFData, Hashable, Read)
254+ PrimitiveTypeConstructor TypeConstructorName AtomType |
255+ RelationAtomTypeConstructor [AttributeExprBase a] |
256+ TypeVariable TypeVarName
257+ deriving (Show, Generic, Binary, Eq, NFData)
262258
263259type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]
264260
@@ -268,20 +264,20 @@ type DataConstructorName = StringType
268264type AtomTypeName = StringType
269265
270266-- | Used to define a data constructor in a type constructor context such as @Left a | Right b@
271−data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Generic, NFData, Hashable, Read)
267+data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Binary, Generic, NFData)
272268
273269type DataConstructorDefs = [DataConstructorDef]
274270
275271data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |
276272 DataConstructorDefTypeVarNameArg TypeVarName
277− deriving (Show, Generic, Eq, NFData, Hashable, Read)
273+ deriving (Show, Generic, Binary, Eq, NFData)
278274
279275type InclusionDependencies = M.Map IncDepName InclusionDependency
280276type RelationVariables = M.Map RelVarName GraphRefRelationalExpr
281277
282278data GraphRefTransactionMarker = TransactionMarker TransactionId |
283279 UncommittedContextMarker
284− deriving (Eq, Show, Generic, NFData, Ord)
280+ deriving (Eq, Show, Binary, Generic, NFData, Ord)
285281
286282-- a fundamental relational expr to which other relational expressions compile
287283type GraphRefRelationalExpr = RelationalExprBase GraphRefTransactionMarker
@@ -292,18 +288,17 @@ type Subschemas = M.Map SchemaName Schema
292288
293289-- | Every transaction has one concrete database context and any number of isomorphic subschemas.
294290data Schemas = Schemas DatabaseContext Subschemas
295− deriving (Generic)
296291
297292-- | The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time.
298293-- 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.
299294newtype Schema = Schema SchemaIsomorphs
300− deriving (Generic)
295+ deriving (Generic, Binary)
301296
302297data SchemaIsomorph = IsoRestrict RelVarName RestrictionPredicateExpr (RelVarName, RelVarName) |
303298 IsoRename RelVarName RelVarName |
304299 IsoUnion (RelVarName, RelVarName) RestrictionPredicateExpr RelVarName --maps two relvars to one relvar
305300 -- IsoTypeConstructor in morphAttrExpr
306− deriving (Generic, Show)
301+ deriving (Generic, Binary, Show)
307302
308303type SchemaIsomorphs = [SchemaIsomorph]
309304
@@ -319,7 +314,9 @@ data DatabaseContext = DatabaseContext {
319314type IncDepName = StringType
320315
321316-- | Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.
322−data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData, Hashable, Read)
317+data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData)
318+
319+instance Binary InclusionDependency
323320
324321type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr
325322
@@ -328,10 +325,10 @@ type DatabaseContextExprName = StringType
328325
329326type DatabaseContextExpr = DatabaseContextExprBase ()
330327
331−instance Hashable DatabaseContextExpr
332−
333328type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker
334329
330+instance Binary GraphRefDatabaseContextExpr
331+
335332-- | Database context expressions modify the database context.
336333data DatabaseContextExprBase a =
337334 NoOperation |
@@ -359,10 +356,9 @@ data DatabaseContextExprBase a =
359356 ExecuteDatabaseContextFunction DatabaseContextFunctionName [AtomExprBase a] |
360357
361358 MultipleExpr [DatabaseContextExprBase a]
362− deriving (Show, Read, Eq, Generic, NFData)
359+ deriving (Show, Eq, Generic)
363360
364−instance Hashable (M.Map AttributeName AtomExpr) where
365− hashWithSalt salt m = salt `hashWithSalt` M.toList m
361+instance Binary DatabaseContextExpr
366362
367363type ObjModuleName = StringType
368364type ObjFunctionName = StringType
@@ -374,7 +370,7 @@ data DatabaseContextIOExprBase a =
374370 AddDatabaseContextFunction DatabaseContextFunctionName [TypeConstructor] DatabaseContextFunctionBodyScript |
375371 LoadDatabaseContextFunctions ObjModuleName ObjFunctionName FilePath |
376372 CreateArbitraryRelation RelVarName [AttributeExprBase a] Range
377− deriving (Show, Eq, Generic)
373+ deriving (Show, Eq, Generic, Binary)
378374
379375type GraphRefDatabaseContextIOExpr = DatabaseContextIOExprBase GraphRefTransactionMarker
380376
@@ -382,8 +378,6 @@ type DatabaseContextIOExpr = DatabaseContextIOExprBase ()
382378
383379type RestrictionPredicateExpr = RestrictionPredicateExprBase ()
384380
385−instance Hashable RestrictionPredicateExpr
386−
387381type GraphRefRestrictionPredicateExpr = RestrictionPredicateExprBase GraphRefTransactionMarker
388382
389383-- | Restriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.
@@ -395,7 +389,9 @@ data RestrictionPredicateExprBase a =
395389 RelationalExprPredicate (RelationalExprBase a) | --type must be same as true and false relations (no attributes)
396390 AtomExprPredicate (AtomExprBase a) | --atom must evaluate to boolean
397391 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple
398− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)
392+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)
393+
394+instance Binary RestrictionPredicateExpr
399395
400396-- child + parent links
401397-- | A transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.
@@ -405,7 +401,6 @@ type TransactionHeads = M.Map HeadName Transaction
405401
406402-- | The transaction graph is the global database's state which references every committed transaction.
407403data TransactionGraph = TransactionGraph TransactionHeads (S.Set Transaction)
408− deriving Generic
409404
410405transactionHeadsForGraph :: TransactionGraph -> TransactionHeads
411406transactionHeadsForGraph (TransactionGraph hs _) = hs
@@ -417,8 +412,7 @@ transactionsForGraph (TransactionGraph _ ts) = ts
417412-- The `TransactionDiff`s represent child/edge relationships to previous transactions (branches or continuations of the same branch).
418413data TransactionInfo = TransactionInfo {
419414 parents :: TransactionParents,
420− stamp :: UTCTime,
421− merkleHash :: MerkleHash
415+ stamp :: UTCTime
422416 } deriving (Show, Generic)
423417
424418type TransactionParents = NE.NonEmpty TransactionId
@@ -428,15 +422,16 @@ data TransactionInfo = TransactionInfo TransactionId TransactionDiffs UTCTime |
428422 deriving (Show, Generic)
429423-}
430424
425+instance Binary TransactionInfo
426+
431427-- | Every set of modifications made to the database are atomically committed to the transaction graph as a transaction.
432428type TransactionId = UUID
433429
434430data Transaction = Transaction TransactionId TransactionInfo Schemas
435− deriving Generic
436431
437432-- | The disconnected transaction represents an in-progress workspace used by sessions before changes are committed. This is similar to git's "index". After a transaction is committed, it is "connected" in the transaction graph and can no longer be modified.
438−data DisconnectedTransaction = DisconnectedTransaction TransactionId Schemas DirtyFlag
439−--the database context expression represents a difference between the disconnected transaction and its immutable parent transaction- is this diff expr used at all?
433+data DisconnectedTransaction = DisconnectedTransaction TransactionId Schemas DatabaseContextExpr
434+--the database context expression represents a difference between the disconnected transaction and its immutable parent transaction
440435
441436type DirtyFlag = Bool
442437
@@ -456,8 +451,6 @@ instance Ord Transaction where
456451
457452type AtomExpr = AtomExprBase ()
458453
459−instance Hashable AtomExpr
460−
461454type GraphRefAtomExpr = AtomExprBase GraphRefTransactionMarker
462455
463456-- | An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.
@@ -466,18 +459,19 @@ data AtomExprBase a = AttributeAtomExpr AttributeName |
466459 FunctionAtomExpr AtomFunctionName [AtomExprBase a] a |
467460 RelationAtomExpr (RelationalExprBase a) |
468461 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a
469− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)
462+ deriving (Eq,Show,Generic, NFData, Foldable, Functor, Traversable)
470463
464+instance Binary AtomExpr
465+
471466-- | Used in tuple creation when creating a relation.
472467data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)
473− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)
468+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)
474469
475470type ExtendTupleExpr = ExtendTupleExprBase ()
476−
477−instance Hashable ExtendTupleExpr
478−
479471type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker
480472
473+instance Binary ExtendTupleExpr
474+
481475--enumerates the list of functions available to be run as part of tuple expressions
482476type AtomFunctions = HS.HashSet AtomFunction
483477
@@ -488,7 +482,6 @@ type AtomFunctionBodyScript = StringType
488482type AtomFunctionBodyType = [Atom] -> Either AtomFunctionError Atom
489483
490484data AtomFunctionBody = AtomFunctionBody (Maybe AtomFunctionBodyScript) AtomFunctionBodyType
491− deriving Generic
492485
493486instance NFData AtomFunctionBody where
494487 rnf (AtomFunctionBody mScript _) = rnf mScript
@@ -523,17 +516,14 @@ data AttributeNamesBase a = AttributeNames (S.Set AttributeName) |
523516 UnionAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |
524517 IntersectAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |
525518 RelationalExprAttributeNames (RelationalExprBase a) -- use attribute names from the relational expression's type
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
519+ deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)
532520
533521type AttributeNames = AttributeNamesBase ()
534522
535523type GraphRefAttributeNames = AttributeNamesBase GraphRefTransactionMarker
536524
525+instance Binary AttributeNames
526+
537527-- | The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.
538528data PersistenceStrategy = NoPersistence | -- ^ no filesystem persistence/memory-only database
539529 MinimalPersistence FilePath | -- ^ fsync off, not crash-safe
@@ -546,27 +536,18 @@ type GraphRefAttributeExpr = AttributeExprBase GraphRefTransactionMarker
546536-- | Create attributes dynamically.
547537data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |
548538 NakedAttributeExpr Attribute
549− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable, Hashable)
539+ deriving (Eq, Show, Generic, Binary, NFData, Foldable, Functor, Traversable)
550540
551541-- | Dynamically create a tuple from attribute names and 'AtomExpr's.
552542newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))
553− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)
554−
555−instance Hashable TupleExpr
543+ deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)
544+
545+instance Binary TupleExpr
556546
557547type TupleExpr = TupleExprBase ()
558548
559549type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker
560550
561−data TupleExprsBase a = TupleExprs a [TupleExprBase a]
562− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)
563−
564−instance Hashable TupleExprs
565−
566−type GraphRefTupleExprs = TupleExprsBase GraphRefTransactionMarker
567−
568−type TupleExprs = TupleExprsBase ()
569−
570551data MergeStrategy =
571552 -- | 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)
572553 UnionMergeStrategy |
@@ -574,7 +555,7 @@ data MergeStrategy =
574555 UnionPreferMergeStrategy HeadName |
575556 -- | 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.
576557 SelectedBranchMergeStrategy HeadName
577− deriving (Eq, Show, Generic, NFData)
558+ deriving (Eq, Show, Binary, Generic, NFData)
578559
579560type DatabaseContextFunctionName = StringType
580561
@@ -611,8 +592,7 @@ attrTypeVars (Attribute _ aType) = case aType of
611592 DateTimeAtomType -> S.empty
612593 ByteStringAtomType -> S.empty
613594 BoolAtomType -> S.empty
614− RelationalExprAtomType -> S.empty
615− (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList (attributesVec attrs)))
595+ (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList attrs))
616596 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap
617597 (TypeVariableType nam) -> S.singleton nam
618598
@@ -635,12 +615,26 @@ atomTypeVars DayAtomType = S.empty
635615atomTypeVars DateTimeAtomType = S.empty
636616atomTypeVars ByteStringAtomType = S.empty
637617atomTypeVars BoolAtomType = S.empty
638−atomTypeVars RelationalExprAtomType = S.empty
639−atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList (attributesVec attrs)))
618+atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList attrs))
640619atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap
641620atomTypeVars (TypeVariableType nam) = S.singleton nam
642621
643622unimplemented :: HasCallStack => a
644−unimplemented = error "unimplemented"
623+unimplemented = undefined
624+
625+--for serializing GraphRefRelationalExpr as part of transaction serialization
626+instance Binary (TupleExprBase GraphRefTransactionMarker)
627+
628+instance Binary GraphRefRelationalExpr
629+
630+instance Binary (AtomExprBase GraphRefTransactionMarker)
631+
632+instance Binary (AttributeNamesBase GraphRefTransactionMarker)
633+
634+instance Binary (RestrictionPredicateExprBase GraphRefTransactionMarker)
635+
636+instance Binary (ExtendTupleExprBase GraphRefTransactionMarker)
637+
638+instance Binary GraphRefWithNameExpr
645639
646−makeBaseFunctor ''RelationalExprBase
640+
src/lib/ProjectM36/Client.hs+309−195
@@ -1,4 +1,4 @@
1−{-# LANGUAGE DeriveGeneric, ScopedTypeVariables, MonoLocalBinds, DerivingVia #-}
1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, ScopedTypeVariables, BangPatterns, PackageImports #-}
22{-|
33Module: ProjectM36.Client
44
@@ -9,7 +9,6 @@ module ProjectM36.Client
99 Connection(..),
1010 Port,
1111 Hostname,
12− ServiceName,
1312 DatabaseName,
1413 ConnectionError(..),
1514 connectProjectM36,
@@ -44,7 +43,6 @@ module ProjectM36.Client
4443 defaultDatabaseName,
4544 defaultRemoteConnectionInfo,
4645 defaultHeadName,
47− addClientNode,
4846 PersistenceStrategy(..),
4947 RelationalExpr,
5048 RelationalExprBase(..),
@@ -55,9 +53,11 @@ module ProjectM36.Client
5553 Attribute(..),
5654 MergeStrategy(..),
5755 attributesFromList,
56+ createNodeId,
5857 createSessionAtCommit,
5958 createSessionAtHead,
6059 closeSession,
60+ addClientNode,
6161 callTestTimeout_,
6262 RelationCardinality(..),
6363 TransactionGraphOperator(..),
@@ -67,6 +67,7 @@ module ProjectM36.Client
6767 TransGraphRelationalExpr,
6868 TransactionIdLookup(..),
6969 TransactionIdHeadBacktrack(..),
70+ NodeId(..),
7071 Atom(..),
7172 Session,
7273 SessionId,
@@ -79,7 +80,6 @@ module ProjectM36.Client
7980 databaseContextExprForUniqueKey,
8081 databaseContextExprForForeignKey,
8182 createScriptedAtomFunction,
82− ProjectM36.Client.validateMerkleHashes,
8383 AttributeExprBase(..),
8484 TypeConstructorBase(..),
8585 TypeConstructorDef(..),
@@ -99,14 +99,12 @@ module ProjectM36.Client
9999 AtomType(..),
100100 Atomable(..),
101101 TupleExprBase(..),
102− TupleExprsBase(..),
103102 AtomExprBase(..),
104103 RestrictionPredicateExprBase(..),
105104 withTransaction
106105 ) where
107106import ProjectM36.Base hiding (inclusionDependencies) --defined in this module as well
108107import qualified ProjectM36.Base as B
109−import ProjectM36.Serialise.Error ()
110108import ProjectM36.Error
111109import ProjectM36.Atomable
112110import ProjectM36.AtomFunction as AF
@@ -119,7 +117,7 @@ import Control.Monad.State
119117import qualified ProjectM36.RelationalExpression as RE
120118import ProjectM36.DatabaseContext (basicDatabaseContext)
121119import qualified ProjectM36.TransactionGraph as Graph
122−import ProjectM36.TransactionGraph as TG
120+import ProjectM36.TransactionGraph
123121import qualified ProjectM36.Transaction as Trans
124122import ProjectM36.TransactionGraph.Persist
125123import ProjectM36.Attribute
@@ -134,16 +132,28 @@ import ProjectM36.Relation (typesAsRelation)
134132import ProjectM36.ScriptSession (initScriptSession, ScriptSession)
135133import qualified ProjectM36.Relation as R
136134import Control.Exception.Base
137−import Control.Concurrent.STM
138−import Control.Concurrent.Async
135+import GHC.Conc.Sync
136+
137+import Network.Transport (Transport(closeTransport))
138+#if MIN_VERSION_network_transport_tcp(0,7,0)
139+import Network.Transport.TCP (createTransport, defaultTCPParameters, TCPAddr(..), TCPAddrInfo(..))
140+import Network.Transport.TCP.Internal (encodeEndPointAddress)
141+#elif MIN_VERSION_network_transport_tcp(0,6,0)
142+import Network.Transport.TCP (createTransport, defaultTCPParameters)
143+import Network.Transport.TCP.Internal (encodeEndPointAddress)
144+#else
145+import Network.Transport.TCP (encodeEndPointAddress, createTransport, defaultTCPParameters)
146+#endif
139147
148+import Control.Distributed.Process.Node (newLocalNode, initRemoteTable, runProcess, LocalNode, forkProcess, closeLocalNode)
149+import Control.Distributed.Process.Extras.Internal.Types (whereisRemote)
150+import Control.Distributed.Process.ManagedProcess.Client (call, safeCall)
140151import Data.Either (isRight)
141152import Data.UUID.V4 (nextRandom)
142153import Data.Word
143−import Data.Hashable
154+import Control.Distributed.Process (ProcessId, Process, receiveWait, send, match, NodeId(..), reconnect)
144155import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)
145156import Control.Concurrent.MVar
146−import Codec.Winery hiding (Schema, schema)
147157import qualified Data.Map as M
148158#if MIN_VERSION_stm_containers(1,0,0)
149159import qualified StmContainers.Map as StmMap
@@ -155,19 +165,20 @@ import qualified STMContainers.Set as StmSet
155165import qualified ProjectM36.Session as Sess
156166import ProjectM36.Session
157167import ProjectM36.Sessions
168+--import "list-t" ListT
169+import Data.Binary (Binary)
158170import GHC.Generics (Generic)
159171import Control.DeepSeq (force)
160172import System.IO
161173import Data.Time.Clock
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)
174+import Data.Typeable
166175
167176type Hostname = String
168177
169178type Port = Word16
170179
180+type DatabaseName = String
181+
171182-- | 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.
172183type NotificationCallback = NotificationName -> EvaluatedNotification -> IO ()
173184
@@ -187,16 +198,15 @@ data RequestTimeoutException = RequestTimeoutException
187198
188199instance Exception RequestTimeoutException
189200
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
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
193204
194205type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification
195206
196207-- | Used for callbacks from the server when monitored changes have been made.
197208newtype NotificationMessage = NotificationMessage EvaluatedNotifications
198− deriving (Eq, Show, Generic)
199− deriving Serialise via WineryVariant NotificationMessage
209+ deriving (Binary, Eq, Show, Generic)
200210
201211-- | 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.
202212data EvaluatedNotification = EvaluatedNotification {
@@ -204,10 +214,13 @@ data EvaluatedNotification = EvaluatedNotification {
204214 reportOldRelation :: Either RelationalError Relation,
205215 reportNewRelation :: Either RelationalError Relation
206216 }
207− deriving (Eq, Show, Generic)
208− deriving Serialise via WineryRecord EvaluatedNotification
217+ deriving(Binary, Eq, Show, Generic)
209218
210219
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+
211224-- | Use this for connecting to remote servers on the default port.
212225defaultServerPort :: Port
213226defaultServerPort = 6543
@@ -222,36 +235,87 @@ defaultHeadName = "master"
222235
223236-- | 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.
224237defaultRemoteConnectionInfo :: ConnectionInfo
225−defaultRemoteConnectionInfo =
226− RemoteConnectionInfo defaultDatabaseName defaultServerHostname (show defaultServerPort) emptyNotificationCallback
238+defaultRemoteConnectionInfo = RemoteProcessConnectionInfo defaultDatabaseName (createNodeId "127.0.0.1" defaultServerPort) emptyNotificationCallback
227239
228−defaultServerHostname :: Hostname
229−defaultServerHostname = "localhost"
240+-- | The 'Connection' represents either local or remote access to a database. All operations flow through the connection.
241+type ClientNodes = StmSet.Set ProcessId
230242
231−newtype RemoteConnectionConf = RemoteConnectionConf RPC.Connection
243+-- internal structure specific to in-process connections
244+data InProcessConnectionConf = InProcessConnectionConf {
245+ ipPersistenceStrategy :: PersistenceStrategy,
246+ ipClientNodes :: ClientNodes,
247+ ipSessions :: Sessions,
248+ ipTransactionGraph :: TVar TransactionGraph,
249+ ipScriptSession :: Maybe ScriptSession,
250+ ipLocalNode :: LocalNode,
251+ ipTransport :: Transport, -- we hold onto this so that we can close it gracefully
252+ ipLocks :: Maybe (LockFile, MVar LockFileHash) -- nothing when NoPersistence
253+ }
254+
255+data RemoteProcessConnectionConf = RemoteProcessConnectionConf {
256+ rLocalNode :: LocalNode,
257+ rProcessId :: ProcessId, --remote processId
258+ rTransport :: Transport --the TCP socket transport
259+ }
232260
233261data Connection = InProcessConnection InProcessConnectionConf |
234− RemoteConnection RemoteConnectionConf
262+ RemoteProcessConnection RemoteProcessConnectionConf
235263
236264-- | There are several reasons why a connection can fail.
237265data ConnectionError = SetupDatabaseDirectoryError PersistenceError |
238266 IOExceptionError IOException |
239267 NoSuchDatabaseByNameError DatabaseName |
240− DatabaseValidationError [MerkleValidationError] |
241268 LoginError
242269 deriving (Show, Eq, Generic)
243270
244271remoteDBLookupName :: DatabaseName -> String
245272remoteDBLookupName = (++) "db-"
246273
274+createLocalNode :: IO (LocalNode, Transport)
275+createLocalNode = do
276+#if MIN_VERSION_network_transport_tcp(0,7,0)
277+ let addrInfo = TCPAddrInfo {
278+ tcpBindHost = "127.0.0.1",
279+ tcpBindPort = "0",
280+ tcpExternalAddress = \sn -> ("127.0.0.1", sn)
281+ }
282+ eLocalTransport <- createTransport (Addressable addrInfo) defaultTCPParameters
283+#elif MIN_VERSION_network_transport_tcp(0,6,0)
284+ eLocalTransport <- createTransport "127.0.0.1" "0" ) defaultTCPParameters
285+#else
286+ eLocalTransport <- createTransport "127.0.0.1" "0" defaultTCPParameters
287+#endif
288+ case eLocalTransport of
289+ Left err -> error ("failed to create transport: " ++ show err)
290+ Right localTransport -> do
291+ localNode <- newLocalNode localTransport initRemoteTable
292+ pure (localNode, localTransport)
293+
294+notificationListener :: NotificationCallback -> Process ()
295+notificationListener callback = do
296+ --pid <- getSelfPid
297+ --liftIO $ putStrLn $ "LISTENER THREAD START " ++ show pid
298+ _ <- forever $
299+ receiveWait [
300+ match (\(NotificationMessage eNots) ->
301+ --say $ "NOTIFICATION: " ++ show eNots
302+ -- when notifications are thrown, they are not adjusted for the current schema which could be problematic, but we don't have access to the current session here
303+ liftIO $ mapM_ (uncurry callback) (M.toList eNots)
304+ )
305+ ]
306+ --say "LISTENER THREAD EXIT"
307+ pure ()
308+
309+startNotificationListener :: LocalNode -> NotificationCallback -> IO ProcessId
310+startNotificationListener localNode callback = forkProcess localNode (notificationListener callback)
311+
247312createScriptSession :: [String] -> IO (Maybe ScriptSession)
248313createScriptSession ghcPkgPaths = do
249314 eScriptSession <- initScriptSession ghcPkgPaths
250315 case eScriptSession of
251− Left err -> hPutStrLn stderr ("Warning: Haskell scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled
316+ Left err -> hPutStrLn stderr ("Failed to load scripting engine- scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled
252317 Right s -> pure (Just s)
253318
254−
255319-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.
256320connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)
257321--create a new in-memory database/transaction graph
@@ -266,63 +330,42 @@ connectProjectM36 (InProcessConnectionInfo strat notificationCallback ghcPkgPath
266330 graphTvar <- newTVarIO freshGraph
267331 clientNodes <- StmSet.newIO
268332 sessions <- StmMap.newIO
333+ (localNode, transport) <- createLocalNode
334+ notificationPid <- startNotificationListener localNode notificationCallback
269335 mScriptSession <- createScriptSession ghcPkgPaths
270− notifAsync <- startNotificationListener clientNodes notificationCallback
336+
271337 let conn = InProcessConnection InProcessConnectionConf {
272338 ipPersistenceStrategy = strat,
273339 ipClientNodes = clientNodes,
274340 ipSessions = sessions,
275341 ipTransactionGraph = graphTvar,
276342 ipScriptSession = mScriptSession,
277− ipLocks = Nothing,
278− ipCallbackAsync = notifAsync
279− }
343+ ipLocalNode = localNode,
344+ ipTransport = transport,
345+ ipLocks = Nothing}
346+ addClientNode conn notificationPid
280347 pure (Right conn)
281348 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths
282349 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths
283350
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
351+connectProjectM36 (RemoteProcessConnectionInfo databaseName serverNodeId notificationCallback) = do
352+ connStatus <- newEmptyMVar
353+ (localNode, transport) <- createLocalNode
354+ let dbName = remoteDBLookupName databaseName
355+ --putStrLn $ "Connecting to " ++ show serverNodeId ++ " " ++ dbName
356+ notificationListenerPid <- startNotificationListener localNode notificationCallback
357+ runProcess localNode $ do
358+ --even a failed connection retains an open socket!
359+ mServerProcessId <- whereisRemote serverNodeId dbName
360+ case mServerProcessId of
361+ Nothing -> liftIO $ putMVar connStatus $ Left (NoSuchDatabaseByNameError databaseName)
362+ Just serverProcessId -> do
363+ loginConfirmation <- safeLogin (Login notificationListenerPid) serverProcessId
364+ if not loginConfirmation then
365+ liftIO $ putMVar connStatus (Left LoginError)
366+ else
367+ liftIO $ putMVar connStatus (Right $ RemoteProcessConnection RemoteProcessConnectionConf {rLocalNode = localNode, rProcessId = serverProcessId, rTransport = transport})
368+ takeMVar connStatus
326369
327370connectPersistentProjectM36 :: PersistenceStrategy ->
328371 DiskSync ->
@@ -341,40 +384,32 @@ connectPersistentProjectM36 strat sync dbdir freshGraph notificationCallback ghc
341384 case graph of
342385 Left err' -> return $ Left (SetupDatabaseDirectoryError err')
343386 Right graph' -> do
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 {
387+ tvarGraph <- newTVarIO graph'
388+ sessions <- StmMap.newIO
389+ clientNodes <- StmSet.newIO
390+ (localNode, transport) <- createLocalNode
391+ lockMVar <- newMVar digest
392+ let conn = InProcessConnection InProcessConnectionConf {
353393 ipPersistenceStrategy = strat,
354394 ipClientNodes = clientNodes,
355395 ipSessions = sessions,
356396 ipTransactionGraph = tvarGraph,
357397 ipScriptSession = mScriptSession,
358− ipLocks = Just (lockFileH, lockMVar),
359− ipCallbackAsync = notifAsync
398+ ipLocalNode = localNode,
399+ ipTransport = transport,
400+ ipLocks = Just (lockFileH, lockMVar)
360401 }
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
371402
403+ notificationPid <- startNotificationListener localNode notificationCallback
404+ addClientNode conn notificationPid
405+ pure (Right conn)
406+
372407-- | Create a new session at the transaction id and return the session's Id.
373408createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)
374409createSessionAtCommit conn@(InProcessConnection _) commitId = do
375410 newSessionId <- nextRandom
376411 atomically $ createSessionAtCommit_ commitId newSessionId conn
377−createSessionAtCommit conn@(RemoteConnection _) uuid = remoteCall conn (CreateSessionAtCommit uuid)
412+createSessionAtCommit conn@(RemoteProcessConnection _) uuid = remoteCall conn (CreateSessionAtCommit uuid)
378413
379414createSessionAtCommit_ :: TransactionId -> SessionId -> Connection -> STM (Either RelationalError SessionId)
380415createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do
@@ -384,14 +419,14 @@ createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do
384419 case RE.transactionForId commitId graph of
385420 Left err -> pure (Left err)
386421 Right transaction -> do
387− let freshDiscon = DisconnectedTransaction commitId (Trans.schemas transaction) False
422+ let freshDiscon = DisconnectedTransaction commitId (Trans.schemas transaction) NoOperation
388423 keyDuplication <- StmMap.lookup newSessionId sessions
389424 case keyDuplication of
390425 Just _ -> pure $ Left (SessionIdInUseError newSessionId)
391426 Nothing -> do
392427 StmMap.insert (Session freshDiscon defaultSchemaName) newSessionId sessions
393428 pure $ Right newSessionId
394−createSessionAtCommit_ _ _ (RemoteConnection _) = error "createSessionAtCommit_ called on remote connection"
429+createSessionAtCommit_ _ _ (RemoteProcessConnection _) = error "createSessionAtCommit_ called on remote connection"
395430
396431-- | 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.
397432createSessionAtHead :: Connection -> HeadName -> IO (Either RelationalError SessionId)
@@ -403,18 +438,22 @@ createSessionAtHead conn@(InProcessConnection conf) headn = do
403438 case transactionForHead headn graph of
404439 Nothing -> pure $ Left (NoSuchHeadNameError headn)
405440 Just trans -> createSessionAtCommit_ (transactionId trans) newSessionId conn
406−createSessionAtHead conn@(RemoteConnection _) headn = remoteCall conn (CreateSessionAtHead headn)
441+createSessionAtHead conn@(RemoteProcessConnection _) headn = remoteCall conn (CreateSessionAtHead headn)
442+
443+-- | Used internally for server connections to keep track of remote nodes for the purpose of sending notifications later.
444+addClientNode :: Connection -> ProcessId -> IO ()
445+addClientNode (RemoteProcessConnection _) _ = error "addClientNode called on remote connection"
446+addClientNode (InProcessConnection conf) newProcessId = atomically (StmSet.insert newProcessId (ipClientNodes conf))
407447
408448-- | Discards a session, eliminating any uncommitted changes present in the session.
409449closeSession :: SessionId -> Connection -> IO ()
410450closeSession sessionId (InProcessConnection conf) =
411451 atomically $ StmMap.delete sessionId (ipSessions conf)
412−closeSession sessionId conn@(RemoteConnection _) = remoteCall conn (CloseSession sessionId)
452+closeSession sessionId conn@(RemoteProcessConnection _) = remoteCall conn (CloseSession sessionId)
413453
414454-- | 'close' cleans up the database access connection and closes any relevant sockets.
415455close :: Connection -> IO ()
416456close (InProcessConnection conf) = do
417− cancel (ipCallbackAsync conf)
418457 atomically $ do
419458 let sessions = ipSessions conf
420459#if MIN_VERSION_stm_containers(1,0,0)
@@ -423,18 +462,22 @@ close (InProcessConnection conf) = do
423462 StmMap.deleteAll sessions
424463#endif
425464 pure ()
465+ closeLocalNode (ipLocalNode conf)
466+ closeTransport (ipTransport conf)
426467 let mLocks = ipLocks conf
427468 case mLocks of
428469 Nothing -> pure ()
429470 Just (lockFileH, _) -> closeLockFile lockFileH
430471
431−close (RemoteConnection (RemoteConnectionConf conn)) =
432− RPC.close conn
472+close conn@(RemoteProcessConnection conf) = do
473+ _ <- remoteCall conn Logout :: IO Bool
474+ closeLocalNode (rLocalNode conf)
475+ closeTransport (rTransport conf)
433476
434477--used only by the server EntryPoints
435478closeRemote_ :: Connection -> IO ()
436479closeRemote_ (InProcessConnection _) = error "invalid call of closeRemote_ on InProcessConnection"
437−closeRemote_ (RemoteConnection (RemoteConnectionConf conn)) = RPC.close conn
480+closeRemote_ (RemoteProcessConnection conf) = runProcess (rLocalNode conf) (reconnect (rProcessId conf))
438481
439482 --we need to actually close the localNode's connection to the remote
440483--within the database server, we must catch and handle all exception lest they take down the database process- this handling might be different for other use-cases
@@ -445,15 +488,35 @@ excEither = handle handler
445488 where
446489 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc
447490 | otherwise = pure (Left (UnhandledExceptionError (show exc)))
491+
492+runProcessResult :: LocalNode -> Process a -> IO a
493+runProcessResult localNode proc = do
494+ ret <- newEmptyMVar
495+ runProcess localNode $ do
496+ val <- proc
497+ liftIO $ putMVar ret val
498+ takeMVar ret
499+
500+safeLogin :: Login -> ProcessId -> Process Bool
501+safeLogin login procId = do
502+ ret <- call procId login
503+ case ret of
504+ Left (_ :: ServerError) -> pure False
505+ Right val -> pure val
448506
449−
450−remoteCall :: (Serialise a, Serialise b) => Connection -> a -> IO b
507+remoteCall :: (Binary a, Binary b, Typeable a, Typeable b) => Connection -> a -> IO b
451508remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"
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
509+remoteCall (RemoteProcessConnection conf) arg = runProcessResult localNode $ do
510+ ret <- safeCall serverProcessId arg
511+ case ret of
512+ Left err -> error ("server died: " ++ show err)
513+ Right ret' -> case ret' of
514+ Left RequestTimeoutError -> liftIO (throwIO RequestTimeoutException)
515+ Left (ProcessDiedError _) -> liftIO (throwIO RemoteProcessDiedException)
516+ Right val -> pure val
517+ where
518+ localNode = rLocalNode conf
519+ serverProcessId = rProcessId conf
457520
458521sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)
459522sessionForSessionId sessionId sessions =
@@ -488,7 +551,7 @@ currentSchemaName sessionId (InProcessConnection conf) = atomically $ do
488551 case eSession of
489552 Left err -> pure (Left err)
490553 Right session -> pure (Right (Sess.schemaName session))
491−currentSchemaName sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveCurrentSchemaName sessionId)
554+currentSchemaName sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveCurrentSchemaName sessionId)
492555
493556-- | Switch to the named isomorphic schema.
494557setCurrentSchemaName :: SessionId -> Connection -> SchemaName -> IO (Either RelationalError ())
@@ -500,7 +563,7 @@ setCurrentSchemaName sessionId (InProcessConnection conf) sname = atomically $ d
500563 Right session -> case Sess.setSchemaName sname session of
501564 Left err -> pure (Left err)
502565 Right newSession -> StmMap.insert newSession sessionId sessions >> pure (Right ())
503−setCurrentSchemaName sessionId conn@(RemoteConnection _) sname = remoteCall conn (ExecuteSetCurrentSchema sessionId sname)
566+setCurrentSchemaName sessionId conn@(RemoteProcessConnection _) sname = remoteCall conn (ExecuteSetCurrentSchema sessionId sname)
504567
505568-- | Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.
506569executeRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)
@@ -524,7 +587,7 @@ executeRelationalExpr sessionId (InProcessConnection conf) expr = excEither $ at
524587 Right rel -> pure (force (Right rel)) -- this is necessary so that any undefined/error exceptions are spit out here
525588 Left err -> pure (Left err)
526589
527−executeRelationalExpr sessionId conn@(RemoteConnection _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)
590+executeRelationalExpr sessionId conn@(RemoteProcessConnection _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)
528591
529592-- | 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.
530593executeDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())
@@ -551,14 +614,14 @@ executeDatabaseContextExpr sessionId (InProcessConnection conf) expr = excEither
551614 if not (RE.dbc_dirty newState) then --nothing dirtied, nothing to do
552615 pure (Right ())
553616 else do
554− let newDiscon = DisconnectedTransaction (Sess.parentId session) newSchemas True
617+ let newDiscon = DisconnectedTransaction (Sess.parentId session) newSchemas NoOperation
555618 context' = RE.dbc_context newState
556619 newSubschemas = Schema.processDatabaseContextExprSchemasUpdate (Sess.subschemas session) expr
557620 newSchemas = Schemas context' newSubschemas
558621 newSession = Session newDiscon (Sess.schemaName session)
559622 StmMap.insert newSession sessionId sessions
560623 pure (Right ())
561−executeDatabaseContextExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)
624+executeDatabaseContextExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)
562625
563626-- | 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.
564627autoMergeToHead :: SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())
@@ -587,7 +650,7 @@ autoMergeToHead sessionId (InProcessConnection conf) strat headName' = do
587650 Left err -> pure (Left err)
588651 Right ((discon', graph'), transactionIdsAdded) ->
589652 pure (Right (discon', graph', transactionIdsAdded))
590−autoMergeToHead sessionId conn@(RemoteConnection _) strat headName' = remoteCall conn (ExecuteAutoMergeToHead sessionId strat headName')
653+autoMergeToHead sessionId conn@(RemoteProcessConnection _) strat headName' = remoteCall conn (ExecuteAutoMergeToHead sessionId strat headName')
591654
592655-- | Execute a database context IO-monad-based expression for the given session and connection. `DatabaseContextIOExpr`s modify the DatabaseContext but cannot be purely implemented.
593656--this is almost completely identical to executeDatabaseContextExpr above
@@ -607,14 +670,28 @@ executeDatabaseContextIOExpr sessionId (InProcessConnection conf) expr = excEith
607670 case res of
608671 Left err -> pure (Left err)
609672 Right newState -> do
610− let newDiscon = DisconnectedTransaction (Sess.parentId session) newSchemas False
673+ let newDiscon = DisconnectedTransaction (Sess.parentId session) newSchemas NoOperation
611674 newSchemas = Schemas context' (Sess.subschemas session)
612675 newSession = Session newDiscon (Sess.schemaName session)
613676 context' = RE.dbc_context newState
614677 atomically $ StmMap.insert newSession sessionId sessions
615678 pure (Right ())
616−executeDatabaseContextIOExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)
679+executeDatabaseContextIOExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)
617680
681+{-
682+executeGraphExprSTM_ :: TransactionId -> SessionId -> Session -> Sessions -> TransactionGraphOperator -> TransactionGraph -> TVar TransactionGraph -> STM (Either RelationalError (TransactionGraph, DisconnectedTransaction)
683+executeGraphExprSTM_ freshId sessionId session sessions graphExpr graph graphTVar= do
684+ case evalGraphOp freshId (Sess.disconnectedTransaction session) graph graphExpr of
685+ Left err -> do
686+ when updateGraphOnError (writeTVar graphTVar graph)
687+ pure $ Left err
688+ Right (discon', graph') -> do
689+ writeTVar graphTVar graph'
690+ let newSession = Session discon' (Sess.schemaName session)
691+ STMMap.insert newSession sessionId sessions
692+ pure $ Right graph'
693+-}
694+
618695-- process notifications for commits
619696executeCommitExprSTM_
620697 :: TransactionGraph
@@ -655,8 +732,78 @@ executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do
655732 --if freshId appears in the graph, then we need to pass it on
656733 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]
657734 pure (Right (discon', graph', transIds))
658−
659−executeGraphExpr sessionId conn@(RemoteConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)
735+{-
736+executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do
737+ let strat = ipPersistenceStrategy conf
738+ clientNodes = ipClientNodes conf
739+ sessions = ipSessions conf
740+ graphTvar = ipTransactionGraph conf
741+ mLockFileH = ipLocks conf
742+ lockHandler body = case graphExpr of
743+ Commit -> case mLockFileH of
744+ Nothing -> body False
745+ Just (lockFileH, lockMVar) -> let acquireLocks = do
746+ lastWrittenDigest <- takeMVar lockMVar
747+ lockFile lockFileH WriteLock
748+ latestDigest <- readGraphTransactionIdDigest strat
749+ pure (latestDigest /= lastWrittenDigest)
750+
751+ releaseLocks _ = do
752+ --still holding the lock- get the latest digest
753+ gDigest <- readGraphTransactionIdDigest strat
754+ unlockFile lockFileH
755+ putMVar lockMVar gDigest
756+ in bracket acquireLocks releaseLocks body
757+ _ -> body False
758+ freshId <- nextRandom
759+ lockHandler $ \dbWrittenByOtherProcess -> do
760+ --if the database file has been updated since we wrote it last, load it before trying to sync our version done- this can result in TransactionNotAHeadErrors
761+ --read transaction data and compare to existing graph
762+ --in the future, we can detect if updated transaction graph can be safely merged (such as with a transaction on a separate head) (rebase-able commits should force the user to rebase from the client to confirm that the action makes sense)
763+ manip <- atomically $ do
764+ eSession <- sessionForSessionId sessionId sessions
765+ --handle graph update by other process
766+ oldGraph <- readTVar graphTvar
767+ case eSession of
768+ Left err -> pure (Left err)
769+ Right session -> do
770+ let mScriptSession = ipScriptSession conf
771+ dbdir = case strat of
772+ MinimalPersistence x -> x
773+ CrashSafePersistence x -> x
774+ _ -> error "accessing dbdir on non-persisted connection"
775+ eRefreshedGraph <- if dbWrittenByOtherProcess then
776+ unsafeIOToSTM (transactionGraphLoad dbdir oldGraph mScriptSession)
777+ else
778+ pure (Right oldGraph)
779+ case eRefreshedGraph of
780+ Left err -> pure (Left (DatabaseLoadError err))
781+ Right refreshedGraph -> do
782+ --snip it
783+ eGraph <- executeGraphExprSTM_ dbWrittenByOtherProcess freshId sessionId session sessions graphExpr refreshedGraph graphTvar
784+ --snip it
785+ case eGraph of
786+ Left err -> pure (Left err)
787+ Right newGraph -> do
788+ --handle commit
789+ if isCommit graphExpr then do
790+ case transactionForId (Sess.parentId session) oldGraph of
791+ Left err -> pure $ Left err
792+ Right previousTrans -> do
793+ (evaldNots, nodes) <- executeCommitExprSTM_ (Trans.concreteDatabaseContext previousTrans) (Sess.concreteDatabaseContext session) clientNodes
794+ nodesToNotify <- toList (StmSet.stream nodes)
795+ pure $ Right (evaldNots, nodesToNotify, newGraph)
796+ else
797+ pure $ Right (M.empty, [], newGraph)
798+ case manip of
799+ Left err -> return $ Just err
800+ Right (notsToFire, nodesToNotify, newGraph) -> do
801+ --update filesystem database, if necessary
802+ processTransactionGraphPersistence strat newGraph
803+ sendNotifications nodesToNotify (ipLocalNode conf) notsToFire
804+ pure Nothing
805+-}
806+executeGraphExpr sessionId conn@(RemoteProcessConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)
660807
661808-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.
662809executeTransGraphRelationalExpr :: SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)
@@ -664,7 +811,10 @@ executeTransGraphRelationalExpr _ (InProcessConnection conf) tgraphExpr = excEit
664811 let graphTvar = ipTransactionGraph conf
665812 graph <- readTVar graphTvar
666813 pure $ force $ optimizeAndEvalTransGraphRelationalExpr graph tgraphExpr
667−executeTransGraphRelationalExpr sessionId conn@(RemoteConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)
814+{- case runReader (RE.evalRelationalExpr relExpr) (RE.mkRelationalExprState DBC.empty) of
815+ Left err -> pure (Left err)
816+ Right rel -> pure (force (Right rel))-}
817+executeTransGraphRelationalExpr sessionId conn@(RemoteProcessConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)
668818
669819-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.
670820executeSchemaExpr :: SessionId -> Connection -> Schema.SchemaExpr -> IO (Either RelationalError ())
@@ -684,27 +834,26 @@ executeSchemaExpr sessionId (InProcessConnection conf) schemaExpr = atomically $
684834 --hm- maybe we should start using lenses
685835 let discon = Sess.disconnectedTransaction session
686836 newSchemas = Schemas newContext newSubschemas
687− newSession = Session (DisconnectedTransaction (Discon.parentId discon) newSchemas False) (Sess.schemaName session)
837+ newSession = Session (DisconnectedTransaction (Discon.parentId discon) newSchemas NoOperation) (Sess.schemaName session)
688838 StmMap.insert newSession sessionId sessions
689839 pure (Right ())
690−executeSchemaExpr sessionId conn@(RemoteConnection _) schemaExpr = remoteCall conn (ExecuteSchemaExpr sessionId schemaExpr)
840+executeSchemaExpr sessionId conn@(RemoteProcessConnection _) schemaExpr = remoteCall conn (ExecuteSchemaExpr sessionId schemaExpr)
691841
692842-- | 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.
693843commit :: SessionId -> Connection -> IO (Either RelationalError ())
694844commit sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Commit
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−
845+commit sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Commit)
846+
847+sendNotifications :: [ProcessId] -> LocalNode -> EvaluatedNotifications -> IO ()
848+sendNotifications pids localNode nots = mapM_ sendNots pids
849+ where
850+ sendNots remoteClientPid =
851+ unless (M.null nots) $ runProcess localNode $ send remoteClientPid (NotificationMessage nots)
852+
704853-- | 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.
705854rollback :: SessionId -> Connection -> IO (Either RelationalError ())
706855rollback sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Rollback
707−rollback sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)
856+rollback sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)
708857
709858-- | Write the transaction graph to disk. This function can be used to incrementally write new transactions to disk.
710859processTransactionGraphPersistence :: PersistenceStrategy -> [TransactionId] -> TransactionGraph -> IO ()
@@ -720,7 +869,7 @@ readGraphTransactionIdDigest (CrashSafePersistence dbdir) = readGraphTransaction
720869-- | 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.
721870typeForRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)
722871typeForRelationalExpr sessionId conn@(InProcessConnection _) relExpr = atomically $ typeForRelationalExprSTM sessionId conn relExpr
723−typeForRelationalExpr sessionId conn@(RemoteConnection _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)
872+typeForRelationalExpr sessionId conn@(RemoteProcessConnection _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)
724873
725874typeForRelationalExprSTM :: SessionId -> Connection -> RelationalExpr -> STM (Either RelationalError Relation)
726875typeForRelationalExprSTM sessionId (InProcessConnection conf) relExpr = do
@@ -757,7 +906,7 @@ inclusionDependencies sessionId (InProcessConnection conf) = do
757906 else
758907 pure (Schema.inclusionDependenciesInSchema schema (B.inclusionDependencies context))
759908
760−inclusionDependencies sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveInclusionDependencies sessionId)
909+inclusionDependencies sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveInclusionDependencies sessionId)
761910
762911typeConstructorMapping :: SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)
763912typeConstructorMapping sessionId (InProcessConnection conf) = do
@@ -768,7 +917,7 @@ typeConstructorMapping sessionId (InProcessConnection conf) = do
768917 Left err -> pure $ Left err
769918 Right (session, _) -> --warning, no schema support for typeconstructors
770919 pure (Right (B.typeConstructorMapping (Sess.concreteDatabaseContext session)))
771−typeConstructorMapping sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveTypeConstructorMapping sessionId)
920+typeConstructorMapping sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveTypeConstructorMapping sessionId)
772921
773922-- | 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.
774923planForDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)
@@ -788,7 +937,7 @@ planForDatabaseContextExpr sessionId (InProcessConnection conf) dbExpr = do
788937 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-}
789938 pure (Left NonConcreteSchemaPlanError)
790939
791−planForDatabaseContextExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)
940+planForDatabaseContextExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)
792941
793942-- | Return a relation which represents the current state of the global transaction graph. The attributes are
794943-- * current- boolean attribute representing whether or not the current session references this transaction
@@ -806,7 +955,7 @@ transactionGraphAsRelation sessionId (InProcessConnection conf) = do
806955 Right session ->
807956 graphAsRelation (Sess.disconnectedTransaction session) <$> readTVar tvar
808957
809−transactionGraphAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveTransactionGraph sessionId)
958+transactionGraphAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveTransactionGraph sessionId)
810959
811960-- | Returns the names and types of the relation variables in the current 'Session'.
812961relationVariablesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)
@@ -828,7 +977,7 @@ relationVariablesAsRelation sessionId (InProcessConnection conf) = do
828977 let schemaContext = context {relationVariables = relvars }
829978 pure $ RE.relationVariablesAsRelation schemaContext graph
830979
831−relationVariablesAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)
980+relationVariablesAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)
832981
833982-- | Returns the names and types of the atom functions in the current 'Session'.
834983atomFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)
@@ -841,7 +990,7 @@ atomFunctionsAsRelation sessionId (InProcessConnection conf) = do
841990 Right (session, _) ->
842991 pure (AF.atomFunctionsAsRelation (atomFunctions (concreteDatabaseContext session)))
843992
844−atomFunctionsAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveAtomFunctionSummary sessionId)
993+atomFunctionsAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveAtomFunctionSummary sessionId)
845994
846995databaseContextFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)
847996databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do
@@ -853,7 +1002,7 @@ databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do
8531002 Right (session, _) ->
8541003 pure (DCF.databaseContextFunctionsAsRelation (dbcFunctions (concreteDatabaseContext session)))
8551004
856−databaseContextFunctionsAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveDatabaseContextFunctionSummary sessionId)
1005+databaseContextFunctionsAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveDatabaseContextFunctionSummary sessionId)
8571006
8581007-- | Returns the transaction id for the connection's disconnected transaction committed parent transaction.
8591008headTransactionId :: SessionId -> Connection -> IO (Either RelationalError TransactionId)
@@ -864,7 +1013,7 @@ headTransactionId sessionId (InProcessConnection conf) = do
8641013 case eSession of
8651014 Left err -> pure (Left err)
8661015 Right session -> pure $ Right (Sess.parentId session)
867−headTransactionId sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveHeadTransactionId sessionId)
1016+headTransactionId sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveHeadTransactionId sessionId)
8681017
8691018headNameSTM_ :: SessionId -> Sessions -> TVar TransactionGraph -> STM (Either RelationalError HeadName)
8701019headNameSTM_ sessionId sessions graphTvar = do
@@ -884,7 +1033,7 @@ headName sessionId (InProcessConnection conf) = do
8841033 let sessions = ipSessions conf
8851034 graphTvar = ipTransactionGraph conf
8861035 atomically (headNameSTM_ sessionId sessions graphTvar)
887−headName sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteHeadName sessionId)
1036+headName sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteHeadName sessionId)
8881037
8891038-- | Returns a listing of all available atom types.
8901039atomTypesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)
@@ -898,7 +1047,7 @@ atomTypesAsRelation sessionId (InProcessConnection conf) = do
8981047 case typesAsRelation (B.typeConstructorMapping (Sess.concreteDatabaseContext session)) of
8991048 Left err -> pure (Left err)
9001049 Right rel -> pure (Right rel)
901−atomTypesAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)
1050+atomTypesAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)
9021051
9031052disconnectedTransactionIsDirty :: SessionId -> Connection -> IO (Either RelationalError Bool)
9041053disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do
@@ -909,12 +1058,12 @@ disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do
9091058 Left err -> pure (Left err)
9101059 Right session ->
9111060 pure (Right (isDirty session))
912−disconnectedTransactionIsDirty sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveSessionIsDirty sessionId)
1061+disconnectedTransactionIsDirty sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveSessionIsDirty sessionId)
9131062
9141063--used only for testing- we expect this to throw an exception
9151064callTestTimeout_ :: SessionId -> Connection -> IO Bool
9161065callTestTimeout_ _ (InProcessConnection _) = error "bad testing call"
917−callTestTimeout_ sessionId conn@(RemoteConnection _) = remoteCall conn (TestTimeout sessionId)
1066+callTestTimeout_ sessionId conn@(RemoteProcessConnection _) = remoteCall conn (TestTimeout sessionId)
9181067
9191068--used in tests only
9201069transactionGraph_ :: Connection -> IO TransactionGraph
@@ -999,8 +1148,15 @@ commitLock_ sessionId conf stmBlock = do
9991148 Right (notsToFire, nodesToNotify, newGraph, transactionIdsToPersist) -> do
10001149 --update filesystem database, if necessary
10011150 processTransactionGraphPersistence strat transactionIdsToPersist newGraph
1002− sendNotifications nodesToNotify notsToFire
1151+ sendNotifications nodesToNotify (ipLocalNode conf) notsToFire
10031152 pure (Right ())
1153+{-
1154+writeDisconAndGraph_ :: TVar TransactionGraph -> SessionId -> Session -> Sessions -> DisconnectedTransaction -> TransactionGraph -> STM ()
1155+writeDisconAndGraph_ graphTvar sessionId session sessions discon graph = do
1156+ writeTVar graphTvar graph
1157+ let newSession = Session discon (Sess.schemaName session)
1158+ StmMap.insert newSession sessionId sessions
1159+-}
10041160
10051161-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.
10061162withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)
@@ -1042,54 +1198,12 @@ executeDataFrameExpr sessionId conn@(InProcessConnection _) dfExpr = do
10421198 case verified of
10431199 Left err -> pure (Left err)
10441200 Right attrs -> do
1045− let attrOrders = zipWith
1046− (DF.AttributeOrder . attributeName)
1047− attrs
1048− orders
1201+ let attrOrders = map (\(attr',order') -> DF.AttributeOrder (attributeName attr') order') (zip attrs orders)
10491202 case DF.sortDataFrameBy attrOrders . DF.toDataFrame $ rel of
10501203 Left err -> pure (Left err)
10511204 Right dFrame -> do
10521205 let dFrame' = maybe dFrame (`DF.drop'` dFrame) (DF.offset dfExpr)
10531206 dFrame'' = maybe dFrame' (`DF.take'` dFrame') (DF.limit dfExpr)
10541207 pure (Right dFrame'')
1055−executeDataFrameExpr sessionId conn@(RemoteConnection _) dfExpr = remoteCall conn (ExecuteDataFrameExpr sessionId dfExpr)
1208+executeDataFrameExpr sessionId conn@(RemoteProcessConnection _) dfExpr = remoteCall conn (ExecuteDataFrameExpr sessionId dfExpr)
10561209
1057−validateMerkleHashes :: SessionId -> Connection -> IO (Either RelationalError ())
1058−validateMerkleHashes sessionId (InProcessConnection conf) = do
1059− let sessions = ipSessions conf
1060− atomically $ do
1061− eSession <- sessionForSessionId sessionId sessions
1062− case eSession of
1063− Left err -> pure (Left err)
1064− Right _ -> do
1065− graph <- readTVar (ipTransactionGraph conf)
1066− case Graph.validateMerkleHashes graph of
1067− Left merkleErrs -> pure $ Left $ someErrors (map (\(MerkleValidationError tid expected actual) -> MerkleHashValidationError tid expected actual) merkleErrs)
1068− Right () -> pure (Right ())
1069−validateMerkleHashes sessionId conn@RemoteConnection{} = remoteCall conn (ExecuteValidateMerkleHashes sessionId)
1070−
1071−type ClientNodes = StmSet.Set ClientInfo
1072−
1073−-- internal structure specific to in-process connections
1074−data InProcessConnectionConf = InProcessConnectionConf {
1075− ipPersistenceStrategy :: PersistenceStrategy,
1076− ipClientNodes :: ClientNodes,
1077− ipSessions :: Sessions,
1078− ipTransactionGraph :: TVar TransactionGraph,
1079− ipScriptSession :: Maybe ScriptSession,
1080− ipLocks :: Maybe (LockFile, MVar LockFileHash), -- nothing when NoPersistence
1081− ipCallbackAsync :: Async ()
1082− }
1083−
1084−-- clients may connect associate one socket/mvar with the server to register for change callbacks
1085−data ClientInfo = RemoteClientInfo (RPC.Locking Socket) |
1086− InProcessClientInfo (MVar EvaluatedNotifications)
1087−
1088−instance Eq ClientInfo where
1089− (RemoteClientInfo a) == (RemoteClientInfo b) = RPC.lockless a == RPC.lockless b
1090− (InProcessClientInfo a) == (InProcessClientInfo b) = a == b
1091− _ == _ = False
1092−
1093−instance Hashable ClientInfo where
1094− hashWithSalt salt (RemoteClientInfo sock) = hashWithSalt salt (show (RPC.lockless sock))
1095− hashWithSalt salt (InProcessClientInfo _) = hashWithSalt salt (1::Int)
src/lib/ProjectM36/DataFrame.hs+15−23
@@ -1,8 +1,8 @@
1−{-# LANGUAGE DeriveGeneric, DerivingVia #-}
1+{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}
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 hiding (drop)
5+import ProjectM36.Attribute as A
66import ProjectM36.Error
77import qualified ProjectM36.Relation as R
88import ProjectM36.Relation.Show.Term
@@ -16,19 +16,15 @@ 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
1920import Control.Arrow
20−#if __GLASGOW_HASKELL__ < 804
21+#if __GLASGOW_HASKELL__ <= 802
2122import Data.Monoid
2223#endif
2324
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)
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)
3228
3329ascending :: T.Text
3430ascending = "⬆"
@@ -43,11 +39,9 @@ data DataFrame = DataFrame {
4339 orders :: [AttributeOrder],
4440 attributes :: Attributes,
4541 tuples :: [DataFrameTuple]
46− }
47− deriving (Show, Generic)
42+ } deriving (Show, Generic, Binary)
4843
49−data DataFrameTuple = DataFrameTuple Attributes (V.Vector Atom)
50− deriving (Eq, Show, Generic)
44+data DataFrameTuple = DataFrameTuple Attributes (V.Vector Atom) deriving (Eq, Show, Generic, Binary)
5145
5246sortDataFrameBy :: [AttributeOrder] -> DataFrame -> Either RelationalError DataFrame
5347sortDataFrameBy attrOrders frame = do
@@ -81,7 +75,7 @@ compareTupleByOneAttributeName attr tuple1 tuple2 =
8175 Right atom2 -> compareAtoms atom1 atom2
8276
8377atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom
84−atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of
78+atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of
8579 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))
8680 Just index -> case tupVec V.!? index of
8781 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))
@@ -128,18 +122,17 @@ data DataFrameExpr = DataFrameExpr {
128122 orderExprs :: [AttributeOrderExpr],
129123 offset :: Maybe Integer,
130124 limit :: Maybe Integer
131− }
132− deriving (Show, Generic)
125+ } deriving (Show, Binary, Generic)
133126
134127dataFrameAsHTML :: DataFrame -> T.Text
135128-- 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
136129dataFrameAsHTML df
137− | length (tuples df) == 1 && A.null (attributes df) = style <>
130+ | length (tuples df) == 1 && L.null (attributes df) = style <>
138131 tablestart <>
139132 "<tr><th></th></tr>" <>
140133 "<tr><td></td></tr>" <>
141134 tablefooter <> "</table>"
142− | L.null (tuples df) && A.null (attributes df) = style <>
135+ | L.null (tuples df) && L.null (attributes df) = style <>
143136 tablestart <>
144137 "<tr><th></th></tr>" <>
145138 tablefooter <>
@@ -162,7 +155,7 @@ tuplesAsHTML = foldr folder ""
162155 folder tuple acc = acc <> tupleAsHTML tuple
163156
164157tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]
165−tupleAssocs (DataFrameTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)
158+tupleAssocs (DataFrameTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)
166159
167160
168161tupleAsHTML :: DataFrameTuple -> T.Text
@@ -170,11 +163,10 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>
170163 where
171164 tupleFrag tup = "<td>" <> atomAsHTML (snd tup) <> "</td>"
172165 atomAsHTML (RelationAtom rel) = RelHTML.relationAsHTML rel
173− atomAsHTML (TextAtom t) = "&quot;" <> t <> "&quot;"
174166 atomAsHTML atom = atomToText atom
175167
176168attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text
177−attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"
169+attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"
178170 where
179171 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"
180172 ordering attrName = " " <> case L.find (\(AttributeOrder nam _) -> nam == attrName) orders' of
src/lib/ProjectM36/DataTypes/Interval.hs−2
@@ -37,7 +37,6 @@ supportsInterval typ = case typ of
3737 BoolAtomType -> False
3838 RelationAtomType _ -> False
3939 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this
40− RelationalExprAtomType -> False
4140 TypeVariableType _ -> False
4241
4342supportsOrdering :: AtomType -> Bool
@@ -51,7 +50,6 @@ supportsOrdering typ = case typ of
5150 ByteStringAtomType -> False
5251 BoolAtomType -> False
5352 RelationAtomType _ -> False
54− RelationalExprAtomType -> False
5553 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this
5654 TypeVariableType _ -> False
5755
src/lib/ProjectM36/DataTypes/Primitive.hs−1
@@ -42,4 +42,3 @@ 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,7 +24,6 @@ isSortableAtomType typ = case typ of
2424 DateTimeAtomType -> True
2525 ByteStringAtomType -> False
2626 BoolAtomType -> True
27− RelationalExprAtomType -> False
2827 RelationAtomType _ -> False
2928 ConstructedAtomType _ _ -> False
3029 TypeVariableType _ -> False
src/lib/ProjectM36/DatabaseContext.hs+2−17
@@ -1,15 +1,11 @@
11module ProjectM36.DatabaseContext where
22import ProjectM36.Base
3−import Control.Monad (void)
43import qualified Data.Map as M
54import qualified Data.HashSet as HS
65import ProjectM36.DataTypes.Basic
76import 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
139
1410empty :: DatabaseContext
1511empty = DatabaseContext { inclusionDependencies = M.empty,
@@ -21,7 +17,7 @@ empty = DatabaseContext { inclusionDependencies = M.empty,
2117
2218-- | Remove TransactionId markers on GraphRefRelationalExpr
2319stripGraphRefRelationalExpr :: GraphRefRelationalExpr -> RelationalExpr
24−stripGraphRefRelationalExpr = void
20+stripGraphRefRelationalExpr = fmap (const ())
2521
2622-- | convert an existing database context into its constituent expression.
2723databaseContextAsDatabaseContextExpr :: DatabaseContext -> DatabaseContextExpr
@@ -41,14 +37,3 @@ basicDatabaseContext = DatabaseContext { inclusionDependencies = M.empty,
4137 notifications = M.empty,
4238 typeConstructorMapping = basicTypeConstructorMapping
4339 }
44−
45−--for building the Merkle hash
46−hashBytes :: DatabaseContext -> BL.ByteString
47−hashBytes ctx = BL.fromChunks [incDeps, rvs, nots, tConsMap] <> atomFs <> dbcFs
48− where
49− incDeps = serialise (inclusionDependencies ctx)
50− rvs = serialise (relationVariables ctx)
51− atomFs = HS.foldr (mappend . AF.hashBytes) mempty (atomFunctions ctx)
52− dbcFs = HS.foldr (mappend . DBCF.hashBytes) mempty (dbcFunctions ctx)
53− nots = serialise (notifications ctx)
54− tConsMap = serialise (typeConstructorMapping ctx)
src/lib/ProjectM36/DatabaseContextFunction.hs+1−17
@@ -1,9 +1,7 @@
1−{-# LANGUAGE CPP #-}
21module ProjectM36.DatabaseContextFunction where
32--implements functions which operate as: [Atom] -> DatabaseContextExpr -> Either RelationalError DatabaseContextExpr
43import ProjectM36.Base
54import ProjectM36.Error
6−import ProjectM36.Serialise.Base ()
75import ProjectM36.Attribute as A
86import ProjectM36.Relation
97import ProjectM36.AtomType
@@ -11,8 +9,6 @@ import qualified Data.HashSet as HS
119import qualified Data.Map as M
1210import ProjectM36.ScriptSession
1311import qualified Data.Text as T
14−import qualified Data.ByteString.Lazy as BL
15−import Codec.Winery
1612
1713emptyDatabaseContextFunction :: DatabaseContextFunctionName -> DatabaseContextFunction
1814emptyDatabaseContextFunction name = DatabaseContextFunction {
@@ -65,11 +61,7 @@ createScriptedDatabaseContextFunction :: DatabaseContextFunctionName -> [TypeCon
6561createScriptedDatabaseContextFunction funcName argsIn retArg = AddDatabaseContextFunction funcName (argsIn ++ [databaseContextFunctionReturnType retArg])
6662
6763loadDatabaseContextFunctions :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError [DatabaseContextFunction])
68−#ifdef PM36_HASKELL_SCRIPTING
6964loadDatabaseContextFunctions = loadFunction
70−#else
71−loadDatabaseContextFunctions _ _ _ = pure (Left LoadSymbolError)
72−#endif
7365
7466databaseContextFunctionsAsRelation :: DatabaseContextFunctions -> Either RelationalError Relation
7567databaseContextFunctionsAsRelation dbcFuncs = mkRelationFromList attrs tups
@@ -80,12 +72,4 @@ databaseContextFunctionsAsRelation dbcFuncs = mkRelationFromList attrs tups
8072 dbcFuncToTuple func = [TextAtom (dbcFuncName func),
8173 TextAtom (dbcTextType (dbcFuncType func))]
8274 dbcTextType typ = T.intercalate " -> " (map prettyAtomType typ ++ ["DatabaseContext", "DatabaseContext"])
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
75+
src/lib/ProjectM36/DatabaseContextFunctionError.hs+2−1
@@ -1,8 +1,9 @@
11{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}
22module ProjectM36.DatabaseContextFunctionError where
33import GHC.Generics
4+import Data.Binary
45import Control.DeepSeq
56
67{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}
78data DatabaseContextFunctionError = DatabaseContextFunctionUserError String
8− deriving (Generic, Eq, Show, NFData)
9+ deriving (Generic, Eq, Show, Binary, NFData)
src/lib/ProjectM36/DisconnectedTransaction.hs+6−2
@@ -11,7 +11,11 @@ parentId :: DisconnectedTransaction -> TransactionId
1111parentId (DisconnectedTransaction pid _ _) = pid
1212
1313isDirty :: DisconnectedTransaction -> Bool
14−isDirty (DisconnectedTransaction _ _ flag) = flag
14+isDirty (DisconnectedTransaction _ _ NoOperation) = False
15+isDirty _ = True
16+
17+diffExpr :: DisconnectedTransaction -> DatabaseContextExpr
18+diffExpr (DisconnectedTransaction _ _ expr) = expr
1519
1620freshTransaction :: TransactionId -> Schemas -> DisconnectedTransaction
17−freshTransaction tid schemas' = DisconnectedTransaction tid schemas' False
21+freshTransaction tid schemas' = DisconnectedTransaction tid schemas' NoOperation
src/lib/ProjectM36/Error.hs+14−20
@@ -1,7 +1,6 @@
11{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}
22module ProjectM36.Error where
33import ProjectM36.Base
4−import ProjectM36.MerkleHash
54import ProjectM36.DatabaseContextFunctionError
65import ProjectM36.AtomFunctionError
76import qualified Data.Set as S
@@ -9,6 +8,7 @@ import Control.DeepSeq (NFData, rnf)
98import Control.DeepSeq.Generics (genericRnf)
109import GHC.Generics (Generic)
1110import 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 ImportError'
84+ | ImportError T.Text -- really? This should be broken out into some other error type- this has nothing to do with relational algebra
8585 | ExportError T.Text
8686 | UnhandledExceptionError String
8787 | MergeTransactionError MergeError
@@ -100,17 +100,14 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)
100100 | NonConcreteSchemaPlanError
101101
102102 | NoUncommittedContextInEvalError
103− | TupleExprsReferenceMultipleMarkersError
104−
105− | MerkleHashValidationError TransactionId MerkleHash MerkleHash
106−
103+
107104 | MultipleErrors [RelationalError]
108− deriving (Show,Eq,Generic,Typeable, NFData)
105+ deriving (Show,Eq,Generic,Binary,Typeable, NFData)
109106
110107data PersistenceError = InvalidDirectoryError FilePath |
111108 MissingTransactionError TransactionId |
112109 WrongDatabaseFormatVersionError String String
113− deriving (Show, Eq, Generic, NFData)
110+ deriving (Show, Eq, Generic, Binary, NFData)
114111
115112--collapse list of errors into normal error- if there is just one, just return one
116113someErrors :: [RelationalError] -> RelationalError
@@ -128,7 +125,7 @@ data MergeError = SelectedHeadMismatchMergeError |
128125 StrategyViolatesComponentMergeError | --failed merge in inc deps, relvars, etc.
129126 StrategyViolatesRelationVariableMergeError |
130127 StrategyViolatesTypeConstructorMergeError
131− deriving (Show, Eq, Generic, Typeable)
128+ deriving (Show, Eq, Generic, Binary, Typeable)
132129
133130instance NFData MergeError where rnf = genericRnf
134131
@@ -136,20 +133,17 @@ data ScriptCompilationError = TypeCheckCompilationError String String | --expect
136133 SyntaxErrorCompilationError String |
137134 ScriptCompilationDisabledError |
138135 OtherScriptCompilationError String
139− deriving (Show, Eq, Generic, Typeable, NFData)
136+ deriving (Show, Eq, Generic, Binary, Typeable, NFData)
140137
141138instance Exception ScriptCompilationError
142139
143140data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |
144141 RelVarInReferencedMoreThanOnce RelVarName |
145142 RelVarOutReferencedMoreThanOnce RelVarName
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)
143+ deriving (Show, Eq, Generic, Binary, Typeable, NFData)
144+
145+
146+-- errors returned from the distributed-process call handlers
147+data ServerError = RequestTimeoutError |
148+ ProcessDiedError String
149+ deriving (Generic, Binary, Eq)
src/lib/ProjectM36/FileLock.hs+1−1
@@ -1,4 +1,4 @@
1−{-# LANGUAGE CPP #-}
1+{-# LANGUAGE CPP, NamedFieldPuns #-}
22--cross-platform file locking utilizing POSIX file locking on Unix/Linux and Windows file locking
33--hackage's System.FileLock doesn't support POSIX advisory locks nor locking file based on file descriptors, hence this needless rewrite
44module ProjectM36.FileLock where
src/lib/ProjectM36/GraphRefRelationalExpr.hs+25−24
@@ -1,37 +1,41 @@
11module ProjectM36.GraphRefRelationalExpr where
22--evaluate relational expressions across the entire transaction graph to support cross-transaction referencing
33import ProjectM36.Base
4+import ProjectM36.Error
45import qualified Data.Set as S
56
6−--import Debug.Trace
7+-- core evaluation function- all other relational expr forms compile to GraphRefRelationalExpr
8+eval :: GraphRefRelationalExpr -> TransactionGraph -> Either RelationalError Relation
9+eval = undefined
10+{-eval (MakeRelationFromExprs mAttrExprs tupleExprs) graph = do
11+ mAttrs <- case mAttrExprs of
12+ Just _ ->
13+ Just . A.attributesFromList <$> mapM (evalAttrExpr tConss) (fromMaybe [] mAttrExprs)
14+ Nothing -> pure Nothing
15+ tuples <- mapM (evalTupleExpr mAttrs) tupleExprs
16+ let attrs = fromMaybe firstTupleAttrs mAttrs
17+ firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)
18+ mkRelation attrs (RelationTupleSet tuples)
19+
20+
21+-}
722
823data SingularTransactionRef = SingularTransactionRef GraphRefTransactionMarker |
924 MultipleTransactionsRef |
1025 NoTransactionsRef
1126 deriving (Eq, Show)
12−
13−instance Semigroup SingularTransactionRef where
14− NoTransactionsRef <> x = x
15− MultipleTransactionsRef <> _ = MultipleTransactionsRef
16− SingularTransactionRef tidA <> s@(SingularTransactionRef tidB) =
17− if tidA == tidB then
18− s
19− else
20− MultipleTransactionsRef
21− s@SingularTransactionRef{} <> NoTransactionsRef = s
22− _ <> MultipleTransactionsRef = MultipleTransactionsRef
23−
24−instance Monoid SingularTransactionRef where
25− mempty = NoTransactionsRef
2627
2728-- | return `Just transid` if this GraphRefRelationalExpr refers to just one transaction in the graph. This is useful for determining if certain optimizations can apply.
28−singularTransaction :: Foldable t => t GraphRefTransactionMarker -> SingularTransactionRef
29−singularTransaction expr
30− | S.null transSet = NoTransactionsRef
31− | S.size transSet == 1 = SingularTransactionRef (head (S.toList transSet))
32− | otherwise = MultipleTransactionsRef
29+singularTransaction :: GraphRefRelationalExpr -> SingularTransactionRef
30+singularTransaction expr =
31+ if S.null transSet then
32+ NoTransactionsRef
33+ else if S.size transSet == 1 then
34+ SingularTransactionRef (head (S.toList transSet))
35+ else
36+ MultipleTransactionsRef
3337 where
34− transSet = foldr S.insert S.empty expr
38+ transSet = foldr (\transId acc -> S.insert transId acc) S.empty expr
3539
3640-- | Return True if two 'GraphRefRelationalExpr's both refer exclusively to the same transaction (or none at all).
3741inSameTransaction :: GraphRefRelationalExpr -> GraphRefRelationalExpr -> Maybe GraphRefTransactionMarker
@@ -40,6 +44,3 @@ inSameTransaction exprA exprB = case (stA, stB) of
4044 _ -> Nothing
4145 where stA = singularTransaction exprA
4246 stB = singularTransaction exprB
43−
44−singularTransactions :: (Foldable f, Foldable t) => f (t GraphRefTransactionMarker) -> SingularTransactionRef
45−singularTransactions = foldMap singularTransaction
src/lib/ProjectM36/InclusionDependency.hs+6−5
@@ -4,16 +4,17 @@ import ProjectM36.Attribute
44import ProjectM36.Error
55import ProjectM36.Relation
66import qualified Data.Map as M
7+import qualified Data.Text as T
78
89inclusionDependenciesAsRelation :: InclusionDependencies -> Either RelationalError Relation
910inclusionDependenciesAsRelation incDeps =
1011 mkRelationFromList attrs (map incDepAsAtoms (M.toList incDeps))
1112 where
1213 attrs = attributesFromList [Attribute "name" TextAtomType,
13− Attribute "sub" RelationalExprAtomType,
14− Attribute "super" RelationalExprAtomType
14+ Attribute "sub" TextAtomType,
15+ Attribute "super" TextAtomType
1516 ]
1617 incDepAsAtoms (name, InclusionDependency exprA exprB) = [TextAtom name,
17− RelationalExprAtom exprA,
18− RelationalExprAtom exprB]
19−
18+ TextAtom (T.pack (show exprA)),
19+ TextAtom (T.pack (show exprB))]
20+
src/lib/ProjectM36/IsomorphicSchema.hs+6−3
@@ -1,4 +1,4 @@
1−{-# LANGUAGE DeriveGeneric, LambdaCase, DerivingVia #-}
1+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, LambdaCase #-}
22module ProjectM36.IsomorphicSchema where
33import ProjectM36.Base
44import ProjectM36.Error
@@ -9,12 +9,14 @@ import ProjectM36.RelationalExpression
99import qualified ProjectM36.AttributeNames as AN
1010import Control.Monad
1111import GHC.Generics
12+import Data.Binary
1213import qualified Data.Map as M
1314import qualified Data.Set as S
1415import qualified Data.List as L
15−#if __GLASGOW_HASKELL__ < 804
16+#if __GLASGOW_HASKELL__ <= 802
1617import Data.Monoid
1718#endif
19+
1820-- isomorphic schemas offer bi-directional functors between two schemas
1921
2022--TODO: note that renaming a relvar should alter any stored isomorphisms as well
@@ -27,7 +29,8 @@ import Data.Monoid
2729
2830data SchemaExpr = AddSubschema SchemaName SchemaIsomorphs |
2931 RemoveSubschema SchemaName
30− deriving (Generic, Show)
32+ deriving (Generic, Binary, Show)
33+
3134
3235isomorphs :: Schema -> SchemaIsomorphs
3336isomorphs (Schema i) = i
src/lib/ProjectM36/Key.hs+1−1
@@ -2,7 +2,7 @@ module ProjectM36.Key where
22import ProjectM36.Base
33import ProjectM36.Relation
44import qualified Data.Set as S
5−#if __GLASGOW_HASKELL__ < 804
5+#if __GLASGOW_HASKELL__ <= 802
66import Data.Monoid
77#endif
88
src/lib/ProjectM36/MerkleHash.hsdeleted−9
@@ -1,9 +0,0 @@
1−{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveGeneric, DerivingVia #-}
2−module ProjectM36.MerkleHash where
3−import Data.ByteString (ByteString)
4−import GHC.Generics
5−import Control.DeepSeq (NFData)
6−
7−newtype MerkleHash = MerkleHash { _unMerkleHash :: ByteString }
8− deriving (Show, Eq, Generic, Monoid, Semigroup, NFData)
9−
src/lib/ProjectM36/NormalizeExpr.hs+2−7
@@ -21,7 +21,7 @@ processRelationalExpr (MakeRelationFromExprs mAttrs tupleExprs) = do
2121 mAttrs' <- case mAttrs of
2222 Nothing -> pure Nothing
2323 Just mAttrs'' -> Just <$> mapM processAttributeExpr mAttrs''
24− MakeRelationFromExprs mAttrs' <$> processTupleExprs tupleExprs
24+ MakeRelationFromExprs mAttrs' <$> mapM processTupleExpr tupleExprs
2525processRelationalExpr (MakeStaticRelation attrs tupSet) = pure (MakeStaticRelation attrs tupSet)
2626processRelationalExpr (ExistingRelation rel) = pure (ExistingRelation rel)
2727--requires current trans id and graph
@@ -115,13 +115,8 @@ processAtomExpr (FunctionAtomExpr fName atomExprs ()) =
115115processAtomExpr (RelationAtomExpr expr) = RelationAtomExpr <$> processRelationalExpr expr
116116processAtomExpr (ConstructedAtomExpr dConsName atomExprs ()) = ConstructedAtomExpr dConsName <$> mapM processAtomExpr atomExprs <*> askMarker
117117
118−processTupleExprs :: TupleExprs -> ProcessExprM GraphRefTupleExprs
119−processTupleExprs (TupleExprs () tupleExprs) = do
120− marker <- askMarker
121− TupleExprs marker <$> mapM processTupleExpr tupleExprs
122−
123118processTupleExpr :: TupleExpr -> ProcessExprM GraphRefTupleExpr
124−processTupleExpr (TupleExpr tMap) =
119+processTupleExpr (TupleExpr tMap) =
125120 TupleExpr . M.fromList <$> mapM (\(k,v) -> (,) k <$> processAtomExpr v) (M.toList tMap)
126121
127122--convert AttributeExpr to GraphRefAttributeExpr
src/lib/ProjectM36/Persist.hs+4−3
@@ -36,6 +36,7 @@ import Foreign.C
3636#endif
3737
3838import System.IO (withFile, IOMode(WriteMode), Handle)
39+import qualified Data.ByteString.Lazy as BS
3940import qualified Data.ByteString as BS'
4041import qualified Data.Text.Encoding as TE
4142
@@ -99,10 +100,10 @@ syncDirectory :: DiskSync -> FilePath -> IO ()
99100syncDirectory FsyncDiskSync path = directoryFsync path
100101syncDirectory NoDiskSync _ = pure ()
101102
102−writeBSFileSync :: DiskSync -> FilePath -> BS'.ByteString -> IO ()
103+writeBSFileSync :: DiskSync -> FilePath -> BS.ByteString -> IO ()
103104writeBSFileSync sync path bstring =
104105 withFile path WriteMode $ \handle -> do
105− BS'.hPut handle bstring
106+ BS.hPut handle bstring
106107 syncHandle sync handle
107108
108109directoryFsync :: FilePath -> IO ()
@@ -130,4 +131,4 @@ fdCount = do
130131 fds <- getDirectoryContents FDDIR
131132 pure ((length fds) - 2)
132133--not supported on non-linux
133−#endif
134+#endif
src/lib/ProjectM36/Relation.hs+22−17
@@ -9,6 +9,7 @@ import ProjectM36.Tuple
99import qualified ProjectM36.Attribute as A
1010import ProjectM36.TupleSet
1111import ProjectM36.Error
12+import ProjectM36.MiscUtils
1213--import qualified Control.Parallel.Strategies as P
1314import qualified ProjectM36.TypeConstructorDef as TCD
1415import qualified ProjectM36.DataConstructorDef as DCD
@@ -16,6 +17,7 @@ import qualified Data.Text as T
1617import Data.Either (isRight)
1718import System.Random.Shuffle
1819import Control.Monad.Random
20+import Data.List (sort)
1921
2022attributes :: Relation -> Attributes
2123attributes (Relation attrs _ ) = attrs
@@ -33,7 +35,7 @@ atomTypeForName :: AttributeName -> Relation -> Either RelationalError AtomType
3335atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrName attrs
3436
3537mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation
36−mkRelationFromList attrs atomMatrix = do
38+mkRelationFromList attrs atomMatrix =
3739 Relation attrs <$> mkTupleSetFromList attrs atomMatrix
3840
3941emptyRelationWithAttrs :: Attributes -> Relation
@@ -41,6 +43,11 @@ emptyRelationWithAttrs attrs = Relation attrs emptyTupleSet
4143
4244mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation
4345mkRelation 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
4451 --check that all tuples have the same keys
4552 --check that all tuples have keys (1-N) where N is the attribute count
4653 case verifyTupleSet attrs tupleSet of
@@ -86,12 +93,13 @@ union (Relation attrs1 tupSet1) (Relation attrs2 tupSet2) =
8693 else
8794 Right $ Relation attrs1 newtuples
8895 where
89− newtuples = tupleSetUnion attrs1 tupSet1 tupSet2
90−
96+ newtuples = RelationTupleSet $ HS.toList . HS.fromList $ asList tupSet1 ++ map (reorderTuple attrs1) (asList tupSet2)
97+
9198project :: S.Set AttributeName -> Relation -> Either RelationalError Relation
9299project attrNames rel@(Relation _ tupSet) = do
93100 newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)
94− newTupleList <- mapM (tupleProject newAttrs) (asList tupSet)
101+ let newAttrNameSet = A.attributeNameSet newAttrs
102+ newTupleList = map (tupleProject newAttrNameSet) (asList tupSet)
95103 pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))
96104
97105rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation
@@ -146,7 +154,7 @@ group groupAttrNames newAttrName rel = do
146154 groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)
147155 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)
148156 matchingRelTuple tupIn = case imageRelationFor tupIn rel of
149− Right rel2 -> RelationTuple (A.singleton groupAttr) (V.singleton (RelationAtom rel2))
157+ Right rel2 -> RelationTuple (V.singleton groupAttr) (V.singleton (RelationAtom rel2))
150158 Left _ -> undefined
151159 mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))
152160 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes
@@ -160,8 +168,7 @@ restrictEq :: RelationTuple -> Relation -> Either RelationalError Relation
160168restrictEq tuple = restrict rfilter
161169 where
162170 rfilter :: RelationTuple -> Either RelationalError Bool
163− rfilter tupleIn = do
164− pure (tupleIntersection tuple tupleIn == tuple)
171+ rfilter tupleIn = pure (tupleIntersection tuple tupleIn == tuple)
165172
166173-- unwrap relation-valued attribute
167174-- return error if relval attrs and nongroup attrs overlap
@@ -183,13 +190,13 @@ ungroup relvalAttrName rel = case attributesForRelval relvalAttrName rel of
183190tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation
184191tupleUngroup relvalAttrName newAttrs tuple = do
185192 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])
192193 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])
193200
194201attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes
195202attributesForRelval relvalAttrName (Relation attrs _) = do
@@ -244,8 +251,7 @@ relMap mapper (Relation attrs tupleSet) =
244251
245252relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation
246253relMogrify mapper newAttributes (Relation _ tupSet) = do
247− newTuples <- mapM (fmap (reorderTuple newAttributes) . mapper) (asList tupSet)
248−
254+ newTuples <- mapM mapper (asList tupSet)
249255 mkRelationFromTuples newAttributes newTuples
250256
251257relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a
@@ -291,8 +297,7 @@ typesAsRelation types = mkRelationFromTuples attrs tuples
291297 dConsType = RelationAtomType subAttrs
292298 tuples = map mkTypeConsDescription types
293299
294− mkTypeConsDescription (tCons, dConsList) =
295− RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])
300+ mkTypeConsDescription (tCons, dConsList) = RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])
296301
297302 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
298303 Left err -> error ("mkRelationFromTuples pooped " ++ show err)
src/lib/ProjectM36/Relation/Parse/CSV.hs+3−7
@@ -38,7 +38,8 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode
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− attrNameSet = A.attributeNameSet attrs
41+ attrNames = V.map A.attributeName attrs
42+ attrNameSet = S.fromList (V.toList attrNames)
4243 headerSet = S.fromList (V.toList strHeader)
4344 parseAtom attrName aType textIn = case APT.parseOnly (parseCSVAtomP attrName tConsMap aType <* APT.endOfInput) textIn of
4445 Left err -> Left (ParseError (T.pack err))
@@ -46,7 +47,7 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode
4647 makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]
4748 makeTupleList tupMap = V.toList $ V.map (\attr ->
4849 either (Left . AttributeMappingError) Right $
49− parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) (attributesVec attrs)
50+ parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) attrs
5051 if attrNameSet == headerSet then do
5152 tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)
5253 case mkRelationFromList attrs tupleList of
@@ -82,11 +83,6 @@ parseCSVAtomP _ _ BoolAtomType = do
8283 case readMaybe bString of
8384 Nothing -> fail ("invalid BoolAtom string: " ++ bString)
8485 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))
9086parseCSVAtomP attrName tConsMap typ@(ConstructedAtomType _ tvmap)
9187 | isIntervalAtomType typ = do
9288 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 as A
4+import ProjectM36.Attribute
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− | A.null attrs =
20+ | V.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) (attributesVec attrs)
26− bsAttrNames = V.map (TE.encodeUtf8 . attributeName) (attributesVec attrs)
25+ relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) attrs
26+ bsAttrNames = V.map (TE.encodeUtf8 . attributeName) 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) (attributesVec (tupleAttributes tuple))
39+ headerOrder (RecordRelationTuple tuple) = V.map (TE.encodeUtf8 . attributeName) (tupleAttributes tuple)
4040
4141newtype RecordAtom = RecordAtom {unAtom :: Atom}
4242
src/lib/ProjectM36/Relation/Show/HTML.hs+3−4
@@ -3,18 +3,18 @@ import ProjectM36.Base
33import ProjectM36.Relation
44import ProjectM36.Tuple
55import ProjectM36.Atom
6−import ProjectM36.Attribute as A
76import ProjectM36.AtomType
87import qualified Data.List as L
98import Data.Text (Text, pack)
109import qualified Data.Text as T
1110import qualified Data.Text.IO as TIO
12−#if __GLASGOW_HASKELL__ < 804
11+import qualified Data.Vector as V
12+#if __GLASGOW_HASKELL__ <= 802
1313import Data.Monoid
1414#endif
1515
1616attributesAsHTML :: Attributes -> Text
17−attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"
17+attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"
1818 where
1919 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> "</th>"
2020
@@ -53,7 +53,6 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>
5353 where
5454 tupleFrag tup = "<td>" <> atomAsHTML (snd tup) <> "</td>"
5555 atomAsHTML (RelationAtom rel) = relationAsHTML rel
56− atomAsHTML (TextAtom t) = "&quot;" <> t <> "&quot;"
5756 atomAsHTML atom = atomToText atom
5857
5958tupleSetAsHTML :: RelationTupleSet -> Text
src/lib/ProjectM36/Relation/Show/Term.hs+1−4
@@ -9,9 +9,7 @@ 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
14−#if __GLASGOW_HASKELL__ < 804
12+#if __GLASGOW_HASKELL__ <= 802
1513import Data.Monoid
1614#endif
1715import ProjectM36.WCWidth --guess the width that the character will appear as in the terminal
@@ -99,7 +97,6 @@ showAtom :: Int -> Atom -> StringType
9997showAtom _ (RelationAtom rel) = renderTable $ relationAsTable rel
10098showAtom level (ConstructedAtom dConsName _ atoms) = showParens (level >= 1 && not (null atoms)) $ T.concat (L.intersperse " " (dConsName : map (showAtom 1) atoms))
10199showAtom _ (TextAtom t) = "\"" <> t <> "\""
102−showAtom _ (ByteStringAtom bs) = TE.decodeUtf8 (B64.encode bs)
103100showAtom _ atom = atomToText atom
104101
105102renderTable :: Table -> StringType
src/lib/ProjectM36/RelationalExpression.hs+369−289
@@ -1,7 +1,6 @@
11{-# LANGUAGE ScopedTypeVariables #-}
22{-# LANGUAGE FlexibleInstances #-}
33{-# LANGUAGE FlexibleContexts #-}
4−{-# LANGUAGE OverloadedStrings #-}
54module ProjectM36.RelationalExpression where
65import ProjectM36.Relation
76import ProjectM36.Tuple
@@ -16,38 +15,32 @@ import ProjectM36.DataTypes.Primitive
1615import ProjectM36.AtomFunction
1716import ProjectM36.DatabaseContextFunction
1817import ProjectM36.Arbitrary
19−import ProjectM36.GraphRefRelationalExpr
2018import ProjectM36.Transaction
2119import qualified ProjectM36.Attribute as A
2220import qualified Data.Map as M
2321import qualified Data.HashSet as HS
2422import qualified Data.Set as S
25−import Control.Monad.State hiding (join)
26−import Data.Bifunctor (second)
23+import Control.Monad.RWS.Strict as RWS hiding (join)
24+import Control.Monad.Trans.Class (lift)
25+import Control.Exception
2726import Data.Maybe
2827import Data.Either
2928import Data.Char (isUpper)
30−import Data.Time
31−import qualified Data.List.NonEmpty as NE
32−import Data.Functor.Identity
3329import qualified Data.Text as T
3430import qualified Data.Vector as V
3531import qualified ProjectM36.TypeConstructorDef as TCD
36−import qualified Control.Monad.RWS.Strict as RWS
37−import Control.Monad.RWS.Strict (RWST, execRWST, runRWST)
3832import Control.Monad.Except hiding (join)
3933import Control.Monad.Trans.Except (except)
4034import Control.Monad.Reader as R hiding (join)
4135import ProjectM36.NormalizeExpr
4236import ProjectM36.WithNameExpr
4337import Test.QuickCheck
44−import qualified Data.Functor.Foldable as Fold
45−import Control.Applicative
46−#ifdef PM36_HASKELL_SCRIPTING
4738import GHC hiding (getContext)
48−import Control.Exception
4939import GHC.Paths
50−#endif
40+import Data.Time.Clock
41+import Data.Time.Calendar
42+import qualified Data.List.NonEmpty as NE
43+import Data.Functor.Identity
5144
5245data DatabaseContextExprDetails = CountUpdatedTuples
5346
@@ -94,10 +87,10 @@ runRelationalExprM :: RelationalExprEnv -> RelationalExprM a -> Either Relationa
9487runRelationalExprM env m = runIdentity (runExceptT (runReaderT m env))
9588
9689reGraph :: RelationalExprM TransactionGraph
97−reGraph = asks re_graph
90+reGraph = re_graph <$> R.ask
9891
9992reContext :: RelationalExprM DatabaseContext
100−reContext = asks re_context
93+reContext = re_context <$> R.ask
10194
10295mkRelationalExprEnv :: DatabaseContext -> TransactionGraph -> RelationalExprEnv
10396mkRelationalExprEnv ctx graph =
@@ -110,13 +103,13 @@ askEnv :: GraphRefRelationalExprM GraphRefRelationalExprEnv
110103askEnv = R.ask
111104
112105mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv
113−mergeTuplesIntoGraphRefRelationalExprEnv tupIn env =
114− env { gre_extra = new_elems }
106+mergeTuplesIntoGraphRefRelationalExprEnv tupIn e =
107+ e{ gre_extra = new_elems }
115108 where
116109 new_elems = Just (Left newTuple)
117− mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple env))
110+ mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple e))
118111 newTuple = mkRelationTupleFromMap mergedTupMap
119−
112+
120113mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv
121114mergeAttributesIntoGraphRefRelationalExprEnv attrsIn e = e { gre_extra = newattrs }
122115 where
@@ -142,12 +135,12 @@ data DatabaseContextEvalEnv = DatabaseContextEvalEnv
142135 }
143136
144137mkDatabaseContextEvalEnv :: TransactionId -> TransactionGraph -> DatabaseContextEvalEnv
145−mkDatabaseContextEvalEnv = DatabaseContextEvalEnv
138+mkDatabaseContextEvalEnv tid graph = DatabaseContextEvalEnv tid graph
146139
147140type DatabaseContextEvalMonad a = RWST DatabaseContextEvalEnv () DatabaseContextEvalState (ExceptT RelationalError Identity) a
148141
149142runDatabaseContextEvalMonad :: DatabaseContext -> DatabaseContextEvalEnv -> DatabaseContextEvalMonad () -> Either RelationalError DatabaseContextEvalState
150−runDatabaseContextEvalMonad ctx env m = runIdentity (runExceptT (fst <$> execRWST m env freshEnv))
143+runDatabaseContextEvalMonad ctx env m = runIdentity (runExceptT (fst <$> (execRWST m env freshEnv)))
151144 where
152145 freshEnv = mkDatabaseContextEvalState ctx
153146
@@ -163,7 +156,7 @@ dbcRelationalExprEnv =
163156 mkRelationalExprEnv <$> getStateContext <*> dbcGraph
164157
165158getStateContext :: DatabaseContextEvalMonad DatabaseContext
166−getStateContext = gets dbc_context
159+getStateContext = dbc_context <$> get
167160
168161putStateContext :: DatabaseContext -> DatabaseContextEvalMonad ()
169162putStateContext ctx' = do
@@ -204,7 +197,7 @@ freshGraphRefRelationalExprEnv mctx graph = GraphRefRelationalExprEnv {
204197 }
205198
206199gfGraph :: GraphRefRelationalExprM TransactionGraph
207−gfGraph = asks gre_graph
200+gfGraph = gre_graph <$> R.ask
208201
209202envContext :: RelationalExprEnv -> DatabaseContext
210203envContext = re_context
@@ -212,27 +205,174 @@ envContext = re_context
212205setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv
213206setEnvContext e ctx = e { re_context = ctx }
214207
208+{-
209+--full evaluation down the graph
210+eval :: RelationalExpr -> RelationalExprState (Either RelationalError Relation)
211+eval expr = do
212+ env <- askEnv
213+ eGfExpr <- processRelationalExpr expr
214+ case eGfExpr of
215+ Left err -> pure (Left err)
216+ Right gfExpr -> pure $ evalGraphRefRelationalExpr gfExpr (re_graph env)
217+-}
218+{-
219+--relvar state is needed in evaluation of relational expression but only as read-only in order to extract current relvar values
220+evalRelationalExpr :: RelationalExpr -> RelationalExprState (Either RelationalError GraphRefRelationalExpr)
221+evalRelationalExpr (RelationVariable name _) = do
222+ relvarTable <- fmap (relationVariables . envContext) askEnv
223+ return $ case M.lookup name relvarTable of
224+ Just res -> Right res
225+ Nothing -> Left $ RelVarNotDefinedError name
226+
227+evalRelationalExpr (Project attrNames expr) = do
228+ eAttrNameSet <- evalAttributeNames attrNames expr
229+ case eAttrNameSet of
230+ Left err -> pure (Left err)
231+ Right attrNameSet -> do
232+ rel <- evalRelationalExpr expr
233+ case rel of
234+ Right rel2 -> pure $ Right (Project (AttributeNames attrNameSet) rel2)
235+ Left err -> pure $ Left err
236+
237+evalRelationalExpr (Union exprA exprB) = do
238+ relA <- evalRelationalExpr exprA
239+ relB <- evalRelationalExpr exprB
240+ case relA of
241+ Left err -> return $ Left err
242+ Right relA2 -> case relB of
243+ Left err -> return $ Left err
244+ Right relB2 -> return $ Right (Union relA2 relB2)
245+
246+evalRelationalExpr (Join exprA exprB) = do
247+ relA <- evalRelationalExpr exprA
248+ relB <- evalRelationalExpr exprB
249+ case relA of
250+ Left err -> return $ Left err
251+ Right relA2 -> case relB of
252+ Left err -> return $ Left err
253+ Right relB2 -> return $ Right (Join relA2 relB2)
254+
255+evalRelationalExpr (Difference exprA exprB) = do
256+ relA <- evalRelationalExpr exprA
257+ relB <- evalRelationalExpr exprB
258+ case relA of
259+ Left err -> return $ Left err
260+ Right relA2 -> case relB of
261+ Left err -> return $ Left err
262+ Right relB2 -> return $ Right (Difference relA2 relB2)
263+
264+evalRelationalExpr (MakeStaticRelation attributeSet tupleSet) =
265+ case mkRelation attributeSet tupleSet of
266+ Right rel -> return $ Right (ExistingRelation rel)
267+ Left err -> return $ Left err
268+
269+evalRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do
270+ currentContext <- fmap envContext askEnv
271+ let tConss = typeConstructorMapping currentContext
272+ -- 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
273+ runExceptT $ do
274+ mAttrs <- case mAttrExprs of
275+ Just _ ->
276+ Just . A.attributesFromList <$> mapM evalGraphRefAttrExpr (fromMaybe [] mAttrExprs)
277+ Nothing -> pure Nothing
278+ tuples <- mapM (liftE . evalTupleExpr mAttrs) tupleExprs
279+ let attrs = fromMaybe firstTupleAttrs mAttrs
280+ firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)
281+ expr <- either throwE pure (mkRelation attrs (RelationTupleSet tuples))
282+ pure (ExistingRelation expr)
283+
284+evalRelationalExpr (ExistingRelation rel) = pure (Right (ExistingRelation rel))
285+
286+evalRelationalExpr (Rename oldAttrName newAttrName relExpr) = do
287+ evald <- evalRelationalExpr relExpr
288+ case evald of
289+ Right expr -> return $ Right (Rename oldAttrName newAttrName expr)
290+ Left err -> return $ Left err
291+
292+evalRelationalExpr (Group oldAttrNames newAttrName relExpr) = do
293+ eOldAttrNameSet <- evalAttributeNames oldAttrNames relExpr
294+ case eOldAttrNameSet of
295+ Left err -> pure (Left err)
296+ Right oldAttrNameSet -> do
297+ evald <- evalRelationalExpr relExpr
298+ case evald of
299+ Right expr -> return $ Right (Group (AttributeNames oldAttrNameSet) newAttrName expr)
300+ Left err -> return $ Left err
301+
302+evalRelationalExpr (Ungroup attrName relExpr) = do
303+ evald <- evalRelationalExpr relExpr
304+ case evald of
305+ Right expr -> return $ Right (Ungroup attrName expr)
306+ Left err -> return $ Left err
307+
308+evalRelationalExpr (Restrict predicateExpr relExpr) = do
309+ evald <- evalRelationalExpr relExpr
310+ pred <- processRestrictionPredicateExpr predicateExpr
311+ case evald of
312+ Left err -> return $ Left err
313+ Right expr ->
314+ pure $ Right (Restrict pred expr)
315+
316+evalRelationalExpr (Equals relExprA relExprB) = do
317+ evaldA <- evalRelationalExpr relExprA
318+ evaldB <- evalRelationalExpr relExprB
319+ case evaldA of
320+ Left err -> return $ Left err
321+ Right exprA -> case evaldB of
322+ Left err -> return $ Left err
323+ Right exprB -> return $ Right (Equals exprA exprB)
324+{-
325+evalRelationalExpr (With views mainExpr) = do
326+ rstate <- ask
327+
328+ let addScopedView ctx (vname,vexpr) = if vname `M.member` relationVariables ctx then
329+ Left (RelVarAlreadyDefinedError vname)
330+ else
331+ case runState (evalDatabaseContextExpr (Assign vname vexpr)) (freshDatabaseState ctx) of
332+ (Left err,_) -> Left err
333+ (Right (), (ctx',_,_)) -> Right ctx'
334+
335+ case foldM addScopedView (stateElemsContext rstate) views of
336+ Left err -> return $ Left err
337+ Right ctx'' -> do
338+ let evalMainExpr expr = runReader (evalRelationalExpr expr) (RelationalExprEnv ctx'')
339+ case evalMainExpr mainExpr of
340+ Left err -> return $ Left err
341+ Right rel -> return $ Right rel
342+-}
343+--warning: copy-pasta from above- refactor
344+evalRelationalExpr (NotEquals relExprA relExprB) = do
345+ evaldA <- evalRelationalExpr relExprA
346+ evaldB <- evalRelationalExpr relExprB
347+ case evaldA of
348+ Left err -> return $ Left err
349+ Right exprA -> case evaldB of
350+ Left err -> return $ Left err
351+ Right exprB -> return $ Right (NotEquals exprA exprB)
352+
353+-- extending a relation adds a single attribute with the results of the per-tuple expression evaluated
354+evalRelationalExpr (Extend tupleExpression relExpr) = do
355+ eExpr <- evalRelationalExpr relExpr
356+ case eExpr of
357+ Left err -> pure (Left err)
358+ Right expr -> do
359+ tupProc <- processExtendTupleExpr tupleExpression
360+ pure (Right (Extend tupProc expr))
361+-}
215362--helper function to process relation variable creation/assignment
216363setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()
217364setRelVar relVarName relExpr = do
365+
218366 currentContext <- getStateContext
219− --prevent recursive relvar definition by resolving references to relvars in previous states
220− relExpr' <- resolve relExpr
221− let newRelVars = M.insert relVarName relExpr' $ relationVariables currentContext
367+ --prevent recursive relvar definition
368+ let newRelVars = M.insert relVarName relExpr $ relationVariables currentContext
222369 potentialContext = currentContext { relationVariables = newRelVars }
223− --optimization: if the relexpr is unchanged, skip the update
224− if M.lookup relVarName (relationVariables currentContext) == Just relExpr then
225− pure ()
226− else do
227− --determine when to check constraints
228− graph <- dbcGraph
229− tid <- dbcTransId
230− case checkConstraints potentialContext tid graph of
231− Left err -> dbErr err
232− Right _ -> putStateContext potentialContext
233−
234−--fast-path insertion- we already know that the previous relvar validated correctly, so we can validate just the relation that is being inserted for attribute matches- without this, even a single tuple relation inserted causes the entire relation to be re-validated unnecessarily
235−--insertIntoRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()
370+ --determine when to check constraints
371+ graph <- dbcGraph
372+ tid <- dbcTransId
373+ case checkConstraints potentialContext tid graph of
374+ Left err -> dbErr err
375+ Right _ -> putStateContext potentialContext
236376
237377-- 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
238378deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()
@@ -258,10 +398,13 @@ evalGraphRefDatabaseContextExpr (Define relVarName attrExprs) = do
258398 let eAttrs = runGraphRefRelationalExprM gfEnv (mapM evalGraphRefAttrExpr attrExprs)
259399 gfEnv = freshGraphRefRelationalExprEnv (Just context) graph
260400 case eAttrs of
261− Left err -> dbErr err
401+ Left err -> dbErr err
262402 Right attrsList -> do
263− lift $ except $ validateAttributes tConss (A.attributesFromList attrsList)
264− case M.member relVarName relvars of
403+ let atomTypeErrs = lefts $ map ((`validateAtomType` tConss) . A.atomType) attrsList
404+ if not (null atomTypeErrs) then
405+ dbErr (someErrors atomTypeErrs)
406+ else
407+ case M.member relVarName relvars of
265408 True -> dbErr (RelVarAlreadyDefinedError relVarName)
266409 False -> setRelVar relVarName (ExistingRelation emptyRelation)
267410 where
@@ -274,17 +417,13 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do
274417 graph <- re_graph <$> dbcRelationalExprEnv
275418 context <- getStateContext
276419 let existingRelVar = M.lookup relVarName (relationVariables context)
277− reEnv = freshGraphRefRelationalExprEnv (Just context) graph
278− eNewExprType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr expr)
279420 case existingRelVar of
280421 Nothing -> do
281− case runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr expr) of
282− Left err -> dbErr err
283− Right reltype -> do
284− lift $ except $ validateAttributes (typeConstructorMapping context) (attributes reltype)
285− setRelVar relVarName expr
422+ setRelVar relVarName expr
286423 Just existingRel -> do
287424 let eExpectedType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr existingRel)
425+ eNewExprType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr expr)
426+ reEnv = freshGraphRefRelationalExprEnv (Just context) graph
288427 case eExpectedType of
289428 Left err -> dbErr err
290429 Right expectedType ->
@@ -292,50 +431,33 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do
292431 Left err -> dbErr err
293432 Right newExprType -> do
294433 if newExprType == expectedType then do
295− lift $ except $ validateAttributes (typeConstructorMapping context) (attributes newExprType)
296434 setRelVar relVarName expr
297435 else
298436 dbErr (RelationTypeMismatchError (attributes expectedType) (attributes newExprType))
299437
300438evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do
301439 gfExpr <- relVarByName relVarName
302− let optExpr = applyUnionCollapse (Union
303− relExpr
304− gfExpr)
305− evalGraphRefDatabaseContextExpr (Assign relVarName optExpr)
440+ evalGraphRefDatabaseContextExpr (Assign relVarName
441+ (Union
442+ gfExpr
443+ relExpr))
306444
307445evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do
308446 gfExpr <- relVarByName relVarName
309− let optExpr = applyRestrictionCollapse (Restrict (NotPredicate predicate) gfExpr)
310− setRelVar relVarName optExpr
447+ setRelVar relVarName (Restrict (NotPredicate predicate) gfExpr)
311448
312449--union of restricted+updated portion and the unrestricted+unupdated portion
313450evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do
314451 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
323452 let unrestrictedPortion = Restrict (NotPredicate pred') rvExpr
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
453+ tmpAttr attr = "_tmp_" <> attr --this could certainly be improved to verify that there is no attribute name conflict
332454 updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)
333455 projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)
334− restrictedPortion = Restrict pred' rvExpr
456+ --TODO restrictedPortion = Restrict pred'
335457 updated = foldr (\(oldname, atomExpr) accum ->
336458 let procAtomExpr = runProcessExprM UncommittedContextMarker (processAtomExpr atomExpr) in
337459 updateAttr oldname procAtomExpr accum
338− ) restrictedPortion (M.toList atomExprMap)
460+ ) rvExpr (M.toList atomExprMap)
339461 -- the atomExprMap could reference other attributes, so we must perform multi-pass folds
340462 updatedPortion = foldr projectAndRename updated (M.keys atomExprMap)
341463 setRelVar relVarName (Union unrestrictedPortion updatedPortion)
@@ -350,8 +472,6 @@ evalGraphRefDatabaseContextExpr (AddInclusionDependency newDepName newDep) = do
350472 dbErr (InclusionDependencyNameInUseError newDepName)
351473 else do
352474 let potentialContext = currContext { inclusionDependencies = newDeps }
353− -- if the potential context passes all constraints, then save it
354− -- potential optimization: validate only the new constraint- all old constraints must already hold
355475 case checkConstraints potentialContext transId graph of
356476 Left err -> dbErr err
357477 Right _ ->
@@ -396,9 +516,9 @@ evalGraphRefDatabaseContextExpr (AddTypeConstructor tConsDef dConsDefList) = do
396516 let oldTypes = typeConstructorMapping currentContext
397517 tConsName = TCD.name tConsDef
398518 -- validate that the constructor's types exist
399− case validateTypeConstructorDef tConsDef dConsDefList oldTypes of
400− Left err -> throwError err
401− Right () | T.null tConsName || not (isUpper (T.head tConsName)) -> dbErr (InvalidAtomTypeName tConsName)
519+ case validateTypeConstructorDef tConsDef dConsDefList of
520+ errs@(_:_) -> dbErr (someErrors errs)
521+ [] | T.null tConsName || not (isUpper (T.head tConsName)) -> dbErr (InvalidAtomTypeName tConsName)
402522 | isJust (findTypeConstructor tConsName oldTypes) -> dbErr (AtomTypeNameInUseError tConsName)
403523 | otherwise -> do
404524 let newTypes = oldTypes ++ [(tConsDef, dConsDefList)]
@@ -414,9 +534,10 @@ evalGraphRefDatabaseContextExpr (RemoveTypeConstructor tConsName) = do
414534 let newTypes = filter (\(tCons, _) -> TCD.name tCons /= tConsName) oldTypes
415535 putStateContext $ currentContext { typeConstructorMapping = newTypes }
416536
417−evalGraphRefDatabaseContextExpr (MultipleExpr exprs) =
537+evalGraphRefDatabaseContextExpr (MultipleExpr exprs) = do
418538 --the multiple expressions must pass the same context around- not the old unmodified context
419− mapM_ evalGraphRefDatabaseContextExpr exprs
539+ ctx <- getContext
540+ mapM_ (\expr -> evalGraphRefDatabaseContextExpr expr) exprs
420541
421542evalGraphRefDatabaseContextExpr (RemoveAtomFunction funcName) = do
422543 currentContext <- getStateContext
@@ -446,7 +567,7 @@ evalGraphRefDatabaseContextExpr (ExecuteDatabaseContextFunction funcName atomArg
446567 context <- getStateContext
447568 graph <- dbcGraph
448569 --resolve atom arguments
449− let eAtomTypes = mapM (runGraphRefRelationalExprM gfEnv . typeForGraphRefAtomExpr emptyAttributes) atomArgExprs
570+ let eAtomTypes = mapM (\atomExpr -> runGraphRefRelationalExprM gfEnv (typeForGraphRefAtomExpr emptyAttributes atomExpr)) atomArgExprs
450571 eFunc = databaseContextFunctionForName funcName (dbcFunctions context)
451572 gfEnv = freshGraphRefRelationalExprEnv (Just context) graph
452573 case eFunc of
@@ -461,13 +582,11 @@ evalGraphRefDatabaseContextExpr (ExecuteDatabaseContextFunction funcName atomArg
461582 case eAtomTypes of
462583 Left err -> dbErr err
463584 Right atomTypes -> do
464− let mValidTypes = zipWith (\ expType actType
465− -> case atomTypeVerify expType actType of
466− Left err -> Just err
467− Right _ -> Nothing)
468− (dbcFuncType func) atomTypes
585+ let mValidTypes = map (\(expType, actType) -> case atomTypeVerify expType actType of
586+ Left err -> Just err
587+ Right _ -> Nothing) (zip (dbcFuncType func) atomTypes)
469588 typeErrors = catMaybes mValidTypes
470− eAtomArgs = map (runGraphRefRelationalExprM gfEnv . evalGraphRefAtomExpr emptyTuple) atomArgExprs
589+ eAtomArgs = map (\arg -> runGraphRefRelationalExprM gfEnv (evalGraphRefAtomExpr emptyTuple arg)) atomArgExprs
471590 if length (lefts eAtomArgs) > 1 then
472591 dbErr (someErrors (lefts eAtomArgs))
473592 else if not (null typeErrors) then
@@ -476,6 +595,7 @@ evalGraphRefDatabaseContextExpr (ExecuteDatabaseContextFunction funcName atomArg
476595 case evalDatabaseContextFunction func (rights eAtomArgs) context of
477596 Left err -> dbErr err
478597 Right newContext -> putStateContext newContext
598+
479599data DatabaseContextIOEvalEnv = DatabaseContextIOEvalEnv
480600 { dbcio_transId :: TransactionId,
481601 dbcio_graph :: TransactionGraph,
@@ -511,15 +631,10 @@ getDBCIOContext = dbc_context <$> RWS.get
511631getDBCIORelationalExprEnv :: DatabaseContextIOEvalMonad RelationalExprEnv
512632getDBCIORelationalExprEnv = do
513633 context <- getDBCIOContext
514− mkRelationalExprEnv context . dbcio_graph <$> RWS.ask
634+ env <- RWS.ask
635+ pure $ mkRelationalExprEnv context (dbcio_graph env)
515636
516637evalGraphRefDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> DatabaseContextIOEvalMonad (Either RelationalError ())
517−#if !defined(PM36_HASKELL_SCRIPTING)
518−evalGraphRefDatabaseContextIOExpr AddAtomFunction{} = pure (Left (ScriptError ScriptCompilationDisabledError))
519−evalGraphRefDatabaseContextIOExpr AddDatabaseContextFunction{} = pure (Left (ScriptError ScriptCompilationDisabledError))
520−evalGraphRefDatabaseContextIOExpr LoadAtomFunctions{} = pure (Left (ScriptError ScriptCompilationDisabledError))
521−evalGraphRefDatabaseContextIOExpr LoadDatabaseContextFunctions{} = pure (Left (ScriptError ScriptCompilationDisabledError))
522−#else
523638evalGraphRefDatabaseContextIOExpr (AddAtomFunction funcName funcType script) = do
524639 eScriptSession <- requireScriptSession
525640 currentContext <- getDBCIOContext
@@ -553,6 +668,7 @@ evalGraphRefDatabaseContextIOExpr (AddAtomFunction funcName funcType script) = d
553668 Right eContext -> case eContext of
554669 Left err -> pure (Left err)
555670 Right context' -> putDBCIOContext context'
671+
556672evalGraphRefDatabaseContextIOExpr (AddDatabaseContextFunction funcName funcType script) = do
557673 eScriptSession <- requireScriptSession
558674 currentContext <- getDBCIOContext
@@ -594,6 +710,7 @@ evalGraphRefDatabaseContextIOExpr (AddDatabaseContextFunction funcName funcType
594710 Right eContext -> case eContext of
595711 Left err -> pure (Left err)
596712 Right context' -> putDBCIOContext context'
713+
597714evalGraphRefDatabaseContextIOExpr (LoadAtomFunctions modName funcName modPath) = do
598715 currentContext <- getDBCIOContext
599716 eLoadFunc <- liftIO $ loadAtomFunctions (T.unpack modName) (T.unpack funcName) modPath
@@ -610,7 +727,7 @@ evalGraphRefDatabaseContextIOExpr (LoadDatabaseContextFunctions modName funcName
610727 Right dbcListFunc -> let newContext = currentContext { dbcFunctions = mergedFuncs }
611728 mergedFuncs = HS.union (dbcFunctions currentContext) (HS.fromList dbcListFunc)
612729 in putDBCIOContext newContext
613−#endif
730+
614731evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs range) = do
615732 --Define
616733 currentContext <- getDBCIOContext
@@ -642,20 +759,28 @@ evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs
642759 Left err -> pure (Left err)
643760 Right dbstate' -> putDBCIOContext (dbc_context dbstate')
644761
762+{-
763+updateTupleWithAtomExprs :: M.Map AttributeName AtomExpr -> DatabaseContext -> TransactionGraph -> RelationTuple -> Either RelationalError RelationTuple
764+updateTupleWithAtomExprs exprMap context graph tupIn = do
765+ --resolve all atom exprs
766+ let
767+ atomsAssoc <- mapM (\(attrName, atomExpr) -> do
768+ let atom = unimplemented
769+ --atom <- runReader (evalAtomExpr tupIn atomExpr) (mkRelationalExprState context graph)
770+ pure (attrName, atom)
771+ ) (M.toList exprMap)
772+ pure (updateTupleWithAtoms (M.fromList atomsAssoc) tupIn)
773+-}
645774--run verification on all constraints
646775checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()
647−checkConstraints context transId graph@(TransactionGraph graphHeads transSet) = do
776+checkConstraints context transId graph@(TransactionGraph graphHeads transSet) =
648777 mapM_ (uncurry checkIncDep) (M.toList deps)
649778 where
650779 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)
651780 tempStamp = UTCTime { utctDay = fromGregorian 2000 1 1,
652781 utctDayTime = secondsToDiffTime 0 }
653782 tempSchemas = Schemas context M.empty
654− tempTrans = Transaction U.nil tempTransInfo tempSchemas
655− tempTransInfo = TransactionInfo { parents = transId NE.:| [],
656− stamp = tempStamp,
657− merkleHash = mempty
658− }
783+ tempTrans = Transaction U.nil (TransactionInfo (transId NE.:| []) tempStamp) tempSchemas
659784
660785 deps = inclusionDependencies context
661786 -- no optimization available here, really? perhaps the optimizer should be passed down to here or the eval function should be passed through the environment
@@ -691,7 +816,16 @@ typeForRelationalExpr expr = do
691816 let gfExpr = runProcessExprM UncommittedContextMarker (processRelationalExpr expr)
692817 gfEnv = freshGraphRefRelationalExprEnv (Just context) graph
693818 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)
694− lift $ except runGf
819+ lift $ except $ runGf
820+
821+--returns a database context with all tuples removed
822+--this is useful for type checking and optimization
823+{-
824+contextWithEmptyTupleSets :: DatabaseContext -> DatabaseContext
825+contextWithEmptyTupleSets contextIn = contextIn { relationVariables = relVars }
826+ where
827+ relVars = M.map (\rel -> ExistingRelation (Relation (attributes rel) emptyTupleSet)) (relationVariables contextIn)
828+-}
695829
696830liftE :: (Monad m) => m (Either a b) -> ExceptT a m b
697831liftE v = do
@@ -740,7 +874,7 @@ predicateRestrictionFilter _ (RelationalExprPredicate relExpr) = do
740874
741875predicateRestrictionFilter attrs (AttributeEqualityPredicate attrName atomExpr) = do
742876 env <- askEnv
743− let attrs' = A.union attrs (envAttributes env)
877+ let attrs' = envAttributes env
744878 ctxtup' = envTuple env
745879 atomExprType <- typeForGraphRefAtomExpr attrs' atomExpr
746880 attr <- lift $ except $ case A.attributeForName attrName attrs of
@@ -784,7 +918,7 @@ tupleExprCheckNewAttrName attrName rel = if isRight (attributeForName attrName r
784918 Right rel
785919
786920extendGraphRefTupleExpressionProcessor :: Relation -> GraphRefExtendTupleExpr -> GraphRefRelationalExprM (Attributes, RelationTuple -> Either RelationalError RelationTuple)
787−extendGraphRefTupleExpressionProcessor relIn (AttributeExtendTupleExpr newAttrName atomExpr) =
921+extendGraphRefTupleExpressionProcessor relIn (AttributeExtendTupleExpr newAttrName atomExpr) = do
788922-- renv <- askEnv
789923 -- check that the attribute name is not in use
790924 case tupleExprCheckNewAttrName newAttrName relIn of
@@ -826,7 +960,7 @@ evalGraphRefAtomExpr tupIn (FunctionAtomExpr funcName arguments tid) = do
826960 throwError (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)
827961 else do
828962 let zippedArgs = zip (safeInit (atomFuncType func)) argTypes
829− mapM_ (\(expType, actType) ->
963+ mapM_ (\(expType, actType) -> do
830964 lift $ except (atomTypeVerify expType actType)) zippedArgs
831965 evaldArgs <- mapM (evalGraphRefAtomExpr tupIn) arguments
832966 case evalAtomFunction func evaldArgs of
@@ -848,6 +982,58 @@ evalGraphRefAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs _) = do
848982 mapM (evalGraphRefAtomExpr tupIn) dConsArgs
849983 pure (ConstructedAtom dConsName aType argAtoms)
850984
985+{-
986+evalAtomExpr :: RelationTuple -> AtomExpr -> RelationalExprM Atom
987+evalAtomExpr tupIn expr =
988+ -}
989+{-
990+
991+evalAtomExpr tupIn (AttributeAtomExpr attrName) = case atomForAttributeName attrName tupIn of
992+ Right atom -> pure (Right atom)
993+ err@(Left (NoSuchAttributeNamesError _)) -> do
994+ rstate <- ask
995+ let stateTup = stateTuple rstate
996+ pure (atomForAttributeName attrName stateTup)
997+ Left err -> pure (Left err)
998+evalAtomExpr _ (NakedAtomExpr atom) = pure (Right atom)
999+evalAtomExpr tupIn (FunctionAtomExpr funcName arguments ()) = do
1000+ argTypes <- mapM (typeFromAtomExpr (tupleAttributes tupIn)) arguments
1001+ context <- fmap stateElemsContext ask
1002+ runExceptT $ do
1003+ let functions = atomFunctions context
1004+ func <- either throwE pure (atomFunctionForName funcName functions)
1005+ let expectedArgCount = length (atomFuncType func) - 1
1006+ actualArgCount = length argTypes
1007+ safeInit [] = [] -- different behavior from normal init
1008+ safeInit xs = init xs
1009+ if expectedArgCount /= actualArgCount then
1010+ throwE (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)
1011+ else do
1012+ let zippedArgs = zip (safeInit (atomFuncType func)) argTypes
1013+ mapM_ (\(expType, eActType) -> do
1014+ actType <- either throwE pure eActType
1015+ either throwE pure (atomTypeVerify expType actType)) zippedArgs
1016+ evaldArgs <- mapM (liftE . evalAtomExpr tupIn) arguments
1017+ case evalAtomFunction func evaldArgs of
1018+ Left err -> throwE (AtomFunctionUserError err)
1019+ Right result -> do
1020+ --validate that the result matches the expected type
1021+ _ <- either throwE pure (atomTypeVerify (last (atomFuncType func)) (atomTypeForAtom result))
1022+ pure result
1023+evalAtomExpr tupIn (RelationAtomExpr relExpr) = do
1024+ --merge existing state tuple context into new state tuple context to support an arbitrary number of levels, but new attributes trounce old attributes
1025+ rstate <- ask
1026+ runExceptT $ do
1027+ let newState = mergeTuplesIntoRelationalExprState tupIn rstate
1028+ relAtom <- either throwE pure (runReader (evalRelationalExpr relExpr) newState)
1029+ pure (RelationAtom relAtom)
1030+evalAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs ()) = runExceptT $ do
1031+ rstate <- lift ask
1032+ let newState = mergeTuplesIntoRelationalExprState tupIn rstate
1033+ aType <- either throwE pure (runReader (typeFromAtomExpr (tupleAttributes tupIn) cons) newState)
1034+ argAtoms <- mapM (\arg -> either throwE pure (runReader (evalAtomExpr tupIn arg) newState)) dConsArgs
1035+ pure (ConstructedAtom dConsName aType argAtoms)
1036+-}
8511037typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType
8521038typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do
8531039 renv <- askEnv
@@ -860,8 +1046,7 @@ typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do
8601046 Right attr -> pure (A.atomType attr)
8611047 Left _ -> case atomForAttributeName attrName envTup of
8621048 Right atom -> pure (atomTypeForAtom atom)
863− Left _ -> --throwError (traceStack (show ("typeForGRAtomExpr", attrs, envTup)) err)
864− throwError err
1049+ Left _ -> throwError err
8651050 Left err -> throwError err
8661051
8671052typeForGraphRefAtomExpr _ (NakedAtomExpr atom) = pure (atomTypeForAtom atom)
@@ -914,7 +1099,7 @@ verifyGraphRefAtomExprTypes relIn (FunctionAtomExpr funcName funcArgExprs tid) e
9141099 let handler :: RelationalError -> GraphRefRelationalExprM AtomType
9151100 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)
9161101 handler err = throwError err
917− verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler
1102+ verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler
9181103 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]
9191104 if length funcArgTypes /= length expectedArgTypes - 1 then
9201105 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)
@@ -938,55 +1123,7 @@ evalGraphRefAttrExpr (AttributeAndTypeNameExpr attrName tCons transId) = do
9381123 pure $ Attribute attrName aType
9391124
9401125evalGraphRefAttrExpr (NakedAttributeExpr attr) = pure attr
941−
942−-- for tuple type concrete resolution (Nothing ==> Maybe Int) when the attributes hint is Nothing, we need to first process all the tuples, then extract the concrete types on a per-attribute basis, then reprocess the tuples to include the concrete types
943−evalGraphRefTupleExprs :: Maybe Attributes -> GraphRefTupleExprs -> GraphRefRelationalExprM [RelationTuple]
944−evalGraphRefTupleExprs _ (TupleExprs _ []) = pure []
945−evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do
946− tuples <- mapM (evalGraphRefTupleExpr mAttrs) tupleExprL
947− finalAttrs <- case mAttrs of
948− Just attrs -> pure attrs
949− Nothing ->
950− case tuples of
951− [] -> pure emptyAttributes
952− (headTuple:tailTuples) -> do
953− --gather up resolved atom types or throw an error if an attribute cannot be made concrete from the inferred types- this could still fail if the type cannot be inferred (e.g. from [Nothing, Nothing])
954− let
955− processTupleAttrs (tupAttr, accAttr) =
956− --if the attribute is a constructedatomtype, we can recurse into it to potentially resolve type variables
957− if isResolvedAttribute accAttr && tupAttr == accAttr then
958− pure accAttr
959− else
960− lift $ except $ resolveAttributes accAttr tupAttr
961− mostResolvedTypes <-
962− foldM (\acc tup -> do
963− let zipped = zip (V.toList . attributesVec $ tupleAttributes tup) acc
964− accNames = S.fromList $ map A.attributeName acc
965− tupNames = A.attributeNameSet (tupleAttributes tup)
966− attrNamesDiff = S.union (S.difference accNames tupNames) (S.difference tupNames accNames)
967− unless (null attrNamesDiff) (throwError (AttributeNamesMismatchError attrNamesDiff))
968− nextTupleAttrs <- mapM processTupleAttrs zipped
969− let diff = A.attributesDifference (A.attributesFromList nextTupleAttrs) (A.attributesFromList acc)
970− if diff == A.emptyAttributes then
971− pure nextTupleAttrs
972− else
973− throwError (TupleAttributeTypeMismatchError diff)
974− ) (V.toList . attributesVec $ tupleAttributes headTuple) tailTuples
975− pure (A.attributesFromList mostResolvedTypes)
976− --strategy: if all the tuple expr transaction markers refer to one location, then we can pass the type constructor mapping from that location, otherwise, we cannot assume that the types are the same
977− tConsMap <- case singularTransactions tupleExprL of
978− SingularTransactionRef commonTransId ->
979− typeConstructorMapping <$> gfDatabaseContextForMarker commonTransId
980− NoTransactionsRef ->
981− typeConstructorMapping <$> gfDatabaseContextForMarker fixedMarker
982− -- if there are multiple transaction markers in the TupleExprs, then we can't assume a single type constructor mapping- this could be improved in the future, but if all the tuples are fully resolved, then we don't need further resolution
983− _ -> throwError TupleExprsReferenceMultipleMarkersError
984− lift $ except $ validateAttributes tConsMap finalAttrs
985− mapM (lift . except . resolveTypesInTuple finalAttrs tConsMap) tuples
986−
987−
988−--resolveAttributes (Attribute "gonk" (ConstructedAtomType "Either" (fromList [("a",IntegerAtomType),("b",TypeVariableType "b")]))) (Attribute "gonk" (ConstructedAtomType "Either" (fromList [("a",TypeVariableType "a"),("b",TextAtomType)])))
989−
1126+
9901127evalGraphRefTupleExpr :: Maybe Attributes -> GraphRefTupleExpr -> GraphRefRelationalExprM RelationTuple
9911128evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do
9921129 -- it's not possible for AtomExprs in tuple constructors to reference other Attributes' atoms due to the necessary order-of-operations (need a tuple to pass to evalAtomExpr)- it may be possible with some refactoring of type usage or delayed evaluation- needs more thought, but not a priority
@@ -1011,12 +1148,62 @@ evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do
10111148 --verify that the attributes match
10121149 when (A.attributeNameSet finalAttrs /= A.attributeNameSet tupAttrs) $ throwError (TupleAttributeTypeMismatchError tupAttrs)
10131150 --we can't resolve types here- they have to be resolved at the atom level where the graph ref is held
1014− --tup' <- lift $ except (resolveTypesInTuple finalAttrs tConss (reorderTuple finalAttrs tup))
1151+-- tup' <- lift $ except (resolveTypesInTuple finalAttrs tConss (reorderTuple finalAttrs tup))
10151152 let tup' = reorderTuple finalAttrs tup
10161153 --TODO: restore type resolution
10171154-- _ <- lift $ except (validateTuple tup' tConss)
10181155 pure tup'
10191156
1157+{-
1158+evalAttributeNames :: AttributeNames -> RelationalExpr -> RelationalExprM (Either RelationalError (S.Set AttributeName))
1159+evalAttributeNames attrNames expr = do
1160+ eExprType <- typeForRelationalExpr expr
1161+ case eExprType of
1162+ Left err -> throwError err
1163+ Right exprTyp -> do
1164+ let typeNameSet = S.fromList (V.toList (A.attributeNames (attributes exprTyp)))
1165+ case attrNames of
1166+ AttributeNames names ->
1167+ case A.projectionAttributesForNames names (attributes exprTyp) of
1168+ Left err -> pure (Left err)
1169+ Right attrs -> pure (Right (S.fromList (V.toList (A.attributeNames attrs))))
1170+
1171+ InvertedAttributeNames names -> do
1172+ let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet
1173+ if not (S.null nonExistentAttributeNames) then
1174+ pure (Left (AttributeNamesMismatchError nonExistentAttributeNames))
1175+ else
1176+ pure (Right (A.nonMatchingAttributeNameSet names typeNameSet))
1177+
1178+ UnionAttributeNames namesA namesB -> do
1179+ eNameSetA <- evalAttributeNames namesA expr
1180+ case eNameSetA of
1181+ Left err -> pure (Left err)
1182+ Right nameSetA -> do
1183+ eNameSetB <- evalAttributeNames namesB expr
1184+ case eNameSetB of
1185+ Left err -> pure (Left err)
1186+ Right nameSetB ->
1187+ pure (Right (S.union nameSetA nameSetB))
1188+
1189+ IntersectAttributeNames namesA namesB -> do
1190+ eNameSetA <- evalAttributeNames namesA expr
1191+ case eNameSetA of
1192+ Left err -> pure (Left err)
1193+ Right nameSetA -> do
1194+ eNameSetB <- evalAttributeNames namesB expr
1195+ case eNameSetB of
1196+ Left err -> pure (Left err)
1197+ Right nameSetB ->
1198+ pure (Right (S.intersection nameSetA nameSetB))
1199+
1200+ RelationalExprAttributeNames attrExpr -> do
1201+ eAttrExprType <- typeForRelationalExpr attrExpr
1202+ case eAttrExprType of
1203+ Left err -> pure (Left err)
1204+ Right attrExprType -> pure (Right (A.attributeNameSet (attributes attrExprType)))
1205+-}
1206+
10201207--temporary implementation until we have a proper planner+executor
10211208evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation
10221209evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do
@@ -1024,7 +1211,7 @@ evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do
10241211 Just _ ->
10251212 Just . A.attributesFromList <$> mapM evalGraphRefAttrExpr (fromMaybe [] mAttrExprs)
10261213 Nothing -> pure Nothing
1027− tuples <- evalGraphRefTupleExprs mAttrs tupleExprs
1214+ tuples <- mapM (evalGraphRefTupleExpr mAttrs) tupleExprs
10281215 let attrs = fromMaybe firstTupleAttrs mAttrs
10291216 firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)
10301217 lift $ except $ mkRelation attrs (RelationTupleSet tuples)
@@ -1078,7 +1265,7 @@ evalGraphRefRelationalExpr (Extend extendTupleExpr expr) = do
10781265 rel <- evalGraphRefRelationalExpr expr
10791266 (newAttrs, tupProc) <- extendGraphRefTupleExpressionProcessor rel extendTupleExpr
10801267 lift $ except $ relMogrify tupProc newAttrs rel
1081−evalGraphRefRelationalExpr expr@With{} =
1268+evalGraphRefRelationalExpr expr@With{} = do
10821269 --strategy A: add relation variables to the contexts in the graph
10831270 --strategy B: drop in macros in place (easier programmatically)
10841271 --strategy B implementation
@@ -1106,10 +1293,10 @@ typeForGraphRefRelationalExpr (ExistingRelation rel) = pure (emptyRelationWithAt
11061293typeForGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do
11071294 mAttrs <- case mAttrExprs of
11081295 Just attrExprs -> do
1109− attrs <- mapM evalGraphRefAttributeExpr attrExprs
1296+ attrs <- mapM (\e -> evalGraphRefAttributeExpr e) attrExprs
11101297 pure (Just (attributesFromList attrs))
11111298 Nothing -> pure Nothing
1112− tuples <- evalGraphRefTupleExprs mAttrs tupleExprs
1299+ tuples <- mapM (evalGraphRefTupleExpr mAttrs) tupleExprs
11131300 let retAttrs = case tuples of
11141301 (tup:_) -> tupleAttributes tup
11151302 [] -> fromMaybe A.emptyAttributes mAttrs
@@ -1119,8 +1306,7 @@ typeForGraphRefRelationalExpr (RelationVariable rvName tid) = do
11191306 relVars <- relationVariables <$> gfDatabaseContextForMarker tid
11201307 case M.lookup rvName relVars of
11211308 Nothing -> throwError (RelVarNotDefinedError rvName)
1122− Just rvExpr ->
1123− typeForGraphRefRelationalExpr rvExpr
1309+ Just rvExpr -> typeForGraphRefRelationalExpr rvExpr
11241310typeForGraphRefRelationalExpr (Project attrNames expr) = do
11251311 exprType' <- typeForGraphRefRelationalExpr expr
11261312 projectionAttrs <- evalGraphRefAttributeNames attrNames expr
@@ -1151,21 +1337,15 @@ typeForGraphRefRelationalExpr (Restrict pred' expr) = do
11511337 expr' <- typeForGraphRefRelationalExpr expr
11521338 filt <- predicateRestrictionFilter (attributes expr') pred'
11531339 lift $ except $ restrict filt expr'
1154−typeForGraphRefRelationalExpr Equals{} =
1340+typeForGraphRefRelationalExpr Equals{} = do
11551341 pure relationFalse
1156−typeForGraphRefRelationalExpr NotEquals{} =
1342+typeForGraphRefRelationalExpr NotEquals{} = do
11571343 pure relationFalse
11581344typeForGraphRefRelationalExpr (Extend extendTupleExpr expr) = do
11591345 rel <- typeForGraphRefRelationalExpr expr
11601346 evalGraphRefRelationalExpr (Extend extendTupleExpr (ExistingRelation rel))
1161−typeForGraphRefRelationalExpr expr@(With withs _) = do
1347+typeForGraphRefRelationalExpr expr@With{} = do
11621348 let expr' = substituteWithNameMacros [] expr
1163− checkMacroName (WithNameExpr macroName tid) = do
1164− rvs <- relationVariables <$> gfDatabaseContextForMarker tid
1165− case M.lookup macroName rvs of
1166− Just _ -> lift $ except $ Left (RelVarAlreadyDefinedError macroName) --this error does not include the transaction marker, but should be good enough to identify the cause
1167− Nothing -> pure ()
1168− mapM_ (checkMacroName . fst) withs
11691349 typeForGraphRefRelationalExpr expr'
11701350
11711351evalGraphRefAttributeNames :: GraphRefAttributeNames -> GraphRefRelationalExpr -> GraphRefRelationalExprM (S.Set AttributeName)
@@ -1181,7 +1361,7 @@ evalGraphRefAttributeNames attrNames expr = do
11811361 InvertedAttributeNames names -> do
11821362 let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet
11831363 if not (S.null nonExistentAttributeNames) then
1184− throwError $ AttributeNamesMismatchError nonExistentAttributeNames
1364+ throwError (AttributeNamesMismatchError nonExistentAttributeNames)
11851365 else
11861366 pure (A.nonMatchingAttributeNameSet names typeNameSet)
11871367
@@ -1211,9 +1391,9 @@ evalGraphRefAttributeExpr (AttributeAndTypeNameExpr attrName tCons tid) = do
12111391evalGraphRefAttributeExpr (NakedAttributeExpr attr) = pure attr
12121392
12131393mkEmptyRelVars :: RelationVariables -> RelationVariables
1214−mkEmptyRelVars = M.map mkEmptyRelVar
1394+mkEmptyRelVars rvMap = M.map mkEmptyRelVar rvMap
12151395 where
1216− mkEmptyRelVar expr@MakeRelationFromExprs{} = expr --do not truncate here because we might lose essential type information in emptying the tuples
1396+ mkEmptyRelVar (MakeRelationFromExprs mAttrs _) = MakeRelationFromExprs mAttrs []
12171397 mkEmptyRelVar (MakeStaticRelation attrs _) = MakeStaticRelation attrs emptyTupleSet
12181398 mkEmptyRelVar (ExistingRelation rel) = ExistingRelation (emptyRelationWithAttrs (attributes rel))
12191399 mkEmptyRelVar rv@RelationVariable{} = Restrict (NotPredicate TruePredicate) rv
@@ -1228,7 +1408,7 @@ mkEmptyRelVars = M.map mkEmptyRelVar
12281408 mkEmptyRelVar (Equals exprA exprB) = Equals (mkEmptyRelVar exprA) (mkEmptyRelVar exprB)
12291409 mkEmptyRelVar (NotEquals exprA exprB) = NotEquals (mkEmptyRelVar exprA) (mkEmptyRelVar exprB)
12301410 mkEmptyRelVar (Extend extTuple expr) = Extend extTuple (mkEmptyRelVar expr)
1231− mkEmptyRelVar (With macros expr) = With (map (second mkEmptyRelVar) macros) (mkEmptyRelVar expr)
1411+ mkEmptyRelVar (With macros expr) = With (map (\(rv, expr') -> (rv, mkEmptyRelVar expr')) macros) (mkEmptyRelVar expr)
12321412
12331413
12341414dbErr :: RelationalError -> DatabaseContextEvalMonad ()
@@ -1245,7 +1425,7 @@ relationVariablesAsRelation ctx graph = do
12451425 let gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph
12461426 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)
12471427 pure (rvName, gfType)
1248− relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributesVec (attributes rel))]
1428+ relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributes rel)]
12491429 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]
12501430 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of
12511431 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)
@@ -1265,6 +1445,15 @@ evalRelationalExpr expr = do
12651445 Left err -> throwError err
12661446 Right rel -> pure rel
12671447
1448+{-
1449+relVarByName :: RelVarName -> GraphRefRelationalExprM GraphRefRelationalExpr
1450+relVarByName = do
1451+ relvars <- relationVariables <$> getStateContext
1452+ case M.lookup relVarName relvars of
1453+ Nothing -> dbErr (RelVarNotDefinedError relVarName)
1454+ Just gfexpr -> pure gfExpr
1455+-}
1456+
12681457class (MonadError RelationalError m, Monad m) => DatabaseContextM m where
12691458 getContext :: m DatabaseContext
12701459
@@ -1281,112 +1470,3 @@ relVarByName rvName = do
12811470 Nothing -> throwError (RelVarNotDefinedError rvName)
12821471 Just gfexpr -> pure gfexpr
12831472
1284−-- | resolve UncommittedTransactionMarker whenever possible- this is important in the DatabaseContext in order to mitigate self-referencing loops for updates
1285−class ResolveGraphRefTransactionMarker a where
1286− resolve :: a -> DatabaseContextEvalMonad a
1287−
1288−-- s := s union t
1289−instance ResolveGraphRefTransactionMarker GraphRefRelationalExpr where
1290− resolve (MakeRelationFromExprs mAttrs tupleExprs) =
1291− MakeRelationFromExprs mAttrs <$> resolve tupleExprs
1292− resolve orig@MakeStaticRelation{} = pure orig
1293− resolve orig@ExistingRelation{} = pure orig
1294− resolve orig@(RelationVariable rvName UncommittedContextMarker) = do
1295− rvMap <- relationVariables <$> getStateContext
1296− case M.lookup rvName rvMap of
1297− Nothing -> pure orig
1298− Just resolvedRv -> resolve resolvedRv
1299− resolve orig@RelationVariable{} = pure orig
1300− resolve (Project attrNames relExpr) = Project <$> resolve attrNames <*> resolve relExpr
1301− resolve (Union exprA exprB) = Union <$> resolve exprA <*> resolve exprB
1302− resolve (Join exprA exprB) = Join <$> resolve exprA <*> resolve exprB
1303− resolve (Rename attrA attrB expr) = Rename attrA attrB <$> resolve expr
1304− resolve (Difference exprA exprB) = Difference <$> resolve exprA <*> resolve exprB
1305− resolve (Group namesA nameB expr) = Group <$> resolve namesA <*> pure nameB <*> resolve expr
1306− resolve (Ungroup nameA expr) = Ungroup nameA <$> resolve expr
1307− resolve (Restrict restrictExpr relExpr) = Restrict <$> resolve restrictExpr <*> resolve relExpr
1308− resolve (Equals exprA exprB) = Equals <$> resolve exprA <*> resolve exprB
1309− resolve (NotEquals exprA exprB) = NotEquals <$> resolve exprA <*> resolve exprB
1310− resolve (Extend extendExpr relExpr) = Extend <$> resolve extendExpr <*> resolve relExpr
1311− resolve (With withExprs relExpr) = With <$> mapM (\(nam, expr) -> (,) <$> resolve nam <*> resolve expr) withExprs <*> resolve relExpr
1312−
1313−instance ResolveGraphRefTransactionMarker GraphRefTupleExprs where
1314− resolve (TupleExprs marker tupleExprs) =
1315− TupleExprs marker <$> mapM resolve tupleExprs
1316−
1317−instance ResolveGraphRefTransactionMarker GraphRefTupleExpr where
1318− resolve (TupleExpr tupMap) = do
1319− tupMap' <- mapM (\(attrName, expr) -> (,) attrName <$> resolve expr ) (M.toList tupMap)
1320− pure (TupleExpr (M.fromList tupMap'))
1321−
1322−instance ResolveGraphRefTransactionMarker GraphRefAttributeNames where
1323− resolve orig@AttributeNames{} = pure orig
1324− resolve orig@InvertedAttributeNames{} = pure orig
1325− resolve (UnionAttributeNames namesA namesB) = UnionAttributeNames <$> resolve namesA <*> resolve namesB
1326− resolve (IntersectAttributeNames namesA namesB) = IntersectAttributeNames <$> resolve namesA <*> resolve namesB
1327− resolve (RelationalExprAttributeNames expr) = RelationalExprAttributeNames <$> resolve expr
1328−
1329−instance ResolveGraphRefTransactionMarker GraphRefRestrictionPredicateExpr where
1330− resolve TruePredicate = pure TruePredicate
1331− resolve (AndPredicate exprA exprB) = AndPredicate <$> resolve exprA <*> resolve exprB
1332− resolve (OrPredicate exprA exprB) = OrPredicate <$> resolve exprA <*> resolve exprB
1333− resolve (NotPredicate expr) = NotPredicate <$> resolve expr
1334− resolve (RelationalExprPredicate expr) = RelationalExprPredicate <$> resolve expr
1335− resolve (AtomExprPredicate expr) = AtomExprPredicate <$> resolve expr
1336− resolve (AttributeEqualityPredicate nam expr)= AttributeEqualityPredicate nam <$> resolve expr
1337−
1338−instance ResolveGraphRefTransactionMarker GraphRefExtendTupleExpr where
1339− resolve (AttributeExtendTupleExpr nam atomExpr) = AttributeExtendTupleExpr nam <$> resolve atomExpr
1340−
1341−instance ResolveGraphRefTransactionMarker GraphRefWithNameExpr where
1342− resolve orig@WithNameExpr{} = pure orig -- match uncommitted marker?
1343−
1344−instance ResolveGraphRefTransactionMarker GraphRefAtomExpr where
1345− resolve orig@AttributeAtomExpr{} = pure orig
1346− resolve orig@NakedAtomExpr{} = pure orig
1347− resolve (FunctionAtomExpr nam atomExprs marker) =
1348− FunctionAtomExpr nam <$> mapM resolve atomExprs <*> pure marker
1349− resolve (RelationAtomExpr expr) = RelationAtomExpr <$> resolve expr
1350− resolve (ConstructedAtomExpr dConsName atomExprs marker) =
1351− ConstructedAtomExpr dConsName <$> mapM resolve atomExprs <*> pure marker
1352−
1353−--convert series of simple Union queries into MakeStaticRelation
1354−-- this is especially useful for long, nested applications of Union with simple tuples
1355−-- Union (MakeRelation x y) (MakeRelation x y') -> MakeRelation x (y + y')
1356−
1357−--MakeRelationFromExprs Nothing (TupleExprs UncommittedContextMarker [TupleExpr (fromList [("name", NakedAtomExpr (TextAtom "steve"))])])
1358−
1359−applyUnionCollapse :: GraphRefRelationalExpr -> GraphRefRelationalExpr
1360−applyUnionCollapse = Fold.cata opt
1361− where
1362− opt :: RelationalExprBaseF GraphRefTransactionMarker GraphRefRelationalExpr -> GraphRefRelationalExpr
1363− opt (UnionF exprA exprB) | exprA == exprB = exprA
1364− opt (UnionF
1365− exprA@(MakeRelationFromExprs mAttrs1 tupExprs1)
1366− exprB@(MakeRelationFromExprs mAttrs2 tupExprs2)) | tupExprs1 == tupExprs2 = MakeRelationFromExprs (mAttrs1 <|> mAttrs2) tupExprs1
1367− | tupExprsNull tupExprs1 = exprB
1368− | tupExprsNull tupExprs2 = exprA
1369− opt x = Fold.embed x
1370− tupExprsNull (TupleExprs _ []) = True
1371− tupExprsNull _ = False
1372−
1373−
1374−--UPDATE optimization- find matching where clause in "lower" levels of renaming
1375−--update x where y=1 set (x:=5,z:=10); update x where y=1 set(x:=6,z:=11)
1376−-- =>
1377−-- update x where y=1 set (x:=6,z:=11)
1378−-- future opt: match individual attributes update x where y=1 set (x:=5); update x where y=1 set (z:=11) => update x where y=1 set (x:=5,z:=11)
1379−
1380−--strategy: try to collapse the top-level update (union (restrict pred MakeRelationFromExpr) expr) if it contains the same predicate and resultant relation
1381−
1382−--DELETE optimization
1383−-- if a restriction matches a previous restriction, combine them
1384−-- O(1) since it only scans at the top level, critical in benchmarks generating redundant deletions
1385−applyRestrictionCollapse :: GraphRefRelationalExpr -> GraphRefRelationalExpr
1386−applyRestrictionCollapse orig@(Restrict npred@(NotPredicate _) expr) =
1387− case expr of
1388− orig'@(Restrict npred'@(NotPredicate _) _) | npred == npred' -> orig'
1389− _ -> orig
1390−applyRestrictionCollapse expr = expr
1391−
1392−
src/lib/ProjectM36/ScriptSession.hs+44−72
@@ -1,12 +1,8 @@
1−{-# LANGUAGE UnboxedTuples, KindSignatures, DataKinds #-}
2−#ifdef PM36_HASKELL_SCRIPTING
3−{-# LANGUAGE MagicHash #-}
4−#endif
1+{-# LANGUAGE MagicHash, UnboxedTuples #-}
52module ProjectM36.ScriptSession where
63
7−#ifdef PM36_HASKELL_SCRIPTING
84import ProjectM36.Error
9−import GHC
5+
106import Control.Exception
117import Control.Monad
128import System.IO.Error
@@ -17,8 +13,9 @@ import System.FilePath
1713import System.Info (os, arch)
1814import Data.Text (Text, unpack)
1915import Data.Maybe
16+
17+import GHC
2018import GHC.Paths (libdir)
21−import System.Environment
2219#if __GLASGOW_HASKELL__ >= 800
2320import GHC.LanguageExtensions
2421import GHCi.ObjLink
@@ -36,41 +33,25 @@ import Unsafe.Coerce
3633#if __GLASGOW_HASKELL__ >= 802
3734import Type
3835#elif __GLASGOW_HASKELL__ >= 710
39−import Type hiding (pprTyThing)
36+import Type hiding (pprTyThing)
4037#else
4138#endif
39+
4240import GHC.Exts (addrToAny#)
4341import GHC.Ptr (Ptr(..))
4442import Encoding
45−#endif
46−
4743
4844data ScriptSession = ScriptSession {
49−#ifdef PM36_HASKELL_SCRIPTING
50− hscEnv :: HscEnv,
45+ hscEnv :: HscEnv,
5146 atomFunctionBodyType :: Type,
5247 dbcFunctionBodyType :: Type
53−#endif
5448 }
55−
56−#ifdef PM36_HASKELL_SCRIPTING
57−data ScriptSessionError = ScriptSessionLoadError GhcException
58− | ScriptingDisabled
49+
50+newtype ScriptSessionError = ScriptSessionLoadError GhcException
5951 deriving (Show)
60−#else
61−data ScriptSessionError = ScriptingDisabled
62− deriving (Show)
63−#endif
64−
65−data LoadSymbolError = LoadSymbolError
66−type ModName = String
67−type FuncName = String
6852
6953-- | Configure a GHC environment/session which we will use for all script compilation.
7054initScriptSession :: [String] -> IO (Either ScriptSessionError ScriptSession)
71−#if !defined(PM36_HASKELL_SCRIPTING)
72−initScriptSession _ = pure (Left ScriptingDisabled)
73−#else
7455initScriptSession ghcPkgPaths = do
7556 --for the sake of convenience, for developers' builds, include the local cabal sandbox package database and the cabal new-build package database
7657 eHomeDir <- tryJust (guard . isDoesNotExistError) getHomeDirectory
@@ -79,30 +60,28 @@ initScriptSession ghcPkgPaths = do
7960 handleGhcException excHandler $ runGhc (Just libdir) $ do
8061 dflags <- getSessionDynFlags
8162 let ghcVersion = projectVersion dflags
82− -- get nix packages dir, if available
83− mNixLibDir <- liftIO $ lookupEnv "NIX_GHC_LIBDIR"
8463
8564 sandboxPkgPaths <- liftIO $ concat <$> mapM glob [
86− --"./dist-newstyle/packagedb/ghc-" ++ ghcVersion, --rely on cabal 3's ghc.environment install: "cabal install --lib project-m36"
65+ "./dist-newstyle/packagedb/ghc-" ++ ghcVersion,
8766 ".cabal-sandbox/*ghc-" ++ ghcVersion ++ "-packages.conf.d",
8867 ".stack-work/install/*/*/" ++ ghcVersion ++ "/pkgdb",
8968 ".stack-work/install/*/pkgdb/", --windows stack build
9069 "C:/sr/snapshots/b201cfe6/pkgdb", --windows stack build- ideally, we could run `stack path --snapshot-pkg-db, but this is sufficient to pass CI
91− homeDir </> ".stack/snapshots/*/*/" ++ ghcVersion ++ "/pkgdb"
92− --homeDir </> ".cabal/store/ghc-" ++ ghcVersion ++ "/package.db"
70+ homeDir </> ".stack/snapshots/*/*/" ++ ghcVersion ++ "/pkgdb",
71+ homeDir </> ".cabal/store/ghc-" ++ ghcVersion ++ "/package.db"
9372 ]
94−
95− let localPkgPaths = map PkgConfFile (ghcPkgPaths ++ sandboxPkgPaths ++ maybeToList mNixLibDir)
96−
97− let dflags' = applyGopts . applyXopts $ dflags { hscTarget = HscInterpreted ,
98− ghcLink = LinkInMemory,
73+
74+ let localPkgPaths = map PkgConfFile (ghcPkgPaths ++ sandboxPkgPaths)
75+
76+ let dflags' = applyGopts . applyXopts $ dflags { hscTarget = HscInterpreted ,
77+ ghcLink = LinkInMemory,
9978 safeHaskell = Sf_Trustworthy,
10079 safeInfer = True,
10180 safeInferred = True,
10281 --verbosity = 3,
103−#if __GLASGOW_HASKELL__ >= 800
82+#if __GLASGOW_HASKELL__ >= 800
10483 trustFlags = map TrustPackage required_packages,
105−#endif
84+#endif
10685 packageFlags = packageFlags dflags ++ packages,
10786#if __GLASGOW_HASKELL__ >= 802
10887 packageDBFlags = map PackageDB localPkgPaths
@@ -115,11 +94,11 @@ initScriptSession ghcPkgPaths = do
11594 applyXopts flags = foldl xopt_set flags xopts
11695#if __GLASGOW_HASKELL__ >= 800
11796 xopts = [OverloadedStrings, ExtendedDefaultRules, ImplicitPrelude, ScopedTypeVariables]
118−#else
97+#else
11998 xopts = [Opt_OverloadedStrings, Opt_ExtendedDefaultRules, Opt_ImplicitPrelude, Opt_ScopedTypeVariables]
12099#endif
121100 gopts = [] --[Opt_DistrustAllPackages, Opt_PackageTrust]
122− required_packages = ["base",
101+ required_packages = ["base",
123102 "containers",
124103 "Glob",
125104 "directory",
@@ -128,6 +107,8 @@ initScriptSession ghcPkgPaths = do
128107 "uuid",
129108 "vector",
130109 "text",
110+ "binary",
111+ "vector-binary-instances",
131112 "time",
132113 "project-m36",
133114 "bytestring"]
@@ -139,33 +120,20 @@ initScriptSession ghcPkgPaths = do
139120 --liftIO $ traceShowM (showSDoc dflags' (ppr packages))
140121 _ <- setSessionDynFlags dflags'
141122 let safeImportDecl mn mQual = ImportDecl {
142−#if __GLASGOW_HASKELL__ >= 802
123+#if __GLASGOW_HASKELL__ >= 802
143124 ideclSourceSrc = NoSourceText,
144125#else
145126 ideclSourceSrc = Nothing,
146127#endif
147−
148−#if __GLASGOW_HASKELL__ >= 810
149− ideclExt = noExtField,
150−#elif __GLASGOW_HASKELL__ >= 806
151− ideclExt = NoExt,
152−#endif
153128 ideclName = noLoc mn,
154129 ideclPkgQual = Nothing,
155130 ideclSource = False,
156131 ideclSafe = True,
157132 ideclImplicit = False,
158−#if __GLASGOW_HASKELL__ >= 810
159− ideclQualified = if isJust mQual then QualifiedPre else NotQualified,
160−#else
161133 ideclQualified = isJust mQual,
162−#endif
163134 ideclAs = mQual,
164135 ideclHiding = Nothing
165136 }
166−#if __GLASGOW_HASKELL__ >= 806
167− :: ImportDecl (GhcPass (c :: Pass))
168−#endif
169137 unqualifiedModules = map (\modn -> IIDecl $ safeImportDecl (mkModuleName modn) Nothing) [
170138 "Prelude",
171139 "Data.Map",
@@ -182,7 +150,7 @@ initScriptSession ghcPkgPaths = do
182150 mkModName = noLoc . mkModuleName
183151#else
184152 mkModName = mkModuleName
185−#endif
153+#endif
186154 qualifiedModules = map (\(modn, qualNam) -> IIDecl $ safeImportDecl (mkModuleName modn) (Just (mkModName qualNam))) [
187155 ("Data.Text", "T")
188156 ]
@@ -195,8 +163,8 @@ initScriptSession ghcPkgPaths = do
195163addImport :: String -> Ghc ()
196164addImport moduleNam = do
197165 ctx <- getContext
198− setContext (IIDecl (simpleImportDecl (mkModuleName moduleNam)) : ctx)
199−
166+ setContext ( (IIDecl $ simpleImportDecl (mkModuleName moduleNam)) : ctx )
167+
200168showType :: DynFlags -> Type -> String
201169showType dflags ty = showSDocForUser dflags alwaysQualify (pprTypeForUser ty)
202170
@@ -221,36 +189,41 @@ compileScript funcType script = do
221189 mErr <- typeCheckScript funcType script
222190 case mErr of
223191 Just err -> pure (Left err)
224− Nothing ->
192+ Nothing ->
225193 --catch exception here
226194 --we could potentially wrap the script with Atom pattern matching so that the script doesn't have to do it, but the change to an Atom ADT should make it easier. Still, it would be nice if the script didn't have to handle a list of arguments, for example.
227195 -- we can't use dynCompileExpr here because
228196 Right . unsafeCoerce <$> compileExpr sScript
229−
230−typeCheckScript :: Type -> Text -> Ghc (Maybe ScriptCompilationError)
197+
198+typeCheckScript :: Type -> Text -> Ghc (Maybe ScriptCompilationError)
231199typeCheckScript expectedType inp = do
232− dflags <- getSessionDynFlags
200+ dflags <- getSessionDynFlags
233201 --catch exception for SyntaxError
234202#if __GLASGOW_HASKELL__ >= 802
235− funcType <- GHC.exprType TM_Inst (unpack inp)
236−#else
203+ funcType <- GHC.exprType TM_Inst (unpack inp)
204+#else
237205 funcType <- GHC.exprType (unpack inp)
238206#endif
239− --liftIO $ putStrLn $ showType dflags expectedType ++ ":::" ++ showType dflags funcType
207+ --liftIO $ putStrLn $ showType dflags expectedType ++ ":::" ++ showType dflags funcType
240208 if eqType funcType expectedType then
241209 pure Nothing
242210 else
243211 pure (Just (TypeCheckCompilationError (showType dflags expectedType) (showType dflags funcType)))
244−
212+
245213mangleSymbol :: Maybe String -> String -> String -> String
246214mangleSymbol pkg module' valsym =
247215 prefixUnderscore ++
248216 maybe "" (\p -> zEncodeString p ++ "_") pkg ++
249217 zEncodeString module' ++ "_" ++ zEncodeString valsym ++ "_closure"
218+
219+type ModName = String
220+type FuncName = String
221+
222+data LoadSymbolError = LoadSymbolError
250223
251224loadFunction :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError a)
252225loadFunction modName funcName objPath = do
253−#if __GLASGOW_HASKELL__ >= 802
226+#if __GLASGOW_HASKELL__ >= 802
254227 initObjLinker RetainCAFs
255228#else
256229 initObjLinker
@@ -262,8 +235,8 @@ loadFunction modName funcName objPath = do
262235 Nothing -> pure (Left LoadSymbolError)
263236 Just (Ptr addr) -> case addrToAny# addr of
264237 (# hval #) -> pure (Right hval)
265−
266−prefixUnderscore :: String
238+
239+prefixUnderscore :: String
267240prefixUnderscore =
268241 case (os,arch) of
269242 ("mingw32","x86_64") -> ""
@@ -271,5 +244,4 @@ prefixUnderscore =
271244 ("mingw32",_) -> "_"
272245 ("darwin",_) -> "_"
273246 ("cygwin",_) -> "_"
274− _ -> ""
275−#endif
247+ _ -> ""
src/lib/ProjectM36/Serialise/AtomFunctionError.hsdeleted−7
@@ -1,7 +0,0 @@
1−{-# LANGUAGE DerivingVia, StandaloneDeriving #-}
2−{-# OPTIONS_GHC -fno-warn-orphans #-}
3−module ProjectM36.Serialise.AtomFunctionError where
4−import Codec.Winery
5−import ProjectM36.AtomFunctionError
6−
7−deriving via WineryVariant AtomFunctionError instance Serialise AtomFunctionError
src/lib/ProjectM36/Serialise/Base.hsdeleted−85
@@ -1,85 +0,0 @@
1−{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeApplications, TypeSynonymInstances, ScopedTypeVariables #-}
2−{-# OPTIONS_GHC -fno-warn-orphans #-}
3−--Serialise instances for ProjectM36.Base data types- orphan instance city
4−module ProjectM36.Serialise.Base where
5−import Codec.Winery hiding (Schema)
6−import Codec.Winery.Internal
7−import Control.Monad
8−import ProjectM36.Base
9−import ProjectM36.MerkleHash
10−import Data.UUID
11−import Data.Proxy
12−import Data.Word
13−import ProjectM36.Attribute as A
14−import qualified Data.List.NonEmpty as NE
15−import qualified Data.Vector as V
16−import Data.Time.Calendar (Day,toGregorian,fromGregorian)
17−
18−deriving via WineryVariant Atom instance Serialise Atom
19−deriving via WineryVariant AtomType instance Serialise AtomType
20−deriving via WineryVariant Attribute instance Serialise Attribute
21−deriving via WineryVariant RelationTupleSet instance Serialise RelationTupleSet
22−deriving via WineryVariant RelationTuple instance Serialise RelationTuple
23−deriving via WineryVariant Relation instance Serialise Relation
24−deriving via WineryVariant RelationCardinality instance Serialise RelationCardinality
25−deriving via WineryVariant (RelationalExprBase a) instance Serialise a => Serialise (RelationalExprBase a)
26−deriving via WineryVariant (WithNameExprBase a) instance Serialise a => Serialise (WithNameExprBase a)
27−deriving via WineryVariant Notification instance Serialise Notification
28−deriving via WineryVariant TypeConstructorDef instance Serialise TypeConstructorDef
29−deriving via WineryVariant (TypeConstructorBase a) instance Serialise a => Serialise (TypeConstructorBase a)
30−deriving via WineryVariant DataConstructorDef instance Serialise DataConstructorDef
31−deriving via WineryVariant DataConstructorDefArg instance Serialise DataConstructorDefArg
32−deriving via WineryVariant GraphRefTransactionMarker instance Serialise GraphRefTransactionMarker
33−deriving via WineryVariant SchemaIsomorph instance Serialise SchemaIsomorph
34−deriving via WineryVariant InclusionDependency instance Serialise InclusionDependency
35−deriving via WineryVariant (DatabaseContextExprBase a) instance Serialise a => Serialise (DatabaseContextExprBase a)
36−deriving via WineryVariant (DatabaseContextIOExprBase a) instance Serialise a => Serialise (DatabaseContextIOExprBase a)
37−deriving via WineryVariant (RestrictionPredicateExprBase a) instance Serialise a => Serialise (RestrictionPredicateExprBase a)
38−deriving via WineryVariant TransactionInfo instance Serialise TransactionInfo
39−deriving via WineryVariant (AtomExprBase a) instance Serialise a => Serialise (AtomExprBase a)
40−deriving via WineryVariant MerkleHash instance Serialise MerkleHash
41−deriving via WineryVariant (AttributeExprBase a) instance Serialise a => Serialise (AttributeExprBase a)
42−deriving via WineryVariant (TupleExprsBase a) instance Serialise a => Serialise (TupleExprsBase a)
43−deriving via WineryVariant (TupleExprBase a) instance Serialise a => Serialise (TupleExprBase a)
44−deriving via WineryVariant (AttributeNamesBase a) instance Serialise a => Serialise (AttributeNamesBase a)
45−deriving via WineryVariant (ExtendTupleExprBase a) instance Serialise a => Serialise (ExtendTupleExprBase a)
46−deriving via WineryVariant Schema instance Serialise Schema
47−deriving via WineryVariant MergeStrategy instance Serialise MergeStrategy
48−
49−fromWordsTup :: (Word32, Word32, Word32, Word32) -> TransactionId
50−fromWordsTup (a,b,c,d) = fromWords a b c d
51−
52−instance Serialise TransactionId where
53− schemaGen _ = getSchema (Proxy @(Word32, Word32, Word32, Word32))
54− toBuilder uuid = toBuilder (toWords uuid)
55− extractor = fromWordsTup <$> extractor
56− decodeCurrent = fromWordsTup <$> decodeCurrent
57−
58−instance Serialise a => Serialise (NE.NonEmpty a) where
59− schemaGen _ = SVector <$> getSchema (Proxy @a)
60− toBuilder xs = varInt (length xs) <> foldMap toBuilder xs
61− extractor = NE.fromList . V.toList <$> extractListBy extractor --use nonempty instead to replace error with winery error
62− decodeCurrent = do
63− n <- decodeVarInt
64− l <- replicateM n decodeCurrent
65− pure (NE.fromList l)
66−
67−fromGregorianTup :: (Integer, Int, Int) -> Day
68−fromGregorianTup (a, b, c) = fromGregorian a b c
69−
70−instance Serialise Day where
71− schemaGen _ = getSchema (Proxy @(Integer, Int, Int))
72− toBuilder day = toBuilder (toGregorian day)
73− extractor = fromGregorianTup <$> extractor
74− decodeCurrent = fromGregorianTup <$> decodeCurrent
75−
76−instance Serialise Attributes where
77− schemaGen _ = SVector <$> getSchema (Proxy @Attribute)
78− toBuilder attrs = varInt (V.length (attributesVec attrs)) <> foldMap toBuilder (V.toList (attributesVec attrs))
79− extractor =
80− attributesFromList . V.toList <$> extractListBy extractor
81−
82− decodeCurrent = do
83− n <- decodeVarInt
84− l <- replicateM n decodeCurrent
85− pure (A.attributesFromList l)
src/lib/ProjectM36/Serialise/DataFrame.hsdeleted−13
@@ -1,13 +0,0 @@
1−{-# LANGUAGE DerivingVia, StandaloneDeriving #-}
2−{-# OPTIONS_GHC -fno-warn-orphans #-}
3−module ProjectM36.Serialise.DataFrame where
4−import Codec.Winery
5−import ProjectM36.DataFrame
6−import ProjectM36.Serialise.Base ()
7−
8−deriving via WineryVariant AttributeOrderExpr instance Serialise AttributeOrderExpr
9−deriving via WineryVariant AttributeOrder instance Serialise AttributeOrder
10−deriving via WineryVariant Order instance Serialise Order
11−deriving via WineryRecord DataFrame instance Serialise DataFrame
12−deriving via WineryVariant DataFrameTuple instance Serialise DataFrameTuple
13−deriving via WineryRecord DataFrameExpr instance Serialise DataFrameExpr
src/lib/ProjectM36/Serialise/DatabaseContextFunctionError.hsdeleted−7
@@ -1,7 +0,0 @@
1−{-# LANGUAGE DerivingVia, StandaloneDeriving #-}
2−{-# OPTIONS_GHC -fno-warn-orphans #-}
3−module ProjectM36.Serialise.DatabaseContextFunctionError where
4−import Codec.Winery
5−import ProjectM36.DatabaseContextFunctionError
6−
7−deriving via WineryVariant DatabaseContextFunctionError instance Serialise DatabaseContextFunctionError
src/lib/ProjectM36/Serialise/Error.hsdeleted−15
@@ -1,15 +0,0 @@
1−{-# LANGUAGE DerivingVia, StandaloneDeriving #-}
2−{-# OPTIONS_GHC -fno-warn-orphans #-}
3−module ProjectM36.Serialise.Error where
4−import ProjectM36.Error
5−import Codec.Winery
6−import ProjectM36.Serialise.Base ()
7−import ProjectM36.Serialise.AtomFunctionError ()
8−import ProjectM36.Serialise.DatabaseContextFunctionError ()
9−
10−deriving via WineryVariant RelationalError instance Serialise RelationalError
11−deriving via WineryVariant MergeError instance Serialise MergeError
12−deriving via WineryVariant ScriptCompilationError instance Serialise ScriptCompilationError
13−deriving via WineryVariant PersistenceError instance Serialise PersistenceError
14−deriving via WineryVariant SchemaError instance Serialise SchemaError
15−deriving via WineryVariant ImportError' instance Serialise ImportError'
src/lib/ProjectM36/Serialise/IsomorphicSchema.hsdeleted−7
@@ -1,7 +0,0 @@
1−{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeSynonymInstances, ScopedTypeVariables #-}
2−{-# OPTIONS_GHC -fno-warn-orphans #-}
3−module ProjectM36.Serialise.IsomorphicSchema where
4−import Codec.Winery
5−import ProjectM36.IsomorphicSchema
6−
7−deriving via WineryVariant SchemaExpr instance Serialise SchemaExpr
src/lib/ProjectM36/Serialise/MergeError.hsdeleted−1
@@ -1 +0,0 @@
1−
src/lib/ProjectM36/Server.hs+99−166
@@ -7,119 +7,80 @@ import ProjectM36.Server.RemoteCallTypes
77import ProjectM36.Server.Config (ServerConfig(..))
88import ProjectM36.FSType
99
10−import Control.Concurrent.MVar (MVar)
10+import Control.Monad.IO.Class (liftIO)
11+#if MIN_VERSION_network_transport_tcp(0,7,0)
12+import Network.Transport.TCP (createTransport, defaultTCPParameters, TCPAddr(..), TCPAddrInfo(..))
13+#else
14+import Network.Transport.TCP (createTransport, defaultTCPParameters)
15+#endif
16+import Network.Transport (EndPointAddress(..), newEndPoint, address)
17+import Control.Distributed.Process.Node (initRemoteTable, runProcess, newLocalNode, initRemoteTable)
18+import Control.Distributed.Process.Extras.Time (Delay(..))
19+import Control.Distributed.Process (Process, register, getSelfPid)
20+import Control.Distributed.Process.ManagedProcess (defaultProcess, UnhandledMessagePolicy(..), ProcessDefinition(..), handleCall, serve, InitHandler, InitResult(..))
21+import Control.Concurrent.MVar (putMVar, MVar)
1122import System.IO (stderr, hPutStrLn)
1223import System.FilePath (takeDirectory)
1324import System.Directory (doesDirectoryExist)
14−import Network.RPC.Curryer.Server
15−import Network.Socket
16−import qualified StmContainers.Map as StmMap
17−import Control.Concurrent.STM
18−
19−type TestMode = Bool
20−
21−requestHandlers :: TestMode -> Maybe Timeout -> RequestHandlers ServerState
22−requestHandlers testFlag ti =
23− [
24− RequestHandler (\sState (Login dbName) -> do
25− addClientLogin dbName sState
26− conn <- getConn sState
27− handleLogin conn (connectionSocket sState)),
28− RequestHandler (\sState Logout -> do
29− conn <- getConn sState
30− handleLogout ti conn),
31− RequestHandler $ \sState (ExecuteHeadName sessionId) -> do
32− --socket -> dbname --maybe create a socket->client state mapping in the server state, too
33− conn <- getConn sState
34− handleExecuteHeadName ti sessionId conn,
35− RequestHandler (\sState (ExecuteRelationalExpr sessionId expr) -> do
36− conn <- getConn sState
37− handleExecuteRelationalExpr ti sessionId conn expr),
38− RequestHandler (\sState (ExecuteDataFrameExpr sessionId expr) -> do
39− conn <- getConn sState
40− handleExecuteDataFrameExpr ti sessionId conn expr),
41− RequestHandler (\sState (ExecuteDatabaseContextExpr sessionId expr) -> do
42− conn <- getConn sState
43− handleExecuteDatabaseContextExpr ti sessionId conn expr),
44− RequestHandler (\sState (ExecuteDatabaseContextIOExpr sessionId expr) -> do
45− conn <- getConn sState
46− handleExecuteDatabaseContextIOExpr ti sessionId conn expr),
47− RequestHandler (\sState (ExecuteGraphExpr sessionId expr) -> do
48− conn <- getConn sState
49− handleExecuteGraphExpr ti sessionId conn expr),
50− RequestHandler (\sState (ExecuteTransGraphRelationalExpr sessionId expr) -> do
51− conn <- getConn sState
52− handleExecuteTransGraphRelationalExpr ti sessionId conn expr),
53− RequestHandler (\sState (ExecuteTypeForRelationalExpr sessionId expr) -> do
54− conn <- getConn sState
55− handleExecuteTypeForRelationalExpr ti sessionId conn expr),
56− RequestHandler (\sState (RetrieveInclusionDependencies sessionId) -> do
57− conn <- getConn sState
58− handleRetrieveInclusionDependencies ti sessionId conn),
59− RequestHandler (\sState (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> do
60− conn <- getConn sState
61− handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr),
62− RequestHandler (\sState (RetrieveHeadTransactionId sessionId) -> do
63− conn <- getConn sState
64− handleRetrieveHeadTransactionId ti sessionId conn),
65− RequestHandler (\sState (RetrieveTransactionGraph sessionId) -> do
66− conn <- getConn sState
67− handleRetrieveTransactionGraph ti sessionId conn),
68− RequestHandler (\sState (CreateSessionAtHead headn) -> do
69− conn <- getConn sState
70− handleCreateSessionAtHead ti conn headn),
71− RequestHandler (\sState (CreateSessionAtCommit commitId) -> do
72− conn <- getConn sState
73− handleCreateSessionAtCommit ti conn commitId),
74− RequestHandler (\sState (CloseSession sessionId) -> do
75− conn <- getConn sState
76− handleCloseSession sessionId conn),
77− RequestHandler (\sState (RetrieveAtomTypesAsRelation sessionId) -> do
78− conn <- getConn sState
79− handleRetrieveAtomTypesAsRelation ti sessionId conn),
80− RequestHandler (\sState (RetrieveRelationVariableSummary sessionId) -> do
81− conn <- getConn sState
82− handleRetrieveRelationVariableSummary ti sessionId conn),
83− RequestHandler (\sState (RetrieveAtomFunctionSummary sessionId) -> do
84− conn <- getConn sState
85− handleRetrieveAtomFunctionSummary ti sessionId conn),
86− RequestHandler (\sState (RetrieveDatabaseContextFunctionSummary sessionId) -> do
87− conn <- getConn sState
88− handleRetrieveDatabaseContextFunctionSummary ti sessionId conn), RequestHandler (\sState (RetrieveCurrentSchemaName sessionId) -> do
89− conn <- getConn sState
90− handleRetrieveCurrentSchemaName ti sessionId conn),
91− RequestHandler (\sState (ExecuteSchemaExpr sessionId schemaExpr) -> do
92− conn <- getConn sState
93− handleExecuteSchemaExpr ti sessionId conn schemaExpr),
94− RequestHandler (\sState (RetrieveSessionIsDirty sessionId) -> do
95− conn <- getConn sState
96− handleRetrieveSessionIsDirty ti sessionId conn),
97− RequestHandler (\sState (ExecuteAutoMergeToHead sessionId strat headName') -> do
98− conn <- getConn sState
99− handleExecuteAutoMergeToHead ti sessionId conn strat headName'),
100− RequestHandler (\sState (RetrieveTypeConstructorMapping sessionId) -> do
101− conn <- getConn sState
102− handleRetrieveTypeConstructorMapping ti sessionId conn),
103− RequestHandler (\sState (ExecuteValidateMerkleHashes sessionId) -> do
104− conn <- getConn sState
105− handleValidateMerkleHashes ti sessionId conn)
106− ] ++ if testFlag then testModeHandlers ti else []
107−
108−getConn :: ConnectionState ServerState -> IO Connection
109−getConn connState = do
110− let sock = lockless (connectionSocket connState)
111− sState = connectionServerState connState
112− mConn <- connectionForClient sock sState
113− case mConn of
114− Nothing -> error "failed to find socket in client map"
115− Just conn -> pure conn
116−
117−testModeHandlers :: Maybe Timeout -> RequestHandlers ServerState
118−testModeHandlers ti = [RequestHandler (\sState (TestTimeout sessionId) -> do
119− conn <- getConn sState
120− handleTestTimeout ti sessionId conn)]
12125
26+-- the state should be a mapping of remote connection to the disconnected transaction- the graph should be the same, so discon must be removed from the stm tuple
27+--trying to refactor this for less repetition is very challenging because the return type cannot be polymorphic or the distributed-process call gets confused and drops messages
28+serverDefinition :: Bool -> Timeout -> ProcessDefinition Connection
29+serverDefinition testBool ti = defaultProcess {
30+ apiHandlers = [
31+ handleCall (\conn (ExecuteHeadName sessionId) -> handleExecuteHeadName ti sessionId conn),
32+ handleCall (\conn (ExecuteRelationalExpr sessionId expr) -> handleExecuteRelationalExpr ti sessionId conn expr),
33+ handleCall (\conn (ExecuteDataFrameExpr sessionId expr) -> handleExecuteDataFrameExpr ti sessionId conn expr),
34+ handleCall (\conn (ExecuteDatabaseContextExpr sessionId expr) -> handleExecuteDatabaseContextExpr ti sessionId conn expr),
35+ handleCall (\conn (ExecuteDatabaseContextIOExpr sessionId expr) -> handleExecuteDatabaseContextIOExpr ti sessionId conn expr),
36+ handleCall (\conn (ExecuteGraphExpr sessionId expr) -> handleExecuteGraphExpr ti sessionId conn expr),
37+ handleCall (\conn (ExecuteTransGraphRelationalExpr sessionId expr) -> handleExecuteTransGraphRelationalExpr ti sessionId conn expr),
38+ handleCall (\conn (ExecuteTypeForRelationalExpr sessionId expr) -> handleExecuteTypeForRelationalExpr ti sessionId conn expr),
39+ handleCall (\conn (RetrieveInclusionDependencies sessionId) -> handleRetrieveInclusionDependencies ti sessionId conn),
40+ handleCall (\conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr),
41+ handleCall (\conn (RetrieveHeadTransactionId sessionId) -> handleRetrieveHeadTransactionId ti sessionId conn),
42+ handleCall (\conn (RetrieveTransactionGraph sessionId) -> handleRetrieveTransactionGraph ti sessionId conn),
43+ handleCall (\conn (Login procId) -> handleLogin ti conn procId),
44+ handleCall (\conn (CreateSessionAtHead headn) -> handleCreateSessionAtHead ti conn headn),
45+ handleCall (\conn (CreateSessionAtCommit commitId) -> handleCreateSessionAtCommit ti conn commitId),
46+ handleCall (\conn (CloseSession sessionId) -> handleCloseSession ti sessionId conn),
47+ handleCall (\conn (RetrieveAtomTypesAsRelation sessionId) -> handleRetrieveAtomTypesAsRelation ti sessionId conn),
48+ handleCall (\conn (RetrieveRelationVariableSummary sessionId) -> handleRetrieveRelationVariableSummary ti sessionId conn),
49+ handleCall (\conn (RetrieveAtomFunctionSummary sessionId) -> handleRetrieveAtomFunctionSummary ti sessionId conn),
50+ handleCall (\conn (RetrieveDatabaseContextFunctionSummary sessionId) -> handleRetrieveDatabaseContextFunctionSummary ti sessionId conn),
51+ handleCall (\conn (RetrieveCurrentSchemaName sessionId) -> handleRetrieveCurrentSchemaName ti sessionId conn),
52+ handleCall (\conn (ExecuteSchemaExpr sessionId schemaExpr) -> handleExecuteSchemaExpr ti sessionId conn schemaExpr),
53+ handleCall (\conn (RetrieveSessionIsDirty sessionId) -> handleRetrieveSessionIsDirty ti sessionId conn),
54+ handleCall (\conn (ExecuteAutoMergeToHead sessionId strat headName') -> handleExecuteAutoMergeToHead ti sessionId conn strat headName'),
55+ handleCall (\conn (RetrieveTypeConstructorMapping sessionId) -> handleRetrieveTypeConstructorMapping ti sessionId conn),
56+ handleCall (\conn Logout -> handleLogout ti conn)
57+ ] ++ testModeHandlers,
58+ unhandledMessagePolicy = Terminate
59+ --unhandledMessagePolicy = Log
60+ }
61+ where
62+ testModeHandlers = if not testBool then
63+ []
64+ else
65+ [handleCall (\conn (TestTimeout sessionId) -> handleTestTimeout ti sessionId conn)]
66+
12267
68+initServer :: InitHandler (Connection, DatabaseName, Maybe (MVar EndPointAddress), EndPointAddress) Connection
69+initServer (conn, dbname, mAddressMVar, saddress) = do
70+ registerDB dbname
71+ case mAddressMVar of
72+ Nothing -> pure ()
73+ Just addressMVar -> liftIO $ putMVar addressMVar saddress
74+ --traceShowM ("server started on " ++ show saddress)
75+ pure $ InitOk conn Infinity
76+
77+registerDB :: DatabaseName -> Process ()
78+registerDB dbname = do
79+ self <- getSelfPid
80+ let dbname' = remoteDBLookupName dbname
81+ register dbname' self
82+ --liftIO $ putStrLn $ "registered " ++ (show self) ++ " " ++ dbname'
83+
12384-- | A notification callback which logs the notification to stderr and does nothing else.
12485loggingNotificationCallback :: NotificationCallback
12586loggingNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received \"" ++ show notName ++ "\": " ++ show evaldNot
@@ -144,47 +105,9 @@ checkFSType performCheck strat =
144105checkFSErrorMsg :: String
145106checkFSErrorMsg = "The filesystem does not support journaling so writes may not be crash-safe. Use --disable-fscheck to disable this fatal error."
146107
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 })
185108-- | A synchronous function to start the project-m36 daemon given an appropriate 'ServerConfig'. Note that this function only returns if the server exits. Returns False if the daemon exited due to an error. If the second argument is not Nothing, the port is put after the server is ready to service the port.
186−launchServer :: ServerConfig -> Maybe (MVar SockAddr) -> IO Bool
187−launchServer daemonConfig mAddr = do
109+launchServer :: ServerConfig -> Maybe (MVar EndPointAddress) -> IO Bool
110+launchServer daemonConfig mAddressMVar = do
188111 checkFSResult <- checkFSType (checkFS daemonConfig) (persistenceStrategy daemonConfig)
189112 if not checkFSResult then do
190113 hPutStrLn stderr checkFSErrorMsg
@@ -197,21 +120,31 @@ launchServer daemonConfig mAddr = do
197120 pure False
198121 Right conn -> do
199122 let hostname = bindHost daemonConfig
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−
123+ port = bindPort daemonConfig
124+#if MIN_VERSION_network_transport_tcp(0,7,0)
125+ addrInfo = TCPAddrInfo {
126+ tcpBindHost = hostname,
127+ tcpBindPort = show port,
128+ tcpExternalAddress = \sn -> (hostname, sn)
129+ }
130+ etransport <- createTransport (Addressable addrInfo) defaultTCPParameters
131+#elif MIN_VERSION_network_transport_tcp(0,6,0)
132+ etransport <- createTransport hostname (show port) (\nam -> (hostname, nam)) defaultTCPParameters
133+#else
134+ etransport <- createTransport hostname (show port) defaultTCPParameters
135+#endif
136+ case etransport of
137+ Left err -> error ("failed to create transport: " ++ show err)
138+ Right transport -> do
139+ eEndpoint <- newEndPoint transport
140+ case eEndpoint of
141+ Left err -> hPutStrLn stderr ("Failed to create transport: " ++ show err) >> pure False
142+ Right endpoint -> do
143+ localTCPNode <- newLocalNode transport initRemoteTable
144+ --traceShowM ("newLocalNode in Server " ++ show (localNodeId localTCPNode))
145+ runProcess localTCPNode $ do
146+ let testBool = testMode daemonConfig
147+ reqTimeout = perRequestTimeout daemonConfig
148+ serve (conn, databaseName daemonConfig, mAddressMVar, address endpoint) initServer (serverDefinition testBool reqTimeout)
149+ liftIO $ putStrLn "serve returned"
150+ pure True
src/lib/ProjectM36/Server/Config.hs−6
@@ -12,12 +12,6 @@ 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−
2115defaultServerConfig :: ServerConfig
2216defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,
2317 checkFS = True,
src/lib/ProjectM36/Server/EntryPoints.hs+153−126
@@ -1,146 +1,173 @@
1−{-# LANGUAGE MonoLocalBinds #-}
21module ProjectM36.Server.EntryPoints where
32import ProjectM36.Base hiding (inclusionDependencies)
43import ProjectM36.IsomorphicSchema
54import ProjectM36.Client as C
5+import ProjectM36.Error
6+import Control.Distributed.Process (Process, ProcessId)
7+import Control.Distributed.Process.ManagedProcess (ProcessReply)
8+import Control.Distributed.Process.ManagedProcess.Server (reply)
9+import Control.Distributed.Process.Async (async, task, waitCancelTimeout, AsyncResult(..))
10+import Control.Monad.IO.Class (liftIO)
611import Data.Map
712import Control.Concurrent (threadDelay)
8−import Network.RPC.Curryer.Server
9−import System.Timeout hiding (Timeout)
10−import Network.Socket
11−import Control.Exception
13+import Data.Typeable
14+import Data.Binary
1215
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
19−
20−timeoutRelErr :: Maybe Timeout -> IO (Either RelationalError a) -> IO (Either RelationalError a)
21−timeoutRelErr mMicros act = do
22− ret <- timeoutOrDie mMicros act
23− case ret of
24− Nothing -> throw TimeoutException
25− Just v -> pure v
26−
16+timeoutOrDie :: (Binary a, Typeable a) => Timeout -> IO a -> Process (Either ServerError a)
17+timeoutOrDie micros act =
18+ if micros == 0 then
19+ liftIO act >>= \x -> pure (Right x)
20+ else do
21+ asyncUnit <- async (task (liftIO act))
22+ asyncRes <- waitCancelTimeout micros asyncUnit
23+ case asyncRes of
24+ AsyncDone x -> pure (Right x)
25+ AsyncCancelled -> pure (Left RequestTimeoutError)
26+ AsyncFailed reason -> pure (Left (ProcessDiedError (show reason)))
27+ AsyncLinkFailed reason -> pure (Left (ProcessDiedError (show reason)))
28+ AsyncPending -> pure (Left (ProcessDiedError "process pending"))
29+
30+type Timeout = Int
2731
28−handleExecuteRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)
29−handleExecuteRelationalExpr ti sessionId conn expr =
30− timeoutRelErr ti (executeRelationalExpr sessionId conn expr)
32+type Reply a = Process (ProcessReply (Either ServerError a) Connection)
33+
34+handleExecuteRelationalExpr :: Timeout -> SessionId -> Connection -> RelationalExpr -> Reply (Either RelationalError Relation)
35+handleExecuteRelationalExpr ti sessionId conn expr = do
36+ ret <- timeoutOrDie ti (executeRelationalExpr sessionId conn expr)
37+ reply ret conn
3138
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)
39+handleExecuteDataFrameExpr :: Timeout -> SessionId -> Connection -> DataFrameExpr -> Reply (Either RelationalError DataFrame)
40+handleExecuteDataFrameExpr ti sessionId conn expr = do
41+ ret <- timeoutOrDie ti (executeDataFrameExpr sessionId conn expr)
42+ reply ret conn
43+
44+handleExecuteDatabaseContextExpr :: Timeout -> SessionId -> Connection -> DatabaseContextExpr -> Reply (Either RelationalError ())
45+handleExecuteDatabaseContextExpr ti sessionId conn dbexpr = do
46+ ret <- timeoutOrDie ti (executeDatabaseContextExpr sessionId conn dbexpr)
47+ reply ret conn
48+
49+handleExecuteDatabaseContextIOExpr :: Timeout -> SessionId -> Connection -> DatabaseContextIOExpr -> Reply (Either RelationalError ())
50+handleExecuteDatabaseContextIOExpr ti sessionId conn dbexpr = do
51+ ret <- timeoutOrDie ti (executeDatabaseContextIOExpr sessionId conn dbexpr)
52+ reply ret conn
53+
54+handleExecuteHeadName :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError HeadName)
55+handleExecuteHeadName ti sessionId conn = do
56+ ret <- timeoutOrDie ti (headName sessionId conn)
57+ reply ret conn
58+
59+handleLogin :: Timeout -> Connection -> ProcessId -> Reply Bool
60+handleLogin ti conn newClientProcessId = do
61+ ret <- timeoutOrDie ti (addClientNode conn newClientProcessId)
62+ case ret of
63+ Right () -> reply (Right True) conn
64+ Left err -> reply (Left err) conn
65+
66+handleExecuteGraphExpr :: Timeout -> SessionId -> Connection -> TransactionGraphOperator -> Reply (Either RelationalError ())
67+handleExecuteGraphExpr ti sessionId conn graphExpr = do
68+ ret <- timeoutOrDie ti (executeGraphExpr sessionId conn graphExpr)
69+ reply ret conn
70+
71+handleExecuteTransGraphRelationalExpr :: Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> Reply (Either RelationalError Relation)
72+handleExecuteTransGraphRelationalExpr ti sessionId conn graphExpr = do
73+ ret <- timeoutOrDie ti (executeTransGraphRelationalExpr sessionId conn graphExpr)
74+ reply ret conn
6075
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)
80−
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
76+handleExecuteTypeForRelationalExpr :: Timeout -> SessionId -> Connection -> RelationalExpr -> Reply (Either RelationalError Relation)
77+handleExecuteTypeForRelationalExpr ti sessionId conn relExpr = do
78+ ret <- timeoutOrDie ti (typeForRelationalExpr sessionId conn relExpr)
79+ reply ret conn
80+
81+handleRetrieveInclusionDependencies :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError (Map IncDepName InclusionDependency))
82+handleRetrieveInclusionDependencies ti sessionId conn = do
83+ ret <- timeoutOrDie ti (inclusionDependencies sessionId conn)
84+ reply ret conn
85+
86+handleRetrievePlanForDatabaseContextExpr :: Timeout -> SessionId -> Connection -> DatabaseContextExpr -> Reply (Either RelationalError GraphRefDatabaseContextExpr)
87+handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr = do
88+ ret <- timeoutOrDie ti (planForDatabaseContextExpr sessionId conn dbExpr)
89+ reply ret conn
90+
91+handleRetrieveTransactionGraph :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)
92+handleRetrieveTransactionGraph ti sessionId conn = do
93+ ret <- timeoutOrDie ti (transactionGraphAsRelation sessionId conn)
94+ reply ret conn
95+
96+handleRetrieveHeadTransactionId :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError TransactionId)
97+handleRetrieveHeadTransactionId ti sessionId conn = do
98+ ret <- timeoutOrDie ti (headTransactionId sessionId conn)
99+ reply ret conn
100+
101+handleCreateSessionAtCommit :: Timeout -> Connection -> TransactionId -> Reply (Either RelationalError SessionId)
102+handleCreateSessionAtCommit ti conn commitId = do
103+ ret <- timeoutOrDie ti (createSessionAtCommit conn commitId)
104+ reply ret conn
105+
106+handleCreateSessionAtHead :: Timeout -> Connection -> HeadName -> Reply (Either RelationalError SessionId)
107+handleCreateSessionAtHead ti conn headn = do
108+ ret <- timeoutOrDie ti (createSessionAtHead conn headn)
109+ reply ret conn
110+
111+handleCloseSession :: Timeout -> SessionId -> Connection -> Reply ()
112+handleCloseSession ti sessionId conn = do
113+ ret <- timeoutOrDie ti (closeSession sessionId conn)
114+ case ret of
115+ Right () -> reply (Right ()) conn
116+ Left err -> reply (Left err) conn
92117
93−handleRetrieveAtomTypesAsRelation :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)
94−handleRetrieveAtomTypesAsRelation ti sessionId conn =
95− timeoutRelErr ti (atomTypesAsRelation sessionId conn)
118+handleRetrieveAtomTypesAsRelation :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)
119+handleRetrieveAtomTypesAsRelation ti sessionId conn = do
120+ ret <- timeoutOrDie ti (atomTypesAsRelation sessionId conn)
121+ reply ret conn
96122
97123-- | Returns a relation which lists the names of relvars in the current session as well as its types.
98−handleRetrieveRelationVariableSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)
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)
124+handleRetrieveRelationVariableSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)
125+handleRetrieveRelationVariableSummary ti sessionId conn = do
126+ ret <- timeoutOrDie ti (relationVariablesAsRelation sessionId conn)
127+ reply ret conn
128+
129+handleRetrieveAtomFunctionSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)
130+handleRetrieveAtomFunctionSummary ti sessionId conn = do
131+ ret <- timeoutOrDie ti (atomFunctionsAsRelation sessionId conn)
132+ reply ret conn
133+
134+handleRetrieveDatabaseContextFunctionSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)
135+handleRetrieveDatabaseContextFunctionSummary ti sessionId conn = do
136+ ret <- timeoutOrDie ti (databaseContextFunctionsAsRelation sessionId conn)
137+ reply ret conn
138+
139+handleRetrieveCurrentSchemaName :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError SchemaName)
140+handleRetrieveCurrentSchemaName ti sessionId conn = do
141+ ret <- timeoutOrDie ti (currentSchemaName sessionId conn)
142+ reply ret conn
113143
114−handleExecuteSchemaExpr :: Maybe Timeout -> SessionId -> Connection -> SchemaExpr -> IO (Either RelationalError ())
115−handleExecuteSchemaExpr ti sessionId conn schemaExpr =
116− timeoutRelErr ti (executeSchemaExpr sessionId conn schemaExpr)
144+handleExecuteSchemaExpr :: Timeout -> SessionId -> Connection -> SchemaExpr -> Reply (Either RelationalError ())
145+handleExecuteSchemaExpr ti sessionId conn schemaExpr = do
146+ ret <- timeoutOrDie ti (executeSchemaExpr sessionId conn schemaExpr)
147+ reply ret conn
117148
118−handleLogout :: Maybe Timeout -> Connection -> IO Bool
119−handleLogout _ _ =
149+handleLogout :: Timeout -> Connection -> Reply Bool
150+handleLogout _ =
120151 --liftIO $ closeRemote_ conn
121− pure True
152+ reply (pure True)
122153
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
154+handleTestTimeout :: Timeout -> SessionId -> Connection -> Reply Bool
155+handleTestTimeout ti _ conn = do
156+ ret <- timeoutOrDie ti (threadDelay 100000 >> pure True)
157+ reply ret conn
129158
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')
159+handleRetrieveSessionIsDirty :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Bool)
160+handleRetrieveSessionIsDirty ti sessionId conn = do
161+ ret <- timeoutOrDie ti (disconnectedTransactionIsDirty sessionId conn)
162+ reply ret conn
163+
164+handleExecuteAutoMergeToHead :: Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> Reply (Either RelationalError ())
165+handleExecuteAutoMergeToHead ti sessionId conn strat headName' = do
166+ ret <- timeoutOrDie ti (autoMergeToHead sessionId conn strat headName')
167+ reply ret conn
139168
140−handleRetrieveTypeConstructorMapping :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)
141−handleRetrieveTypeConstructorMapping ti sessionId conn =
142− timeoutRelErr ti (C.typeConstructorMapping sessionId conn)
169+handleRetrieveTypeConstructorMapping :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError TypeConstructorMapping)
170+handleRetrieveTypeConstructorMapping ti sessionId conn = do
171+ ret <- timeoutOrDie ti (C.typeConstructorMapping sessionId conn)
172+ reply ret conn
143173
144−handleValidateMerkleHashes :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError ())
145−handleValidateMerkleHashes ti sessionId conn =
146− timeoutRelErr ti (C.validateMerkleHashes sessionId conn)
src/lib/ProjectM36/Server/ParseArgs.hs+16−39
@@ -3,7 +3,7 @@ import ProjectM36.Base
33import ProjectM36.Client
44import Options.Applicative
55import ProjectM36.Server.Config
6−#if __GLASGOW_HASKELL__ < 804
6+#if __GLASGOW_HASKELL__ <= 802
77import Data.Monoid
88#endif
99
@@ -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,69 +34,46 @@ 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")
9174
9275helpOption :: Parser (a -> a)
93−helpOption = abortOption helpText $ mconcat
76+helpOption = abortOption ShowHelpText $ mconcat
9477 [ long "help"
9578 , help "Show this help text"
9679 , hidden ]
97− where
98−#if MIN_VERSION_optparse_applicative(0,16,0)
99− helpText = ShowHelpText Nothing
100−#else
101− helpText = ShowHelpText
102−#endif
src/lib/ProjectM36/Server/RemoteCallTypes.hs+35−67
@@ -1,4 +1,4 @@
1−{-# LANGUAGE DeriveGeneric, DerivingVia, CPP #-}
1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}
22module ProjectM36.Server.RemoteCallTypes where
33import ProjectM36.Base
44import ProjectM36.IsomorphicSchema
@@ -6,98 +6,66 @@ import ProjectM36.TransactionGraph
66import ProjectM36.DataFrame
77import ProjectM36.TransGraphRelationalExpression
88import ProjectM36.Session
9−import ProjectM36.Serialise.DataFrame ()
10−import ProjectM36.Serialise.IsomorphicSchema ()
119import GHC.Generics
12−import Codec.Winery
13−
14−#define RPCData(typeName) deriving Generic \
15− deriving Serialise via WineryVariant typeName
10+import Data.Binary
11+import Control.Distributed.Process (ProcessId)
1612
1713{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}
1814-- | The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.
19−data Login = Login DatabaseName
20− RPCData(Login)
15+data Login = Login ProcessId
16+ deriving (Binary, Generic)
2117
2218data Logout = Logout
23− RPCData(Logout)
24−
25−data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr
26− RPCData(ExecuteRelationalExpr)
27−
19+ deriving (Binary, Generic)
20+data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr
21+ deriving (Binary, Generic)
2822data ExecuteDataFrameExpr = ExecuteDataFrameExpr SessionId DataFrameExpr
29− RPCData(ExecuteDataFrameExpr)
30−
23+ deriving (Binary, Generic)
3124data ExecuteDatabaseContextExpr = ExecuteDatabaseContextExpr SessionId DatabaseContextExpr
32− RPCData(ExecuteDatabaseContextExpr)
33−
25+ deriving (Binary, Generic)
3426data ExecuteDatabaseContextIOExpr = ExecuteDatabaseContextIOExpr SessionId DatabaseContextIOExpr
35− RPCData(ExecuteDatabaseContextIOExpr)
36−
27+ deriving (Binary, Generic)
3728data ExecuteGraphExpr = ExecuteGraphExpr SessionId TransactionGraphOperator
38− RPCData(ExecuteGraphExpr)
39−
29+ deriving (Binary, Generic)
4030data ExecuteTransGraphRelationalExpr = ExecuteTransGraphRelationalExpr SessionId TransGraphRelationalExpr
41− RPCData(ExecuteTransGraphRelationalExpr)
42−
31+ deriving (Binary, Generic)
4332data ExecuteHeadName = ExecuteHeadName SessionId
44− RPCData(ExecuteHeadName)
45−
33+ deriving (Binary, Generic)
4634data ExecuteTypeForRelationalExpr = ExecuteTypeForRelationalExpr SessionId RelationalExpr
47− RPCData(ExecuteTypeForRelationalExpr)
48−
49−data ExecuteSchemaExpr = ExecuteSchemaExpr SessionId SchemaExpr RPCData(ExecuteSchemaExpr)
50−
35+ deriving (Binary, Generic)
36+data ExecuteSchemaExpr = ExecuteSchemaExpr SessionId SchemaExpr
37+ deriving (Binary, Generic)
5138data ExecuteSetCurrentSchema = ExecuteSetCurrentSchema SessionId SchemaName
52− RPCData(ExecuteSetCurrentSchema)
53−
39+ deriving (Binary, Generic)
5440data RetrieveInclusionDependencies = RetrieveInclusionDependencies SessionId
55− RPCData(RetrieveInclusionDependencies)
56−
41+ deriving (Binary, Generic)
5742data RetrievePlanForDatabaseContextExpr = RetrievePlanForDatabaseContextExpr SessionId DatabaseContextExpr
58− RPCData(RetrievePlanForDatabaseContextExpr)
59−
43+ deriving (Binary, Generic)
6044data RetrieveTransactionGraph = RetrieveTransactionGraph SessionId
61− RPCData(RetrieveTransactionGraph)
62−
45+ deriving (Binary, Generic)
6346data RetrieveHeadTransactionId = RetrieveHeadTransactionId SessionId
64− RPCData(RetrieveHeadTransactionId)
65−
47+ deriving (Binary, Generic)
6648data CreateSessionAtCommit = CreateSessionAtCommit TransactionId
67− RPCData(CreateSessionAtCommit)
68−
49+ deriving (Binary, Generic)
6950data CreateSessionAtHead = CreateSessionAtHead HeadName
70− RPCData(CreateSessionAtHead)
71−
51+ deriving (Binary, Generic)
7252data CloseSession = CloseSession SessionId
73− RPCData(CloseSession)
74−
53+ deriving (Binary, Generic)
7554data RetrieveAtomTypesAsRelation = RetrieveAtomTypesAsRelation SessionId
76− RPCData(RetrieveAtomTypesAsRelation)
77−
55+ deriving (Binary, Generic)
7856data RetrieveRelationVariableSummary = RetrieveRelationVariableSummary SessionId
79− RPCData(RetrieveRelationVariableSummary)
80−
57+ deriving (Binary, Generic)
8158data RetrieveAtomFunctionSummary = RetrieveAtomFunctionSummary SessionId
82− RPCData(RetrieveAtomFunctionSummary)
83−
59+ deriving (Binary, Generic)
8460data RetrieveDatabaseContextFunctionSummary = RetrieveDatabaseContextFunctionSummary SessionId
85− RPCData(RetrieveDatabaseContextFunctionSummary)
86−
61+ deriving (Binary, Generic)
8762data RetrieveCurrentSchemaName = RetrieveCurrentSchemaName SessionId
88− RPCData(RetrieveCurrentSchemaName)
89−
63+ deriving (Binary, Generic)
9064data TestTimeout = TestTimeout SessionId
91− RPCData(TestTimeout)
92−
93−data RetrieveSessionIsDirty = RetrieveSessionIsDirty SessionId
94− RPCData(RetrieveSessionIsDirty)
95−
65+ deriving (Binary, Generic)
66+data RetrieveSessionIsDirty = RetrieveSessionIsDirty SessionId
67+ deriving (Binary, Generic)
9668data ExecuteAutoMergeToHead = ExecuteAutoMergeToHead SessionId MergeStrategy HeadName
97− RPCData(ExecuteAutoMergeToHead)
98−
69+ deriving (Binary, Generic)
9970data RetrieveTypeConstructorMapping = RetrieveTypeConstructorMapping SessionId
100− RPCData(RetrieveTypeConstructorMapping)
101−
102−data ExecuteValidateMerkleHashes = ExecuteValidateMerkleHashes SessionId
103− RPCData(ExecuteValidateMerkleHashes)
71+ deriving (Binary, Generic)
src/lib/ProjectM36/Sessions.hs+3−3
@@ -14,11 +14,9 @@ import ProjectM36.Session
1414import ProjectM36.Relation
1515import ProjectM36.Error
1616import qualified Data.UUID as U
17−#if MIN_VERSION_stm_containers(1,0,0)
1817import qualified Control.Foldl as Foldl
18+#if MIN_VERSION_stm_containers(1,0,0)
1919import qualified DeferredFolds.UnfoldlM as UF
20−#else
21−import "list-t" ListT
2220#endif
2321
2422type Sessions = StmMap.Map SessionId Session
@@ -47,3 +45,5 @@ sessionsAsRelation sessions = do
4745 let atomMatrix = map (\(sessionId, session) -> [uuidAtom sessionId, uuidAtom (parentId session)]) sessionAssocs
4846 pure $ mkRelationFromList (attributesFromList [Attribute "sessionid" TextAtomType,
4947 Attribute "parentCommit" TextAtomType]) atomMatrix
48+
49+
src/lib/ProjectM36/Shortcuts.hsdeleted−247
@@ -1,247 +0,0 @@
1−{-# OPTIONS_GHC -fno-warn-orphans #-}
2−{-# LANGUAGE ScopedTypeVariables #-}
3−{-# LANGUAGE TypeApplications #-}
4−{-# LANGUAGE FlexibleInstances #-}
5−{-# LANGUAGE MultiParamTypeClasses #-}
6−{-# LANGUAGE TypeFamilies #-}
7−{-# LANGUAGE ExtendedDefaultRules #-}
8−{-# LANGUAGE ExistentialQuantification #-}
9−{-# LANGUAGE FlexibleContexts #-}
10−{-# LANGUAGE GADTs #-}
11−{-# LANGUAGE UndecidableInstances #-}
12−module ProjectM36.Shortcuts where
13−-- users need OverloadedLabels, OverloadedLists, and default(Int,Text) to use these shortcuts.
14−import Data.Text hiding (foldl, map)
15−import ProjectM36.Base
16−import ProjectM36.Relation
17−import ProjectM36.Atomable
18−import Prelude hiding ((!!))
19−import Data.Proxy
20−import GHC.OverloadedLabels
21−import GHC.TypeLits hiding (Text)
22−import qualified Data.Text as T
23−import qualified Data.Map as M
24−import qualified Data.Set as S
25−import GHC.Exts (IsList(..))
26−import Data.Convertible
27−
28−default (Text)
29−
30−instance IsList (AttributeNamesBase ()) where
31− type Item (AttributeNamesBase ()) = AttributeName
32− fromList = AttributeNames . S.fromList
33− toList (AttributeNames ns) = S.toList ns
34− toList _ = error "needs AttributeNames"
35−
36−instance IsList (TupleExprsBase ()) where
37− type Item TupleExprs = TupleExpr
38− fromList ts = TupleExprs () ts
39− toList (TupleExprs _ ts) = ts
40−
41−instance IsList TupleExpr where
42− type Item TupleExpr = (AttributeName, AtomExpr)
43− fromList attributeValues = TupleExpr (M.fromList attributeValues)
44− toList (TupleExpr attributeValues) = M.toList attributeValues
45−
46−
47−-- #xxx :: Text
48−instance KnownSymbol x => IsLabel x Text where
49− fromLabel = T.pack $ symbolVal @x Proxy
50−
51−-- #relvarName :: RelationalExpr
52−instance KnownSymbol x => IsLabel x RelationalExpr where
53− fromLabel = RelationVariable (T.pack $ symbolVal @x Proxy) ()
54−
55−-- *Main> #a Int :: AttributeExpr
56−-- NakedAttributeExpr (Attribute "a" IntAtomType)
57−-- *Main> #a (Attr @[Int]) :: AttributeExpr
58−-- NakedAttributeExpr (Attribute "a" (ConstructedAtomType "List" (fromList [("a",IntAtomType)])))
59−-- can't offer a Relation atomtype -- don't know how to express a Relation type in haskell type. Maybe something a HList of (Text, a) ?
60−--
61−-- ps. I don't understand the usage of "AttributeAndTypeNameExpr AttributeName TypeConstructor a"
62−instance (KnownSymbol x, Atomable a)=> IsLabel x (HaskAtomType a -> AttributeExpr) where
63− fromLabel = (NakedAttributeExpr . Attribute name) . toAtomType''
64− where name = T.pack $ symbolVal @x Proxy
65−
66−-- (#a 1) :: ExtendTupleExpr
67−-- no need for :=
68−instance (Convertible a AtomExpr, KnownSymbol x) => IsLabel x (a -> ExtendTupleExpr) where
69− fromLabel x = AttributeExtendTupleExpr name (convert x)
70− where name = T.pack $ symbolVal @x Proxy
71−
72−-- #name AtomExpr
73−-- ex. tuple [ #name 3 ]
74−-- default(Text) is needed in client code to avoid `no Atomable Char`
75−instance (Convertible a AtomExpr, KnownSymbol x) => IsLabel x (a -> (AttributeName, AtomExpr)) where
76− fromLabel = \x -> (name, convert x)
77− where name = T.pack $ symbolVal @x Proxy
78−
79−-- *Main> #a [1] :: AtomExpr
80−-- FunctionAtomExpr "a" [NakedAtomExpr (IntegerAtom 1)] ()
81−--
82−-- This usage is not working in RestrictionPredicateExpr and AttributeExtendTupleExpr. Use f "a" [1] instead.
83−instance (KnownSymbol x, Convertible a AtomExpr) => IsLabel x ([a] -> AtomExpr) where
84− fromLabel = \as' -> FunctionAtomExpr name (map convert as') ()
85− where name = T.pack $ symbolVal @x Proxy
86−
87−instance (KnownSymbol x) => IsLabel x AtomExpr where
88− fromLabel = AttributeAtomExpr name
89− where name = T.pack $ symbolVal @x Proxy
90−
91−
92−data HaskAtomType a where
93− Int :: HaskAtomType Int
94− Integer :: HaskAtomType Integer
95− Double :: HaskAtomType Double
96− Text :: HaskAtomType Text
97−-- Day :: HaskAtomType Day
98−-- DateTime :: HaskAtomType DateTime
99−-- ByteString :: HaskAtomType ByteString
100− Bool :: HaskAtomType Bool
101− Attr :: Atomable a => HaskAtomType a -- a Proxy-like value for type application.
102−
103−toAtomType'' :: Atomable a => HaskAtomType a -> AtomType
104−toAtomType'' (_ :: HaskAtomType a) = toAtomType (Proxy @a)
105−
106−-- usage: relation [tuple [#a 1, #b "b"], tuple [#a 2, #b "b"]]
107−relation :: [TupleExpr] -> RelationalExpr
108−relation ts = MakeRelationFromExprs Nothing (TupleExprs () ts)
109−
110−relation' :: [AttributeExprBase ()] -> [TupleExpr] -> RelationalExpr
111−relation' as' ts = MakeRelationFromExprs (Just as') (TupleExprs () ts)
112−
113−-- usage: tuple [#name "Mike",#age 6]
114−tuple :: [(AttributeName, AtomExpr)] -> TupleExprBase ()
115−tuple as' = TupleExpr (M.fromList as')
116−
117−-- #a rename [#b `as` #c]
118−rename :: RelationalExpr -> [(AttributeName,AttributeName)] -> RelationalExpr
119−rename relExpr renameList = case renameList of
120− [] -> Restrict TruePredicate relExpr
121− renames ->
122− foldl (\acc (old,new) -> Rename old new acc) relExpr renames
123−
124−--project !!
125−-- #a !! [#b,#c]
126−infix 9 !!
127−(!!) :: RelationalExpr -> AttributeNames -> RelationalExpr
128−relExpr !! xs = Project xs relExpr
129−
130−--join ><
131−-- #a >< #b
132−(><) :: RelationalExpr -> RelationalExpr -> RelationalExpr
133−a >< b = Join a b
134−
135−allBut :: AttributeNames -> AttributeNames
136−allBut (AttributeNames ns) = InvertedAttributeNames ns
137−allBut _ = error "give allBut something other than attribute names."
138−
139−allFrom :: RelationalExpr -> AttributeNames
140−allFrom = RelationalExprAttributeNames
141−
142−as :: AttributeNames -> AttributeName -> (AttributeNames, AttributeName)
143−as = (,)
144−
145−-- #a `group` ([#b,#c] `as` #d)
146−group :: RelationalExpr -> (AttributeNames, AttributeName) -> RelationalExpr
147−group relExpr (aNames, aName) = Group aNames aName relExpr
148−
149−-- #a `ungroup` #b
150−ungroup :: RelationalExpr -> AttributeName -> RelationalExpr
151−ungroup relExpr aName = Ungroup aName relExpr
152−
153−-- *Main> #a #:= true #: ( #b (f "count" [1,2]))
154−-- Assign "a" (Extend (AttributeExtendTupleExpr "b" (FunctionAtomExpr "count" [NakedAtomExpr (IntegerAtom 1),NakedAtomExpr (IntegerAtom 2)] ())) (ExistingRelation (Relation attributesFromList [] (RelationTupleSet {asList = [RelationTuple attributesFromList [] []]}))))
155−(#:) :: RelationalExpr -> ExtendTupleExpr -> RelationalExpr
156−a #: b = Extend b a
157−infix 8 #:
158−
159−instance Convertible AtomExpr AtomExpr where
160− safeConvert n = Right n
161−
162−instance Convertible RelVarName AtomExpr where
163− safeConvert n = Right $ RelationAtomExpr (RelationVariable n ())
164−
165−instance Convertible RelationalExpr AtomExpr where
166− safeConvert relExpr = Right $ RelationAtomExpr relExpr
167−
168−instance Convertible RelVarName RelationalExpr where
169− safeConvert n = Right $ RelationVariable n ()
170−
171−-- @ in tutd
172−-- (@@) "aaa"
173−(@@) :: AttributeName -> AtomExpr
174−(@@) = AttributeAtomExpr
175−
176−-- works in RestrictedPredicateExpr and AttributeExtendTupleExpr
177−-- usage: f "gte" [1]
178−f :: Convertible a AtomExpr => AtomFunctionName -> [a] -> AtomExpr
179−f n as' = FunctionAtomExpr n (map convert as') ()
180−
181−-- DatabaseContextExpr
182−-- define
183−(#::) :: RelVarName -> [AttributeExpr] -> DatabaseContextExpr
184−s #:: xs = Define s xs
185−infix 5 #::
186−
187−-- assign
188−(#:=) :: RelVarName -> RelationalExpr -> DatabaseContextExpr
189−s #:= r = Assign s r
190−infix 5 #:=
191−
192−class Boolean a b where
193− (&&&) :: a -> b -> RestrictionPredicateExpr
194− infixl 6 &&&
195− (|||) :: a -> b -> RestrictionPredicateExpr
196− infixl 5 |||
197−
198−-- where: @~ mimics the restriction symbol in algebra
199−-- usage: true #: (#a 1) @~ #a ?= 1 &&& not' false ||| (f "gte" [1])
200−(@~) :: Convertible a RestrictionPredicateExpr => RelationalExpr -> a -> RelationalExpr
201−(@~) relExpr resPreExpr = Restrict (convert resPreExpr) relExpr
202−infix 4 @~
203−
204−true :: RelationalExpr
205−true = ExistingRelation relationTrue
206−
207−false :: RelationalExpr
208−false = ExistingRelation relationFalse
209−
210−trueP :: RestrictionPredicateExprBase a
211−trueP = TruePredicate
212−
213−falseP :: RestrictionPredicateExprBase a
214−falseP = NotPredicate TruePredicate
215−
216−(?=) :: Convertible a AtomExpr => AttributeName -> a -> RestrictionPredicateExpr
217−(?=) name a = AttributeEqualityPredicate name (convert a)
218−infix 9 ?=
219−
220−not' :: Convertible a RestrictionPredicateExpr => a -> RestrictionPredicateExpr
221−not' = NotPredicate . convert
222−
223−instance (Convertible a RestrictionPredicateExpr, Convertible b RestrictionPredicateExpr) => Boolean a b where
224− a &&& b = AndPredicate (convert a) (convert b)
225− a ||| b = OrPredicate (convert a) (convert b)
226−
227−instance {-# Incoherent #-} Atomable a => Convertible a RestrictionPredicateExpr where
228− safeConvert n = Right $ AtomExprPredicate $ toAtomExpr . toAtom $ n
229−
230−instance {-# Incoherent #-} Convertible RelationalExpr RestrictionPredicateExpr where
231− safeConvert a = Right $ RelationalExprPredicate a
232−
233−instance {-# Incoherent #-} Convertible AtomExpr RestrictionPredicateExpr where
234− safeConvert a = Right $ AtomExprPredicate a
235−
236−instance {-# Incoherent #-} Convertible RestrictionPredicateExpr RestrictionPredicateExpr where
237− safeConvert a = Right a
238−
239−instance {-# Incoherent #-} Atomable a => Convertible a AtomExpr where
240− safeConvert n = Right $ toAtomExpr . toAtom $ n
241−
242−toAtomExpr :: Atom -> AtomExpr
243−toAtomExpr (ConstructedAtom n _ xs) = ConstructedAtomExpr n (toAtomExpr <$> xs) ()
244−toAtomExpr a = NakedAtomExpr a
245−
246−
247−
src/lib/ProjectM36/StaticOptimizer.hs+19−19
@@ -1,3 +1,4 @@
1+{-# LANGUAGE TypeSynonymInstances #-}
12{-# LANGUAGE FlexibleInstances #-}
23{-# LANGUAGE FlexibleContexts #-}
34module ProjectM36.StaticOptimizer where
@@ -56,22 +57,22 @@ class Monad m => AskGraphContext m where
5657 askContext :: m DatabaseContext
5758
5859instance AskGraphContext (ReaderT GraphRefSOptDatabaseContextExprEnv (ExceptT RelationalError Identity)) where
59− askGraph = asks odce_graph
60− askContext = asks odce_context
60+ askGraph = odce_graph <$> ask
61+ askContext = odce_context <$> ask
6162
6263instance AskGraphContext (ReaderT GraphRefSOptRelationalExprEnv (ExceptT RelationalError Identity)) where
63− askGraph = asks ore_graph
64+ askGraph = ore_graph <$> ask
6465 askContext = do
65− mctx <- asks ore_mcontext
66+ mctx <- ore_mcontext <$> ask
6667 case mctx of
6768 Nothing -> throwError NoUncommittedContextInEvalError
6869 Just ctx -> pure ctx
6970
7071askTransId :: GraphRefSOptDatabaseContextExprM TransactionId
71−askTransId = asks odce_transId
72+askTransId = odce_transId <$> ask
7273
7374askMaybeContext :: GraphRefSOptRelationalExprM (Maybe DatabaseContext)
74−askMaybeContext = asks ore_mcontext
75+askMaybeContext = ore_mcontext <$> ask
7576
7677optimizeDatabaseContextExpr :: DatabaseContextExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextExpr
7778optimizeDatabaseContextExpr expr = do
@@ -80,8 +81,8 @@ optimizeDatabaseContextExpr expr = do
8081
8182optimizeAndEvalDatabaseContextExpr :: Bool -> DatabaseContextExpr -> DatabaseContextEvalMonad ()
8283optimizeAndEvalDatabaseContextExpr optimize expr = do
83− graph <- asks dce_graph
84− transId <- asks dce_transId
84+ graph <- dce_graph <$> ask
85+ transId <- dce_transId <$> ask
8586 context <- getStateContext
8687 let gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextExpr expr)
8788 eOptExpr = if optimize then
@@ -102,9 +103,9 @@ optimizeAndEvalTransGraphRelationalExpr graph tgExpr = do
102103
103104optimizeAndEvalDatabaseContextIOExpr :: DatabaseContextIOExpr -> DatabaseContextIOEvalMonad (Either RelationalError ())
104105optimizeAndEvalDatabaseContextIOExpr expr = do
105− transId <- asks dbcio_transId
106+ transId <- dbcio_transId <$> ask
106107 ctx <- getDBCIOContext
107− graph <- asks dbcio_graph
108+ graph <- dbcio_graph <$> ask
108109 let gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextIOExpr expr)
109110 eOptExpr = runGraphRefSOptDatabaseContextExprM transId ctx graph (optimizeDatabaseContextIOExpr gfExpr)
110111 case eOptExpr of
@@ -161,8 +162,8 @@ optimizeGraphRefRelationalExpr' mctx graph expr =
161162-- | optimize relational expression within database context expr monad
162163liftGraphRefRelExpr :: GraphRefSOptRelationalExprM a -> GraphRefSOptDatabaseContextExprM a
163164liftGraphRefRelExpr m = do
164− context <- asks odce_context
165− graph <- asks odce_graph
165+ context <- odce_context <$> ask
166+ graph <- odce_graph <$> ask
166167 lift $ except $ runGraphRefSOptRelationalExprM (Just context) graph m
167168
168169fullOptimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr
@@ -177,7 +178,7 @@ fullOptimizeGraphRefRelationalExpr expr = do
177178optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr
178179optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e
179180
180−optimizeGraphRefRelationalExpr e@MakeRelationFromExprs{} = pure e
181+optimizeGraphRefRelationalExpr e@(MakeRelationFromExprs _ _) = pure e
181182
182183optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e
183184
@@ -207,8 +208,6 @@ optimizeGraphRefRelationalExpr (Union exprA exprB) = do
207208 case (optExprA, optExprB) of
208209 (Restrict predA (RelationVariable nameA sA),
209210 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'
212211 _ -> if optExprA == optExprB then
213212 pure optExprA
214213 else
@@ -357,8 +356,10 @@ applyStaticPredicateOptimization predi = do
357356 OrPredicate pred1 pred2 -> do
358357 optPredA <- applyStaticPredicateOptimization pred1
359358 optPredB <- applyStaticPredicateOptimization pred2
360− if (optPredA == optPredB) || isTrueExpr optPredA then
359+ if optPredA == optPredB then
361360 pure optPredA
361+ else if isTrueExpr optPredA then
362+ pure optPredA -- True or x -> True
362363 else if isTrueExpr optPredB then
363364 pure optPredB
364365 else
@@ -390,7 +391,7 @@ isFalseExpr _ = False
390391
391392-- determine if the created relation can statically be determined to be empty
392393isEmptyRelationExpr :: RelationalExprBase a -> Bool
393−isEmptyRelationExpr (MakeRelationFromExprs _ (TupleExprs _ [])) = True
394+isEmptyRelationExpr (MakeRelationFromExprs _ []) = True
394395isEmptyRelationExpr (MakeStaticRelation _ tupSet) = null (asList tupSet)
395396isEmptyRelationExpr (ExistingRelation rel) = rel == emptyRelationWithAttrs (attributes rel)
396397isEmptyRelationExpr _ = False
@@ -574,5 +575,4 @@ applyStaticRestrictionPushdown expr = case expr of
574575
575576-- no optimizations available
576577optimizeDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextIOExpr
577−optimizeDatabaseContextIOExpr = pure
578−
578+optimizeDatabaseContextIOExpr x = pure x
src/lib/ProjectM36/TransGraphPlanExpr.hsnew file+5
@@ -0,0 +1,5 @@
1+module ProjectM36.TransGraphPlanExpr where
2+import ProjectM36.Base
3+-- used to create an execution plan which can potentially read from the query cache
4+
5+data TransGraphPlanExpr = ExecuteTransGraphRelationalExprPlan TransGraphRelationalExpr
src/lib/ProjectM36/TransGraphRelationalExpression.hs+18−9
@@ -10,27 +10,40 @@ import Control.Monad.Trans.Reader
1010import Control.Monad.Trans.Class
1111import Control.Monad.Trans.Except
1212import Data.Functor.Identity
13+import Data.Binary
1314
1415-- | The TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time).
1516type TransGraphRelationalExpr = RelationalExprBase TransactionIdLookup
1617
18+instance Binary TransGraphRelationalExpr
19+
1720type TransGraphAttributeNames = AttributeNamesBase TransactionIdLookup
1821
22+instance Binary TransGraphAttributeNames
23+
1924type TransGraphExtendTupleExpr = ExtendTupleExprBase TransactionIdLookup
2025
26+instance Binary TransGraphExtendTupleExpr
27+
2128type TransGraphTupleExpr = TupleExprBase TransactionIdLookup
2229
23−type TransGraphTupleExprs = TupleExprsBase TransactionIdLookup
30+instance Binary TransGraphTupleExpr
2431
2532type TransGraphRestrictionPredicateExpr = RestrictionPredicateExprBase TransactionIdLookup
2633
34+instance Binary TransGraphRestrictionPredicateExpr
35+
2736type TransGraphAtomExpr = AtomExprBase TransactionIdLookup
2837
38+instance Binary TransGraphAtomExpr
39+
2940type TransGraphAttributeExpr = AttributeExprBase TransactionIdLookup
3041
3142type TransGraphWithNameExpr = WithNameExprBase TransactionIdLookup
3243
33−newtype TransGraphEvalEnv = TransGraphEvalEnv {
44+instance Binary TransGraphWithNameExpr
45+
46+data TransGraphEvalEnv = TransGraphEvalEnv {
3447 tge_graph :: TransactionGraph
3548 }
3649
@@ -56,7 +69,7 @@ findTrans tlook = do
5669-- OUTDATED a previous attempt at this function attempted to convert TransGraphRelationalExpr to RelationalExpr by resolving the transaction lookups. However, there is no way to resolve a FunctionAtomExpr to an Atom without fully evaluating the higher levels (TupleExpr, etc.). An anonymous function expression cannot be serialized, so that workaround is out. Still, I suspect we can reuse the existing static optimizer logic to work on both structures. The current conversion reduces the chance of whole-query optimization due to full-evaluation on top of full-evaluation, so this function would benefit from some re-design.
5770processTransGraphRelationalExpr :: TransGraphRelationalExpr -> TransGraphEvalMonad GraphRefRelationalExpr
5871processTransGraphRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do
59− tupleExprs' <- processTransGraphTupleExprs tupleExprs
72+ tupleExprs' <- mapM processTransGraphTupleExpr tupleExprs
6073 case mAttrExprs of
6174 Nothing -> pure (MakeRelationFromExprs Nothing tupleExprs')
6275 Just attrExprs -> do
@@ -106,11 +119,7 @@ processTransGraphRelationalExpr (With views expr) = do
106119 ) views
107120 expr' <- processTransGraphRelationalExpr expr
108121 pure (With evaldViews expr')
109−
110−processTransGraphTupleExprs :: TransGraphTupleExprs -> TransGraphEvalMonad GraphRefTupleExprs
111−processTransGraphTupleExprs (TupleExprs marker texprs) =
112− TupleExprs <$> findTransId marker <*> mapM processTransGraphTupleExpr texprs
113−
122+
114123processTransGraphTupleExpr :: TransGraphTupleExpr -> TransGraphEvalMonad GraphRefTupleExpr
115124processTransGraphTupleExpr (TupleExpr attrMap) = do
116125 let attrAssoc = mapM (\(attrName, atomExpr) -> do
@@ -152,7 +161,7 @@ evalTransGraphRestrictionPredicateExpr (AttributeEqualityPredicate attrName expr
152161 AttributeEqualityPredicate attrName <$> expr'
153162
154163processTransGraphExtendTupleExpr :: TransGraphExtendTupleExpr -> TransGraphEvalMonad GraphRefExtendTupleExpr
155−processTransGraphExtendTupleExpr (AttributeExtendTupleExpr attrName expr) =
164+processTransGraphExtendTupleExpr (AttributeExtendTupleExpr attrName expr) = do
156165 AttributeExtendTupleExpr attrName <$> processTransGraphAtomExpr expr
157166
158167processTransGraphAttributeExpr :: TransGraphAttributeExpr -> TransGraphEvalMonad GraphRefAttributeExpr
src/lib/ProjectM36/Transaction.hs+5−10
@@ -17,10 +17,11 @@ 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− tinfo { parents = case
21− NE.filter (`S.member` filterIds) (parents tinfo) of
20+ TransactionInfo { parents = case
21+ NE.filter (\parent -> S.member parent filterIds) (parents tinfo) of
2222 [] -> rootParent
23− xs -> NE.fromList xs}
23+ xs -> NE.fromList xs,
24+ stamp = stamp tinfo }
2425
2526filterParent :: TransactionId -> S.Set TransactionId -> TransactionId
2627filterParent parentId validIds = if S.member parentId validIds then parentId else U.nil
@@ -42,13 +43,7 @@ subschemas :: Transaction -> Subschemas
4243subschemas (Transaction _ _ (Schemas _ sschemas)) = sschemas
4344
4445fresh :: TransactionId -> UTCTime -> Schemas -> Transaction
45−fresh freshId stamp' = Transaction freshId tinfo
46− where
47− tinfo = TransactionInfo {parents = rootParent,
48− stamp = stamp',
49− merkleHash = mempty
50− }
46+fresh freshId stamp' newSchemas = Transaction freshId (TransactionInfo rootParent stamp') newSchemas
5147
5248timestamp :: Transaction -> UTCTime
5349timestamp (Transaction _ tinfo _) = stamp tinfo
54−
src/lib/ProjectM36/Transaction/Persist.hs+31−51
@@ -1,4 +1,3 @@
1−{-# LANGUAGE TypeApplications #-}
21module ProjectM36.Transaction.Persist where
32import ProjectM36.Base
43import ProjectM36.Error
@@ -8,19 +7,17 @@ import ProjectM36.AtomFunction
87import ProjectM36.Persist (writeBSFileSync, DiskSync, renameSync)
98import qualified Data.Map as M
109import qualified Data.HashSet as HS
10+import qualified Data.Binary as B
11+--import qualified Data.ByteString as BS
1112import System.FilePath
1213import System.Directory
1314import qualified Data.Text as T
1415import Control.Monad
1516import ProjectM36.ScriptSession
1617import ProjectM36.AtomFunctions.Basic (precompiledAtomFunctions)
17−import Codec.Winery
18−
19−#ifdef PM36_HASKELL_SCRIPTING
20−import GHC
2118import Control.Exception
19+import GHC
2220import GHC.Paths
23−#endif
2421
2522getDirectoryNames :: FilePath -> IO [FilePath]
2623getDirectoryNames path =
@@ -62,7 +59,7 @@ readTransaction dbdir transId mScriptSession = do
6259 return $ Left $ MissingTransactionError transId
6360 else do
6461 relvars <- readRelVars transDir
65− transInfo <- readFileDeserialise (transactionInfoPath transDir)
62+ transInfo <- B.decodeFile (transactionInfoPath transDir)
6663 incDeps <- readIncDeps transDir
6764 typeCons <- readTypeConstructorMapping transDir
6865 sschemas <- readSubschemas transDir
@@ -92,68 +89,61 @@ writeTransaction sync dbdir trans = do
9289 writeDBCFuncs sync tempTransDir (dbcFunctions context)
9390 writeTypeConstructorMapping sync tempTransDir (typeConstructorMapping context)
9491 writeSubschemas sync tempTransDir (subschemas trans)
95− writeFileSerialise (transactionInfoPath tempTransDir) (transactionInfo trans)
92+ B.encodeFile (transactionInfoPath tempTransDir) (transactionInfo trans)
9693 --move the temp directory to final location
9794 renameSync sync tempTransDir finalTransDir
9895
9996writeRelVars :: DiskSync -> FilePath -> RelationVariables -> IO ()
10097writeRelVars sync transDir relvars = do
10198 let path = relvarsPath transDir
102− writeBSFileSync sync path (serialise relvars)
99+ writeBSFileSync sync path (B.encode relvars)
103100
104101readRelVars :: FilePath -> IO RelationVariables
105−readRelVars transDir =
106− readFileDeserialise (relvarsPath transDir)
102+readRelVars transDir = do
103+ B.decodeFile (relvarsPath transDir)
107104
108105writeAtomFuncs :: DiskSync -> FilePath -> AtomFunctions -> IO ()
109106writeAtomFuncs sync transDir funcs = do
110107 let atomFuncPath = atomFuncsPath transDir
111− writeBSFileSync sync atomFuncPath (serialise $ map (\f -> (atomFuncType f, atomFuncName f, atomFunctionScript f)) (HS.toList funcs))
108+ writeBSFileSync sync atomFuncPath (B.encode $ map (\f -> (atomFuncType f, atomFuncName f, atomFunctionScript f)) (HS.toList funcs))
112109
113110--all the atom functions are in one file
114111readAtomFuncs :: FilePath -> Maybe ScriptSession -> IO AtomFunctions
115112readAtomFuncs transDir mScriptSession = do
116− atomFuncsList <- readFileDeserialise (atomFuncsPath transDir)
113+ atomFuncsList <- B.decodeFile (atomFuncsPath transDir)
117114 --only Haskell script functions can be serialized
118115 --we always return the pre-compiled functions
119116 funcs <- mapM (\(funcType, funcName, mFuncScript) -> loadAtomFunc precompiledAtomFunctions mScriptSession funcName funcType mFuncScript) atomFuncsList
120117 pure (HS.union precompiledAtomFunctions (HS.fromList funcs))
121118
122119loadAtomFunc :: AtomFunctions -> Maybe ScriptSession -> AtomFunctionName -> [AtomType] -> Maybe AtomFunctionBodyScript -> IO AtomFunction
123−loadAtomFunc precompiledFuncs _mScriptSession funcName _funcType mFuncScript = case mFuncScript of
120+loadAtomFunc precompiledFuncs mScriptSession funcName funcType mFuncScript = case mFuncScript of
124121 --handle pre-compiled case- pull it from the precompiled list
125122 Nothing -> case atomFunctionForName funcName precompiledFuncs of
126123 --WARNING: possible landmine here if we remove a precompiled atom function in the future, then the transaction cannot be restored
127124 Left _ -> error ("expected precompiled atom function: " ++ T.unpack funcName)
128125 Right realFunc -> pure realFunc
129126 --handle a real Haskell scripted function- compile and load
130− Just _funcScript ->
131−#ifdef PM36_HASKELL_SCRIPTING
132− case _mScriptSession of
127+ Just funcScript ->
128+ case mScriptSession of
133129 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"
134130 Just scriptSession -> do
135131 --risk of GHC exception during compilation here
136132 eCompiledScript <- runGhc (Just libdir) $ do
137133 setSession (hscEnv scriptSession)
138− compileScript (atomFunctionBodyType scriptSession) _funcScript
134+ compileScript (atomFunctionBodyType scriptSession) funcScript
139135 case eCompiledScript of
140136 Left err -> throwIO err
141137 Right compiledScript -> pure AtomFunction { atomFuncName = funcName,
142− atomFuncType = _funcType,
143− atomFuncBody = AtomFunctionBody (Just _funcScript) compiledScript }
144−#else
145− error "Haskell scripting is disabled"
146−#endif
138+ atomFuncType = funcType,
139+ atomFuncBody = AtomFunctionBody (Just funcScript) compiledScript }
147140
148141--if the script session is enabled, compile the script, otherwise, hard error!
149142
150143readAtomFunc :: FilePath -> AtomFunctionName -> Maybe ScriptSession -> AtomFunctions -> IO AtomFunction
151−#if !defined(PM36_HASKELL_SCRIPTING)
152−readAtomFunc _ _ _ _ = error "Haskell scripting is disabled"
153−#else
154144readAtomFunc transDir funcName mScriptSession precompiledFuncs = do
155145 let atomFuncPath = atomFuncsPath transDir
156− (funcType, mFuncScript) <- readFileDeserialise @([AtomType],Maybe T.Text) atomFuncPath
146+ (funcType, mFuncScript) <- B.decodeFile atomFuncPath
157147 case mFuncScript of
158148 --handle pre-compiled case- pull it from the precompiled list
159149 Nothing -> case atomFunctionForName funcName precompiledFuncs of
@@ -161,8 +151,7 @@ readAtomFunc transDir funcName mScriptSession precompiledFuncs = do
161151 Left _ -> error ("expected precompiled atom function: " ++ T.unpack funcName)
162152 Right realFunc -> pure realFunc
163153 --handle a real Haskell scripted function- compile and load
164− Just funcScript ->
165−
154+ Just funcScript ->
166155 case mScriptSession of
167156 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"
168157 Just scriptSession -> do
@@ -175,7 +164,6 @@ readAtomFunc transDir funcName mScriptSession precompiledFuncs = do
175164 Right compiledScript -> pure AtomFunction { atomFuncName = funcName,
176165 atomFuncType = funcType,
177166 atomFuncBody = AtomFunctionBody (Just funcScript) compiledScript }
178−#endif
179167
180168
181169writeDBCFuncs :: DiskSync -> FilePath -> DatabaseContextFunctions -> IO ()
@@ -184,7 +172,7 @@ writeDBCFuncs sync transDir funcs = mapM_ (writeDBCFunc sync transDir) (HS.toLis
184172writeDBCFunc :: DiskSync -> FilePath -> DatabaseContextFunction -> IO ()
185173writeDBCFunc sync transDir func = do
186174 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack (dbcFuncName func)
187− writeBSFileSync sync dbcFuncPath (serialise (dbcFuncType func, databaseContextFunctionScript func))
175+ writeBSFileSync sync dbcFuncPath (B.encode (dbcFuncType func, databaseContextFunctionScript func))
188176
189177readDBCFuncs :: FilePath -> Maybe ScriptSession -> IO DatabaseContextFunctions
190178readDBCFuncs transDir mScriptSession = do
@@ -194,38 +182,30 @@ readDBCFuncs transDir mScriptSession = do
194182 let funcs = mapM ((\name -> readDBCFunc transDir name mScriptSession precompiledDatabaseContextFunctions) . T.pack) funcNames
195183 HS.union basicDatabaseContextFunctions . HS.fromList <$> funcs
196184
197−readDBCFunc :: FilePath -> DatabaseContextFunctionName -> Maybe ScriptSession -> DatabaseContextFunctions -> IO DatabaseContextFunction
198−#if !defined(PM36_HASKELL_SCRIPTING)
199−readDBCFunc transDir funcName _ precompiledFuncs = do
200−#else
185+readDBCFunc :: FilePath -> DatabaseContextFunctionName -> Maybe ScriptSession -> DatabaseContextFunctions -> IO DatabaseContextFunction
201186readDBCFunc transDir funcName mScriptSession precompiledFuncs = do
202−#endif
203187 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack funcName
204− (_funcType, mFuncScript) <- readFileDeserialise @([AtomType], Maybe T.Text) dbcFuncPath
188+ (funcType, mFuncScript) <- B.decodeFile dbcFuncPath
205189 case mFuncScript of
206190 Nothing -> case databaseContextFunctionForName funcName precompiledFuncs of
207191 Left _ -> error ("expected precompiled dbc function: " ++ T.unpack funcName)
208192 Right realFunc -> pure realFunc --return precompiled function
209− Just _funcScript ->
210−#ifdef PM36_HASKELL_SCRIPTING
193+ Just funcScript ->
211194 case mScriptSession of
212195 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"
213196 Just scriptSession -> do
214197 eCompiledScript <- runGhc (Just libdir) $ do
215198 setSession (hscEnv scriptSession)
216− compileScript (dbcFunctionBodyType scriptSession) _funcScript
199+ compileScript (dbcFunctionBodyType scriptSession) funcScript
217200 case eCompiledScript of
218201 Left err -> throwIO err
219202 Right compiledScript -> pure DatabaseContextFunction { dbcFuncName = funcName,
220− dbcFuncType = _funcType,
221− dbcFuncBody = DatabaseContextFunctionBody (Just _funcScript) compiledScript}
222−#else
223− error "Haskell scripting is disabled"
224−#endif
203+ dbcFuncType = funcType,
204+ dbcFuncBody = DatabaseContextFunctionBody (Just funcScript) compiledScript}
225205
226206writeIncDep :: DiskSync -> FilePath -> (IncDepName, InclusionDependency) -> IO ()
227207writeIncDep sync transDir (incDepName, incDep) =
228− writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ serialise incDep
208+ writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ B.encode incDep
229209
230210writeIncDeps :: DiskSync -> FilePath -> M.Map IncDepName InclusionDependency -> IO ()
231211writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toList incdeps
@@ -233,7 +213,7 @@ writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toLis
233213readIncDep :: FilePath -> IncDepName -> IO (IncDepName, InclusionDependency)
234214readIncDep transDir incdepName = do
235215 let incDepPath = incDepsDir transDir </> T.unpack incdepName
236− incDepData <- readFileDeserialise incDepPath
216+ incDepData <- B.decodeFile incDepPath
237217 pure (incdepName, incDepData)
238218
239219readIncDeps :: FilePath -> IO (M.Map IncDepName InclusionDependency)
@@ -245,20 +225,20 @@ readIncDeps transDir = do
245225readSubschemas :: FilePath -> IO Subschemas
246226readSubschemas transDir = do
247227 let sschemasPath = subschemasPath transDir
248− readFileDeserialise sschemasPath
228+ B.decodeFile sschemasPath
249229
250230writeSubschemas :: DiskSync -> FilePath -> Subschemas -> IO ()
251231writeSubschemas sync transDir sschemas = do
252232 let sschemasPath = subschemasPath transDir
253− writeBSFileSync sync sschemasPath (serialise sschemas)
233+ writeBSFileSync sync sschemasPath (B.encode sschemas)
254234
255235writeTypeConstructorMapping :: DiskSync -> FilePath -> TypeConstructorMapping -> IO ()
256236writeTypeConstructorMapping sync path types = let atPath = typeConsPath path in
257− writeBSFileSync sync atPath $ serialise types
237+ writeBSFileSync sync atPath $ B.encode types
258238
259239readTypeConstructorMapping :: FilePath -> IO TypeConstructorMapping
260240readTypeConstructorMapping path = do
261241 let atPath = typeConsPath path
262− readFileDeserialise atPath
242+ B.decodeFile atPath
263243
264244
src/lib/ProjectM36/TransactionGraph.hs+77−166
@@ -1,4 +1,4 @@
1−{-# LANGUAGE DeriveGeneric, CPP, FlexibleContexts, DerivingVia #-}
1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}
22module ProjectM36.TransactionGraph where
33import ProjectM36.Base
44import ProjectM36.Error
@@ -9,44 +9,37 @@ import ProjectM36.TupleSet
99import ProjectM36.Tuple
1010import ProjectM36.RelationalExpression
1111import ProjectM36.TransactionGraph.Merge
12−import ProjectM36.MerkleHash
1312import qualified ProjectM36.DisconnectedTransaction as Discon
14−import qualified ProjectM36.Attribute as A
1513
16−import Codec.Winery
17−import Control.Monad.Except hiding (join)
18−import Control.Monad.Reader hiding (join)
1914import qualified Data.Vector as V
15+import qualified ProjectM36.Attribute as A
2016import qualified Data.UUID as U
2117import qualified Data.Set as S
2218import qualified Data.Map as M
2319import qualified Data.List.NonEmpty as NE
20+import Control.Monad
2421import Data.Time.Clock
2522import qualified Data.Text as T
2623import GHC.Generics
24+import Data.Binary
2725import Data.Either (lefts, rights, isRight)
28−#if __GLASGOW_HASKELL__ < 804
29−import Data.Monoid
30−#endif
3126import Control.Arrow
3227import Data.Maybe
3328import Data.UUID.V4
34−import qualified Data.ByteString.Lazy as BL
35−import ProjectM36.DatabaseContext as DBC
36−import Crypto.Hash.SHA256
29+#if __GLASGOW_HASKELL__ <= 802
30+import Data.Monoid
31+#endif
3732
3833-- | Record a lookup for a specific transaction in the graph.
3934data TransactionIdLookup = TransactionIdLookup TransactionId |
4035 TransactionIdHeadNameLookup HeadName [TransactionIdHeadBacktrack]
41− deriving (Show, Eq, Generic)
42− deriving Serialise via WineryVariant TransactionIdLookup
36+ deriving (Show, Eq, Binary, Generic)
4337
4438-- | Used for git-style head backtracking such as topic~3^2.
45−data TransactionIdHeadBacktrack = TransactionIdHeadParentBacktrack Int | -- ^ git equivalent of ~v: walk back n parents, arbitrarily choosing a parent when a choice must be made
39+data TransactionIdHeadBacktrack = TransactionIdHeadParentBacktrack Int | -- ^ git equivalent of ~: walk back n parents, arbitrarily choosing a parent when a choice must be made
4640 TransactionIdHeadBranchBacktrack Int | -- ^ git equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent
4741 TransactionStampHeadBacktrack UTCTime -- ^ git equivalent of 'git-rev-list -n 1 --before X' find the first transaction which was created before the timestamp
48− deriving (Show, Eq, Generic)
49− deriving Serialise via WineryVariant TransactionIdHeadBacktrack
42+ deriving (Show, Eq, Binary, Generic)
5043
5144
5245-- | Operators which manipulate a transaction graph and which transaction the current 'Session' is based upon.
@@ -58,14 +51,13 @@ data TransactionGraphOperator = JumpToHead HeadName |
5851 MergeTransactions MergeStrategy HeadName HeadName |
5952 Commit |
6053 Rollback
61− deriving (Eq, Show, Generic)
62− deriving Serialise via WineryVariant TransactionGraphOperator
54+ deriving (Eq, Show, Binary, Generic)
6355
6456isCommit :: TransactionGraphOperator -> Bool
6557isCommit Commit = True
6658isCommit _ = False
6759
68−data ROTransactionGraphOperator = ShowGraph | ValidateMerkleHashes
60+data ROTransactionGraphOperator = ShowGraph
6961 deriving Show
7062
7163bootstrapTransactionGraph :: UTCTime -> TransactionId -> DatabaseContext -> TransactionGraph
@@ -74,15 +66,14 @@ bootstrapTransactionGraph stamp' freshId context = TransactionGraph bootstrapHea
7466 bootstrapHeads = M.singleton "master" freshTransaction
7567 newSchemas = Schemas context M.empty
7668 freshTransaction = fresh freshId stamp' newSchemas
77− hashedTransaction = Transaction freshId ((transactionInfo freshTransaction) { merkleHash = calculateMerkleHash freshTransaction emptyTransactionGraph }) newSchemas
78− bootstrapTransactions = S.singleton hashedTransaction
69+ bootstrapTransactions = S.singleton freshTransaction
7970
8071-- | Create a transaction graph from a context.
8172freshTransactionGraph :: DatabaseContext -> IO (TransactionGraph, TransactionId)
8273freshTransactionGraph ctx = do
8374 now <- getCurrentTime
8475 freshId <- nextRandom
85− pure (bootstrapTransactionGraph now freshId ctx, freshId)
76+ pure $ (bootstrapTransactionGraph now freshId ctx, freshId)
8677
8778
8879emptyTransactionGraph :: TransactionGraph
@@ -115,7 +106,7 @@ rootTransactions graph = S.filter isRootTransaction (transactionsForGraph graph)
115106
116107-- the first transaction has no parent - all other do have parents- merges have two parents
117108parentTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)
118−parentTransactions trans = transactionsForIds (parentIds trans)
109+parentTransactions trans graph = transactionsForIds (parentIds trans) graph
119110
120111childTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)
121112childTransactions trans graph = transactionsForIds childIds graph
@@ -133,13 +124,10 @@ addBranch stamp' newId newBranchName branchPointId graph = do
133124
134125--adds a disconnected transaction to a transaction graph at some head
135126addDisconnectedTransaction :: UTCTime -> TransactionId -> HeadName -> DisconnectedTransaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)
136−addDisconnectedTransaction stamp' newId headName (DisconnectedTransaction parentId schemas' _) graph = addTransactionToGraph headName newTrans' graph
127+addDisconnectedTransaction stamp' newId headName (DisconnectedTransaction parentId schemas' _) = addTransactionToGraph headName newTrans
137128 where
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
129+ newTrans = Transaction newId (TI.singleParent parentId stamp') schemas'
130+
143131addTransactionToGraph :: HeadName -> Transaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)
144132addTransactionToGraph headName newTrans graph = do
145133 let parentIds' = parentIds newTrans
@@ -157,24 +145,10 @@ addTransactionToGraph headName newTrans graph = do
157145 unless (S.null childTs) (Left $ NewTransactionMayNotHaveChildrenError newId)
158146 --validate that the trasaction's id is unique
159147 when (isRight (transactionForId newId graph)) (Left (TransactionIdInUseError newId))
160− --replace all references to UncommittedTransactionMarker to new transaction id
161− let newTrans' = newTransUncommittedReplace newTrans
162− updatedTransSet = S.insert newTrans' (transactionsForGraph graph)
163− updatedHeads = M.insert headName newTrans' (transactionHeadsForGraph graph)
164− pure (newTrans', TransactionGraph updatedHeads updatedTransSet)
165−
166−--replace all occurrences of the uncommitted context marker
167−newTransUncommittedReplace :: Transaction -> Transaction
168−newTransUncommittedReplace trans@(Transaction tid tinfo (Schemas ctx sschemas)) =
169− Transaction tid tinfo (Schemas fixedContext sschemas)
170− where
171− uncommittedReplace UncommittedContextMarker = TransactionMarker tid
172− uncommittedReplace marker = marker
173− relvars = relationVariables (concreteDatabaseContext trans)
174− fixedRelvars = M.map (fmap uncommittedReplace) relvars
175− fixedContext = ctx { relationVariables = fixedRelvars }
176−
177148
149+ let updatedTransSet = S.insert newTrans (transactionsForGraph graph)
150+ updatedHeads = M.insert headName newTrans (transactionHeadsForGraph graph)
151+ pure (newTrans, TransactionGraph updatedHeads updatedTransSet)
178152
179153validateGraph :: TransactionGraph -> Maybe [RelationalError]
180154validateGraph graph@(TransactionGraph _ transSet) = do
@@ -231,12 +205,12 @@ evalGraphOp _ _ _ graph (JumpToTransaction jumpId) = case transactionForId jumpI
231205 Left err -> Left err
232206 Right parentTrans -> Right (newTrans, graph)
233207 where
234− newTrans = DisconnectedTransaction jumpId (schemas parentTrans) False
208+ newTrans = DisconnectedTransaction jumpId (schemas parentTrans) NoOperation
235209
236210-- switch from one head to another
237211evalGraphOp _ _ _ graph (JumpToHead headName) =
238212 case transactionForHead headName graph of
239− Just newHeadTransaction -> let disconnectedTrans = DisconnectedTransaction (transactionId newHeadTransaction) (schemas newHeadTransaction) False in
213+ Just newHeadTransaction -> let disconnectedTrans = DisconnectedTransaction (transactionId newHeadTransaction) (schemas newHeadTransaction) NoOperation in
240214 Right (disconnectedTrans, graph)
241215 Nothing -> Left $ NoSuchHeadNameError headName
242216
@@ -290,10 +264,7 @@ evalGraphOp _ _ (DisconnectedTransaction parentId _ _) graph Rollback = case tra
290264 where
291265 newDiscon = Discon.freshTransaction parentId (schemas parentTransaction)
292266
293−evalGraphOp stamp' newId (DisconnectedTransaction parentId _ _) graph (MergeTransactions mergeStrategy headNameA headNameB) =
294− runGraphRefRelationalExprM env $ mergeTransactions stamp' newId parentId mergeStrategy (headNameA, headNameB)
295− where
296− env = freshGraphRefRelationalExprEnv Nothing graph
267+evalGraphOp stamp' newId (DisconnectedTransaction parentId _ _) graph (MergeTransactions mergeStrategy headNameA headNameB) = mergeTransactions stamp' newId parentId mergeStrategy (headNameA, headNameB) graph
297268
298269evalGraphOp _ _ discon graph@(TransactionGraph graphHeads transSet) (DeleteBranch branchName) = case transactionForHead branchName graph of
299270 Nothing -> Left (NoSuchHeadNameError branchName)
@@ -306,7 +277,6 @@ graphAsRelation (DisconnectedTransaction parentId _ _) graph@(TransactionGraph _
306277 mkRelationFromList attrs tupleMatrix
307278 where
308279 attrs = A.attributesFromList [Attribute "id" TextAtomType,
309− Attribute "hash" ByteStringAtomType,
310280 Attribute "stamp" DateTimeAtomType,
311281 Attribute "parents" (RelationAtomType parentAttributes),
312282 Attribute "current" BoolAtomType,
@@ -316,7 +286,6 @@ graphAsRelation (DisconnectedTransaction parentId _ _) graph@(TransactionGraph _
316286 tupleGenerator transaction = case transactionParentsRelation transaction graph of
317287 Left err -> Left err
318288 Right parentTransRel -> Right [TextAtom $ T.pack $ show (transactionId transaction),
319− ByteStringAtom $ _unMerkleHash (merkleHash (transactionInfo transaction)),
320289 DateTimeAtom (timestamp transaction),
321290 RelationAtom parentTransRel,
322291 BoolAtom $ parentId == transactionId transaction,
@@ -344,34 +313,29 @@ evalROGraphOp discon graph ShowGraph = do
344313-}
345314
346315-- | Execute the merge strategy against the transactions, returning a new transaction which can be then added to the transaction graph
347−createMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> (Transaction, Transaction) -> GraphRefRelationalExprM Transaction
348−createMergeTransaction stamp' newId (SelectedBranchMergeStrategy selectedBranch) t2@(trans1, trans2) = do
349− graph <- gfGraph
350− selectedTrans <- validateHeadName selectedBranch graph t2
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)
316+createMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> TransactionGraph -> (Transaction, Transaction) -> Either MergeError Transaction
317+createMergeTransaction stamp' newId (SelectedBranchMergeStrategy selectedBranch) graph t2@(trans1, trans2) = do
318+ let selectedTrans = validateHeadName selectedBranch graph t2
319+ Transaction newId (TransactionInfo {
320+ parents = NE.fromList [transactionId trans1,
321+ transactionId trans2],
322+ stamp = stamp' }) . schemas <$> selectedTrans
357323
358324-- merge functions, relvars, individually
359−createMergeTransaction stamp' newId strat@UnionMergeStrategy t2 =
360− createUnionMergeTransaction stamp' newId strat t2
325+createMergeTransaction stamp' newId strat@UnionMergeStrategy graph t2 = createUnionMergeTransaction stamp' newId strat graph t2
361326
362327-- merge function, relvars, but, on error, just take the component from the preferred branch
363−createMergeTransaction stamp' newId strat@(UnionPreferMergeStrategy _) t2 =
364− createUnionMergeTransaction stamp' newId strat t2
328+createMergeTransaction stamp' newId strat@(UnionPreferMergeStrategy _) graph t2 = createUnionMergeTransaction stamp' newId strat graph t2
365329
366330-- | Returns the correct Transaction for the branch name in the graph and ensures that it is one of the two transaction arguments in the tuple.
367−validateHeadName :: HeadName -> TransactionGraph -> (Transaction, Transaction) -> GraphRefRelationalExprM Transaction
331+validateHeadName :: HeadName -> TransactionGraph -> (Transaction, Transaction) -> Either MergeError Transaction
368332validateHeadName headName graph (t1, t2) =
369333 case transactionForHead headName graph of
370− Nothing -> throwError (MergeTransactionError SelectedHeadMismatchMergeError)
334+ Nothing -> Left SelectedHeadMismatchMergeError
371335 Just trans -> if trans /= t1 && trans /= t2 then
372− throwError (MergeTransactionError SelectedHeadMismatchMergeError)
336+ Left SelectedHeadMismatchMergeError
373337 else
374− pure trans
338+ Right trans
375339
376340-- Algorithm: start at one transaction and work backwards up the parents. If there is a node we have not yet visited as a child, then walk that up to its head. If that branch contains the goal transaction, then we have completed a valid subgraph traversal.
377341subGraphOfFirstCommonAncestor :: TransactionGraph -> TransactionHeads -> Transaction -> Transaction -> S.Set Transaction -> Either RelationalError TransactionGraph
@@ -384,7 +348,7 @@ subGraphOfFirstCommonAncestor origGraph resultHeads currentTrans' goalTrans trav
384348 else do
385349 currentTransChildren <- childTransactions currentTrans' origGraph
386350 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren
387− searchChild start' = pathToTransaction origGraph start' goalTrans (S.insert currentTrans' traverseSet)
351+ searchChild start = pathToTransaction origGraph start goalTrans (S.insert currentTrans' traverseSet)
388352 childSearches = map searchChild (S.toList searchChildren)
389353 errors = lefts childSearches
390354 pathsFound = rights childSearches
@@ -424,28 +388,26 @@ pathToTransaction graph currentTransaction targetTransaction accumTransSet = do
424388 else --we have some paths!
425389 Right (S.unions paths)
426390
427−mergeTransactions :: UTCTime -> TransactionId -> TransactionId -> MergeStrategy -> (HeadName, HeadName) -> GraphRefRelationalExprM (DisconnectedTransaction, TransactionGraph)
428−mergeTransactions stamp' newId parentId mergeStrategy (headNameA, headNameB) = do
429− graph <- gfGraph
391+mergeTransactions :: UTCTime -> TransactionId -> TransactionId -> MergeStrategy -> (HeadName, HeadName) -> TransactionGraph -> Either RelationalError (DisconnectedTransaction, TransactionGraph)
392+mergeTransactions stamp' newId parentId mergeStrategy (headNameA, headNameB) graph = do
430393 let transactionForHeadErr name = case transactionForHead name graph of
431− Nothing -> throwError (NoSuchHeadNameError name)
432− Just t -> pure t
433− runE e = case e of
434− Left e' -> throwError e'
435− Right v -> pure v
436− transA <- transactionForHeadErr headNameA
437− transB <- transactionForHeadErr headNameB
438− disconParent <- gfTransForId parentId
394+ Nothing -> Left (NoSuchHeadNameError name)
395+ Just t -> Right t
396+ transA <- transactionForHeadErr headNameA
397+ transB <- transactionForHeadErr headNameB
398+ disconParent <- transactionForId parentId graph
439399 let subHeads = M.filterWithKey (\k _ -> k `elem` [headNameA, headNameB]) (transactionHeadsForGraph graph)
440− subGraph <- runE $ subGraphOfFirstCommonAncestor graph subHeads transA transB S.empty
441− subGraph' <- runE $ filterSubGraph subGraph subHeads
442− mergedTrans <- local (const (freshGraphRefRelationalExprEnv Nothing subGraph')) $ createMergeTransaction stamp' newId mergeStrategy (transA, transB)
443− case headNameForTransaction disconParent graph of
444− Nothing -> throwError (TransactionIsNotAHeadError parentId)
400+ subGraph <- subGraphOfFirstCommonAncestor graph subHeads transA transB S.empty
401+ subGraph' <- filterSubGraph subGraph subHeads
402+ case createMergeTransaction stamp' newId mergeStrategy subGraph' (transA, transB) of
403+ Left err -> Left (MergeTransactionError err)
404+ Right mergedTrans ->
405+ case headNameForTransaction disconParent graph of
406+ Nothing -> Left (TransactionIsNotAHeadError parentId)
445407 Just headName -> do
446− (newTrans, newGraph) <- runE $ addTransactionToGraph headName mergedTrans graph
408+ (newTrans, newGraph) <- addTransactionToGraph headName mergedTrans graph
447409 case checkConstraints (concreteDatabaseContext mergedTrans) newId graph of
448− Left err -> throwError err
410+ Left err -> Left err
449411 Right _ -> do
450412 let newGraph' = TransactionGraph (transactionHeadsForGraph newGraph) (transactionsForGraph newGraph)
451413 newDiscon = Discon.freshTransaction newId (schemas newTrans)
@@ -475,29 +437,25 @@ filterSubGraph graph heads = Right $ TransactionGraph newHeads newTransSet
475437 newHeads = M.map (filterTransaction validIds) heads
476438
477439--helper function for commonalities in union merge
478−createUnionMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> (Transaction, Transaction) -> GraphRefRelationalExprM Transaction
479−createUnionMergeTransaction stamp' newId strategy (t1,t2) = do
440+createUnionMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> TransactionGraph -> (Transaction, Transaction) -> Either MergeError Transaction
441+createUnionMergeTransaction stamp' newId strategy graph (t1,t2) = do
480442 let contextA = concreteDatabaseContext t1
481443 contextB = concreteDatabaseContext t2
482− liftMergeE x = case x of
483− Left e -> throwError (MergeTransactionError e)
484− Right t -> pure t
485−
486− graph <- gfGraph
444+
487445 preference <- case strategy of
488446 UnionMergeStrategy -> pure PreferNeither
489447 UnionPreferMergeStrategy preferBranch ->
490448 case transactionForHead preferBranch graph of
491− Nothing -> throwError (MergeTransactionError (PreferredHeadMissingMergeError preferBranch))
449+ Nothing -> Left (PreferredHeadMissingMergeError preferBranch)
492450 Just preferredTrans -> pure $ if t1 == preferredTrans then PreferFirst else PreferSecond
493− badStrat -> throwError (MergeTransactionError (InvalidMergeStrategyError badStrat))
451+ badStrat -> Left (InvalidMergeStrategyError badStrat)
494452
495− incDeps <- liftMergeE $ unionMergeMaps preference (inclusionDependencies contextA) (inclusionDependencies contextB)
453+ incDeps <- unionMergeMaps preference (inclusionDependencies contextA) (inclusionDependencies contextB)
496454 relVars <- unionMergeRelVars preference (relationVariables contextA) (relationVariables contextB)
497− atomFuncs <- liftMergeE $ unionMergeAtomFunctions preference (atomFunctions contextA) (atomFunctions contextB)
498− notifs <- liftMergeE $ unionMergeMaps preference (notifications contextA) (notifications contextB)
499− types <- liftMergeE $ unionMergeTypeConstructorMapping preference (typeConstructorMapping contextA) (typeConstructorMapping contextB)
500− dbcFuncs <- liftMergeE $ unionMergeDatabaseContextFunctions preference (dbcFunctions contextA) (dbcFunctions contextB)
455+ atomFuncs <- unionMergeAtomFunctions preference (atomFunctions contextA) (atomFunctions contextB)
456+ notifs <- unionMergeMaps preference (notifications contextA) (notifications contextB)
457+ types <- unionMergeTypeConstructorMapping preference (typeConstructorMapping contextA) (typeConstructorMapping contextB)
458+ dbcFuncs <- unionMergeDatabaseContextFunctions preference (dbcFunctions contextA) (dbcFunctions contextB)
501459 -- TODO: add merge of subschemas
502460 let newContext = DatabaseContext {
503461 inclusionDependencies = incDeps,
@@ -508,12 +466,10 @@ createUnionMergeTransaction stamp' newId strategy (t1,t2) = do
508466 typeConstructorMapping = types
509467 }
510468 newSchemas = Schemas newContext (subschemas t1)
511− pure $ addMerkleHash graph $
512− Transaction newId (TransactionInfo {
513− parents = NE.fromList [transactionId t1,
514− transactionId t2],
515− stamp = stamp',
516− merkleHash = mempty }) newSchemas
469+ pure (Transaction newId (TransactionInfo {
470+ parents = NE.fromList [transactionId t1,
471+ transactionId t2],
472+ stamp = stamp'}) newSchemas)
517473
518474lookupTransaction :: TransactionGraph -> TransactionIdLookup -> Either RelationalError Transaction
519475lookupTransaction graph (TransactionIdLookup tid) = transactionForId tid graph
@@ -530,16 +486,15 @@ backtrackGraph :: TransactionGraph -> TransactionId -> TransactionIdHeadBacktrac
530486-- tilde, step back one parent link- if a choice must be made, choose the "first" link arbitrarily
531487backtrackGraph graph currentTid (TransactionIdHeadParentBacktrack steps) = do
532488 trans <- transactionForId currentTid graph
533−
534− let parentIds' = S.toAscList (parentIds trans)
535− case parentIds' of
536− [] -> Left RootTransactionTraversalError
537− firstParentId:_ -> do
538− parentTrans <- transactionForId firstParentId graph
539− if steps == 1 then
540− pure (transactionId parentTrans)
541− else
542− backtrackGraph graph (transactionId parentTrans) (TransactionIdHeadParentBacktrack (steps - 1))
489+ let parentIds' = S.toList (parentIds trans)
490+ if length parentIds' < 1 then
491+ Left RootTransactionTraversalError
492+ else do
493+ parentTrans <- transactionForId (head parentIds') graph
494+ if steps == 1 then
495+ pure (transactionId parentTrans)
496+ else
497+ backtrackGraph graph (transactionId parentTrans) (TransactionIdHeadParentBacktrack (steps - 1))
543498
544499backtrackGraph graph currentTid (TransactionIdHeadBranchBacktrack steps) = do
545500 trans <- transactionForId currentTid graph
@@ -589,47 +544,3 @@ autoMergeToHead stamp' (tempBranchTransId, tempCommitTransId, mergeTransId) disc
589544 pure (discon''''', graph''''')
590545
591546
592−addMerkleHash :: TransactionGraph -> Transaction -> Transaction
593−addMerkleHash graph trans = Transaction (transactionId trans) newInfo (schemas trans)
594− where
595− newInfo = (transactionInfo trans) { merkleHash = calculateMerkleHash trans graph }
596−
597−-- the new hash includes the parents' ids, the current id, and the hash of the context, and the merkle hashes of the parent transactions
598−calculateMerkleHash :: Transaction -> TransactionGraph -> MerkleHash
599−calculateMerkleHash trans graph = MerkleHash $ hashlazy (BL.fromChunks [transIds,
600− schemasBytes
601− ] <> dbcBytes <> parentMerkleHashes)
602− where
603− parentMerkleHashes = BL.fromChunks $ map (_unMerkleHash . getMerkleHash) parentTranses
604− parentTranses =
605− case transactionsForIds (parentIds trans) graph of
606− Left RootTransactionTraversalError -> []
607− Left e -> error ("failed to find transaction in Merkle hash construction: " ++ show e)
608− Right t -> S.toList t
609− getMerkleHash t = merkleHash (transactionInfo t)
610− transIds = serialise (transactionId trans : S.toList (parentIds trans))
611− dbcBytes = DBC.hashBytes (concreteDatabaseContext trans)
612− schemasBytes = serialise (subschemas trans)
613−
614−validateMerkleHash :: Transaction -> TransactionGraph -> Either MerkleValidationError ()
615−validateMerkleHash trans graph =
616− if expectedHash /= actualHash then
617− Left (MerkleValidationError (transactionId trans) expectedHash actualHash)
618− else
619− pure ()
620− where
621− expectedHash = merkleHash (transactionInfo trans)
622− actualHash = calculateMerkleHash trans graph
623−
624−data MerkleValidationError = MerkleValidationError TransactionId MerkleHash MerkleHash
625− deriving (Show, Eq, Generic)
626−
627−validateMerkleHashes :: TransactionGraph -> Either [MerkleValidationError] ()
628−validateMerkleHashes graph =
629− if null errs then pure () else Left errs
630− where
631− errs = S.foldr validateTrans [] (transactionsForGraph graph)
632− validateTrans trans acc =
633− case validateMerkleHash trans graph of
634− Left err -> err : acc
635− _ -> acc
src/lib/ProjectM36/TransactionGraph/Merge.hs+15−19
@@ -2,11 +2,10 @@
22module ProjectM36.TransactionGraph.Merge where
33import ProjectM36.Base
44import ProjectM36.Error
5−import ProjectM36.RelationalExpression
6−import Control.Monad.Except hiding (join)
75import qualified Data.Set as S
86import qualified Data.Map as M
97import qualified ProjectM36.TypeConstructorDef as TCD
8+import ProjectM36.Relation
109import Control.Monad (foldM)
1110import qualified Data.HashSet as HS
1211
@@ -23,23 +22,20 @@ unionMergeMaps prefer mapA mapB = case prefer of
2322 Left StrategyViolatesComponentMergeError
2423
2524-- perform the merge even if the attributes are different- is this what we want? Obviously, we need finer-grained merge options.
26−unionMergeRelation :: MergePreference -> GraphRefRelationalExpr -> GraphRefRelationalExpr -> GraphRefRelationalExprM GraphRefRelationalExpr
27−unionMergeRelation prefer relA relB = do
28− let unioned = Union relA relB
29− mergeErr = MergeTransactionError StrategyViolatesRelationVariableMergeError
30− preferredRelVar =
31− case prefer of
32− PreferFirst -> pure relA
33− PreferSecond -> pure relB
34− PreferNeither -> throwError mergeErr
35− handler AttributeNamesMismatchError{} = preferredRelVar
36− handler _err' = throwError mergeErr
37− --typecheck first?
38− (evalGraphRefRelationalExpr unioned >> pure (Union relA relB)) `catchError` handler
25+unionMergeRelation :: MergePreference -> Relation -> Relation -> Either MergeError Relation
26+unionMergeRelation prefer relA relB = case relA `union` relB of
27+ Right unionRel -> pure unionRel
28+ Left (AttributeNamesMismatchError _) -> preferredRelVar
29+ Left _ -> Left StrategyViolatesRelationVariableMergeError
30+ where
31+ preferredRelVar = case prefer of
32+ PreferFirst -> Right relA
33+ PreferSecond -> Right relB
34+ PreferNeither -> Left StrategyViolatesRelationVariableMergeError
3935
4036--try to execute unions against the relvars contents -- if a relvar only appears in one context, include it
41−unionMergeRelVars :: MergePreference -> RelationVariables -> RelationVariables -> GraphRefRelationalExprM RelationVariables
42−unionMergeRelVars prefer relvarsA relvarsB = do
37+unionMergeRelVars :: MergePreference -> RelationVariables -> RelationVariables -> Either MergeError RelationVariables
38+unionMergeRelVars _ relvarsA relvarsB = do
4339 let allNames = S.toList (S.union (M.keysSet relvarsA) (M.keysSet relvarsB))
4440 foldM (\acc name -> do
4541 mergedRel <- do
@@ -47,8 +43,8 @@ unionMergeRelVars prefer relvarsA relvarsB = do
4743 lookupA = findRel relvarsA
4844 lookupB = findRel relvarsB
4945 case (lookupA, lookupB) of
50− (Just relA, Just relB) ->
51− unionMergeRelation prefer relA relB
46+ (Just _, Just _) -> unimplemented
47+ --unionMergeRelation prefer relA relB
5248 (Nothing, Just relB) -> pure relB
5349 (Just relA, Nothing) -> pure relA
5450 (Nothing, Nothing) -> error "impossible relvar naming lookup"
src/lib/ProjectM36/TransactionGraph/Persist.hs+3−3
@@ -24,14 +24,14 @@ import Control.Exception.Base
2424import qualified Data.ByteString as BS
2525import qualified Data.Text.Encoding as TE
2626import Data.ByteString (ByteString)
27−#if __GLASGOW_HASKELL__ < 804
28−import Data.Monoid
29−#endif
3027import qualified Crypto.Hash.SHA256 as SHA256
3128import Control.Arrow
3229import Data.Time.Clock
3330import Data.Text.Read
3431import System.FilePath.Glob
32+#if __GLASGOW_HASKELL__ <= 802
33+import Data.Monoid
34+#endif
3535
3636type LockFileHash = ByteString
3737
src/lib/ProjectM36/TransactionInfo.hs+3−5
@@ -1,12 +1,10 @@
11module ProjectM36.TransactionInfo where
22import ProjectM36.Base
33import Data.Time.Clock
4−import qualified Data.List.NonEmpty as NE
4+import Data.List.NonEmpty
55
66-- | Create a TransactionInfo with just one parent transaction ID.
77singleParent :: TransactionId -> UTCTime -> TransactionInfo
88singleParent tid stamp' = TransactionInfo {
9− parents = tid NE.:| [],
10− stamp = stamp',
11− merkleHash = mempty }
12−
9+ parents = tid :| [],
10+ stamp = stamp' }
src/lib/ProjectM36/Tuple.hs+33−47
@@ -1,7 +1,7 @@
11module ProjectM36.Tuple where
22import ProjectM36.Base
33import ProjectM36.Error
4−import ProjectM36.Attribute as A
4+import ProjectM36.Attribute
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 mempty mempty
18+emptyTuple = RelationTuple V.empty V.empty
1919
2020tupleSize :: RelationTuple -> Int
21−tupleSize (RelationTuple tupAttrs _) = arity tupAttrs
21+tupleSize (RelationTuple tupAttrs _) = V.length tupAttrs
2222
2323tupleAttributeNameSet :: RelationTuple -> S.Set AttributeName
24−tupleAttributeNameSet (RelationTuple tupAttrs _) = attributeNameSet tupAttrs
24+tupleAttributeNameSet (RelationTuple tupAttrs _) = S.fromList $ V.toList $ V.map attributeName tupAttrs
2525
2626tupleAttributes :: RelationTuple -> Attributes
2727tupleAttributes (RelationTuple tupAttrs _) = tupAttrs
2828
2929tupleAssocs :: RelationTuple -> [(AttributeName, Atom)]
30−tupleAssocs (RelationTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)
30+tupleAssocs (RelationTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)
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) (attributesVec tupAttrs) of
45+atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) 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 (attributeNames attrs))
62+ mapper attrName = fromMaybe (error "logic failure in vectorIndicesForAttributeNames") (V.elemIndex attrName (V.map attributeName 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 (attributesFromList attrs) (V.map (attrMap M.!) (V.fromList attrNames))
89+mkRelationTupleFromMap attrMap = RelationTuple attrs (V.map (attrMap M.!) attrNames)
9090 where
91− attrNames = M.keys attrMap
92− attrs = map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames
91+ attrNames = V.fromList (M.keys attrMap)
92+ attrs = V.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` attributesVec tupAttrs1) (attributesVec tupAttrs2)
124− newVec = V.map (findAtomForAttributeName . attributeName) (attributesVec joinedAttrs)
123+ attrsIntersection = V.filter (`V.elem` tupAttrs1) tupAttrs2
124+ newVec = V.map (findAtomForAttributeName . attributeName) joinedAttrs
125125 --search both tuples for the attribute
126126 findAtomForAttributeName attrName = head $ rights $ fmap (atomForAttributeName attrName) [tup1, tup2]
127127
@@ -138,31 +138,23 @@ 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 <> tupAttrs2
142− newVec = tupVec1 <> tupVec2
141+ newAttrs = tupAttrs1 V.++ tupAttrs2
142+ newVec = tupVec1 V.++ tupVec2
143143
144144tupleAtomExtend :: AttributeName -> Atom -> RelationTuple -> RelationTuple
145145tupleAtomExtend newAttrName atom tupIn = tupleExtend tupIn newTup
146146 where
147− newTup = RelationTuple (A.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)
147+ newTup = RelationTuple (V.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)
148148
149−{-tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple
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
150151tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec
151152 where
152− deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) (attributesVec attrs)
153+ deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) attrs
153154 indexDeleter = V.ifilter (\index _ -> V.notElem index deleteIndices)
154− newAttrs = case A.projectionAttributesForNames projectAttrs attrs of
155− Left err -> error (show (err, projectAttrs, attrs))
156− Right attrs' -> attrs'
155+ newAttrs = indexDeleter attrs
157156 newTupVec = indexDeleter tupVec
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)
157+
166158--return the attributes and atoms which are equal in both vectors
167159--semi-join
168160tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple
@@ -170,14 +162,12 @@ tupleIntersection tuple1 tuple2 = RelationTuple newAttrs newTupVec
170162 where
171163 attrs1 = tupleAttributes tuple1
172164 attrs2 = tupleAttributes tuple2
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)
165+ matchingIndices = V.findIndices (\attr -> V.elem attr attrs2 &&
166+ atomForAttributeName (attributeName attr) tuple1 ==
167+ atomForAttributeName (attributeName attr) tuple2
168+ ) attrs1
177169 indexFilter = V.ifilter (\index _ -> V.elem index matchingIndices)
178− newAttrs = case A.projectionAttributesForNames (A.attributeNameSet intersectAttrs) attrs1 of
179− Left _ -> mempty
180− Right attrs' -> attrs'
170+ newAttrs = indexFilter attrs1
181171 newTupVec = indexFilter (tupleAtoms tuple1)
182172
183173-- | An optimized form of tuple update which updates vectors efficiently.
@@ -185,20 +175,19 @@ updateTupleWithAtoms :: M.Map AttributeName Atom -> RelationTuple -> RelationTup
185175updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec
186176 where
187177 updateKeysSet = M.keysSet updateMap
188− updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed (attributesVec attrs))
178+ updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed attrs)
189179 newVec = V.update tupVec updateVec
190180 updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec
191181
192182tupleToMap :: RelationTuple -> M.Map AttributeName Atom
193183tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList
194184 where
195− assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed (attributesVec attrs))
185+ assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed attrs)
196186
197−-- | Validate that the tuple has the correct attributes in the correct order
198187verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple
199−verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs
188+verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs
200189 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in
201− if A.arity attrs /= V.length tupleTypes then
190+ if V.length attrs /= V.length tupleTypes then
202191 Left $ TupleAttributeCountMismatchError 0
203192 else do
204193 mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)
@@ -207,18 +196,15 @@ verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs
207196--two tuples can be equal but the vectors of attributes could be out-of-order
208197--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering
209198reorderTuple :: Attributes -> RelationTuple -> RelationTuple
210−reorderTuple attrs tupIn = if attributesAndOrderEqual (tupleAttributes tupIn) attrs then
199+reorderTuple attrs tupIn = if tupleAttributes tupIn == attrs then
211200 tupIn
212201 else
213− RelationTuple attrs (V.map mapper (attributesVec attrs))
202+ RelationTuple attrs (V.map mapper attrs)
214203 where
215204 mapper attr = case atomForAttributeName (attributeName attr) tupIn of
216− Left err -> error ("logic bug in reorderTuple: " ++ show err <> show tupIn)
205+ Left err -> error ("logic bug in reorderTuple: " ++ show err)
217206 Right atom -> atom
218207
219208--used in Generics derivation for ADTs without named attributes
220209trimTuple :: Int -> RelationTuple -> RelationTuple
221−trimTuple index (RelationTuple attrs vals) =
222− RelationTuple newAttrs (V.drop index vals)
223− where
224− newAttrs = A.drop index attrs
210+trimTuple index (RelationTuple attrs vals) = RelationTuple (V.drop index attrs) (V.drop index vals)
src/lib/ProjectM36/TupleSet.hs−7
@@ -31,10 +31,3 @@ 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+36−113
@@ -4,47 +4,28 @@
44{-# LANGUAGE ScopedTypeVariables #-}
55{-# LANGUAGE TypeOperators #-}
66{-# LANGUAGE UndecidableInstances #-}
7−{-# LANGUAGE CPP #-}
8−
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
7+
8+module ProjectM36.Tupleable where
299
3010import Data.Foldable
3111import Data.List (partition)
3212import qualified Data.Map as Map
33−#if __GLASGOW_HASKELL__ < 804
34−import Data.Monoid
35−#endif
13+--import Data.Monoid
3614import Data.Proxy
3715import qualified Data.Text as T
3816import qualified Data.Vector as V
3917import GHC.Generics
4018import ProjectM36.Atomable
41−import ProjectM36.Attribute as A hiding (null, toList)
19+import ProjectM36.Attribute hiding (null)
4220import ProjectM36.Base
4321import ProjectM36.DataTypes.Primitive
4422import ProjectM36.Error
4523import ProjectM36.Tuple
4624import ProjectM36.TupleSet
4725import qualified Data.Set as S
26+#if __GLASGOW_HASKELL__ <= 802
27+import Data.Monoid
28+#endif
4829
4930{-import Data.Binary
5031import Control.DeepSeq
@@ -89,7 +70,7 @@ toInsertExpr vals rvName = do
8970
9071-- | 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'.
9172toDefineExpr :: forall a proxy. Tupleable a => proxy a -> RelVarName -> DatabaseContextExpr
92−toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList (attributesVec attrs)))
73+toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList attrs))
9374 where
9475 attrs = toAttributes (Proxy :: Proxy a)
9576
@@ -140,110 +121,56 @@ validateAttributes actualAttrs expectedAttrs val
140121 where
141122 nonMatchingAttrs = attributeNamesNotContained actualAttrs expectedAttrs
142123
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
124+
164125class Tupleable a where
165126 toTuple :: a -> RelationTuple
166127
167128 fromTuple :: RelationTuple -> Either RelationalError a
168129
169− toAttributes :: Proxy a -> Attributes
130+ toAttributes :: proxy a -> Attributes
170131
171132 default toTuple :: (Generic a, TupleableG (Rep a)) => a -> RelationTuple
172− toTuple = genericToTuple defaultTupleableOptions
133+ toTuple v = toTupleG (from v)
173134
174135 default fromTuple :: (Generic a, TupleableG (Rep a)) => RelationTuple -> Either RelationalError a
175− fromTuple = genericFromTuple defaultTupleableOptions
176−
177− default toAttributes :: (Generic a, TupleableG (Rep a)) => Proxy a -> Attributes
178− toAttributes = genericToAttributes defaultTupleableOptions
179−
180−-- | Options that influence deriving behavior.
181−newtype TupleableOptions = TupleableOptions {
182− -- | A function that translates record field names into attribute names.
183− fieldModifier :: T.Text -> T.Text
184− }
185−
186−-- | The default options for deriving Tupleable instances.
187−--
188−-- These options can be customized by using record update syntax. For example,
189−--
190−-- > defaultTupleableOptions
191−-- > { fieldModifier = \fieldName ->
192−-- > case Data.Text.stripPrefix "example" fieldName of
193−-- > Nothing -> fieldName
194−-- > Just attributeName -> attributeName
195−-- > }
196−--
197−-- will result in record field names being translated into attribute names by
198−-- removing the prefix "example" from the field names.
199−defaultTupleableOptions :: TupleableOptions
200−defaultTupleableOptions = TupleableOptions {
201− fieldModifier = id
202− }
203−
204−genericToTuple :: (Generic a, TupleableG (Rep a)) => TupleableOptions -> a -> RelationTuple
205−genericToTuple opts v = toTupleG opts (from v)
206−
207−genericFromTuple :: (Generic a, TupleableG (Rep a)) => TupleableOptions -> RelationTuple -> Either RelationalError a
208−genericFromTuple opts tup = to <$> fromTupleG opts tup
136+ fromTuple tup = to <$> fromTupleG tup
209137
210−genericToAttributes :: forall a. (Generic a, TupleableG (Rep a)) => TupleableOptions -> Proxy a -> Attributes
211−genericToAttributes opts _ = toAttributesG opts (from (undefined :: a))
138+ default toAttributes :: (Generic a, TupleableG (Rep a)) => proxy a -> Attributes
139+ toAttributes _ = toAttributesG (from (undefined :: a))
212140
213141class TupleableG g where
214− toTupleG :: TupleableOptions -> g a -> RelationTuple
215− toAttributesG :: TupleableOptions -> g a -> Attributes
216− fromTupleG :: TupleableOptions -> RelationTuple -> Either RelationalError (g a)
142+ toTupleG :: g a -> RelationTuple
143+ toAttributesG :: g a -> Attributes
144+ fromTupleG :: RelationTuple -> Either RelationalError (g a)
217145 isRecordTypeG :: g a -> Bool
218146
219147--data type metadata
220148instance (Datatype c, TupleableG a) => TupleableG (M1 D c a) where
221− toTupleG opts (M1 v) = toTupleG opts v
222− toAttributesG opts (M1 v) = toAttributesG opts v
223− fromTupleG opts v = M1 <$> fromTupleG opts v
149+ toTupleG (M1 v) = toTupleG v
150+ toAttributesG (M1 v) = toAttributesG v
151+ fromTupleG v = M1 <$> fromTupleG v
224152 isRecordTypeG (M1 v) = isRecordTypeG v
225153
226154--constructor metadata
227155instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) where
228− toTupleG opts (M1 v) = RelationTuple attrs atoms
156+ toTupleG (M1 v) = RelationTuple attrs atoms
229157 where
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
158+ attrsToCheck = toAttributesG v
159+ counter = V.generate (V.length attrsToCheck) id
160+ attrs = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then
234161 Attribute ("attr" <> T.pack (show (num + 1))) typ
235162 else
236− attr) counter (attributesVec attrsToCheck)
163+ attr) counter attrsToCheck
237164 atoms = V.fromList (toAtomsG v)
238− toAttributesG opts (M1 v) = toAttributesG opts v
239− fromTupleG opts tup = M1 <$> fromTupleG opts tup
165+ toAttributesG (M1 v) = toAttributesG v
166+ fromTupleG tup = M1 <$> fromTupleG tup
240167 isRecordTypeG (M1 v) = isRecordTypeG v
241168
242169-- product types
243170instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where
244171 toTupleG = error "toTupleG"
245− toAttributesG opts ~(x :*: y) = toAttributesG opts x <> toAttributesG opts y --a bit of extra laziness prevents whnf so that we can use toAttributes (undefined :: Test2T Int Int) without throwing an exception
246− fromTupleG opts tup = (:*:) <$> fromTupleG opts tup <*> fromTupleG opts processedTuple
172+ toAttributesG ~(x :*: y) = toAttributesG x V.++ toAttributesG y --a bit of extra laziness prevents whnf so that we can use toAttributes (undefined :: Test2T Int Int) without throwing an exception
173+ fromTupleG tup = (:*:) <$> fromTupleG tup <*> fromTupleG processedTuple
247174 where
248175 processedTuple = if isRecordTypeG (undefined :: a x) then
249176 tup
@@ -254,22 +181,18 @@ instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where
254181--selector/record
255182instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where
256183 toTupleG = error "toTupleG"
257− toAttributesG opts m@(M1 v) = A.singleton (Attribute modifiedName aType)
184+ toAttributesG m@(M1 v) = V.singleton (Attribute name aType)
258185 where
259186 name = T.pack (selName m)
260− modifiedName = if T.null name then
261− name
262− else
263− fieldModifier opts name
264187 aType = toAtomTypeG v
265− fromTupleG opts tup = if null name then -- non-record type, just pull off the first tuple item
188+ fromTupleG tup = if null name then -- non-record type, just pull off the first tuple item
266189 M1 <$> atomv (V.head (tupleAtoms tup))
267190 else do
268− atom <- atomForAttributeName (fieldModifier opts (T.pack name)) tup
191+ atom <- atomForAttributeName (T.pack name) tup
269192 val <- atomv atom
270193 pure (M1 val)
271194 where
272− expectedAtomType = atomType (V.head (attributesVec (toAttributesG opts (undefined :: M1 S c a x))))
195+ expectedAtomType = atomType (V.head (toAttributesG (undefined :: M1 S c a x)))
273196 atomv atom = maybe (Left (AtomTypeMismatchError
274197 expectedAtomType
275198 (atomTypeForAtom atom)
@@ -280,8 +203,8 @@ instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where
280203--constructors with no arguments
281204--basically useless but orthoganal to relationTrue
282205instance TupleableG U1 where
283− toTupleG _ _ = emptyTuple
284− toAttributesG _ _ = emptyAttributes
285− fromTupleG _ _ = pure U1
206+ toTupleG _= emptyTuple
207+ toAttributesG _ = emptyAttributes
208+ fromTupleG _ = pure U1
286209 isRecordTypeG _ = False
287210
src/lib/ProjectM36/Tupleable/Deriving.hsdeleted−229
@@ -1,229 +0,0 @@
1−{-# LANGUAGE ScopedTypeVariables #-}
2−{-# LANGUAGE TypeOperators #-}
3−{-# LANGUAGE KindSignatures #-}
4−{-# LANGUAGE DataKinds #-}
5−{-# LANGUAGE FlexibleContexts #-}
6−{-# LANGUAGE UndecidableInstances #-}
7−
8−-- | Newtypes for deriving Tupleable instances with customization using
9−-- @DerivingVia@.
10−--
11−-- Inspired by
12−-- [Dhall.Deriving](https://hackage.haskell.org/package/dhall-1.33.1/docs/Dhall-Deriving.html)
13−-- which in turn was inspired by Matt Parson's blog post
14−-- [Mirror Mirror: Reflection and Encoding Via](https://www.parsonsmatt.org/2020/02/04/mirror_mirror.html).
15−--
16−-- required extensions:
17−--
18−-- * DerivingVia
19−-- * DeriveGenerics
20−-- * TypeOperators (for @('<<<')@ and @('>>>')@)
21−-- * DataKinds (for types that take a string argument)
22−
23−module ProjectM36.Tupleable.Deriving
24− ( -- * DerivingVia Newtype
25− Codec(..)
26−
27− -- * Type-level Options
28− , ModifyOptions(..)
29− , Field
30−
31− -- * Type-level 'T.Text' -> 'T.Text' Functions
32− , ModifyText(..)
33− , AddPrefix
34− , DropPrefix
35− , AddSuffix
36− , DropSuffix
37− , UpperCase
38− , LowerCase
39− , TitleCase
40− , CamelCase
41− , PascalCase
42− , SnakeCase
43− , SpinalCase
44− , TrainCase
45−
46− -- * Composition
47− , AsIs
48− , type (<<<)
49− , type (>>>)
50−
51− -- * Re-Exports
52− , Generic
53− , module ProjectM36.Tupleable
54− ) where
55−import Data.Maybe (fromMaybe)
56−import Data.Proxy
57−import qualified Data.Text as T
58−import Data.Text.Manipulate
59−import GHC.TypeLits
60−import GHC.Generics (Generic, Rep)
61−import ProjectM36.Tupleable
62−
63−
64−-- | A newtype wrapper to allow for easier deriving of 'Tupleable' instances
65−-- with customization.
66−--
67−-- The @tag@ type variable can be used to specify options for converting the
68−-- datatype to and from a 'RelationTuple'. For example,
69−--
70−-- > data Example = Example
71−-- > { exampleFoo :: Int
72−-- > , exampleBar :: Int
73−-- > }
74−-- > deriving stock (Generic)
75−-- > deriving (Tupleable)
76−-- > via Codec (Field (DropPrefix "example" >>> CamelCase)) Example
77−--
78−-- will derive an instance of 'Tupleable' where field names are translated into
79−-- attribute names by dropping the prefix @"example"@ and then converting the
80−-- result to camelCase. So @"exampleFoo"@ becomes @"foo"@ and @"exampleBar"@
81−-- becomes @"bar"@.
82−--
83−-- Requires the @DerivingGeneric@ and @DerivingVia@ extensions to be enabled.
84−newtype Codec tag a = Codec { unCodec :: a }
85−
86−instance (ModifyOptions tag, Generic a, TupleableG (Rep a)) => Tupleable (Codec tag a) where
87− toTuple v = genericToTuple opts (unCodec v)
88− where
89− opts = modifyOptions (Proxy :: Proxy tag) defaultTupleableOptions
90−
91− fromTuple tup = Codec <$> genericFromTuple opts tup
92− where
93− opts = modifyOptions (Proxy :: Proxy tag) defaultTupleableOptions
94−
95− toAttributes _ = genericToAttributes opts (Proxy :: Proxy a)
96− where
97− opts = modifyOptions (Proxy :: Proxy tag) defaultTupleableOptions
98−
99−-- | Types that can be used as tags for 'Codec'.
100−class ModifyOptions a where
101− modifyOptions :: proxy a -> TupleableOptions -> TupleableOptions
102−
103−-- | Change how record field names are translated into attribute names. For
104−-- example,
105−--
106−-- > Field SnakeCase
107−--
108−-- will translate the field name @fooBar@ into the attribute name @foo_bar@.
109−data Field a
110−
111−instance ModifyText a => ModifyOptions (Field a) where
112− modifyOptions _ opts = opts { fieldModifier = newFieldModifier }
113− where
114− newFieldModifier = modifyText (Proxy :: Proxy a) . fieldModifier opts
115−
116−-- | Types that can be used in options that modify 'T.Text' such as in 'Field'.
117−class ModifyText a where
118− modifyText :: proxy a -> T.Text -> T.Text
119−
120−-- | Add a prefix. @AddPrefix "foo"@ will transform @"bar"@ into @"foobar"@.
121−data AddPrefix (prefix :: Symbol)
122−
123−instance KnownSymbol prefix => ModifyText (AddPrefix prefix) where
124− modifyText _ oldText = prefixText <> oldText
125− where
126− prefixText = T.pack (symbolVal (Proxy :: Proxy prefix))
127−
128−-- | Drop a prefix. @DropPrefix "bar"@ will transform @"foobar"@ into @"foo"@.
129−data DropPrefix (prefix :: Symbol)
130−
131−instance KnownSymbol prefix => ModifyText (DropPrefix prefix) where
132− modifyText _ oldText = fromMaybe oldText (T.stripPrefix prefixText oldText)
133− where
134− prefixText = T.pack (symbolVal (Proxy :: Proxy prefix))
135−
136−-- | Add a suffix. @AddSuffix "bar"@ will transform @"foo"@ into @"foobar"@.
137−data AddSuffix (suffix :: Symbol)
138−
139−instance KnownSymbol suffix => ModifyText (AddSuffix suffix) where
140− modifyText _ oldText = oldText <> suffixText
141− where
142− suffixText = T.pack (symbolVal (Proxy :: Proxy suffix))
143−
144−-- | Drop a suffix. @DropSuffix "bar"@ will transform @"foobar"@ into @"foo"@.
145−data DropSuffix (suffix :: Symbol)
146−
147−instance KnownSymbol suffix => ModifyText (DropSuffix suffix) where
148− modifyText _ oldText = fromMaybe oldText (T.stripSuffix suffixText oldText)
149− where
150− suffixText = T.pack (symbolVal (Proxy :: Proxy suffix))
151−
152−-- | Convert to UPPERCASE. Will transform @"foobar"@ into @\"FOOBAR\"@.
153−data UpperCase
154−
155−instance ModifyText UpperCase where
156− modifyText _ = T.toUpper
157−
158−-- | Convert to lowercase. Will transform @\"FOOBAR\"@ into @"foobar"@.
159−data LowerCase
160−
161−instance ModifyText LowerCase where
162− modifyText _ = T.toLower
163−
164−-- | Convert to Title Case. Will transform @"fooBar"@ into @\"Foo Bar\"@.
165−data TitleCase
166−
167−instance ModifyText TitleCase where
168− modifyText _ = toTitle
169−
170−-- | Convert to camelCase. Will transform @"foo_bar"@ into @"fooBar"@.
171−data CamelCase
172−
173−instance ModifyText CamelCase where
174− modifyText _ = toCamel
175−
176−-- | Convert to PascalCase. Will transform @"foo_bar"@ into @\"FooBar\"@.
177−data PascalCase
178−
179−instance ModifyText PascalCase where
180− modifyText _ = toPascal
181−
182−-- | Convert to snake_case. Will transform @"fooBar"@ into @"foo_bar"@.
183−data SnakeCase
184−
185−instance ModifyText SnakeCase where
186− modifyText _ = toSnake
187−
188−-- | Convert to spinal-case. will transform @"fooBar"@ into @"foo-bar"@.
189−data SpinalCase
190−
191−instance ModifyText SpinalCase where
192− modifyText _ = toSpinal
193−
194−-- | Convert to Train-Case. Will transform @"fooBar"@ into @\"Foo-Bar\"@.
195−data TrainCase
196−
197−instance ModifyText TrainCase where
198− modifyText _ = toTrain
199−
200−-- | Identity option.
201−type AsIs = ()
202−
203−instance ModifyOptions () where
204− modifyOptions _ = id
205−
206−instance ModifyText () where
207− modifyText _ = id
208−
209−-- | Right to left composition.
210−--
211−-- Requires the @TypeOperators@ extension to be enabled.
212−data a <<< b
213−
214−instance (ModifyOptions a, ModifyOptions b) => ModifyOptions (a <<< b) where
215− modifyOptions _ = modifyOptions (Proxy :: Proxy a) . modifyOptions (Proxy :: Proxy b)
216−
217−instance (ModifyText a, ModifyText b) => ModifyText (a <<< b) where
218− modifyText _ = modifyText (Proxy :: Proxy a) . modifyText (Proxy :: Proxy b)
219−
220−-- | Left to right composition.
221−--
222−-- Requires the @TypeOperators@ extension to be enabled.
223−data a >>> b
224−
225−instance (ModifyOptions a, ModifyOptions b) => ModifyOptions (a >>> b) where
226− modifyOptions _ = modifyOptions (Proxy :: Proxy b) . modifyOptions (Proxy :: Proxy a)
227−
228−instance (ModifyText a, ModifyText b) => ModifyText (a >>> b) where
229− modifyText _ = modifyText (Proxy :: Proxy b) . modifyText (Proxy :: Proxy a)
src/lib/ProjectM36/WithNameExpr.hs+3−5
@@ -17,7 +17,7 @@ substituteWithNameMacros macros e@(RelationVariable rvname tid) =
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,11 +42,9 @@ 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 update nested with exprs
45+ --collect and override existing macros and recurse
4646 let newMacros = foldr macroFolder macros moreMacros
47− macroFolder (wnexpr, mexpr) acc =
48− let subExpr = substituteWithNameMacros macros mexpr in
49− filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, subExpr)] in
47+ macroFolder (wnexpr, mexpr) acc = filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, mexpr)] in
5048 --scan for a match- if it exists, replace it (representing a with clause at a lower level
5149 substituteWithNameMacros newMacros expr
5250
stack.ghc8.0.yamlnew file+50
@@ -0,0 +1,50 @@
1+# This file was automatically generated by stack init
2+# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/
3+
4+# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)
5+resolver: lts-8.5
6+
7+# Local packages, usually specified by relative directory name
8+packages:
9+- '.'
10+# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
11+extra-deps:
12+- data-accessor-transformers-0.2.1.7
13+- data-interval-1.2.0
14+- extended-reals-0.2.1.0
15+- gnuplot-0.5.4.1
16+- text-1.2.2.1
17+- aeson-1.2.1.00
18+- distributed-process-0.6.6
19+- distributed-process-async-0.2.4
20+- distributed-process-client-server-0.2.3
21+- distributed-process-extras-0.3.2
22+- deferred-folds-0.6.12
23+- rset-1.0.0
24+
25+# Override default flag values for local packages and extra-deps
26+flags: {}
27+
28+# Extra package databases containing global packages
29+extra-package-dbs: []
30+
31+# Control whether we use the GHC we find on the path
32+# system-ghc: true
33+
34+# Require a specific version of stack, using version ranges
35+# require-stack-version: -any # Default
36+# require-stack-version: >= 1.0.0
37+
38+# Override the architecture used by stack, especially useful on Windows
39+# arch: i386
40+# arch: x86_64
41+
42+# Extra directories used by stack for building
43+# extra-include-dirs: [/path/to/dir]
44+# extra-lib-dirs: [/path/to/dir]
45+
46+# Allow a newer minor version of GHC than the snapshot specifies
47+# compiler-check: newer-minor
48+
49+allow-newer: true
50+
stack.ghc8.10.yamldeleted−19
@@ -1,19 +0,0 @@
1−resolver: lts-17.13
2−packages:
3− - "."
4−
5−extra-deps:
6− - git: https://github.com/agentm/curryer.git
7− commit: 74ecaac619ad1165a4517d5c0f4e530493bda130
8− - git: https://github.com/composewell/streamly.git
9− commit: ac3af8749194f1788704dda8667d0b3807075cc2
10− - fast-builder-0.1.2.1
11− - rset-1.0.0
12− - winery-1.3.2
13− - barbies-th-0.1.8
14− - base16-bytestring-1.0.1.0
15−
16−flags:
17− project-m36:
18− stack: true
19−# allow-newer: true
stack.ghc8.8.yaml → stack.ghc8.2.yamlrenamed+15−26
@@ -2,39 +2,27 @@
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-16.4
5+resolver: lts-11.20
66
77# Local packages, usually specified by relative directory name
88packages:
9− - "."
9+- '.'
1010# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
1111extra-deps:
12− - git: https://github.com/agentm/curryer.git
13− commit: 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
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
3523
3624# Override default flag values for local packages and extra-deps
37−flags:
25+flags:
3826 project-m36:
3927 stack: true
4028
@@ -60,3 +48,4 @@ extra-package-dbs: []
6048# compiler-check: newer-minor
6149
6250allow-newer: true
51+
stack.ghc8.6.yaml → stack.ghc8.4.yamlrenamed+17−26
@@ -2,39 +2,29 @@
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.27
5+resolver: lts-12.11
66
77# Local packages, usually specified by relative directory name
88packages:
9− - "."
9+- '.'
1010# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)
1111extra-deps:
12− - git: https://github.com/agentm/curryer.git
13− commit: 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
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.5.3
16+- aeson-1.2.1.00
17+- distributed-process-0.7.4
18+- distributed-process-async-0.2.4.1
19+- distributed-process-client-server-0.2.3
20+- distributed-process-extras-0.3.2
21+#- deferred-folds-0.9.7.1
22+- rset-1.0.0
23+- hashable-time-0.2.0.2
24+- network-transport-tcp-0.6.0
3525
3626# Override default flag values for local packages and extra-deps
37−flags:
27+flags:
3828 project-m36:
3929 stack: true
4030
@@ -60,3 +50,4 @@ extra-package-dbs: []
6050# compiler-check: newer-minor
6151
6252allow-newer: true
53+
test/Client/Simple.hs+2−1
@@ -9,6 +9,7 @@ import System.IO.Temp
99import System.FilePath
1010import ProjectM36.TupleSet
1111import ProjectM36.Attribute
12+import qualified Data.Vector as V
1213import qualified Data.Map as M
1314
1415main :: IO ()
@@ -58,7 +59,7 @@ testSimpleCommitFailure = TestCase $ do
5859 execute $ Assign "x" (ExistingRelation relationTrue)
5960 --cause error
6061 execute $ Assign "x" (MakeStaticRelation failAttrs emptyTupleSet)
61− let expectedErr = Left (RelError (RelationTypeMismatchError mempty failAttrs))
62+ let expectedErr = Left (RelError (RelationTypeMismatchError V.empty failAttrs))
6263 assertEqual "dbc error" expectedErr err
6364
6465-- #176 default merge couldn't handle Update
test/IsomorphicSchema.hs+3−1
@@ -13,7 +13,7 @@ import qualified Data.Map as M
1313import qualified Data.Set as S
1414
1515testList :: Test
16−testList = TestList [testIsoRename, testIsoRestrict, testIsoUnion, testSchemaValidation]
16+testList = TestList [testIsoRename, testIsoRestrict]--, testIsoUnion, testSchemaValidation]
1717
1818main :: IO ()
1919main = do
@@ -77,6 +77,7 @@ testIsoRestrict = TestCase $ do
7777 let predicate = AttributeEqualityPredicate "boss" (NakedAtomExpr (TextAtom ""))
7878 reenv = mkRelationalExprEnv DBC.empty graph
7979 bossRel <- assertEither $ runRelationalExprM reenv (evalRelationalExpr (Restrict predicate (ExistingRelation emprel)))
80+ print "spam1"
8081 nonBossRel <- assertEither $ runRelationalExprM reenv (evalRelationalExpr (Restrict (NotPredicate predicate) (ExistingRelation emprel)))
8182
8283 let schemaA = mkRelationalExprEnv baseContext graph
@@ -93,6 +94,7 @@ testIsoRestrict = TestCase $ do
9394 let empResult = evalRelExpr (evalRelationalExpr empExpr)
9495 unionResult = evalRelExpr (evalRelationalExpr unionq)
9596 evalRelExpr = runRelationalExprM schemaA
97+ print "spam2"
9698 assertEqual "boss/nonboss isorestrict" unionResult empResult
9799 --execute database context expr
98100 bobRel <- assertEither (mkRelationFromList empattrs [[TextAtom "Bob", TextAtom ""]])
test/Relation/Atomable.hs+20−52
@@ -1,7 +1,8 @@
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, DerivingVia #-}
2+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings #-}
33import Test.HUnit
44import ProjectM36.Client
5+import Data.Binary
56import Control.DeepSeq
67import System.Exit
78import TutorialD.Interpreter.TestBase
@@ -12,65 +13,47 @@ import Data.Time.Calendar (fromGregorian)
1213import Data.Text
1314import qualified Data.Map as M
1415import 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, NFData, Atomable)
20− deriving Serialise via WineryVariant Test1T
19+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)
2120
2221data Test2T x = Test2C x
23− deriving (Show, Generic, Eq, NFData, Atomable)
24− deriving Serialise via WineryVariant (Test2T x)
22+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)
2523
2624data Test3T = Test3C Integer Integer
27− deriving (Show, Generic, Eq, NFData, Atomable)
28− deriving Serialise via WineryVariant Test3T
25+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)
2926
3027data Test4T = Test4Ca Integer |
3128 Test4Cb Integer
32− deriving (Show, Generic, Eq, NFData, Atomable)
33− deriving Serialise via WineryVariant Test4T
29+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)
3430
3531data TestListT = TestListC [Integer]
36− deriving (Show, Generic, Eq, NFData, Atomable)
37− deriving Serialise via WineryVariant TestListT
32+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)
3833
3934data TestNonEmptyT = TestNonEmptyC [Integer]
40− deriving (Show, Generic, Eq, NFData, Atomable)
41− deriving Serialise via WineryVariant TestNonEmptyT
35+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)
4236
4337data Test5T = Test5C {
4438 con1 :: Integer,
4539 con2 :: Integer
46− } deriving (Show, Generic, Eq, NFData, Atomable)
47− deriving Serialise via WineryRecord Test5T
40+ } deriving (Show, Generic, Eq, Binary, NFData, Atomable)
4841
4942data Test6T = Test6C (Maybe Integer)
50− deriving (Show, Generic, Eq, NFData, Atomable)
51− deriving Serialise via WineryVariant Test6T
43+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)
5244
5345data Test7T = Test7C (Either Integer Integer)
54− deriving (Show, Generic, Eq, NFData, Atomable)
55− deriving Serialise via WineryVariant Test7T
46+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)
5647
5748data Test8T = Test8C Test1T
58− deriving (Show, Generic, Eq, NFData, Atomable)
59− deriving Serialise via WineryVariant Test8T
60−
61−data User = User
62− { userFirstName :: Text
63− , userLastName :: Text
64− } deriving (Eq, Ord, Show, Generic, NFData, Atomable)
65− deriving Serialise via WineryRecord User
49+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)
6650
6751data Test9_4T = Test9_4C {
6852 f9_41 :: Int,
6953 f9_42 :: Int,
7054 f9_43 :: Int,
7155 f9_44 :: Int }
72− deriving (Show, Generic, Eq, NFData, Atomable)
73− deriving Serialise via WineryRecord Test9_4T
56+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)
7457
7558data Test9_5T = Test9_5C {
7659 f9_51 :: Int,
@@ -79,16 +62,17 @@ data Test9_5T = Test9_5C {
7962 f9_54 :: Int,
8063 f9_55 :: Int
8164 }
82− deriving (Show, Generic, Eq, NFData, Atomable)
83− deriving Serialise via WineryRecord Test9_5T
65+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)
8466
67+
8568main :: IO ()
8669main = do
8770 tcounts <- runTestTT testList
8871 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
8972
9073testList :: Test
91−testList = TestList [testHaskell2DB, testADT1, testADT2, testADT3, testADT4, testADT5, testBasicMarshaling, testSimpleList, testListInstance, testNonEmptyInstance, testADT6Maybe, testADT7Either, testNonPrimitiveValues, testRecordType, testManyFields]
74+testList = TestList [testHaskell2DB, testADT1, testADT2, testADT3, testADT4, testADT5, testBasicMarshaling, testListInstance, testNonEmptyInstance, testADT6Maybe, testADT7Either, testNonPrimitiveValues]
75+
9276
9377-- test some basic data types like int, day, etc.
9478testBasicMarshaling :: Test
@@ -117,7 +101,7 @@ testHaskell2DB = TestCase $ do
117101 let createRelExpr = Assign "x" rel
118102
119103 rel = MakeRelationFromExprs Nothing
120− (TupleExprs () [TupleExpr (M.singleton "a1" (NakedAtomExpr atomVal))])
104+ [TupleExpr (M.singleton "a1" (NakedAtomExpr atomVal))]
121105 atomVal = toAtom exampleVal
122106 exampleVal = Test1C 10
123107 checkExecuteDatabaseContextExpr sessionId dbconn createRelExpr
@@ -173,12 +157,6 @@ testListInstance = TestCase $ do
173157 let example = TestListC [3,4,5]
174158 assertEqual "List instance" example (fromAtom (toAtom example))
175159
176−testSimpleList :: Test
177−testSimpleList = TestCase $ do
178− let example = toAtom @[Integer] [1,2,3]
179− expected = ConstructedAtom "Cons" (ConstructedAtomType "List" (M.fromList [("a",IntegerAtomType)])) [IntegerAtom 1,ConstructedAtom "Cons" (ConstructedAtomType "List" (M.fromList [("a",IntegerAtomType)])) [IntegerAtom 2,ConstructedAtom "Cons" (ConstructedAtomType "List" (M.fromList [("a",IntegerAtomType)])) [IntegerAtom 3,ConstructedAtom "Empty" (ConstructedAtomType "List" (M.fromList [("a",IntegerAtomType)])) []]]]
180− assertEqual "simple list" expected example
181−
182160testNonEmptyInstance :: Test
183161testNonEmptyInstance = TestCase $ do
184162 let example = TestNonEmptyC [3,4,5]
@@ -189,21 +167,11 @@ testNonPrimitiveValues = TestCase $ do
189167 let example = Test8C (Test1C 3)
190168 assertEqual "non-primitive values" example (fromAtom (toAtom example))
191169
192−testRecordType :: Test
193−testRecordType = TestCase $ do
194− let example = User { userFirstName = "Bob"
195− ,userLastName = "Smith"
196− }
197− assertEqual "User record" example (fromAtom (toAtom example))
198− let expected = AddTypeConstructor (ADTypeConstructorDef "User" []) [DataConstructorDef "User" [DataConstructorDefTypeConstructorArg (PrimitiveTypeConstructor "Text" TextAtomType),DataConstructorDefTypeConstructorArg (PrimitiveTypeConstructor "Text" TextAtomType)]]
199−
200− assertEqual "User record to database context expr" expected (toAddTypeExpr (Proxy :: Proxy User))
201−
202170--test both odd and even product types with more than 2 fields
203171testManyFields :: Test
204172testManyFields = TestCase $ do
205− let example4 = Test9_4C 1 2 3 4
173+ let example4 = Test9_4T 1 2 3 4
206174 assertEqual "four fields product type" example4 (fromAtom (toAtom example4))
207175
208− let example5 = Test9_5C 1 2 3 4 5
176+ let example5 = Test9_5T 1 2 3 4 5
209177 assertEqual "five fields product type" example5 (fromAtom (toAtom example5))
test/Relation/Basic.hs+14−15
@@ -3,6 +3,8 @@ import ProjectM36.Base
33import ProjectM36.Relation
44import ProjectM36.Error
55import ProjectM36.DateExamples
6+import ProjectM36.TupleSet
7+import ProjectM36.Attribute hiding (null, attributeNames)
68import ProjectM36.DataTypes.Primitive
79import ProjectM36.RelationalExpression
810import ProjectM36.TransactionGraph
@@ -23,8 +25,8 @@ testList = TestList [testRelation "relationTrue" relationTrue, testRelation "rel
2325 testRelation "products" productsRel,
2426 testRelation "supplierProducts" supplierProductsRel,
2527 testMkRelationFromExprsBadAttrs,
26− testExistingRelationType,
27− testReorderTuple
28+ testDuplicateAttributes,
29+ testExistingRelationType
2830 ]
2931
3032main :: IO ()
@@ -62,8 +64,8 @@ validateAttrTypesMatchTupleAttrTypes rel@(Relation attrs tupSet) = foldr (\tuple
6264 tupleAtomCheck tuple = V.all (== True) (attrChecks tuple)
6365 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of
6466 Left _ -> False
65− Right atom -> Right (atomTypeForAtom atom) ==
66− A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributesVec (attributes rel))
67+ Right atom -> (Right $ atomTypeForAtom atom) ==
68+ A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributes rel)
6769
6870simpleRel :: Relation
6971simpleRel = case mkRelation attrs tupleSet of
@@ -95,25 +97,22 @@ testMkRelationFromExprsBadAttrs = TestCase $ do
9597 let context = DBC.empty
9698 (graph,_) <- freshTransactionGraph context
9799 let reenv = mkRelationalExprEnv context graph
98− reExpr = MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "badAttr1" (PrimitiveTypeConstructor "Int" IntAtomType) ()]) (TupleExprs () [TupleExpr (M.singleton "badAttr2" (NakedAtomExpr (IntAtom 1)))])
100+ reExpr = MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "badAttr1" (PrimitiveTypeConstructor "Int" IntAtomType) ()]) [TupleExpr (M.singleton "badAttr2" (NakedAtomExpr (IntAtom 1)))]
99101 evald = runRelationalExprM reenv (evalRelationalExpr reExpr)
100102 case evald of
101103 Left err -> assertEqual "tuple type mismatch" (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "badAttr2" IntAtomType])) err
102104 Right _ -> assertFailure "expected tuple type mismatch"
103105
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+
104113testExistingRelationType :: Test
105114testExistingRelationType = TestCase $ do
106115 (graph, _) <- freshTransactionGraph dateExamples
107116 let typeResult = runRelationalExprM reenv (typeForRelationalExpr (ExistingRelation relationTrue))
108117 reenv = mkRelationalExprEnv dateExamples graph
109118 assertEqual "ExistingRelation with tuples type" (Right relationFalse) typeResult
110−
111−-- | Ensure that tuple reordering honors the
112−testReorderTuple :: Test
113−testReorderTuple = TestCase $ do
114− let tup1 = mkRelationTuple attrs1 (V.fromList [IntAtom 4, TextAtom "test"])
115− attrs1 = A.attributesFromList [Attribute "a" IntAtomType, Attribute "b" TextAtomType]
116− attrs2 = A.attributesFromList [Attribute "b" TextAtomType, Attribute "a" IntAtomType]
117− actual = reorderTuple attrs2 tup1
118− expected = mkRelationTuple attrs2 (V.fromList [TextAtom "test", IntAtom 4])
119− assertEqual "reorderTuple" expected actual
test/Relation/Export/CSV.hs+18−23
@@ -1,5 +1,3 @@
1−{-# LANGUAGE CPP #-}
2−
31import ProjectM36.Base
42import ProjectM36.Relation.Show.CSV
53import ProjectM36.Relation.Parse.CSV
@@ -13,11 +11,7 @@ import System.Exit
1311import Test.HUnit
1412import Data.Time.Calendar
1513import Data.Time.Clock
16−
17−#if __GLASGOW_HASKELL__ < 804
1814import Data.Monoid
19−#endif
20−
2115{-
2216import qualified Data.Text.Lazy as TL
2317import qualified Data.Text.Lazy.Encoding as TE
@@ -25,9 +19,9 @@ import ProjectM36.Relation.Show.Term
2519import qualified Data.ByteString.Lazy as BS
2620-}
2721
28−main :: IO ()
29−main = do
30− tcounts <- runTestTT $ TestList [testCSVExport,
22+main :: IO ()
23+main = do
24+ tcounts <- runTestTT $ TestList [testCSVExport,
3125 testADTExport]
3226 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
3327
@@ -37,8 +31,8 @@ assertEither x = do
3731 case res of
3832 Left err -> assertFailure (show err) >> undefined
3933 Right val -> pure val
40−
41−testADTExport :: Test
34+
35+testADTExport :: Test
4236testADTExport = TestCase $ do
4337 let adtCSV = "a\nCons 4 (Cons 5 Empty)\n"
4438 attrs = A.attributesFromList [Attribute "a" (listAtomType IntegerAtomType)]
@@ -46,17 +40,17 @@ testADTExport = TestCase $ do
4640 case csvAsRelation attrs basicTypeConstructorMapping adtCSV of
4741 Left err -> assertFailure ("import failure: " <> show err)
4842 Right rel -> assertEqual "import cons list" expectedRel (Right rel)
49−
43+
5044--round-trip various atom types through CSV export/import
5145testCSVExport :: Test
5246testCSVExport = TestCase $ do
5347 now <- getCurrentTime
54− testInterval <- assertEither $ pure (createInterval
55− (DateTimeAtom now)
48+ testInterval <- assertEither $ pure (createInterval
49+ (DateTimeAtom now)
5650 (DateTimeAtom (addUTCTime 86400 now))
5751 True
5852 False)
59− let attrs = A.attributesFromList [Attribute "textattr" TextAtomType,
53+ let attrs = A.attributesFromList [Attribute "textattr" TextAtomType,
6054 Attribute "integerattr" IntegerAtomType,
6155 Attribute "dayattr" DayAtomType,
6256 Attribute "datetimeattr" DateTimeAtomType,
@@ -67,8 +61,8 @@ testCSVExport = TestCase $ do
6761 ]
6862 sampleByteString = "\1\0\244\34\150"
6963 relOrErr = mkRelationFromList attrs [
70− [TextAtom "text atom with \"quote\"",
71− IntegerAtom 123,
64+ [TextAtom "text atom with \"quote\"",
65+ IntegerAtom 123,
7266 DayAtom (fromGregorian 2017 4 10),
7367 DateTimeAtom now,
7468 ByteStringAtom sampleByteString,
@@ -76,19 +70,19 @@ testCSVExport = TestCase $ do
7670 listCons TextAtomType [TextAtom "text1", TextAtom "text2"],
7771 testInterval
7872 ],
79− [TextAtom "second text atom with 漢字",
80− IntegerAtom 314,
73+ [TextAtom "second text atom with 漢字",
74+ IntegerAtom 314,
8175 DayAtom (fromGregorian 1001 6 28),
8276 DateTimeAtom (addUTCTime 360 now),
83− ByteStringAtom sampleByteString,
77+ ByteStringAtom sampleByteString,
8478 listCons IntegerAtomType [IntegerAtom 10, IntegerAtom 11, IntegerAtom 12],
8579 listCons TextAtomType [TextAtom "text5\"", TextAtom "text6\r\n"],
8680 testInterval
8781 ]]
88−
89− case relOrErr of
82+
83+ case relOrErr of
9084 Left err -> assertFailure $ "export relation creation failure: " ++ show err
91− Right rel ->
85+ Right rel ->
9286 case relationAsCSV rel of
9387 Left err -> assertFailure $ "export failed: " ++ show err
9488 Right csvData ->
@@ -97,3 +91,4 @@ testCSVExport = TestCase $ do
9791 case csvAsRelation attrs basicTypeConstructorMapping csvData of -- import csv data back to relation
9892 Left err -> assertFailure $ "re-import failed: " ++ show err
9993 Right rel' -> assertEqual "relation CSV comparison" rel rel'
94+
test/Relation/Tupleable.hs+9−187
@@ -1,29 +1,19 @@
1−{-# LANGUAGE
2− DeriveGeneric
3− , FlexibleInstances
4− , FlexibleContexts
5− , DeriveAnyClass
6− , ScopedTypeVariables
7− , TypeApplications
8− , DataKinds
9− , TypeOperators
10− , AllowAmbiguousTypes
11− , DerivingVia
12− #-}
1+{-# LANGUAGE DeriveGeneric, FlexibleInstances, FlexibleContexts, TypeOperators, DeriveAnyClass #-}
132import Test.HUnit
14−import ProjectM36.Tupleable.Deriving
3+import ProjectM36.Tupleable
154import ProjectM36.Atomable
16−import ProjectM36.Attribute as A
5+import ProjectM36.Attribute
176import ProjectM36.Error
7+import Data.Binary
188import ProjectM36.Base
199import Control.DeepSeq (NFData)
10+import GHC.Generics
2011import qualified Data.Vector as V
2112import qualified Data.Map as M
2213import qualified Data.Text as T
2314import qualified Data.Set as S
2415import System.Exit
2516import Data.Proxy
26−import Codec.Winery
2717
2818{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}
2919
@@ -31,43 +21,35 @@ data Test1T = Test1C {
3121 attrA :: Integer
3222 }
3323 deriving (Generic, Eq, Show)
34− deriving Serialise via WineryRecord Test1T
3524
3625data Test2T = Test2C {
3726 attrB :: Integer,
3827 attrC :: Integer
3928 }
4029 deriving (Generic, Eq, Show)
41− deriving Serialise via WineryRecord Test2T
4230
4331data Test3T = Test3C Integer
4432 deriving (Generic, Eq, Show)
45− deriving Serialise via WineryVariant Test3T
4633
4734data Test4T = Test4C
4835 deriving (Generic, Eq, Show)
49− deriving Serialise via WineryVariant Test4T
5036
5137data Test5T = Test5C1 Integer |
5238 Test5C2 Integer
5339 deriving (Generic, Eq, Show)
54− deriving Serialise via WineryVariant Test5T
5540
5641data Test6T = Test6C T.Text Integer Double
5742 deriving (Generic, Eq, Show)
5843
5944data Test7A = Test7AC Integer
60− deriving (Generic, Show, Eq, NFData, Atomable)
61− deriving Serialise via WineryVariant Test7A
45+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)
6246
6347
6448data Test7T = Test7C Test7A
6549 deriving (Generic, Show, Eq)
66− deriving Serialise via WineryVariant Test7T
6750
6851data Test8T = Test8C
6952 deriving (Generic, Show, Eq)
70− deriving Serialise via WineryVariant Test8T
7153
7254data Test9T = Test9C
7355 {
@@ -76,15 +58,6 @@ data Test9T = Test9C
7658 attr9C :: Double
7759 }
7860 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
8861
8962instance Tupleable Test1T
9063
@@ -110,7 +83,7 @@ main = do
11083 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
11184
11285testList :: Test
113−testList = TestList [testADT1, testADT2, testADT3, testADT4, testADT6, testADT7, testADT8 ,testInsertExpr, testDefineExpr, testUpdateExpr, testUpdateExprEmptyAttrs, testDeleteExpr, testUpdateExprWrongAttr, testReorderedTuple, testAddPrefixField, testDropPrefixField, testAddSuffixField, testDropSuffixField, testUpperCaseField, testLowerCaseField, testTitleCaseField, testCamelCaseField, testPascalCaseField, testSnakeCaseField, testSpinalCaseField, testTrainCaseField, testAsIsCodec, testAsIsField, testComposeRLCodec, testComposeRLField, testComposeLRCodec, testComposeLRField]
86+testList = TestList [testADT1, testADT2, testADT3, testADT4, testADT6, testADT7, testADT8, testInsertExpr, testDefineExpr, testUpdateExpr, testUpdateExprEmptyAttrs, testDeleteExpr, testUpdateExprWrongAttr, testReorderedTuple]
11487
11588testADT1 :: Test
11689testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))
@@ -148,7 +121,7 @@ testADT7 :: Test
148121testADT7 = TestCase $ do
149122 let example = Test7C (Test7AC 3)
150123 assertEqual "atom type" (Right example) (fromTuple (toTuple example))
151− let expectedAttrs = A.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))
124+ let expectedAttrs = V.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))
152125 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))
153126
154127testADT8 :: Test
@@ -222,159 +195,8 @@ testDeleteExpr = TestCase $ do
222195testReorderedTuple :: Test
223196testReorderedTuple = TestCase $ do
224197 let tupleRev :: RelationTuple -> RelationTuple
225− tupleRev (RelationTuple v1 v2) = RelationTuple (revAttrs v1) (V.reverse v2)
226− revAttrs attrs = A.attributesFromList (reverse (A.toList attrs))
198+ tupleRev (RelationTuple v1 v2) = RelationTuple (V.reverse v1) (V.reverse v2)
227199 expected = Test2C {attrB = 3,
228200 attrC = 4}
229201 actual = fromTuple . tupleRev . toTuple $ expected
230202 assertEqual "reordered tuple" (Right expected) actual
231−
232−testCodec :: forall tag. ModifyOptions tag => String -> [AttributeName] -> Test
233−testCodec msg expected = TestCase $
234− assertEqual msg (S.fromList expected) actual
235− where
236− actual = attributeNameSet $ toAttributes (Proxy :: Proxy (Codec tag Test10T))
237−
238−testAddPrefixField :: Test
239−testAddPrefixField = testCodec
240− @(Field (AddPrefix "prefix_"))
241− "codec field add prefix attributes"
242− ["prefix_longAttrNameA10",
243− "prefix_long_attr_name_b10",
244− "prefix_longMixed_attr_NameC10"]
245−
246−testDropPrefixField :: Test
247−testDropPrefixField = testCodec
248− @(Field (DropPrefix "long"))
249− "codec field drop prefix"
250− ["AttrNameA10",
251− "_attr_name_b10",
252− "Mixed_attr_NameC10"]
253−
254−testAddSuffixField :: Test
255−testAddSuffixField = testCodec
256− @(Field (AddSuffix "_suffix"))
257− "codec field add suffix"
258− ["longAttrNameA10_suffix",
259− "long_attr_name_b10_suffix",
260− "longMixed_attr_NameC10_suffix"]
261−
262−testDropSuffixField :: Test
263−testDropSuffixField = testCodec
264− @(Field (DropSuffix "10"))
265− "codec field drop suffix"
266− ["longAttrNameA",
267− "long_attr_name_b",
268− "longMixed_attr_NameC"]
269−
270−testUpperCaseField :: Test
271−testUpperCaseField = testCodec
272− @(Field UpperCase)
273− "codec field uppercase"
274− ["LONGATTRNAMEA10",
275− "LONG_ATTR_NAME_B10",
276− "LONGMIXED_ATTR_NAMEC10"]
277−
278−testLowerCaseField :: Test
279−testLowerCaseField = testCodec
280− @(Field LowerCase)
281− "codec field lowercase"
282− ["longattrnamea10",
283− "long_attr_name_b10",
284− "longmixed_attr_namec10"]
285−
286−testTitleCaseField :: Test
287−testTitleCaseField = testCodec
288− @(Field TitleCase)
289− "codec field title case"
290− ["Long Attr Name A10",
291− "Long Attr Name B10",
292− "Long Mixed Attr Name C10"]
293−
294−testCamelCaseField :: Test
295−testCamelCaseField = testCodec
296− @(Field CamelCase)
297− "codec field camel case"
298− ["longAttrNameA10",
299− "longAttrNameB10",
300− "longMixedAttrNameC10"]
301−
302−testPascalCaseField :: Test
303−testPascalCaseField = testCodec
304− @(Field PascalCase)
305− "codec field pascal case"
306− ["LongAttrNameA10",
307− "LongAttrNameB10",
308− "LongMixedAttrNameC10"]
309−
310−testSnakeCaseField :: Test
311−testSnakeCaseField = testCodec
312− @(Field SnakeCase)
313− "codec field snake case"
314− ["long_attr_name_a10",
315− "long_attr_name_b10",
316− "long_mixed_attr_name_c10"]
317−
318−testSpinalCaseField :: Test
319−testSpinalCaseField = testCodec
320− @(Field SpinalCase)
321− "codec field spinal case"
322− ["long-attr-name-a10",
323− "long-attr-name-b10",
324− "long-mixed-attr-name-c10"]
325−
326−testTrainCaseField :: Test
327−testTrainCaseField = testCodec
328− @(Field TrainCase)
329− "codec field train case"
330− ["Long-Attr-Name-A10",
331− "Long-Attr-Name-B10",
332− "Long-Mixed-Attr-Name-C10"]
333−
334−testAsIsCodec :: Test
335−testAsIsCodec = testCodec
336− @AsIs
337− "codec as is"
338− ["longAttrNameA10",
339− "long_attr_name_b10",
340− "longMixed_attr_NameC10"]
341−
342−testAsIsField :: Test
343−testAsIsField = testCodec
344− @(Field AsIs)
345− "codec field as is"
346− ["longAttrNameA10",
347− "long_attr_name_b10",
348− "longMixed_attr_NameC10"]
349−
350−testComposeRLCodec :: Test
351−testComposeRLCodec = testCodec
352− @(Field UpperCase <<< Field (DropPrefix "long"))
353− "codec (<<<)"
354− ["ATTRNAMEA10",
355− "_ATTR_NAME_B10",
356− "MIXED_ATTR_NAMEC10"]
357−
358−testComposeRLField :: Test
359−testComposeRLField = testCodec
360− @(Field (UpperCase <<< DropPrefix "long"))
361− "codec field (<<<)"
362− ["ATTRNAMEA10",
363− "_ATTR_NAME_B10",
364− "MIXED_ATTR_NAMEC10"]
365−
366−testComposeLRCodec :: Test
367−testComposeLRCodec = testCodec
368− @(Field (DropPrefix "long") >>> Field UpperCase)
369− "codec (>>>)"
370− ["ATTRNAMEA10",
371− "_ATTR_NAME_B10",
372− "MIXED_ATTR_NAMEC10"]
373−
374−testComposeLRField :: Test
375−testComposeLRField = testCodec
376− @(Field (DropPrefix "long" >>> UpperCase))
377− "codec field (>>>)"
378− ["ATTRNAMEA10",
379− "_ATTR_NAME_B10",
380− "MIXED_ATTR_NAMEC10"]
test/Server/Main.hs+23−24
@@ -5,6 +5,7 @@ test client/server interaction
55import Test.HUnit
66import ProjectM36.Client
77import qualified ProjectM36.Client as C
8+import ProjectM36.Server.EntryPoints
89import ProjectM36.Server
910import ProjectM36.Server.Config
1011import ProjectM36.Relation
@@ -13,8 +14,16 @@ import ProjectM36.IsomorphicSchema
1314import ProjectM36.Base
1415
1516import System.Exit
16−import Network.Socket (SockAddr(..))
17+
1718import 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+
1827import Data.Either (isRight)
1928import Control.Exception
2029import System.IO.Temp
@@ -23,8 +32,6 @@ import System.FilePath
2332import System.Directory
2433#endif
2534
26−type Timeout = Int
27−
2835testList :: SessionId -> Connection -> MVar () -> Test
2936testList sessionId conn notificationTestMVar = TestList $ serverTests ++ sessionTests
3037 where
@@ -42,7 +49,7 @@ testList sessionId conn notificationTestMVar = TestList $ serverTests ++ session
4249 testRelationVariableSummary,
4350 testNotification notificationTestMVar
4451 ]
45− serverTests = [testRequestTimeout, testFileDescriptorCount, testClientConnectFail]
52+ serverTests = [testRequestTimeout, testFileDescriptorCount]
4653
4754main :: IO ()
4855main = do
@@ -62,9 +69,11 @@ main = do
6269testDatabaseName :: DatabaseName
6370testDatabaseName = "test"
6471
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)
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)
6877 --putStrLn ("testConnection: " ++ show serverAddress)
6978 eConn <- connectProjectM36 connInfo
7079 case eConn of
@@ -76,7 +85,7 @@ testConnection serverPort mvar = do
7685 Right sessionId -> pure $ Right (sessionId, conn)
7786
7887-- | A version of 'launchServer' which returns the port on which the server is listening on a secondary thread
79−launchTestServer :: Timeout -> IO (Port, ThreadId)
88+launchTestServer :: Timeout -> IO (EndPointAddress, ThreadId)
8089launchTestServer ti = do
8190 addressMVar <- newEmptyMVar
8291 tid <- forkIO $
@@ -85,14 +94,13 @@ launchTestServer ti = do
8594 persistenceStrategy = CrashSafePersistence (tempdir </> "db"),
8695 perRequestTimeout = ti,
8796 testMode = True,
88− bindPort = 0,
89− checkFS = False --not stricly needed for these tests
97+ bindPort = 0
9098 }
9199
92100 launchServer config (Just addressMVar) >> pure ()
93− (SockAddrInet port _) <- takeMVar addressMVar
101+ endPointAddress <- takeMVar addressMVar
94102 --liftIO $ putStrLn ("launched server on " ++ show endPointAddress)
95− pure (fromIntegral port, tid)
103+ pure (endPointAddress, tid)
96104
97105testRelationalExpr :: SessionId -> Connection -> Test
98106testRelationalExpr sessionId conn = TestCase $ do
@@ -138,11 +146,10 @@ testPlanForDatabaseContextExpr sessionId conn = TestCase $ do
138146 let attrExprs = [AttributeAndTypeNameExpr "x" (PrimitiveTypeConstructor "Int" IntAtomType) ()]
139147 testrv = "testrv"
140148 dbExpr = Define testrv attrExprs
141− expected = Define testrv [AttributeAndTypeNameExpr "x" (PrimitiveTypeConstructor "Int" IntAtomType) UncommittedContextMarker]
142149 planResult <- planForDatabaseContextExpr sessionId conn dbExpr
143150 case planResult of
144151 Left err -> assertFailure (show err)
145− Right plan -> assertEqual "planForDatabaseContextExpr failure" expected plan
152+ Right plan -> assertEqual "planForDatabaseContextExpr failure" dbExpr plan
146153
147154testTransactionGraphAsRelation :: SessionId -> Connection -> Test
148155testTransactionGraphAsRelation sessionId conn = TestCase $ do
@@ -208,7 +215,7 @@ testRequestTimeout = TestCase $ do
208215 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure
209216 Right (session, testConn) -> do
210217 res <- catchJust (\exc -> if exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))
211− assertBool "timeout exception was not thrown" (not res)
218+ assertBool "exception was not thrown" (not res)
212219 killThread serverTid
213220
214221testFileDescriptorCount :: Test
@@ -237,12 +244,4 @@ fdCount = do
237244#else
238245--pass on non-linux platforms
239246testFileDescriptorCount = TestCase (pure ())
240−#endif
241−
242−testClientConnectFail :: Test
243−testClientConnectFail = TestCase $ do
244− let connInfo = RemoteConnectionInfo "nonexistentdb" "127.0.0.1" "7777" emptyNotificationCallback
245− eConn <- connectProjectM36 connInfo
246− case eConn of
247− Left (IOExceptionError _) -> pure ()
248− _ -> assertFailure "connection failure failed"
247+#endif
test/Server/WebSocket.hs+12−8
@@ -18,6 +18,12 @@ 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+
2127
2228--start the websocket server
2329-- run some tutoriald against it
@@ -26,17 +32,16 @@ launchTestServer :: IO (PortNumber, DatabaseName)
2632launchTestServer = do
2733 addressMVar <- newEmptyMVar
2834 let config = defaultServerConfig { databaseName = testDatabaseName,
29− bindPort = 0,
30− checkFS = False}
35+ bindPort = 0 }
3136 testDatabaseName = "test"
3237 -- start normal server
3338 _ <- forkIO (launchServer config (Just addressMVar) >> pure ())
34− (SockAddrInet dbPort _) <- takeMVar addressMVar
39+ serverAddress <- takeMVar addressMVar
3540 let wsServerHost = "127.0.0.1"
3641 wsServerPort = 8889
37− dbHost = "127.0.0.1"
42+ Just (dbHost, dbPort, _) = decodeEndPointAddress serverAddress
3843 -- start websocket server proxy -- runServer doesn't support returning an arbitrary socket
39− _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (fromIntegral dbPort) dbHost))
44+ _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (read dbPort) dbHost))
4045 --wait for socket to be listening
4146 waitForListenSocket 5 (fromIntegral wsServerPort)
4247 pure (fromIntegral wsServerPort, testDatabaseName)
@@ -51,14 +56,13 @@ waitForListenSocket secondsToTry port =
5156 if secondsToTry <= 0 then
5257 throw WaitForSocketListenException
5358 else do
54− --hostaddr <- inet_addr "127.0.0.1"
55− hostaddr:_ <- getAddrInfo Nothing (Just "127.0.0.1") (Just (show port))
59+ hostaddr <- inet_addr "127.0.0.1"
5660 sock <- socket AF_INET Stream defaultProtocol
5761 let handler :: IOException -> IO ()
5862 handler _ = do
5963 threadDelay 1000000
6064 waitForListenSocket (secondsToTry - 1) port
61− catch (connect sock (addrAddress hostaddr)) handler
65+ catch (connect sock (SockAddrInet port hostaddr)) handler
6266
6367main :: IO ()
6468main = do
test/TransactionGraph/Merge.hs+39−70
@@ -4,28 +4,15 @@ import ProjectM36.Base
44import ProjectM36.Attribute
55import ProjectM36.Relation
66import ProjectM36.Transaction
7−import ProjectM36.TransactionInfo as TI
87import ProjectM36.TransactionGraph
98import ProjectM36.Error
109import ProjectM36.Key
1110import qualified ProjectM36.DisconnectedTransaction as Discon
1211import qualified ProjectM36.DatabaseContext as DBC
1312import ProjectM36.RelationalExpression
14−import ProjectM36.StaticOptimizer
1513
1614import qualified Data.ByteString.Lazy as BS
1715import System.Exit
18−
19−
20−
21−
22−
23−
24−
25−
26−
27−
28−
2916import Data.Word
3017import qualified Data.UUID as U
3118import qualified Data.Set as S
@@ -34,6 +21,8 @@ import Data.Maybe
3421import Data.Time.Clock
3522import Data.Time.Calendar
3623
24+import Control.Monad.State
25+
3726{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
3827
3928testTime :: UTCTime
@@ -73,8 +62,8 @@ basicTransactionGraph = do
7362 uuidB = fakeUUID 11
7463 uuidRoot = fakeUUID 1
7564 rootContext = concreteDatabaseContext rootTrans
76− (_, bsGraph') <- addTransaction "branchA" (createTrans uuidA (TI.singleParent uuidRoot testTime) rootContext) bsGraph
77− (_, bsGraph'') <- addTransaction "branchB" (createTrans uuidB (TI.singleParent uuidRoot testTime) rootContext) bsGraph'
65+ (_, bsGraph') <- addTransaction "branchA" (createTrans uuidA (TransactionInfo S.empty testTime) rootContext) bsGraph
66+ (_, bsGraph'') <- addTransaction "branchB" (createTrans uuidB (TransactionInfo S.empty testTime) rootContext) bsGraph'
7867 pure bsGraph''
7968
8069addTransaction :: HeadName -> Transaction -> TransactionGraph -> IO (Transaction, TransactionGraph)
@@ -118,7 +107,7 @@ testSubGraphToFirstAncestorSnipBranch = TestCase $ do
118107 baseGraph <- basicTransactionGraph
119108 transA <- assertMaybe (transactionForHead "branchA" baseGraph) "failed to get branchA"
120109 transB <- assertMaybe (transactionForHead "branchB" baseGraph) "failed to get branchB"
121− (_, graph) <- addTransaction "branchC" (createTrans (fakeUUID 12) (TI.singleParent (fakeUUID 1) testTime) (concreteDatabaseContext transA)) baseGraph
110+ (_, graph) <- addTransaction "branchC" (createTrans (fakeUUID 12) (TransactionInfo (fakeUUID 1) S.empty testTime) (concreteDatabaseContext transA)) baseGraph
122111 subgraph <- assertEither $ subGraphOfFirstCommonAncestor graph (transactionHeadsForGraph baseGraph) transA transB S.empty
123112 assertGraph subgraph
124113 let graphEq graphArg = S.map transactionId (transactionsForGraph graphArg)
@@ -132,18 +121,16 @@ testSubGraphToFirstAncestorMoreTransactions = TestCase $ do
132121
133122-- add another relvar to branchB
134123 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "failed to get branchB head"
135− let env = mkDatabaseContextEvalEnv (transactionId branchBTrans) graph
136− branchBContext = concreteDatabaseContext branchBTrans
137− updatedBranchBContext <- case runDatabaseContextEvalMonad branchBContext env (optimizeAndEvalDatabaseContextExpr True (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) of
138− Left err -> assertFailure (show err) >> undefined
139− Right st -> pure $ dbc_context st
140− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) updatedBranchBContext) graph
124+ (updatedBranchBContext,_,_) <- case runState (evalDatabaseContextExpr (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) (freshDatabaseState (concreteDatabaseContext branchBTrans)) of
125+ (Left err, _) -> assertFailure (show err) >> undefined
126+ (Right (), context) -> pure context
127+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans) S.empty testTime) updatedBranchBContext) graph
141128 branchBTrans' <- assertMaybe (transactionForHead "branchB" graph') "failed to get branchB head"
142129 assertEqual "branchB id 3" (fakeUUID 3) (transactionId branchBTrans')
143130
144131 -- add another transaction to branchA
145132 branchATrans <- assertMaybe (transactionForHead "branchA" graph) "failed to get branchA head"
146− (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchATrans) testTime) (concreteDatabaseContext branchATrans)) graph'
133+ (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchATrans) S.empty testTime) (concreteDatabaseContext branchATrans)) graph'
147134 branchATrans' <- assertMaybe (transactionForHead "branchA" graph'') "failed to get branchA head"
148135 assertEqual "branchA id 4" (fakeUUID 4) (transactionId branchATrans')
149136
@@ -161,15 +148,12 @@ testSelectedBranchMerge = TestCase $ do
161148
162149 -- add another relvar to branchB
163150 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "failed to get branchB head"
164− let env = mkDatabaseContextEvalEnv (transactionId branchBTrans) graph
165− branchBContext = concreteDatabaseContext branchBTrans
166− updatedBranchBContext <- case runDatabaseContextEvalMonad branchBContext env (optimizeAndEvalDatabaseContextExpr True (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) of
167− Left err -> assertFailure (show err) >> undefined
168− Right st -> pure (dbc_context st)
169− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) updatedBranchBContext) graph
151+ (updatedBranchBContext,_,_) <- case runState (evalDatabaseContextExpr (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) (freshDatabaseState (concreteDatabaseContext branchBTrans)) of
152+ (Left err, _) -> assertFailure (show err) >> undefined
153+ (Right (), context) -> pure context
154+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans) S.empty testTime) updatedBranchBContext) graph
170155 --create the merge transaction in the graph
171− let eGraph' = runGraphRefRelationalExprM gfEnv $ mergeTransactions testTime (fakeUUID 4) (fakeUUID 10) (SelectedBranchMergeStrategy "branchA") ("branchA", "branchB")
172− gfEnv = freshGraphRefRelationalExprEnv Nothing graph'
156+ let eGraph' = mergeTransactions testTime (fakeUUID 4) (fakeUUID 10) (SelectedBranchMergeStrategy "branchA") ("branchA", "branchB") graph'
173157
174158 (_, graph'') <- assertEither eGraph'
175159
@@ -191,22 +175,18 @@ testUnionPreferMergeStrategy = TestCase $ do
191175 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "branchBTrans"
192176 branchBRelVar <- assertEither $ mkRelationFromList (attributesFromList [Attribute "conflict" IntAtomType]) []
193177 let branchAContext = (concreteDatabaseContext branchATrans) {relationVariables = M.insert conflictRelVarName branchARelVar (relationVariables (concreteDatabaseContext branchATrans))}
194− branchARelVar = ExistingRelation relationTrue
195− branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.insert conflictRelVarName (ExistingRelation branchBRelVar) (relationVariables (concreteDatabaseContext branchBTrans))}
196− conflictRelVarName = "conflictRelVar"
178+ branchARelVar = relationTrue
179+ branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.insert conflictRelVarName branchBRelVar (relationVariables (concreteDatabaseContext branchBTrans))}
180+ conflictRelVarName = "conflictRelVar"
197181
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'
182+ (_, graph') <- addTransaction "branchA" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchATrans) S.empty testTime) branchAContext) graph
183+ (_, graph'') <- addTransaction "branchB" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchBTrans) S.empty testTime) branchBContext) graph'
200184 -- validate that the conflict is hidden because we preferred a branch
201− let merged = runGraphRefRelationalExprM env $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) (UnionPreferMergeStrategy "branchB") ("branchA", "branchB")
202− env = freshGraphRefRelationalExprEnv Nothing graph''
185+ let merged = mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) (UnionPreferMergeStrategy "branchB") ("branchA", "branchB") graph''
203186 case merged of
204187 Left err -> assertFailure ("expected merge success: " ++ show err)
205− Right (discon, _) -> do
206− let Just rvExpr = M.lookup conflictRelVarName (relationVariables (Discon.concreteDatabaseContext discon))
207− reEnv = freshGraphRefRelationalExprEnv (Just (Discon.concreteDatabaseContext discon)) graph
208− let eRvRel = runGraphRefRelationalExprM reEnv (evalGraphRefRelationalExpr rvExpr)
209− assertEqual "branchB relvar preferred in conflict" (Right branchBRelVar) eRvRel
188+ Right (discon, _) ->
189+ assertEqual "branchB relvar preferred in conflict" (Just branchBRelVar) (M.lookup conflictRelVarName (relationVariables (Discon.concreteDatabaseContext discon)))
210190
211191-- try various individual component conflicts and check for merge failure
212192testUnionMergeStrategy :: Test
@@ -221,41 +201,31 @@ testUnionMergeStrategy = TestCase $ do
221201
222202 let updatedBranchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.insert branchBOnlyRelVarName branchBOnlyRelVar (relationVariables (concreteDatabaseContext branchBTrans)) }
223203 updatedBranchAContext = (concreteDatabaseContext branchATrans) {inclusionDependencies = M.insert branchAOnlyIncDepName branchAOnlyIncDep (inclusionDependencies (concreteDatabaseContext branchATrans)) }
224− branchBOnlyRelVar = ExistingRelation relationTrue
204+ branchBOnlyRelVar = relationTrue
225205 branchAOnlyIncDepName = "branchAOnlyIncDep"
226206 branchBOnlyRelVarName = "branchBOnlyRelVar"
227207 branchAOnlyIncDep = InclusionDependency (ExistingRelation relationTrue) (ExistingRelation relationTrue)
228− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) updatedBranchBContext) graph
229− let env = freshGraphRefRelationalExprEnv Nothing graph'
230− (discon, _) <- assertEither $ runGraphRefRelationalExprM env $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 10) UnionMergeStrategy ("branchA", "branchB")
231− let Just rvExpr = M.lookup branchBOnlyRelVarName (relationVariables (Discon.concreteDatabaseContext discon))
232− Right rvRel = runGraphRefRelationalExprM reEnv (evalGraphRefRelationalExpr rvExpr)
233− reEnv = freshGraphRefRelationalExprEnv (Just (Discon.concreteDatabaseContext discon)) graph
234−
235− assertEqual "branchBOnlyRelVar should appear in the merge" relationTrue rvRel
236− (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchATrans) testTime) updatedBranchAContext) graph'
237− let eMergeGraph = runGraphRefRelationalExprM gfEnv $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB")
238− gfEnv = freshGraphRefRelationalExprEnv Nothing graph''
208+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans) S.empty testTime) updatedBranchBContext) graph
209+ (discon, _) <- assertEither $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 10) UnionMergeStrategy ("branchA", "branchB") graph'
210+ assertEqual "branchBOnlyRelVar should appear in the merge" (M.lookup branchBOnlyRelVarName (relationVariables (Discon.concreteDatabaseContext discon))) (Just relationTrue)
211+ (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchATrans) S.empty testTime) updatedBranchAContext) graph'
212+ let eMergeGraph = mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB") graph''
239213 case eMergeGraph of
240214 Left err -> assertFailure ("expected merge success: " ++ show err)
241215 Right (_, mergeGraph) -> do
242216 -- check that the new merge transaction has the correct parents
243217 mergeTrans <- assertEither $ transactionForId (fakeUUID 5) mergeGraph
244218 let mergeContext = concreteDatabaseContext mergeTrans
245− assertEqual "merge transaction parents" (parentIds mergeTrans) (S.fromList [fakeUUID 3, fakeUUID 4])
219+ assertEqual "merge transaction parents" (transactionParentIds mergeTrans) (S.fromList [fakeUUID 3, fakeUUID 4])
246220 -- check that the new merge tranasction has elements from both A and B branches
247− let Just rvExpr' = M.lookup branchBOnlyRelVarName (relationVariables mergeContext)
248− Right rvRel' = runGraphRefRelationalExprM reEnv' (evalGraphRefRelationalExpr rvExpr')
249− reEnv' = freshGraphRefRelationalExprEnv (Just mergeContext) graph
250− assertEqual "merge transaction relvars" relationTrue rvRel'
221+ assertEqual "merge transaction relvars" (Just relationTrue) (M.lookup branchBOnlyRelVarName (relationVariables mergeContext))
251222 assertEqual "merge transaction incdeps" (Just branchAOnlyIncDep) (M.lookup branchAOnlyIncDepName (inclusionDependencies mergeContext))
252223 -- test an expected conflict- add branchBOnlyRelVar with same name but different attributes
253224 conflictRelVar <- assertEither $ mkRelationFromList (attributesFromList [Attribute "conflict" IntAtomType]) []
254− let conflictContextA = updatedBranchAContext {relationVariables = M.insert branchBOnlyRelVarName (ExistingRelation conflictRelVar) (relationVariables updatedBranchAContext) }
225+ let conflictContextA = updatedBranchAContext {relationVariables = M.insert branchBOnlyRelVarName conflictRelVar (relationVariables updatedBranchAContext) }
255226 conflictBranchATrans <- assertMaybe (transactionForHead "branchA" graph'') "retrieving head transaction for expected conflict"
256− (_, graph''') <- addTransaction "branchA" (createTrans (fakeUUID 6) (TI.singleParent (transactionId conflictBranchATrans) testTime) conflictContextA) graph''
257− let failingMerge = runGraphRefRelationalExprM gfEnv' $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB")
258− gfEnv' = freshGraphRefRelationalExprEnv Nothing graph'''
227+ (_, graph''') <- addTransaction "branchA" (createTrans (fakeUUID 6) (TransactionInfo (transactionId conflictBranchATrans) S.empty testTime) conflictContextA) graph''
228+ let failingMerge = mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB") graph'''
259229 case failingMerge of
260230 Right _ -> assertFailure "expected merge failure"
261231 Left err -> assertEqual "merge failure" err (MergeTransactionError StrategyViolatesRelationVariableMergeError)
@@ -274,21 +244,20 @@ testUnionMergeIncDepViolation = TestCase $ do
274244 rvName = "x"
275245 Right branchArv = eRel 2
276246 Right branchBrv = eRel 3
277− branchAContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.singleton rvName (ExistingRelation branchArv)}
278− branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.singleton rvName (ExistingRelation branchBrv),
247+ branchAContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.singleton rvName branchArv}
248+ branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.singleton rvName branchBrv,
279249 inclusionDependencies = M.singleton incDepName incDep}
280250 incDepName = "x_key"
281251 incDep = inclusionDependencyForKey (AttributeNames (S.singleton "x")) (RelationVariable "x" ())
282252
283253
284254 --add the rv in new commits to both branches
285− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) branchBContext) graph
255+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans) S.empty testTime) branchBContext) graph
286256
287− (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchATrans) testTime) branchAContext) graph'
257+ (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchATrans) S.empty testTime) branchAContext) graph'
288258
289259 --check that the union merge fails due to a violated constraint
290− let eMerge = runGraphRefRelationalExprM env $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB")
291− env = freshGraphRefRelationalExprEnv Nothing graph''
260+ let eMerge = mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB") graph''
292261 case eMerge of
293262 Left (InclusionDependencyCheckError incDepName') -> assertEqual "incdep violation name" incDepName incDepName'
294263 Left err -> assertFailure ("other error: " ++ show err)
test/TransactionGraph/Persist.hs+15−79
@@ -1,14 +1,14 @@
1−{-# LANGUAGE CPP #-}
21import Test.HUnit
32import ProjectM36.Base
43import ProjectM36.Persist (DiskSync(NoDiskSync))
54import ProjectM36.TransactionGraph.Persist
6−import ProjectM36.TransactionGraph as TG
5+import ProjectM36.TransactionGraph
76import ProjectM36.Transaction
87import ProjectM36.DateExamples
8+import ProjectM36.Client
9+import ProjectM36.Relation
910import System.IO.Temp
1011import System.Exit
11−import System.Directory
1212import Data.Either
1313import Data.UUID.V4 (nextRandom)
1414import System.FilePath
@@ -17,9 +17,6 @@ import qualified Data.Map as M
1717import qualified Data.Set as S
1818import Data.Time.Clock
1919import Data.Time.Calendar
20−import ProjectM36.Client as C
21−import ProjectM36.Relation
22−import ProjectM36.Transaction.Persist
2320
2421main :: IO ()
2522main = do
@@ -29,12 +26,11 @@ main = do
2926testList :: Test
3027testList = TestList [testBootstrapDB,
3128 testDBSimplePersistence,
32− testFunctionPersistence,
33− testMerkleHashValidation]
29+ testFunctionPersistence]
3430
3531
36−stamp' :: UTCTime
37−stamp' = UTCTime (fromGregorian 1980 01 01) (secondsToDiffTime 1000)
32+stamp :: UTCTime
33+stamp = UTCTime (fromGregorian 1980 01 01) (secondsToDiffTime 1000)
3834
3935{- bootstrap a database, ensure that it can be read -}
4036testBootstrapDB :: Test
@@ -42,7 +38,7 @@ testBootstrapDB = TestCase $ withSystemTempDirectory "m36testdb" $ \tempdir -> d
4238 let dbdir = tempdir </> "dbdir"
4339 freshId <- nextRandom
4440
45− _ <- bootstrapDatabaseDir NoDiskSync dbdir (bootstrapTransactionGraph stamp' freshId dateExamples)
41+ _ <- bootstrapDatabaseDir NoDiskSync dbdir (bootstrapTransactionGraph stamp freshId dateExamples)
4642 loadedGraph <- transactionGraphLoad dbdir emptyTransactionGraph Nothing
4743 assertBool "transactionGraphLoad" $ isRight loadedGraph
4844
@@ -52,17 +48,17 @@ testDBSimplePersistence = TestCase $ withSystemTempDirectory "m36testdb" $ \temp
5248 let dbdir = tempdir </> "dbdir"
5349 freshId <- nextRandom
5450
55− let graph = bootstrapTransactionGraph stamp' freshId dateExamples
51+ let graph = bootstrapTransactionGraph stamp freshId dateExamples
5652 _ <- bootstrapDatabaseDir NoDiskSync dbdir graph
5753 case transactionForHead "master" graph of
5854 Nothing -> assertFailure "Failed to retrieve head transaction for master branch."
5955 Just headTrans ->
60− case interpretDatabaseContextExpr (concreteDatabaseContext headTrans) (transactionId headTrans) graph "x:=s" of
56+ case interpretDatabaseContextExpr (concreteDatabaseContext headTrans) "x:=s" of
6157 Left err -> assertFailure (show err)
6258 Right context' -> do
6359 freshId' <- nextRandom
64− let newdiscon = DisconnectedTransaction (transactionId headTrans) (Schemas context' M.empty) False
65− addTrans = addDisconnectedTransaction stamp' freshId' "master" newdiscon graph
60+ let newdiscon = DisconnectedTransaction (transactionId headTrans) (Schemas context' M.empty) True
61+ addTrans = addDisconnectedTransaction stamp freshId' "master" newdiscon graph
6662 --add a transaction to the graph
6763 case addTrans of
6864 Left err -> assertFailure (show err)
@@ -75,69 +71,11 @@ testDBSimplePersistence = TestCase $ withSystemTempDirectory "m36testdb" $ \temp
7571 case graphErr of
7672 Left err -> assertFailure (show err)
7773 Right graph'' -> assertBool "graph equality" (mapEq graph'' == mapEq graph')
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−
74+
13475
13576--only Haskell-scripted dbc and atom functions can be serialized
13677testFunctionPersistence :: Test
137−#if !defined(PM36_HASKELL_SCRIPTING)
138−testFunctionPersistence = TestCase $ pure ()
139−#else
140−testFunctionPersistence = TestCase $
78+testFunctionPersistence = TestCase $
14179 withSystemTempDirectory "m36testdb" $ \tempdir -> do
14280 let dbdir = tempdir </> "dbdir"
14381 connInfo = InProcessConnectionInfo (MinimalPersistence dbdir) emptyNotificationCallback []
@@ -155,12 +93,10 @@ testFunctionPersistence = TestCase $
15593 conn2 <- assertIOEither $ connectProjectM36 connInfo
15694 sess2 <- assertIOEither $ createSessionAtHead conn2 "master"
15795
158− res <- executeRelationalExpr sess2 conn2 (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (M.singleton "a" (FunctionAtomExpr "testdisk" [NakedAtomExpr (IntAtom 3)] ()))]))
96+ res <- executeRelationalExpr sess2 conn2 (MakeRelationFromExprs Nothing [TupleExpr (M.singleton "a" (FunctionAtomExpr "testdisk" [NakedAtomExpr (IntAtom 3)] ()))])
15997 let expectedRel = mkRelationFromList (attributesFromList [Attribute "a" IntAtomType]) [[IntAtom 3]]
16098 assertEqual "testdisk dbc function run" expectedRel res
161−
162−#endif
163−
99+
164100assertIOEither :: (Show a) => IO (Either a b) -> IO b
165101assertIOEither x = do
166102 ret <- x
test/TutorialD/InterpreterTest.hs → test/TutorialD/Interpreter.hsrenamed+13−78
@@ -41,8 +41,8 @@ main = do
4141 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
4242 where
4343 tests = [
44− simpleRelTests,
45− dateExampleRelTests,
44+ simpleRelTests
45+{- dateExampleRelTests,
4646 transactionGraphBasicTest,
4747 transactionGraphAddCommitTest,
4848 transactionRollbackTest,
@@ -75,20 +75,13 @@ main = do
7575 testNonEmptyListType,
7676 testUnresolvedAtomTypes,
7777 testWithClause,
78− testAtomFunctionArgumentMismatch,
79− testInvalidDataConstructor,
80− testBasicList,
81− testRelationDeclarationMismatch,
82− testInvalidTuples,
83− testSelfReferencingUncommittedContext,
84− testUnionAndIntersectionAttributeExprs
78+ testAtomFunctionArgumentMismatch-}
8579 ]
8680
8781simpleRelTests :: Test
8882simpleRelTests = TestCase $ do
8983 (graph, transId) <- freshTransactionGraph dateExamples
90− mapM_ (\(tutd, expected) ->
91− assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups
84+ mapM_ (\(tutd, expected) -> assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups
9285 where
9386 testTups = [("x:=true", Right relationTrue),
9487 ("x:=false", Right relationFalse),
@@ -123,8 +116,7 @@ simpleRelTests = TestCase $ do
123116 ("x:=relation{tuple{a 5}} : {b:=6}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 6])]),
124117 ("x:=relation{tuple{a 5}} : {b:=add(@a,5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 10])]),
125118 ("x:=relation{tuple{a 5}} : {b:=add(@a,\"spam\")}", Left (AtomFunctionTypeError "add" 2 IntegerAtomType TextAtomType)),
126− ("x:=relation{tuple{a 5}} : {b:=add(add(@a,2),5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 12])]),
127− ("x:=false:{a:=1,b:=2}", mkRelationFromTuples simpleDAttributes [])
119+ ("x:=relation{tuple{a 5}} : {b:=add(add(@a,2),5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 12])])
128120 ]
129121 simpleAAttributes = A.attributesFromList [Attribute "a" IntegerAtomType]
130122 simpleBAttributes = A.attributesFromList [Attribute "d" IntegerAtomType]
@@ -136,8 +128,7 @@ simpleRelTests = TestCase $ do
136128dateExampleRelTests :: Test
137129dateExampleRelTests = TestCase $ do
138130 (graph, transId) <- freshTransactionGraph dateExamples
139− mapM_ (\(tutd, expected) ->
140− assertTutdEqual dateExamples transId graph expected tutd) testTups
131+ mapM_ (\(tutd, expected) -> assertTutdEqual dateExamples transId graph expected tutd) testTups
141132 where
142133 simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]
143134 maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)
@@ -155,7 +146,7 @@ dateExampleRelTests = TestCase $ do
155146 else Right tuple) suppliersRel
156147 extendTestAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" $ RelationAtomType (R.attributes suppliersRel)]
157148 testTups = [("x:=s where true", Right suppliersRel),
158− ("x:=s where city = \"London\"", restrict (\tuple -> pure $ atomForAttributeName "city" tuple == Right (TextAtom "London")) suppliersRel),
149+ ("x:=s where city = \"London\"", restrict (\tuple -> pure $ atomForAttributeName "city" tuple == (Right $ TextAtom "London")) suppliersRel),
159150 ("x:=s where false", Right $ Relation (R.attributes suppliersRel) emptyTupleSet),
160151 ("x:=p where color=\"Blue\" and city=\"Paris\"", mkRelationFromList (R.attributes productsRel) [[TextAtom "P5", TextAtom "Cam", TextAtom "Blue", IntegerAtom 12, TextAtom "Paris"]]),
161152 ("a:=s; update a (status:=50); x:=a{status}", mkRelation (A.attributesFromList [Attribute "status" IntegerAtomType]) (RelationTupleSet [mkRelationTuple (A.attributesFromList [Attribute "status" IntegerAtomType]) (V.fromList [IntegerAtom 50])])),
@@ -163,7 +154,7 @@ dateExampleRelTests = TestCase $ do
163154 --atom function tests
164155 ("x:=((s : {status2 := add(10,@status)}) where status2=add(10,@status)){city,s#,sname,status}", Right suppliersRel),
165156 ("x:=relation{tuple{a 5}} : {b:=s}", mkRelation extendTestAttributes (RelationTupleSet [mkRelationTuple extendTestAttributes (V.fromList [IntegerAtom 5, RelationAtom suppliersRel])])),
166− ("x:=s; update x where sname=\"Blake\" (city:=\"Boston\")", relMap (\tuple -> if atomForAttributeName "sname" tuple == Right (TextAtom "Blake") then Right $ updateTupleWithAtoms (M.singleton "city" (TextAtom "Boston")) tuple else Right tuple) suppliersRel),
157+ ("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),
167158 ("x:=s; update x where city=\"Paris\" (status:=add(@status,10))", updateParisPlus10),
168159 --relatom function tests
169160 ("x:=((s group ({city} as y)):{z:=count(@y)}){z}", mkRelation groupCountAttrs (RelationTupleSet [mkRelationTuple groupCountAttrs (V.singleton $ IntegerAtom 1)])),
@@ -362,7 +353,7 @@ testComments :: Test
362353testComments = TestCase $ do
363354 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
364355 mapM_ (executeTutorialD sessionId dbconn) [
365− ":branch testbranch --test comment",
356+ ":branch testbranch --test comment\n",
366357 ":jumphead {- test comment -} master"]
367358
368359-- create a graph and query from two disparate contexts
@@ -500,22 +491,16 @@ testEmptyCommits = TestCase $ do
500491 assertEqual "empty insert empty commit" (Right False) dirty'
501492 Right () <- commit sessionId dbconn
502493
503− --update no tuples- since we defer the restriction, we can only assume the context is dirty, perhaps the constraint checker could offer an optimization here
494+ --update no tuples
504495 Right () <- executeDatabaseContextExpr sessionId dbconn (Update "s" (M.singleton "sname" (NakedAtomExpr (TextAtom "Bob"))) (AttributeEqualityPredicate "sname" (NakedAtomExpr (TextAtom "Mike"))))
505496 dirty'' <- disconnectedTransactionIsDirty sessionId dbconn
506− assertEqual "empty update empty commit" (Right True) dirty''
507− Right () <- commit sessionId dbconn
508−
509− --assign the same rel expr
510− Right () <- executeDatabaseContextExpr sessionId dbconn (Assign "true" (ExistingRelation relationTrue))
511− sameREdirty <- disconnectedTransactionIsDirty sessionId dbconn
512− assertEqual "same relexpr assigned" (Right False) sameREdirty
497+ assertEqual "empty update empty commit" (Right False) dirty''
513498 Right () <- commit sessionId dbconn
514499
515500 --delete no tuples
516501 Right () <- executeDatabaseContextExpr sessionId dbconn (Delete "s" (AttributeEqualityPredicate "sname" (NakedAtomExpr (TextAtom "Mike"))))
517502 dirty''' <- disconnectedTransactionIsDirty sessionId dbconn
518− assertEqual "empty delete empty commit" (Right True) dirty'''
503+ assertEqual "empty delete empty commit" (Right False) dirty'''
519504
520505testIntervalAtom :: Test
521506testIntervalAtom = TestCase $ do
@@ -545,7 +530,7 @@ testListConstructedAtom = TestCase $ do
545530testTypeChecker :: Test
546531testTypeChecker = TestCase $ do
547532 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
548− let err1 = "AtomFunctionTypeError \"max\" 1"
533+ let err1 = "AtomFunctionTypeError \"max\" 1 (RelationAtomType [Attribute \"_\" IntegerAtomType]) IntegerAtomType"
549534 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"
550535
551536--exercise expression parser
@@ -665,10 +650,6 @@ testWithClause = TestCase $ do
665650 executeTutorialD sessionId dbconn "x:=with (x as s) x"
666651 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())
667652 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
672653
673654 let err1 = "RelVarAlreadyDefinedError"
674655 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"
@@ -684,49 +665,3 @@ testAtomFunctionArgumentMismatch = TestCase $ do
684665 --wrong argument count
685666 let err2 = "FunctionArgumentCountMismatchError"
686667 expectTutorialDErr sessionId dbconn (T.isPrefixOf err2) "x:=relation{tuple{a 5}} where ^gt(@a,1,3)"
687−
688−testInvalidDataConstructor :: Test
689−testInvalidDataConstructor = TestCase $ do
690− --test that a referenced TypeConstructor in a DataConstructor definition matches the expected count of arguments
691− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
692− let err1 = "ConstructedAtomArgumentCountMismatchError"
693− expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "data TestT = TestT Maybe Int"
694−
695−testBasicList :: Test
696−testBasicList = TestCase $ do
697− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
698− executeTutorialD sessionId dbconn "x := relation{tuple{ a (Cons 1 (Cons 2 Empty)) }}"
699−
700−testRelationDeclarationMismatch :: Test
701−testRelationDeclarationMismatch = TestCase $ do
702− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
703− expectTutorialDErr sessionId dbconn (T.isPrefixOf "AtomTypeMismatchError") "data A a = A a | B | C; a := relation{a A Integer}{tuple{a A \"1\"}}"
704−
705−--generate errors when the tuples in a new relation don't match
706−testInvalidTuples :: Test
707−testInvalidTuples = TestCase $ do
708− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
709− expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{b 2}}"
710− expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{a 2, b 3}}"
711−-- expectTutorialDErr sessionId dbconn (T.isPrefixOf "ParseErrorBundle") ":showexpr relation{tuple{a 2, a 3}}" --parse failure can't be validated with this function
712−
713−testSelfReferencingUncommittedContext :: Test
714−testSelfReferencingUncommittedContext = TestCase $ do
715− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
716− executeTutorialD sessionId dbconn "s:=s union s"
717− eS <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())
718− _ <- rollback sessionId dbconn
719− eSorig <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())
720− assertEqual "s=s'" eSorig eS
721−
722−testUnionAndIntersectionAttributeExprs :: Test
723−testUnionAndIntersectionAttributeExprs = TestCase $ do
724− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback
725− executeTutorialD sessionId dbconn "x:=s{intersection of {all but sname} {sname}}"
726− xRel <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())
727− assertEqual "intersection attrs" (Right relationTrue) xRel
728−
729− executeTutorialD sessionId dbconn "y:=s{union of {all but sname} {sname}}"
730− yRel <- executeRelationalExpr sessionId dbconn (RelationVariable "y" ())
731− assertEqual "union attrs" (Right suppliersRel) yRel
732−
test/TutorialD/Interpreter/AtomFunctionScript.hs+17−25
@@ -1,32 +1,25 @@
1−{-# LANGUAGE CPP #-}
1+import TutorialD.Interpreter.TestBase
22import System.Exit
33import Test.HUnit
4−#ifdef PM36_HASKELL_SCRIPTING
5−import TutorialD.Interpreter.TestBase
64import ProjectM36.Client
75import ProjectM36.Relation
86import ProjectM36.DataTypes.Maybe
97import qualified Data.Vector as V
108import qualified Data.Map as M
11−#endif
129
1310{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
1411main :: IO ()
1512main = do
16− tcounts <- runTestTT (TestList [
17−#ifdef PM36_HASKELL_SCRIPTING
18− testBasicAtomFunction,
19− testExceptionAtomFunction,
20− testErrorAtomFunction,
21− testNoArgumentAtomFunction,
22− testArgumentTypeMismatch,
23− testPolymorphicReturnType,
24− testScriptedTypeVariable
25−#endif
26− ])
13+ tcounts <- runTestTT (TestList [testBasicAtomFunction,
14+ testExceptionAtomFunction,
15+ testErrorAtomFunction,
16+ testNoArgumentAtomFunction,
17+ testArgumentTypeMismatch,
18+ testPolymorphicReturnType,
19+ testScriptedTypeVariable
20+ ])
2721 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
2822
29−#ifdef PM36_HASKELL_SCRIPTING
3023--add an atom function and run it
3124testBasicAtomFunction :: Test
3225testBasicAtomFunction = TestCase $ do
@@ -36,7 +29,7 @@ testBasicAtomFunction = TestCase $ do
3629 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()
3730 tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]
3831 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 3]]
39− result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) (TupleExprs () tupleExprs))
32+ result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)
4033
4134 assertEqual "simple atom function equality" expectedResult result
4235
@@ -47,7 +40,7 @@ testExceptionAtomFunction = TestCase $ do
4740 executeTutorialD sess conn "addatomfunction \"mkTest\" Integer -> Either AtomFunctionError Integer \"\"\"(\\(IntegerAtom x:xs) -> (error (show 1))) :: [Atom] -> Either AtomFunctionError Atom\"\"\""
4841 let attrs = [Attribute "x" IntegerAtomType]
4942 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()
50− tupleExprs = TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)]
43+ tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]
5144 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)
5245 assertBool "catch error exception from script" (case result of
5346 Left (UnhandledExceptionError _) -> True
@@ -64,7 +57,7 @@ testNoArgumentAtomFunction = TestCase $ do
6457 executeTutorialD sess conn "addatomfunction \"mkTest\" Either AtomFunctionError Integer \"\"\"(\\x -> pure (IntegerAtom 5)) :: [Atom] -> Either AtomFunctionError Atom\"\"\""
6558 let attrs = [Attribute "x" IntegerAtomType]
6659 funcAtomExpr = FunctionAtomExpr "mkTest" [] ()
67− tupleExprs = TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)]
60+ tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]
6861 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 5]]
6962 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)
7063 assertEqual "no argument scripted function" expectedResult result
@@ -73,7 +66,7 @@ testArgumentTypeMismatch :: Test
7366testArgumentTypeMismatch = TestCase $ do
7467 (sess, conn) <- dateExamplesConnection emptyNotificationCallback
7568 executeTutorialD sess conn "addatomfunction \"mkTest\" Integer -> Either AtomFunctionError Integer \"\"\"(\\(IntegerAtom x:_) -> pure $ TextAtom \"wrong type\") :: [Atom] -> Either AtomFunctionError Atom\"\"\""
76− let tupleExprs = TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)]
69+ let tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]
7770 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()
7871 attrs = [Attribute "x" IntegerAtomType]
7972 expectedResult = Left (AtomTypeMismatchError IntegerAtomType TextAtomType)
@@ -87,7 +80,7 @@ testPolymorphicReturnType = TestCase $ do
8780 let funcAtomExpr = FunctionAtomExpr "fromMaybe" [NakedAtomExpr (IntegerAtom 5),
8881 NakedAtomExpr maybeAtom] ()
8982 maybeAtom = ConstructedAtom "Just" (maybeAtomType IntegerAtomType) [IntegerAtom 3]
90− relExpr = MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)])
83+ relExpr = MakeRelationFromExprs Nothing [TupleExpr (M.singleton "x" funcAtomExpr)]
9184 mRelType <- typeForRelationalExpr sess conn relExpr
9285 case mRelType of
9386 Left err -> assertFailure (show err)
@@ -101,7 +94,7 @@ testPolymorphicReturnType = TestCase $ do
10194 let failFuncAtomExpr = FunctionAtomExpr "fromMaybe" [NakedAtomExpr (IntegerAtom 5),
10295 NakedAtomExpr mismatchAtom] ()
10396 mismatchAtom = ConstructedAtom "Just" (maybeAtomType TextAtomType) [TextAtom "fail"]
104− failRelExpr = MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (M.singleton "x" failFuncAtomExpr)])
97+ failRelExpr = MakeRelationFromExprs Nothing [TupleExpr (M.singleton "x" failFuncAtomExpr)]
10598 mFailRes <- executeRelationalExpr sess conn failRelExpr
10699 let expectedErr = Left (AtomFunctionTypeVariableMismatch "a" IntegerAtomType TextAtomType)
107100 assertEqual "expected type variable mismatch" expectedErr mFailRes
@@ -113,10 +106,9 @@ testScriptedTypeVariable = TestCase $ do
113106 executeTutorialD sess conn "addatomfunction \"idTest\" a -> Either AtomFunctionError a \"(\\\\(x:_) -> pure x) :: [Atom] -> Either AtomFunctionError Atom\""
114107 let attrs = [Attribute "x" IntegerAtomType]
115108 funcAtomExpr = FunctionAtomExpr "idTest" [NakedAtomExpr (IntegerAtom 3)] ()
116− tupleExprs = TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)]
109+ tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]
117110 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 3]]
118111 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)
119112
120113 assertEqual "id function equality" expectedResult result
121−
122−#endif
114+
test/TutorialD/Interpreter/DatabaseContextFunctionScript.hs+6−13
@@ -1,26 +1,19 @@
1−{-# LANGUAGE CPP #-}
1+import TutorialD.Interpreter.TestBase
22import System.Exit
33import Test.HUnit
4−#ifdef PM36_HASKELL_SCRIPTING
5−import TutorialD.Interpreter.TestBase
64import ProjectM36.Client
75import ProjectM36.Relation
86import qualified Data.Text as T
9−#endif
107
118main :: IO ()
129main = do
13− tcounts <- runTestTT (TestList [
14−#ifdef PM36_HASKELL_SCRIPTING
15− testBasicDBCFunction,
16− testErrorDBCFunction,
17− testExceptionDBCFunction,
18− testDBCFunctionWithAtomArguments
19−#endif
10+ tcounts <- runTestTT (TestList [testBasicDBCFunction,
11+ testErrorDBCFunction,
12+ testExceptionDBCFunction,
13+ testDBCFunctionWithAtomArguments
2014 ])
2115 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
2216
23−#ifdef PM36_HASKELL_SCRIPTING
2417testBasicDBCFunction :: Test
2518testBasicDBCFunction = TestCase $ do
2619 (sess, conn) <- dateExamplesConnection emptyNotificationCallback
@@ -62,4 +55,4 @@ testDBCFunctionWithAtomArguments = TestCase $ do
6255 assertEqual "person relation" expectedPerson result
6356 expectTutorialDErr sess conn (T.isPrefixOf "AtomTypeMismatchError") "execute multiArgFunc(\"fail\", \"fail\")"
6457
65−#endif
58+
test/TutorialD/Interpreter/Import/ImportTest.hsdeleted−47
@@ -1,47 +0,0 @@
1−import Test.HUnit
2−import ProjectM36.Base
3−import TutorialD.Interpreter.Import.TutorialD
4−import System.Exit
5−import qualified Data.Text as T
6−import System.IO.Temp
7−import System.FilePath
8−import qualified Data.Map as M
9−import System.IO
10−import System.Directory
11−import qualified Data.ByteString as BS
12−import qualified Data.Text.Encoding as TE
13−import Text.URI hiding (makeAbsolute)
14−
15−main :: IO ()
16−main = do
17− tcounts <- runTestTT $ TestList [testTutdFileImport
18− ,testTutdHTTPSImport
19− ]
20− if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
21−
22−testTutdFileImport :: Test
23−testTutdFileImport = TestCase $
24− withSystemTempFile "m.tutd" $ \tempPath handle -> do
25− BS.hPut handle (TE.encodeUtf8 "x:=relation{tuple{a 5,b \"spam\"}}; y:=relation{tuple{b \"漢字\"}}")
26− hClose handle
27− let expectedExpr = MultipleExpr [
28− Assign "x" (MakeRelationFromExprs Nothing
29− $ TupleExprs () [TupleExpr (M.fromList [("a", NakedAtomExpr $ IntegerAtom 5),
30− ("b", NakedAtomExpr $ TextAtom "spam")])]),
31− Assign "y" (MakeRelationFromExprs Nothing
32− $ TupleExprs () [TupleExpr (M.fromList [("b", NakedAtomExpr (TextAtom "漢字"))])])]
33− --on Windows, the file URI should not include the drive letter "/c/Users..." -> "/Users"
34− let uri = "file://" <> map (\c -> if c == '\\' then '/' else c) ( joinDrive "/" (dropDrive tempPath))
35− fileURI <- mkURI (T.pack uri)
36− imported <- importTutorialDFromFile fileURI Nothing
37− assertEqual "import tutd" (Right expectedExpr) imported
38−
39−testTutdHTTPSImport :: Test
40−testTutdHTTPSImport = TestCase $ do
41− uri <- mkURI "https://raw.githubusercontent.com/agentm/project-m36/master/test/TutorialD/Interpreter/Import/httpimporttest.tutd"
42− let hash = "effe32b247586dc3ac0079fc241b9618d41d189afcaeb7907edbe5a8b45992a4"
43− expected = Right (MultipleExpr [Assign "x" (RelationVariable "true" ()),Assign "y" (RelationVariable "false" ())])
44− actual <- importTutorialDViaHTTP uri (Just hash)
45− assertEqual "github https" expected actual
46−
47−
test/TutorialD/Interpreter/Import/TutorialD.hsnew file+29
@@ -0,0 +1,29 @@
1+import Test.HUnit
2+import ProjectM36.Base
3+import TutorialD.Interpreter.Import.TutorialD
4+import System.Exit
5+import System.IO.Temp
6+import qualified Data.Map as M
7+import System.IO
8+import qualified Data.ByteString as BS
9+import qualified Data.Text.Encoding as TE
10+
11+main :: IO ()
12+main = do
13+ tcounts <- runTestTT $ TestList [testTutdImport]
14+ if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
15+
16+testTutdImport :: Test
17+testTutdImport = TestCase $
18+ withSystemTempFile "m.tutd" $ \tempPath handle -> do
19+ BS.hPut handle (TE.encodeUtf8 "x:=relation{tuple{a 5,b \"spam\"}}; y:=relation{tuple{b \"漢字\"}}")
20+ hClose handle
21+ let expectedExpr = MultipleExpr [
22+ Assign "x" (MakeRelationFromExprs Nothing
23+ [TupleExpr (M.fromList [("a", NakedAtomExpr $ IntegerAtom 5),
24+ ("b", NakedAtomExpr $ TextAtom "spam")])]),
25+ Assign "y" (MakeRelationFromExprs Nothing
26+ [TupleExpr (M.fromList [("b", NakedAtomExpr (TextAtom "漢字"))])])]
27+ imported <- importTutorialD tempPath
28+ assertEqual "import tutd" (Right expectedExpr) imported
29+
test/TutorialD/Interpreter/Import/httpimporttest.tutddeleted−2
@@ -1,2 +0,0 @@
1−x:=true;
2−y:=false;
test/TutorialD/Interpreter/TestBase.hs+8−8
@@ -28,13 +28,13 @@ executeTutorialD sessionId conn tutd = case parseTutorialD tutd of
2828 Right parsed -> do
2929 result <- evalTutorialD sessionId conn UnsafeEvaluation parsed
3030 case result of
31− QuitResult -> assertFailure "quit?"
32− DisplayResult _ -> assertFailure "display?"
33− DisplayIOResult _ -> assertFailure "displayIO?"
34− DisplayRelationResult _ -> assertFailure "displayrelation?"
35− DisplayDataFrameResult _ -> assertFailure "displaydataframe?"
36− DisplayParseErrorResult _ _ -> assertFailure "displayparseerrorresult?"
37− DisplayErrorResult err -> assertFailure (show tutd ++ ": " ++ show err)
31+ QuitResult -> putStrLn "yyy" >> assertFailure "quit?"
32+ DisplayResult _ -> putStrLn "xxx" >> assertFailure "display?"
33+ DisplayIOResult _ -> putStrLn "z" >> assertFailure "displayIO?"
34+ DisplayRelationResult _ -> putStrLn "Y" >> assertFailure "displayrelation?"
35+ DisplayDataFrameResult _ -> putStrLn "DF" >> assertFailure "displaydataframe?"
36+ DisplayParseErrorResult _ _ -> putStrLn "X" >> assertFailure "displayparseerrorresult?"
37+ DisplayErrorResult err -> putStrLn "asd" >> assertFailure (show tutd ++ ": " ++ show err)
3838 QuietSuccessResult -> pure ()
3939
4040expectTutorialDErr :: SessionId -> Connection -> (Text -> Bool) -> Text -> IO ()
@@ -49,7 +49,7 @@ expectTutorialDErr sessionId conn matchFunc tutd = case parseTutorialD tutd of
4949 DisplayRelationResult _ -> assertFailure "displayrelation?"
5050 DisplayDataFrameResult _ -> assertFailure "displaydataframe?"
5151 DisplayParseErrorResult _ _ -> assertFailure "displayparseerrorresult?"
52− DisplayErrorResult err -> assertBool (unpack tutd ++ " match error on: " ++ unpack err) (matchFunc err)
52+ DisplayErrorResult err -> assertBool ("match error on: " ++ unpack err) (matchFunc err)
5353 QuietSuccessResult -> pure ()
5454
5555eitherFail :: Either RelationalError a -> IO ()
test/TutorialD/PrinterTest.hsdeleted−47
@@ -1,47 +0,0 @@
1−{-# LANGUAGE OverloadedStrings #-}
2−import Test.HUnit
3−import ProjectM36.Base
4−import System.Exit
5−import Data.Text.Prettyprint.Doc
6−import Data.Map (fromList)
7−import TutorialD.Printer ()
8−import TutorialD.Interpreter.RelationalExpr
9−import Text.Megaparsec
10−import Data.Text (pack)
11−
12−testList :: Test
13−testList = TestList [
14− testPretty "true" (RelationVariable "true" ()),
15− testPretty "relation{tuple{a 3, b \"x\"}, tuple{a 4, b \"y\"}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",NakedAtomExpr (IntegerAtom 3)),("b",NakedAtomExpr (TextAtom "x"))]),TupleExpr (fromList [("a",NakedAtomExpr (IntegerAtom 4)),("b",NakedAtomExpr (TextAtom "y"))])])),
16− testPretty "true:{a:=1, b:=1}" (Extend (AttributeExtendTupleExpr "b" (NakedAtomExpr (IntegerAtom 1))) (Extend (AttributeExtendTupleExpr "a" (NakedAtomExpr (IntegerAtom 1))) (RelationVariable "true" ()))),
17− testPretty "relation{tuple{a fromGregorian(2014, 2, 4)}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",FunctionAtomExpr "fromGregorian" [NakedAtomExpr (IntegerAtom 2014),NakedAtomExpr (IntegerAtom 2),NakedAtomExpr (IntegerAtom 4)] ())])])),
18− testPretty "relation{tuple{a bytestring(\"dGVzdGRhdGE=\")}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",FunctionAtomExpr "bytestring" [NakedAtomExpr (TextAtom "dGVzdGRhdGE=")] ())])])),
19− testPretty "relation{tuple{a t}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",NakedAtomExpr (BoolAtom True))])])),
20− testPretty "relation{tuple{a Cons 4 (Cons 5 Empty)}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",ConstructedAtomExpr "Cons" [NakedAtomExpr (IntegerAtom 4),ConstructedAtomExpr "Cons" [NakedAtomExpr (IntegerAtom 5),ConstructedAtomExpr "Empty" [] ()] ()] ())])])),
21− testPretty "relation{a Int, b Text, c Bool}{}" (MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "a" (ADTypeConstructor "Int" []) (),AttributeAndTypeNameExpr "b" (ADTypeConstructor "Text" []) (),AttributeAndTypeNameExpr "c" (ADTypeConstructor "Bool" []) ()]) (TupleExprs () [])),
22− testPretty "relation{a relation{b Int}}{}" (MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "a" (RelationAtomTypeConstructor [AttributeAndTypeNameExpr "b" (ADTypeConstructor "Int" []) ()]) ()]) (TupleExprs () []))
23− ]
24−
25−main :: IO ()
26−main = do
27− tcounts <- runTestTT testList
28− if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess
29−
30−testPretty :: String -> RelationalExpr -> Test
31−testPretty tutdStr relExprADT =
32− TestCase $ do
33− let relExprStr = show (pretty relExprADT)
34− print relExprStr
35− roundTrip <- parseRelExpr relExprStr
36− {-tutdIn <- parseRelExpr tutdStr
37− print ("tutd parsed", tutdIn)-}
38− assertEqual ("pretty ADT " <> tutdStr) tutdStr relExprStr
39− assertEqual ("round-trip " <> tutdStr) relExprADT roundTrip
40−
41−--round trip tutoriald
42−parseRelExpr :: String -> IO RelationalExpr
43−parseRelExpr tutdStr =
44− case parse relExprP "test" (pack tutdStr) of
45− Left err ->
46− assertFailure (show err)
47− Right parsed -> pure parsed
test/scripts.hs+2−5
@@ -4,8 +4,6 @@ import TutorialD.Interpreter.Import.TutorialD
44import System.Directory
55import Data.List (isSuffixOf)
66import System.Exit
7−import qualified Data.Text as T
8−import Text.URI
97
108testList :: IO Test
119testList = do
@@ -22,8 +20,7 @@ main = do
2220
2321testScript :: FilePath -> Test
2422testScript tutdFile = TestCase $ do
25− fileURI <- mkURI (T.pack ("file://" <> tutdFile))
26− eImport <- importTutorialDFromFile fileURI Nothing
23+ eImport <- importTutorialD tutdFile
2724 case eImport of
2825 Left err -> assertFailure ("tutd import failure in " ++ tutdFile ++ ": " ++ show err)
29− Right _ -> pure ()
26+ Right _ -> pure ()