master..4b341b5 · project-m36

git.iko.soy/project-m36

84 files changed+1102−1917

unifiedsplit

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

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

66 dockerimage:

77 runs-on: ubuntu-latest

88 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/

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+ run: echo ${{secrets.DOCKERHUB_PASSWORD}} | docker login --username ${{secrets.DOCKERHUB_USER}} --password-stdin

22+ - name: docker tag with version

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

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

25+ - name: docker tag latest

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

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

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

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

.gitignore−1

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

2020juyter/dist

2121.ipynb_checkpoints

2222project-m36.nix

23−stack.yaml

.travis.ymlnew file+60

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

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

2+language: c

3+sudo: false

5+git:

6+ submodules: false # whether to recursively clone submodules

8+cache:

9+ directories:

10+ - $HOME/.ghc

11+ - $HOME/.cabal

12+ - $HOME/.stack

13+ - .stack-work

14+ timeout: 1000

15+

16+matrix:

17+ fast_finish: true

18+ include:

19+ - env: CACHE_NAME=8.4.4 STACK_YAML=stack.ghc8.4.yaml

20+ compiler: ": #stack 8.4.4"

21+

22+ - env: CACHE_NAME=8.6.5 STACK_YAML=stack.ghc8.6.yaml

23+ compiler: ": #stack 8.6.5"

24+

25+ - env: CACHE_NAME=osx-8.6.5 STACK_YAML=stack.ghc8.6.yaml

26+ os: osx

27+ osx_image: xcode11

28+ compiler: ": #stack 8.6.5"

29+

30+before_script:

31+ - unset CC

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

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

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

35+

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

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

38+script:

39+ - |

40+ # Run tests

41+ set -e

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

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

44+ - |

45+ #Run HLint

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

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

48+ fi

49+ - |

50+ #Run Haddock

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

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

53+ fi

54+

55+after_success:

56+ - |

57+ # Build and ship binary

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

59+

60+# EOF

.travis/attach-binary.shnew file+25

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

1+#!/bin/sh

2+set -o errexit -o verbose

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

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

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

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

5+set -eux

7+travis_retry() {

8+ cmd=$*

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

10+}

11+

12+fetch_stack_osx() {

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

14+}

15+

16+fetch_stack_linux() {

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

18+}

19+

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

21+# builds.

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

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

24+ travis_retry fetch_stack_osx

25+else

26+ travis_retry fetch_stack_linux

27+fi

Changelog.markdown−9

@@ -1,12 +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−

101# 2020-11-21 (v0.8.2)

112

123* support multiple extend expressions in TutorialD

README.markdown+3−2

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

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)

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

910

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

4445

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

4647* [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)

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

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

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

5051

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

9495

9596## Development

9697

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

98+Project:M36 is developed in Haskell and compiled with GHC 8.2.2 or later.

9899

99100## Related Projects

100101

cabal.project+5−2

@@ -1,7 +1,10 @@

11packages: project-m36.cabal

3−package *

4− split-sections: True

3+--RPC library

4+source-repository-package

5+ type: git

6+ location: https://github.com/agentm/curryer.git

7+ tag: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

69--high-performance streaming library

710source-repository-package

docker.nix+11−16

@@ -1,18 +1,13 @@

1−{ compiler ? "ghc8104"

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

3−, pkgs ? import sources.nixpkgs { }

4−}:

1+{ pkgs ? import ./pkgs.nix }:

52let

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

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

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

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

85in

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

6+ pkgs.dockerTools.buildImage {

7+ name = "project-m36";

8+ tag = "latest";

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

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

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

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

13+ }

docs/15_minute_tutorial.markdown+8−4

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

55## Prerequisites

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

7+* any Linux

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

9+* cabal (package downloader) installed

810

911## Download and Install

1012

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

1214

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

1416

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

17+or build it yourself:

1618

1719```bash

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

19−cabal new-run tutd

21+cabal sandbox init

22+cabal install --dependencies-only

23+cabal run tutd

2024```

2125

2226## Some Basic TutorialD

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

2832### Load the Canonical Chris Date Example

2933

3034```

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

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

3236```

3337

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

docs/import_export_csv.markdown+2−2

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

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

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

5151

5252To build with stack:

5353

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

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

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

5656* Linux, macOS, or Microsoft Windows

5757

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

6363

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

6565

66−Alternative building with GHC 8.6.5 or greater:

66+Alternative building with GHC 8.4.4 or greater:

6767

6868* ```cabal new-build```

6969

docs/introduction_to_the_relational_algebra.markdown+1−1

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

202202

203203(Course Relation)

204204

205−|(Course Name, Course Name Type)|(Instructor 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|

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/tutd_cheatsheet.markdown+1−3

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

4747

4848|Database Context Expression |Description |

4949|------------------------------------------------------|---------------------------------------|

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|

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

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

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

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

docs/tutd_tutorial.markdown+1−19

@@ -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:

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/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); }

pkgs.nixnew file+7

@@ -0,0 +1,7 @@

1+let

2+nixpkgs = builtins.fetchGit {

3+ url = "https://github.com/NixOS/nixpkgs";

4+ rev = "f58482658eabf7d695f45904ecbc5f49c19fef98";

5+};

6+in

7+import nixpkgs { config.allowBroken = true; }

project-m36.cabal+44−69

@@ -1,8 +1,7 @@

11Cabal-Version: 2.2

22Name: 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

3+Version: 0.9.0

4+License: Unlicense

65Build-Type: Simple

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

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

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

3534 Default: True

3635

3736Library

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

37+ Build-Depends: base>=4.8 && < 4.15, ghc-paths, mtl, containers, unordered-containers, hashable, haskeline, directory, MonadRandom, random-shuffle, uuid >= 1.3.12, cassava >= 0.4.5.1 && < 0.6, text, bytestring, deepseq, deepseq-generics, vector, parallel, monad-parallel, exceptions, transformers, gnuplot, filepath, zlib, directory, temporary, stm, time, hashable-time, old-locale, rset, attoparsec, either, base64-bytestring, data-interval, extended-reals, network-transport, aeson >= 1.1, path-pieces, conduit, resourcet, http-api-data, semigroups, QuickCheck, quickcheck-instances, list-t, stm-containers >= 0.2.15, foldl, optparse-applicative, Glob, cryptohash-sha256, text-manipulate >= 0.2.0.1 && < 0.3, winery, curryer, network, async, vector-instances

3938 if flag(haskell-scripting)

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

4140 CPP-Options: -DPM36_HASKELL_SCRIPTING

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

6362 ProjectM36.AtomFunction,

6463 ProjectM36.AtomFunctionError,

6564 ProjectM36.ScriptSession,

66− ProjectM36.Shortcuts,

6765 ProjectM36.DatabaseContextFunction,

6866 ProjectM36.DatabaseContextFunctionError,

6967 ProjectM36.DatabaseContextFunctionUtils,

@@ -136,14 +134,14 @@ Library

136134 Other-Modules: ProjectM36.Win32Handle

137135 else

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

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

137+ GHC-Options: -rdynamic

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

141139 Build-Depends: unix

142140 CC-Options: -fPIC

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

144142 Default-Language: Haskell2010

145143 Default-Extensions: OverloadedStrings, CPP

146− if !flag(stack)

144+ if !flag(stack)

147145 Build-Depends: deferred-folds

148146

149147Executable tutd

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

175173 directory,

176174 filepath,

177175 temporary,

178− megaparsec >= 5.2.0 && < 10,

176+ megaparsec >= 5.2.0 && < 9,

179177 haskeline,

180178 random, MonadRandom,

181179 base64-bytestring,

@@ -184,14 +182,8 @@ Executable tutd

184182 stm-containers >= 1.0.0,

185183 list-t,

186184 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

185+ curryer,

186+ prettyprinter

195187 Other-Modules: TutorialD.Interpreter,

196188 TutorialD.Interpreter.Base,

197189 TutorialD.Interpreter.DatabaseContextExpr,

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

237229 optparse-applicative,

238230 hashable-time,

239231 time,

232+ vector-binary-instances,

240233 text,

241234 deepseq-generics,

242235 mtl,

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

258251Executable bigrel

259252 Default-Language: Haskell2010

260253 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

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

262255 Other-Modules: TutorialD.Interpreter.Base,

263256 TutorialD.Interpreter.DatabaseContextExpr,

264257 TutorialD.Interpreter.RelationalExpr,

@@ -270,11 +263,11 @@ Executable bigrel

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

271264

272265Common commontest

273− Default-Language: Haskell2010

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

266+ Default-Language: Haskell2010

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

275268 Default-Extensions: OverloadedStrings

276269 GHC-Options: -Wall -threaded

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

270+ Hs-Source-Dirs: ./src/bin, ., test/

278271

279272Benchmark basic-benchmark

280273 Default-Language: Haskell2010

@@ -287,79 +280,67 @@ Benchmark basic-benchmark

287280 if flag(profiler)

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

289282

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−

302283Test-Suite test-tutoriald

303284 import: commontest

304285 type: exitcode-stdio-1.0

305− main-is: TutorialD/InterpreterTest.hs

286+ main-is: test/TutorialD/Interpreter.hs

306287 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

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

308289

309290Test-Suite test-tutoriald-atomfunctionscript

310291 import: commontest

311292 type: exitcode-stdio-1.0

312293 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

294+ main-is: test/TutorialD/Interpreter/AtomFunctionScript.hs

314295

315296Test-Suite test-tutoriald-databasecontextfunctionscript

316297 import: commontest

317298 type: exitcode-stdio-1.0

318299 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

300+ main-is: test/TutorialD/Interpreter/DatabaseContextFunctionScript.hs

320301

321302Test-Suite test-relation

322303 import: commontest

323304 type: exitcode-stdio-1.0

324− main-is: Relation/Basic.hs

305+ main-is: test/Relation/Basic.hs

325306

326307Test-Suite test-static-optimizer

327308 import: commontest

328309 type: exitcode-stdio-1.0

329− main-is: Relation/StaticOptimizer.hs

310+ main-is: test/Relation/StaticOptimizer.hs

330311

331312Test-Suite test-transactiongraph-persist

332313 import: commontest

333314 type: exitcode-stdio-1.0

334− main-is: TransactionGraph/Persist.hs

315+ main-is: test/TransactionGraph/Persist.hs

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

336317

337318Test-Suite test-relation-import-csv

338319 import: commontest

339320 type: exitcode-stdio-1.0

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

321+ main-is: test/Relation/Import/CSV.hs

341322

342323Test-Suite test-tutoriald-import-tutoriald

343324 import: commontest

344325 type: exitcode-stdio-1.0

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

326+ main-is: test/TutorialD/Interpreter/Import/TutorialD.hs

346327 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

347328

348329Test-Suite test-relation-export-csv

349330 import: commontest

350331 type: exitcode-stdio-1.0

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

332+ main-is: test/Relation/Export/CSV.hs

352333

353334Test-Suite test-transactiongraph-merge

354335 import: commontest

355336 type: exitcode-stdio-1.0

356− main-is: TransactionGraph/Merge.hs

337+ main-is: test/TransactionGraph/Merge.hs

357338

358339

359340Test-Suite test-prettyprinter

360341 import: commontest

361342 type: exitcode-stdio-1.0

362− main-is: TutorialD/PrinterTest.hs

343+ main-is: test/TutorialD/Printer.hs

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

364345

365346benchmark bench

@@ -370,48 +351,41 @@ benchmark bench

370351Test-Suite test-server

371352 import: commontest

372353 type: exitcode-stdio-1.0

373− main-is: Server/Main.hs

354+ main-is: test/Server/Main.hs

374355

375356

376357Executable Example-SimpleClient

377358 Default-Language: Haskell2010

378359 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

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

380361 Main-Is: examples/SimpleClient.hs

381362 GHC-Options: -Wall -threaded

382363

383364Executable Example-OutOfTheTarpit

384365 Default-Language: Haskell2010

385366 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

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

387368 Main-Is: examples/out_of_the_tarpit.hs

388369 GHC-Options: -Wall -threaded

389370

390371Executable Example-Blog

391372 Default-Language: Haskell2010

392373 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

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

394375 Main-Is: examples/blog.hs

395376 GHC-Options: -Wall -threaded

396377

397378Executable Example-Hair

398379 Default-Language: Haskell2010

399380 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

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

401382 Main-Is: examples/hair.hs

402383 GHC-Options: -Wall -threaded

403384

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−

411385Executable Example-CustomTupleable

412386 Default-Language: Haskell2010

413387 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

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

415389 Main-Is: examples/CustomTupleable.hs

416390 GHC-Options: -Wall -threaded

417391

@@ -428,12 +402,13 @@ Executable Example-DerivingCustomTupleable

428402Test-Suite test-scripts

429403 import: commontest

430404 type: exitcode-stdio-1.0

431− main-is: scripts.hs

405+ main-is: test/scripts.hs

432406 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

433407

434408Executable project-m36-websocket-server

435409 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

410+ Build-Depends: base, aeson, path-pieces, either, conduit, http-api-data, template-haskell, websockets, aeson, optparse-applicative, project-m36, containers, bytestring, text, vector, uuid, megaparsec, haskeline, mtl, directory, base64-bytestring, random, MonadRandom, time, network-transport-tcp, semigroups, attoparsec, parser-combinators, prettyprinter, network

411+ 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

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

438413 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

439414 GHC-Options: -Wall -threaded

@@ -443,46 +418,46 @@ Executable project-m36-websocket-server

443418Test-Suite test-websocket-server

444419 import: commontest

445420 type: exitcode-stdio-1.0

446− main-is: Server/WebSocket.hs

421+ main-is: test/Server/WebSocket.hs

447422 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

448423

449424Test-Suite test-isomorphic-schemas

450425 import: commontest

451426 type: exitcode-stdio-1.0

452− main-is: IsomorphicSchema.hs

427+ main-is: test/IsomorphicSchema.hs

453428

454429Test-Suite test-atomable

455430 import: commontest

456431 type: exitcode-stdio-1.0

457− main-is: Relation/Atomable.hs

432+ main-is: test/Relation/Atomable.hs

458433 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

459434

460435Test-Suite test-multiprocess-access

461436 import: commontest

462437 type: exitcode-stdio-1.0

463− main-is: MultiProcessDatabaseAccess.hs

438+ main-is: test/MultiProcessDatabaseAccess.hs

464439

465440Test-Suite test-transactiongraph-automerge

466441 import: commontest

467442 type: exitcode-stdio-1.0

468− main-is: TransactionGraph/Automerge.hs

443+ main-is: test/TransactionGraph/Automerge.hs

469444 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

470445

471446Test-Suite test-tupleable

472447 import: commontest

473448 type: exitcode-stdio-1.0

474− main-is: Relation/Tupleable.hs

449+ main-is: test/Relation/Tupleable.hs

475450

476451Test-Suite test-client-simple

477452 import: commontest

478− Main-Is: Client/Simple.hs

453+ Main-Is: test/Client/Simple.hs

479454 type: exitcode-stdio-1.0

480455

481456-- test for file handle leaks

482457Executable handles

483458 Default-Language: Haskell2010

484459 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

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

486461 main-is: benchmark/Handles.hs

487462 Other-Modules: TutorialD.Interpreter,

488463 TutorialD.Interpreter.Base,

@@ -506,9 +481,9 @@ Executable handles

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

507482 if flag(profiler)

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

509−

484+

510485Test-Suite test-dataframe

511486 import: commontest

512487 type: exitcode-stdio-1.0

513− Main-Is: DataFrame.hs

488+ Main-Is: test/DataFrame.hs

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

release.nix+58−17

@@ -1,30 +1,71 @@

1−{ compiler ? "ghc8104"

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

3−, pkgs ? import sources.nixpkgs { }

1+{ compiler ? "ghc865"

2+, pkgs ? import ./pkgs.nix

43}:

55let

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

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

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

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

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

11+ distProcessPkg = pkg : dontHaddock (doJailbreak (dontCheck pkg));

12+ callHackageDirectWithOptions = {pkg,ver, sha256, options}:

13+ let pkgver = "${pkg}-${ver}";

14+ in

15+ haskellPackages.callCabal2nixWithOptions pkg (pkgs.fetchzip {

16+ url = "mirror://hackage/${pkgver}/${pkgver}.tar.gz";

17+ inherit sha256;

18+ }) options;

19+

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

1521 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" { }));

22+ rank1dynamic =

23+ distProcessPkg (self.callHackageDirect {

24+ pkg = "rank1dynamic";

25+ ver = "0.4.0";

26+ sha256 = "1x6p9z53s7xwp93jp4n1lq6m5xspcn6w62p461v8vqnp9600328b";

27+}{});

28+ stm-hamt =

29+ self.callHackageDirect {

30+ pkg = "stm-hamt";

31+ ver = "1.2.0.3";

32+ sha256 = "1i8j7q8nhx3l7gydrjlsyhkvllr6bppgrjf0hp38zpm7p6xcv2bb";

33+ }{};

34+

35+ stm-containers =

36+ self.callHackageDirect {

37+ pkg = "stm-containers";

38+ ver = "1.1.0.4";

39+ sha256 = "0h9z6lawdm44minx9spvdb7sp645l36ri5cnxvhrcxwzr64s7qb5";

40+ }{};

41+

42+ data-interval =

43+ self.callHackageDirect {

44+ pkg = "data-interval";

45+ ver = "2.0.1";

46+ sha256 = "085j4yjr8wimxampxqdrg47p577whwg2mjxgfdl44yfck52fb6an";

47+ }{};

48+

49+ curryer =

50+ self.callHackageDirect {

51+ pkg = "curryer";

52+ ver = "0.1";

53+ sha256 = "085j4yjr8wimxampxqdrg47p577whwg2mjxgfdl44yfck52fb6ac";

54+ }{};

55+

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

57+

1958 };

2059 };

60+

61+ project = haskellPackages.project-m36;

2162in

2263{

23− project = haskellPackages.project-m36;

64+ project = project;

2465

2566 shell = haskellPackages.shellFor {

26− packages = p: [

27− p.project-m36

67+ packages = p: with p; [

68+ project

2869 ];

2970 buildInputs = [

3071 haskellPackages.ghcid

@@ -33,4 +74,4 @@ in

3374 ];

3475 withHoogle = true;

3576 };

36−}

77+}

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

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

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

1111import ProjectM36.IsomorphicSchema

1212import ProjectM36.Server.RemoteCallTypes

1313import ProjectM36.MerkleHash

14−import ProjectM36.Attribute as A

1514

1615import Data.Aeson

1716import Data.ByteString.Base64 as B64

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

4544instance ToJSON Relation

4645instance FromJSON Relation

4746

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"

47+instance ToJSON Attribute

48+instance FromJSON Attribute

5349

5450instance ToJSON ExtendTupleExpr

5551instance FromJSON ExtendTupleExpr

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

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

150146 Right bs -> pure (MerkleHash bs)

151147

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−

158148instance ToJSON RelationalError

159149instance FromJSON RelationalError

160150

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

164154instance ToJSON MergeError

165155instance FromJSON MergeError

166156

167−instance ToJSON ImportError'

168−instance FromJSON ImportError'

169−

170157instance ToJSON DatabaseContextFunctionError

171158instance FromJSON DatabaseContextFunctionError

172159

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

181168

182169instance ToJSON WithNameExpr

183170instance FromJSON WithNameExpr

184−

185−

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

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

2222import Control.Applicative

2323import Text.Megaparsec.Error

2424import Data.Functor

25−import Data.Either (fromRight)

2625

2726#if MIN_VERSION_megaparsec(7,0,0)

2827import Data.List.NonEmpty as NE

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

118117promptInfo sessionId conn = do

119118 eHeadName <- headName sessionId conn

120119 eSchemaName <- currentSchemaName sessionId conn

121− pure (fromRight "<unknown>" eHeadName, fromRight "<no schema>" eSchemaName)

120+ pure (either (const "<unknown>") id eHeadName, either (const "<no schema>") id eSchemaName)

122121

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

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

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

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

126126 <li>:showrelvars</li>

127127 <li>:showexpr true</li>

128128 <li>:showexpr false</li>

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

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

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

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

132132 <li>:showexpr s</li>

src/bin/ProjectM36/Server/WebSocket/websocket-server.hs+9−42

@@ -1,40 +1,23 @@

11{-# LANGUAGE CPP #-}

2−

2+import ProjectM36.Server.WebSocket

3+import ProjectM36.Server.Config

4+import ProjectM36.Server.ParseArgs

5+import ProjectM36.Server

36import Control.Concurrent

7+import qualified Network.WebSockets as WS

48import Control.Exception

5−import Control.Monad (when)

6−import Data.Maybe (isJust)

7−import Data.String (fromString)

8−import Network.HTTP.Types (status400)

99import Network.Socket

10−import Network.Wai (Application, responseLBS)

11−import Network.Wai.Handler.Warp

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

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

14−import Network.WebSockets (defaultConnectionOptions)

15−import ProjectM36.Server

16−import ProjectM36.Server.Config

17−import ProjectM36.Server.ParseArgs

18−import ProjectM36.Server.WebSocket

1910

2011main :: IO ()

2112main = do

2213 -- launch normal project-m36-server

2314 addressMVar <- newEmptyMVar

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

25−

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

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

27− let serverConfig = wsServerConfig wsConfig

28− wsHost = bindHost serverConfig

17+ let wsHost = bindHost serverConfig

2918 wsPort = bindPort serverConfig

3019 serverHost = "127.0.0.1"

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

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

3922 --wait for server to be listening

4023 addr <- takeMVar addressMVar

@@ -42,22 +25,6 @@ main = do

4225 case addr of

4326 SockAddrInet port' _ -> fromIntegral port'

4427 _ -> 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"

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

29+ WS.runServer wsHost (fromIntegral wsPort) (websocketProxyServer port serverHost)

5530

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+1−3

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

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)

@@ -78,7 +77,7 @@ 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

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

8281

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

8483parseTutorialD = parse interpreterParserP ""

@@ -216,7 +215,6 @@ 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

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

@@ -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,6 +30,7 @@ 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

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

4444import Data.Time.Clock

4545import Data.Time.Format

4646import Control.Monad (void)

47−import Data.Char

4847

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

5049anySingle :: Parsec Void Text (Token Text)

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

8281type ParseStr = String

8382#endif

8483

85−-- consumes only horizontal spaces

8684spaceConsumer :: Parser ()

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

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

8886

8987opChar :: Parser Char

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

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

137135semi :: Parser Text

138136semi = symbol ";"

139137

140−nline :: Parser Text

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

142−

143138integer :: Parser Integer

144139#if MIN_VERSION_megaparsec(6,0,0)

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

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

155150#endif

156151

157152float :: Parser Double

158−float = Lex.float <* spaceConsumer

153+float = Lex.float

159154

160155capitalizedIdentifier :: Parser Text

161156capitalizedIdentifier =

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

168163showRelationAttributes :: Attributes -> Text

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

170165 where

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

172− attrsL = A.toList attrs

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

167+ attrsL = V.toList attrs

173168

174169type PromptLength = Int

175170

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

205200quotedString :: Parser Text

206201quotedString = try tripleQuotedString <|> normalQuotedString

207202

208−quoted :: Parser a -> Parser a

209−quoted = between quote quote

210−

211203uuidP :: Parser U.UUID

212204uuidP = do

213205 uuidStart <- count 8 hexDigitChar

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

236228colonOp opStr = do

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

238230 pure ()

239−

240−hex :: Parser Text

241−hex = takeWhileP (Just "hexadecimal")

242− (\c ->

243− isDigit c

244− || (c >= 'a' && c <= 'f'))

245−

src/bin/TutorialD/Interpreter/DatabaseContextExpr.hs+2−3

@@ -53,9 +53,8 @@ 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

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

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

22module TutorialD.Interpreter.Import.Base where

33import ProjectM36.Base

44import ProjectM36.Error

5−import Text.URI (URI)

6−import Data.Text (Text)

75#if __GLASGOW_HASKELL__ < 804

86import Data.Monoid

97#endif

@@ -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/RelationalExpr.hs+2−3

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

216216 attributeAtomExprP <|>

217217 try nakedAtomExprP <|>

218218 relationalAtomExprP

219−

220219

221220attributeAtomExprP :: Parser (AtomExprBase a)

222221attributeAtomExprP = do

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

235234-- used only for primitive type parsing ?

236235atomP :: Parser Atom

237236atomP = stringAtomP <|>

238− try doubleAtomP <|>

237+ doubleAtomP <|>

239238 integerAtomP <|>

240239 boolAtomP

241240

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

250249stringAtomP = TextAtom <$> quotedString

251250

252251doubleAtomP :: Parser Atom

253−doubleAtomP = DoubleAtom <$> float

252+doubleAtomP = DoubleAtom <$> try float

254253

255254integerAtomP :: Parser Atom

256255integerAtomP = IntegerAtom <$> integer

src/bin/TutorialD/Printer.hs+6−6

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

55{-# LANGUAGE TypeApplications #-}

66module TutorialD.Printer where

77import ProjectM36.Base

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

8+import ProjectM36.Attribute hiding (null)

99import Data.Text.Prettyprint.Doc

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

1111import qualified Data.Vector as V

@@ -60,9 +60,9 @@ instance Pretty RelationTuple where

6060 pretty (RelationTuple attrs atoms) = "tuple" <> bracesList (zipWith (\x y-> pretty x <+> pretty y) (V.toList (attributeNames attrs)) (V.toList atoms))

6161

6262instance 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)

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

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

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

6666

6767instance Pretty Attribute where

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

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

7676 pretty (Extend ext r) = collectExtends r <> pretty ext <> "}"

7777 pretty (MakeRelationFromExprs Nothing (TupleExprs () tupExprs)) = "relation" <> prettyBracesList tupExprs

7878 pretty (MakeRelationFromExprs (Just attrExprs) (TupleExprs () tupExprs)) = "relation" <> prettyBracesList attrExprs <> prettyBracesList tupExprs

79− pretty (MakeStaticRelation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)

79+ pretty (MakeStaticRelation attrs tupSet) = "relation" <> prettyBracesList (V.toList attrs) <> prettyBracesList (asList tupSet)

8080 pretty (Union a b) = parens $ pretty' a <+> "union" <+> pretty' b

8181 pretty (Join a b) = parens $ pretty' a <+> "join" <+> pretty' b

8282 pretty (Rename n1 n2 relExpr) = parens $ pretty relExpr <+> "rename" <+> braces (pretty n1 <+> "as" <+> pretty n2)

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

130130 pretty DateTimeAtomType = "DateTime"

131131 pretty ByteStringAtomType = "ByteString"

132132 pretty BoolAtomType = "Bool"

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

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

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

135135 pretty RelationalExprAtomType = "RelationalExpr"

136136 pretty (TypeVariableType x) = pretty x

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

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

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

8585arbitraryRelationTuple attris = do

8686 tcMap <- ask

87− listOfMaybeAType <- lift $ mapM ((\aTy -> runReaderT (arbitrary' aTy) tcMap) . atomType) (V.toList (attributesVec attris))

87+ listOfMaybeAType <- lift $ mapM ((\aTy -> runReaderT (arbitrary' aTy) tcMap) . atomType) (V.toList attris)

8888 case sequence listOfMaybeAType of

8989 Left err -> pure $ Left err

9090 Right listOfAttr -> do

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

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

211211

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

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

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

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

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

216216

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

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

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

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

297297resolveTypesInTuple resolvedAttrs tConss (RelationTuple _ tupAtoms) = do

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

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

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

300300

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

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

314314 _ -> Right ()

315315validateAtomType (RelationAtomType attrs) tConss =

316316 mapM_ (\attr ->

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

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

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

319319validateAtomType _ _ = pure ()

320320

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

325325 else

326326 pure ()

327327 where

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

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

329329

330330--ensure that all type vars are fully resolved

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

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

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

359359 Left $ AtomTypeMismatchError x y

360360 else

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

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

362362 return x

363363atomTypeVerify x y = if x == y then

364364 Right x

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

375375 (M.toAscList b)

376376

377377prettyAtomType :: AtomType -> T.Text

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

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

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

380380 where

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

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

448448 TypeVariableType _ -> False

449449

450450isResolvedAttributes :: Attributes -> Bool

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

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

452452

453453isResolvedAttribute :: Attribute -> Bool

454454isResolvedAttribute = isResolvedType . A.atomType

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

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

237237typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x

238238typeToTypeConstructor x@RelationalExprAtomType = PrimitiveTypeConstructor "RelationalExpr" x

239239typeToTypeConstructor (RelationAtomType attrs)

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

240+ = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList attrs

241241 where

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

243243typeToTypeConstructor (ConstructedAtomType tcName tvMap)

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+21−33

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

1−{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveTraversable, DerivingVia, TemplateHaskell, TypeFamilies #-}

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

22{-# OPTIONS_GHC -fno-warn-orphans #-}

44module ProjectM36.Base where

@@ -6,7 +6,6 @@ import ProjectM36.DatabaseContextFunctionError

66import ProjectM36.AtomFunctionError

77import ProjectM36.MerkleHash

9−import Data.Functor.Foldable.TH

109import qualified Data.Map as M

1110import qualified Data.HashSet as HS

1211import Data.Hashable (Hashable, hashWithSalt)

@@ -99,29 +98,17 @@ data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Read, Gene

9998instance Hashable Attribute where

10099 hashWithSalt salt (Attribute attrName _) = hashWithSalt salt attrName

101100

102−type AttributesHash = Int

103−

104101-- | '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

102+type Attributes = V.Vector Attribute

122103

104+-- | Equality function for a set of attributes.

105+attributesEqual :: Attributes -> Attributes -> Bool

106+attributesEqual attrs1 attrs2 = attrsAsSet attrs1 == attrsAsSet attrs2

107+ where

108+ attrsAsSet = HS.fromList . V.toList

109+

123110sortedAttributesIndices :: Attributes -> [(Int, Attribute)]

124−sortedAttributesIndices attrs = L.sortBy (\(_, Attribute name1 _) (_,Attribute name2 _) -> compare name1 name2) $ V.toList (V.indexed (attributesVec attrs))

111+sortedAttributesIndices attrs = L.sortBy (\(_, Attribute name1 _) (_,Attribute name2 _) -> compare name1 name2) $ V.toList (V.indexed attrs)

125112

126113-- | The relation's tuple set is the body of the relation.

127114newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic, Read)

@@ -140,8 +127,8 @@ instance NFData RelationTupleSet where rnf = genericRnf

140127instance Hashable RelationTuple where

141128 --sanity check the tuple for attribute and tuple counts

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

130+ hashWithSalt salt (RelationTuple attrs tupVec) = if V.length attrs /= V.length tupVec then

131+ error "invalid tuple: attributes and tuple count mismatch"

145132 else

146133 salt `hashWithSalt`

147134 sortedAttrs `hashWithSalt`

@@ -155,20 +142,19 @@ instance Hashable RelationTuple where

155142data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Read, Generic)

156143

157144instance Eq RelationTuple where

158− tuple1@(RelationTuple attrs1 _) == tuple2@(RelationTuple attrs2 _) =

159− attrs1 == attrs2 && atomsEqual

145+ (==) tuple1@(RelationTuple attrs1 _) tuple2@(RelationTuple attrs2 _) = attributesEqual attrs1 attrs2 && atomsEqual

160146 where

161− atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) (attributesVec attrs) of

147+ atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) attrs of

162148 Nothing -> Nothing

163149 Just index -> tupVec V.!? index

164− atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) (attributesVec attrs1)

150+ atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) attrs1

165151

166152instance NFData RelationTuple where rnf = genericRnf

167153

168154data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)

169155

170156instance Eq Relation where

171− Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attrs1 == attrs2 && tupSet1 == tupSet2

157+ Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attributesEqual attrs1 attrs2 && tupSet1 == tupSet2

172158

173159instance NFData Relation where rnf = genericRnf

174160

@@ -612,7 +598,7 @@ attrTypeVars (Attribute _ aType) = case aType of

612598 ByteStringAtomType -> S.empty

613599 BoolAtomType -> S.empty

614600 RelationalExprAtomType -> S.empty

615− (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

601+ (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList attrs))

616602 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap

617603 (TypeVariableType nam) -> S.singleton nam

618604

@@ -636,11 +622,13 @@ atomTypeVars DateTimeAtomType = S.empty

636622atomTypeVars ByteStringAtomType = S.empty

637623atomTypeVars BoolAtomType = S.empty

638624atomTypeVars RelationalExprAtomType = S.empty

639−atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

625+atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList attrs))

640626atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap

641627atomTypeVars (TypeVariableType nam) = S.singleton nam

642628

643629unimplemented :: HasCallStack => a

644−unimplemented = error "unimplemented"

630+unimplemented = undefined

631+

632+--for serializing GraphRefRelationalExpr as part of transaction serialization

645633

646−makeBaseFunctor ''RelationalExprBase

634+

src/lib/ProjectM36/Client.hs+10−12

@@ -248,7 +248,7 @@ createScriptSession :: [String] -> IO (Maybe ScriptSession)

248248createScriptSession ghcPkgPaths = do

249249 eScriptSession <- initScriptSession ghcPkgPaths

250250 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

251+ 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

252252 Right s -> pure (Just s)

253253

254254

@@ -297,18 +297,16 @@ connectProjectM36 (RemoteConnectionInfo dbName hostName servicePort notification

297297 \(NotificationMessage notifications') ->

298298 forM_ (M.toList notifications') (uncurry notificationCallback)

299299 ]

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

300+-- TODO missing async callback

301+ conn <- RPC.connect notificationHandlers (hostAddressToTuple addr) port

302+ eRet <- RPC.call conn (Login dbName)

303+-- TODO handle connection errors

304+ case eRet of

305+ Left err -> error (show err)

306+ Right False -> error "wtf"

307+ Right True ->

310308 --TODO handle connection errors!

311− pure (Right (RemoteConnection (RemoteConnectionConf conn)))

309+ pure (Right (RemoteConnection (RemoteConnectionConf conn)))

312310

313311--convert RPC errors into exceptions

314312convertRPCErrors :: RPC.ConnectionError -> IO a

src/lib/ProjectM36/DataFrame.hs+6−6

@@ -2,7 +2,7 @@

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

@@ -81,7 +81,7 @@ compareTupleByOneAttributeName attr tuple1 tuple2 =

8181 Right atom2 -> compareAtoms atom1 atom2

8282

8383atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom

84−atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of

84+atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of

8585 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

8686 Just index -> case tupVec V.!? index of

8787 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

@@ -134,12 +134,12 @@ data DataFrameExpr = DataFrameExpr {

134134dataFrameAsHTML :: DataFrame -> T.Text

135135-- web browsers don't display tables with empty cells or empty headers, so we have to insert some placeholders- it's not technically the same, but looks as expected in the browser

136136dataFrameAsHTML df

137− | length (tuples df) == 1 && A.null (attributes df) = style <>

137+ | length (tuples df) == 1 && L.null (attributes df) = style <>

138138 tablestart <>

139139 "<tr><th></th></tr>" <>

140140 "<tr><td></td></tr>" <>

141141 tablefooter <> "</table>"

142− | L.null (tuples df) && A.null (attributes df) = style <>

142+ | L.null (tuples df) && L.null (attributes df) = style <>

143143 tablestart <>

144144 "<tr><th></th></tr>" <>

145145 tablefooter <>

@@ -162,7 +162,7 @@ tuplesAsHTML = foldr folder ""

162162 folder tuple acc = acc <> tupleAsHTML tuple

163163

164164tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]

165−tupleAssocs (DataFrameTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)

165+tupleAssocs (DataFrameTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)

166166

167167

168168tupleAsHTML :: DataFrameTuple -> T.Text

@@ -174,7 +174,7 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>

174174 atomAsHTML atom = atomToText atom

175175

176176attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text

177−attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"

177+attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"

178178 where

179179 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"

180180 ordering attrName = " " <> case L.find (\(AttributeOrder nam _) -> nam == attrName) orders' of

src/lib/ProjectM36/Error.hs+2−10

@@ -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

@@ -144,12 +144,4 @@ data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |

144144 RelVarInReferencedMoreThanOnce RelVarName |

145145 RelVarOutReferencedMoreThanOnce RelVarName

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

147+

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

@@ -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

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

@@ -3,7 +3,6 @@ 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)

@@ -12,9 +11,10 @@ import qualified Data.Text.IO as TIO

1211#if __GLASGOW_HASKELL__ < 804

1312import Data.Monoid

1413#endif

14+import qualified Data.Vector as V

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

src/lib/ProjectM36/RelationalExpression.hs+300−77

@@ -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

@@ -41,8 +40,6 @@ import Control.Monad.Reader as R hiding (join)

4140import ProjectM36.NormalizeExpr

4241import ProjectM36.WithNameExpr

4342import Test.QuickCheck

44−import qualified Data.Functor.Foldable as Fold

45−import Control.Applicative

4643#ifdef PM36_HASKELL_SCRIPTING

4744import GHC hiding (getContext)

4845import Control.Exception

@@ -110,11 +107,11 @@ askEnv :: GraphRefRelationalExprM GraphRefRelationalExprEnv

110107askEnv = R.ask

111108

112109mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

113−mergeTuplesIntoGraphRefRelationalExprEnv tupIn env =

114− env { gre_extra = new_elems }

110+mergeTuplesIntoGraphRefRelationalExprEnv tupIn e =

111+ e{ gre_extra = new_elems }

115112 where

116113 new_elems = Just (Left newTuple)

117− mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple env))

114+ mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple e))

118115 newTuple = mkRelationTupleFromMap mergedTupMap

119116

120117mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

@@ -212,6 +209,160 @@ envContext = re_context

212209setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv

213210setEnvContext e ctx = e { re_context = ctx }

214211

212+{-

213+--full evaluation down the graph

214+eval :: RelationalExpr -> RelationalExprState (Either RelationalError Relation)

215+eval expr = do

216+ env <- askEnv

217+ eGfExpr <- processRelationalExpr expr

218+ case eGfExpr of

219+ Left err -> pure (Left err)

220+ Right gfExpr -> pure $ evalGraphRefRelationalExpr gfExpr (re_graph env)

221+-}

222+{-

223+--relvar state is needed in evaluation of relational expression but only as read-only in order to extract current relvar values

224+evalRelationalExpr :: RelationalExpr -> RelationalExprState (Either RelationalError GraphRefRelationalExpr)

225+evalRelationalExpr (RelationVariable name _) = do

226+ relvarTable <- fmap (relationVariables . envContext) askEnv

227+ return $ case M.lookup name relvarTable of

228+ Just res -> Right res

229+ Nothing -> Left $ RelVarNotDefinedError name

230+

231+evalRelationalExpr (Project attrNames expr) = do

232+ eAttrNameSet <- evalAttributeNames attrNames expr

233+ case eAttrNameSet of

234+ Left err -> pure (Left err)

235+ Right attrNameSet -> do

236+ rel <- evalRelationalExpr expr

237+ case rel of

238+ Right rel2 -> pure $ Right (Project (AttributeNames attrNameSet) rel2)

239+ Left err -> pure $ Left err

240+

241+evalRelationalExpr (Union exprA exprB) = do

242+ relA <- evalRelationalExpr exprA

243+ relB <- evalRelationalExpr exprB

244+ case relA of

245+ Left err -> return $ Left err

246+ Right relA2 -> case relB of

247+ Left err -> return $ Left err

248+ Right relB2 -> return $ Right (Union relA2 relB2)

249+

250+evalRelationalExpr (Join exprA exprB) = do

251+ relA <- evalRelationalExpr exprA

252+ relB <- evalRelationalExpr exprB

253+ case relA of

254+ Left err -> return $ Left err

255+ Right relA2 -> case relB of

256+ Left err -> return $ Left err

257+ Right relB2 -> return $ Right (Join relA2 relB2)

258+

259+evalRelationalExpr (Difference exprA exprB) = do

260+ relA <- evalRelationalExpr exprA

261+ relB <- evalRelationalExpr exprB

262+ case relA of

263+ Left err -> return $ Left err

264+ Right relA2 -> case relB of

265+ Left err -> return $ Left err

266+ Right relB2 -> return $ Right (Difference relA2 relB2)

267+

268+evalRelationalExpr (MakeStaticRelation attributeSet tupleSet) =

269+ case mkRelation attributeSet tupleSet of

270+ Right rel -> return $ Right (ExistingRelation rel)

271+ Left err -> return $ Left err

272+

273+evalRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

274+ currentContext <- fmap envContext askEnv

275+ let tConss = typeConstructorMapping currentContext

276+ -- if the mAttrExprs is Nothing, then we should attempt to infer the tuple attributes from the first tuple itself- note that this is not always possible

277+ runExceptT $ do

278+ mAttrs <- case mAttrExprs of

279+ Just _ ->

280+ Just . A.attributesFromList <$> mapM evalGraphRefAttrExpr (fromMaybe [] mAttrExprs)

281+ Nothing -> pure Nothing

282+ tuples <- mapM (liftE . evalTupleExpr mAttrs) tupleExprs

283+ let attrs = fromMaybe firstTupleAttrs mAttrs

284+ firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)

285+ expr <- either throwE pure (mkRelation attrs (RelationTupleSet tuples))

286+ pure (ExistingRelation expr)

287+

288+evalRelationalExpr (ExistingRelation rel) = pure (Right (ExistingRelation rel))

289+

290+evalRelationalExpr (Rename oldAttrName newAttrName relExpr) = do

291+ evald <- evalRelationalExpr relExpr

292+ case evald of

293+ Right expr -> return $ Right (Rename oldAttrName newAttrName expr)

294+ Left err -> return $ Left err

295+

296+evalRelationalExpr (Group oldAttrNames newAttrName relExpr) = do

297+ eOldAttrNameSet <- evalAttributeNames oldAttrNames relExpr

298+ case eOldAttrNameSet of

299+ Left err -> pure (Left err)

300+ Right oldAttrNameSet -> do

301+ evald <- evalRelationalExpr relExpr

302+ case evald of

303+ Right expr -> return $ Right (Group (AttributeNames oldAttrNameSet) newAttrName expr)

304+ Left err -> return $ Left err

305+

306+evalRelationalExpr (Ungroup attrName relExpr) = do

307+ evald <- evalRelationalExpr relExpr

308+ case evald of

309+ Right expr -> return $ Right (Ungroup attrName expr)

310+ Left err -> return $ Left err

311+

312+evalRelationalExpr (Restrict predicateExpr relExpr) = do

313+ evald <- evalRelationalExpr relExpr

314+ pred <- processRestrictionPredicateExpr predicateExpr

315+ case evald of

316+ Left err -> return $ Left err

317+ Right expr ->

318+ pure $ Right (Restrict pred expr)

319+

320+evalRelationalExpr (Equals relExprA relExprB) = do

321+ evaldA <- evalRelationalExpr relExprA

322+ evaldB <- evalRelationalExpr relExprB

323+ case evaldA of

324+ Left err -> return $ Left err

325+ Right exprA -> case evaldB of

326+ Left err -> return $ Left err

327+ Right exprB -> return $ Right (Equals exprA exprB)

328+{-

329+evalRelationalExpr (With views mainExpr) = do

330+ rstate <- ask

331+

332+ let addScopedView ctx (vname,vexpr) = if vname `M.member` relationVariables ctx then

333+ Left (RelVarAlreadyDefinedError vname)

334+ else

335+ case runState (evalDatabaseContextExpr (Assign vname vexpr)) (freshDatabaseState ctx) of

336+ (Left err,_) -> Left err

337+ (Right (), (ctx',_,_)) -> Right ctx'

338+

339+ case foldM addScopedView (stateElemsContext rstate) views of

340+ Left err -> return $ Left err

341+ Right ctx'' -> do

342+ let evalMainExpr expr = runReader (evalRelationalExpr expr) (RelationalExprEnv ctx'')

343+ case evalMainExpr mainExpr of

344+ Left err -> return $ Left err

345+ Right rel -> return $ Right rel

346+-}

347+--warning: copy-pasta from above- refactor

348+evalRelationalExpr (NotEquals relExprA relExprB) = do

349+ evaldA <- evalRelationalExpr relExprA

350+ evaldB <- evalRelationalExpr relExprB

351+ case evaldA of

352+ Left err -> return $ Left err

353+ Right exprA -> case evaldB of

354+ Left err -> return $ Left err

355+ Right exprB -> return $ Right (NotEquals exprA exprB)

356+

357+-- extending a relation adds a single attribute with the results of the per-tuple expression evaluated

358+evalRelationalExpr (Extend tupleExpression relExpr) = do

359+ eExpr <- evalRelationalExpr relExpr

360+ case eExpr of

361+ Left err -> pure (Left err)

362+ Right expr -> do

363+ tupProc <- processExtendTupleExpr tupleExpression

364+ pure (Right (Extend tupProc expr))

365+-}

215366--helper function to process relation variable creation/assignment

216367setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

217368setRelVar relVarName relExpr = do

@@ -231,9 +382,6 @@ setRelVar relVarName relExpr = do

231382 Left err -> dbErr err

232383 Right _ -> putStateContext potentialContext

233384

234−--fast-path insertion- we already know that the previous relvar validated correctly, so we can validate just the relation that is being inserted for attribute matches- without this, even a single tuple relation inserted causes the entire relation to be re-validated unnecessarily

235−--insertIntoRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

236−

237385-- 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

238386deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()

239387deleteRelVar relVarName = do

@@ -299,36 +447,20 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do

299447

300448evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do

301449 gfExpr <- relVarByName relVarName

302− let optExpr = applyUnionCollapse (Union

303− relExpr

304− gfExpr)

305− evalGraphRefDatabaseContextExpr (Assign relVarName optExpr)

450+ evalGraphRefDatabaseContextExpr (Assign relVarName

451+ (Union

452+ gfExpr

453+ relExpr))

306454

307455evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do

308456 gfExpr <- relVarByName relVarName

309− let optExpr = applyRestrictionCollapse (Restrict (NotPredicate predicate) gfExpr)

310− setRelVar relVarName optExpr

457+ setRelVar relVarName (Restrict (NotPredicate predicate) gfExpr)

311458

312459--union of restricted+updated portion and the unrestricted+unupdated portion

313460evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do

314461 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

323462 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

463+ tmpAttr attr = "_tmp_" <> attr --this could certainly be improved to verify that there is no attribute name conflict

332464 updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)

333465 projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)

334466 restrictedPortion = Restrict pred' rvExpr

@@ -642,9 +774,21 @@ evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs

642774 Left err -> pure (Left err)

643775 Right dbstate' -> putDBCIOContext (dbc_context dbstate')

644776

777+{-

778+updateTupleWithAtomExprs :: M.Map AttributeName AtomExpr -> DatabaseContext -> TransactionGraph -> RelationTuple -> Either RelationalError RelationTuple

779+updateTupleWithAtomExprs exprMap context graph tupIn = do

780+ --resolve all atom exprs

781+ let

782+ atomsAssoc <- mapM (\(attrName, atomExpr) -> do

783+ let atom = unimplemented

784+ --atom <- runReader (evalAtomExpr tupIn atomExpr) (mkRelationalExprState context graph)

785+ pure (attrName, atom)

786+ ) (M.toList exprMap)

787+ pure (updateTupleWithAtoms (M.fromList atomsAssoc) tupIn)

788+-}

645789--run verification on all constraints

646790checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()

647−checkConstraints context transId graph@(TransactionGraph graphHeads transSet) = do

791+checkConstraints context transId graph@(TransactionGraph graphHeads transSet) =

648792 mapM_ (uncurry checkIncDep) (M.toList deps)

649793 where

650794 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)

@@ -693,6 +837,15 @@ typeForRelationalExpr expr = do

693837 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

694838 lift $ except runGf

695839

840+--returns a database context with all tuples removed

841+--this is useful for type checking and optimization

842+{-

843+contextWithEmptyTupleSets :: DatabaseContext -> DatabaseContext

844+contextWithEmptyTupleSets contextIn = contextIn { relationVariables = relVars }

845+ where

846+ relVars = M.map (\rel -> ExistingRelation (Relation (attributes rel) emptyTupleSet)) (relationVariables contextIn)

847+-}

848+

696849liftE :: (Monad m) => m (Either a b) -> ExceptT a m b

697850liftE v = do

698851 y <- lift v

@@ -848,6 +1001,58 @@ evalGraphRefAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs _) = do

8481001 mapM (evalGraphRefAtomExpr tupIn) dConsArgs

8491002 pure (ConstructedAtom dConsName aType argAtoms)

8501003

1004+{-

1005+evalAtomExpr :: RelationTuple -> AtomExpr -> RelationalExprM Atom

1006+evalAtomExpr tupIn expr =

1007+ -}

1008+{-

1009+

1010+evalAtomExpr tupIn (AttributeAtomExpr attrName) = case atomForAttributeName attrName tupIn of

1011+ Right atom -> pure (Right atom)

1012+ err@(Left (NoSuchAttributeNamesError _)) -> do

1013+ rstate <- ask

1014+ let stateTup = stateTuple rstate

1015+ pure (atomForAttributeName attrName stateTup)

1016+ Left err -> pure (Left err)

1017+evalAtomExpr _ (NakedAtomExpr atom) = pure (Right atom)

1018+evalAtomExpr tupIn (FunctionAtomExpr funcName arguments ()) = do

1019+ argTypes <- mapM (typeFromAtomExpr (tupleAttributes tupIn)) arguments

1020+ context <- fmap stateElemsContext ask

1021+ runExceptT $ do

1022+ let functions = atomFunctions context

1023+ func <- either throwE pure (atomFunctionForName funcName functions)

1024+ let expectedArgCount = length (atomFuncType func) - 1

1025+ actualArgCount = length argTypes

1026+ safeInit [] = [] -- different behavior from normal init

1027+ safeInit xs = init xs

1028+ if expectedArgCount /= actualArgCount then

1029+ throwE (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)

1030+ else do

1031+ let zippedArgs = zip (safeInit (atomFuncType func)) argTypes

1032+ mapM_ (\(expType, eActType) -> do

1033+ actType <- either throwE pure eActType

1034+ either throwE pure (atomTypeVerify expType actType)) zippedArgs

1035+ evaldArgs <- mapM (liftE . evalAtomExpr tupIn) arguments

1036+ case evalAtomFunction func evaldArgs of

1037+ Left err -> throwE (AtomFunctionUserError err)

1038+ Right result -> do

1039+ --validate that the result matches the expected type

1040+ _ <- either throwE pure (atomTypeVerify (last (atomFuncType func)) (atomTypeForAtom result))

1041+ pure result

1042+evalAtomExpr tupIn (RelationAtomExpr relExpr) = do

1043+ --merge existing state tuple context into new state tuple context to support an arbitrary number of levels, but new attributes trounce old attributes

1044+ rstate <- ask

1045+ runExceptT $ do

1046+ let newState = mergeTuplesIntoRelationalExprState tupIn rstate

1047+ relAtom <- either throwE pure (runReader (evalRelationalExpr relExpr) newState)

1048+ pure (RelationAtom relAtom)

1049+evalAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs ()) = runExceptT $ do

1050+ rstate <- lift ask

1051+ let newState = mergeTuplesIntoRelationalExprState tupIn rstate

1052+ aType <- either throwE pure (runReader (typeFromAtomExpr (tupleAttributes tupIn) cons) newState)

1053+ argAtoms <- mapM (\arg -> either throwE pure (runReader (evalAtomExpr tupIn arg) newState)) dConsArgs

1054+ pure (ConstructedAtom dConsName aType argAtoms)

1055+-}

8511056typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType

8521057typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

8531058 renv <- askEnv

@@ -914,7 +1119,7 @@ verifyGraphRefAtomExprTypes relIn (FunctionAtomExpr funcName funcArgExprs tid) e

9141119 let handler :: RelationalError -> GraphRefRelationalExprM AtomType

9151120 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)

9161121 handler err = throwError err

917− verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

1122+ verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

9181123 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]

9191124 if length funcArgTypes /= length expectedArgTypes - 1 then

9201125 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)

@@ -960,7 +1165,7 @@ evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do

9601165 lift $ except $ resolveAttributes accAttr tupAttr

9611166 mostResolvedTypes <-

9621167 foldM (\acc tup -> do

963− let zipped = zip (V.toList . attributesVec $ tupleAttributes tup) acc

1168+ let zipped = zip (V.toList $ tupleAttributes tup) acc

9641169 accNames = S.fromList $ map A.attributeName acc

9651170 tupNames = A.attributeNameSet (tupleAttributes tup)

9661171 attrNamesDiff = S.union (S.difference accNames tupNames) (S.difference tupNames accNames)

@@ -971,7 +1176,7 @@ evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do

9711176 pure nextTupleAttrs

9721177 else

9731178 throwError (TupleAttributeTypeMismatchError diff)

974− ) (V.toList . attributesVec $ tupleAttributes headTuple) tailTuples

1179+ ) (V.toList $ tupleAttributes headTuple) tailTuples

9751180 pure (A.attributesFromList mostResolvedTypes)

9761181 --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

9771182 tConsMap <- case singularTransactions tupleExprL of

@@ -1017,6 +1222,56 @@ evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do

10171222-- _ <- lift $ except (validateTuple tup' tConss)

10181223 pure tup'

10191224

1225+{-

1226+evalAttributeNames :: AttributeNames -> RelationalExpr -> RelationalExprM (Either RelationalError (S.Set AttributeName))

1227+evalAttributeNames attrNames expr = do

1228+ eExprType <- typeForRelationalExpr expr

1229+ case eExprType of

1230+ Left err -> throwError err

1231+ Right exprTyp -> do

1232+ let typeNameSet = S.fromList (V.toList (A.attributeNames (attributes exprTyp)))

1233+ case attrNames of

1234+ AttributeNames names ->

1235+ case A.projectionAttributesForNames names (attributes exprTyp) of

1236+ Left err -> pure (Left err)

1237+ Right attrs -> pure (Right (S.fromList (V.toList (A.attributeNames attrs))))

1238+

1239+ InvertedAttributeNames names -> do

1240+ let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet

1241+ if not (S.null nonExistentAttributeNames) then

1242+ pure (Left (AttributeNamesMismatchError nonExistentAttributeNames))

1243+ else

1244+ pure (Right (A.nonMatchingAttributeNameSet names typeNameSet))

1245+

1246+ UnionAttributeNames namesA namesB -> do

1247+ eNameSetA <- evalAttributeNames namesA expr

1248+ case eNameSetA of

1249+ Left err -> pure (Left err)

1250+ Right nameSetA -> do

1251+ eNameSetB <- evalAttributeNames namesB expr

1252+ case eNameSetB of

1253+ Left err -> pure (Left err)

1254+ Right nameSetB ->

1255+ pure (Right (S.union nameSetA nameSetB))

1256+

1257+ IntersectAttributeNames namesA namesB -> do

1258+ eNameSetA <- evalAttributeNames namesA expr

1259+ case eNameSetA of

1260+ Left err -> pure (Left err)

1261+ Right nameSetA -> do

1262+ eNameSetB <- evalAttributeNames namesB expr

1263+ case eNameSetB of

1264+ Left err -> pure (Left err)

1265+ Right nameSetB ->

1266+ pure (Right (S.intersection nameSetA nameSetB))

1267+

1268+ RelationalExprAttributeNames attrExpr -> do

1269+ eAttrExprType <- typeForRelationalExpr attrExpr

1270+ case eAttrExprType of

1271+ Left err -> pure (Left err)

1272+ Right attrExprType -> pure (Right (A.attributeNameSet (attributes attrExprType)))

1273+-}

1274+

10201275--temporary implementation until we have a proper planner+executor

10211276evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation

10221277evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

@@ -1245,7 +1500,7 @@ relationVariablesAsRelation ctx graph = do

12451500 let gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph

12461501 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

12471502 pure (rvName, gfType)

1248− relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributesVec (attributes rel))]

1503+ relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributes rel)]

12491504 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]

12501505 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of

12511506 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)

@@ -1265,6 +1520,15 @@ evalRelationalExpr expr = do

12651520 Left err -> throwError err

12661521 Right rel -> pure rel

12671522

1523+{-

1524+relVarByName :: RelVarName -> GraphRefRelationalExprM GraphRefRelationalExpr

1525+relVarByName = do

1526+ relvars <- relationVariables <$> getStateContext

1527+ case M.lookup relVarName relvars of

1528+ Nothing -> dbErr (RelVarNotDefinedError relVarName)

1529+ Just gfexpr -> pure gfExpr

1530+-}

1531+

12681532class (MonadError RelationalError m, Monad m) => DatabaseContextM m where

12691533 getContext :: m DatabaseContext

12701534

@@ -1349,44 +1613,3 @@ instance ResolveGraphRefTransactionMarker GraphRefAtomExpr where

13491613 resolve (RelationAtomExpr expr) = RelationAtomExpr <$> resolve expr

13501614 resolve (ConstructedAtomExpr dConsName atomExprs marker) =

13511615 ConstructedAtomExpr dConsName <$> mapM resolve atomExprs <*> pure marker

1352−

1353−--convert series of simple Union queries into MakeStaticRelation

1354−-- this is especially useful for long, nested applications of Union with simple tuples

1355−-- Union (MakeRelation x y) (MakeRelation x y') -> MakeRelation x (y + y')

1356−

1357−--MakeRelationFromExprs Nothing (TupleExprs UncommittedContextMarker [TupleExpr (fromList [("name", NakedAtomExpr (TextAtom "steve"))])])

1358−

1359−applyUnionCollapse :: GraphRefRelationalExpr -> GraphRefRelationalExpr

1360−applyUnionCollapse = Fold.cata opt

1361− where

1362− opt :: RelationalExprBaseF GraphRefTransactionMarker GraphRefRelationalExpr -> GraphRefRelationalExpr

1363− opt (UnionF exprA exprB) | exprA == exprB = exprA

1364− opt (UnionF

1365− exprA@(MakeRelationFromExprs mAttrs1 tupExprs1)

1366− exprB@(MakeRelationFromExprs mAttrs2 tupExprs2)) | tupExprs1 == tupExprs2 = MakeRelationFromExprs (mAttrs1 <|> mAttrs2) tupExprs1

1367− | tupExprsNull tupExprs1 = exprB

1368− | tupExprsNull tupExprs2 = exprA

1369− opt x = Fold.embed x

1370− tupExprsNull (TupleExprs _ []) = True

1371− tupExprsNull _ = False

1372−

1373−

1374−--UPDATE optimization- find matching where clause in "lower" levels of renaming

1375−--update x where y=1 set (x:=5,z:=10); update x where y=1 set(x:=6,z:=11)

1376−-- =>

1377−-- update x where y=1 set (x:=6,z:=11)

1378−-- future opt: match individual attributes update x where y=1 set (x:=5); update x where y=1 set (z:=11) => update x where y=1 set (x:=5,z:=11)

1379−

1380−--strategy: try to collapse the top-level update (union (restrict pred MakeRelationFromExpr) expr) if it contains the same predicate and resultant relation

1381−

1382−--DELETE optimization

1383−-- if a restriction matches a previous restriction, combine them

1384−-- O(1) since it only scans at the top level, critical in benchmarks generating redundant deletions

1385−applyRestrictionCollapse :: GraphRefRelationalExpr -> GraphRefRelationalExpr

1386−applyRestrictionCollapse orig@(Restrict npred@(NotPredicate _) expr) =

1387− case expr of

1388− orig'@(Restrict npred'@(NotPredicate _) _) | npred == npred' -> orig'

1389− _ -> orig

1390−applyRestrictionCollapse expr = expr

1391−

1392−

src/lib/ProjectM36/ScriptSession.hs+2

@@ -128,6 +128,8 @@ initScriptSession ghcPkgPaths = do

128128 "uuid",

129129 "vector",

130130 "text",

131+ "binary",

132+ "vector-binary-instances",

131133 "time",

132134 "project-m36",

133135 "bytestring"]

src/lib/ProjectM36/Serialise/Base.hs+1−10

@@ -10,7 +10,6 @@ import ProjectM36.MerkleHash

1010import Data.UUID

1111import Data.Proxy

1212import Data.Word

13−import ProjectM36.Attribute as A

1413import qualified Data.List.NonEmpty as NE

1514import qualified Data.Vector as V

1615import Data.Time.Calendar (Day,toGregorian,fromGregorian)

@@ -73,13 +72,5 @@ instance Serialise Day where

7372 extractor = fromGregorianTup <$> extractor

7473 decodeCurrent = fromGregorianTup <$> decodeCurrent

7574

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

8175

82− decodeCurrent = do

83− n <- decodeVarInt

84− l <- replicateM n decodeCurrent

85− pure (A.attributesFromList l)

76+

src/lib/ProjectM36/Serialise/Error.hs−1

@@ -12,4 +12,3 @@ deriving via WineryVariant MergeError instance Serialise MergeError

1212deriving via WineryVariant ScriptCompilationError instance Serialise ScriptCompilationError

1313deriving via WineryVariant PersistenceError instance Serialise PersistenceError

1414deriving via WineryVariant SchemaError instance Serialise SchemaError

15−deriving via WineryVariant ImportError' instance Serialise ImportError'

src/lib/ProjectM36/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+2−2

@@ -5,8 +5,8 @@ import ProjectM36.IsomorphicSchema

55import ProjectM36.Client as C

66import Data.Map

77import Control.Concurrent (threadDelay)

8−import Network.RPC.Curryer.Server

9−import System.Timeout hiding (Timeout)

8+import Network.RPC.Curryer.Server

9+import System.Timeout

1010import Network.Socket

1111import Control.Exception

1212

src/lib/ProjectM36/Server/ParseArgs.hs+14−31

@@ -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,60 +34,43 @@ parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>

3434

3535parseTestMode :: Parser Bool

3636parseTestMode = flag True False (long "test-mode" <> hidden)

37−

38−parseCheckFS :: Parser Bool

37+

38+parseCheckFS :: Parser Bool

3939parseCheckFS = flag True False (long "disable-fscheck" <>

4040 help "Disable filesystem check for journaling.")

41−

41+

4242parseDatabaseName :: Parser DatabaseName

4343parseDatabaseName = strOption (short 'n' <>

4444 long "database" <>

4545 metavar "DATABASE_NAME")

4646

47−parseHostname :: Hostname -> Parser Hostname

47+parseHostname :: Hostname -> Parser Hostname

4848parseHostname defHostname = strOption (short 'h' <>

4949 long "hostname" <>

5050 metavar "HOST_NAME" <>

5151 value defHostname)

52−

52+

5353parsePort :: Port -> Parser Port

5454parsePort defPort = option auto (short 'p' <>

5555 long "port" <>

5656 metavar "PORT_NUMBER" <>

5757 value defPort)

58−

58+

5959parseGhcPkgPath :: Parser String

6060parseGhcPkgPath = strOption (long "ghc-pkg-dir" <>

6161 metavar "GHC_PACKAGE_DIRECTORY")

62−

63−parseTimeout :: Int -> Parser Int

62+

63+parseTimeout :: Int -> Parser Int

6464parseTimeout defTimeout = option auto (long "timeout" <>

6565 metavar "MICROSECONDS" <>

6666 value defTimeout)

6767

6868parseConfig :: IO ServerConfig

6969parseConfig = parseConfigWithDefaults defaultServerConfig

70−

70+

7171parseConfigWithDefaults :: ServerConfig -> IO ServerConfig

7272parseConfigWithDefaults defaults = execParser (info (parseArgsWithDefaults defaults <**> helpOption) idm)

7373

74−parseWSConfigWithDefaults :: ServerConfig -> IO WebsocketServerConfig

75−parseWSConfigWithDefaults defaults = execParser (info (parseWSArgsWithDefaults defaults <**> helpOption) idm)

76−

77−parseWSArgsWithDefaults :: ServerConfig -> Parser WebsocketServerConfig

78−parseWSArgsWithDefaults defaults = WebsocketServerConfig <$>

79− parseArgsWithDefaults defaults <*>

80− parseTlsCertificatePath <*>

81− parseTlsKeyPath

82−

83−

84−parseTlsCertificatePath :: Parser (Maybe String)

85−parseTlsCertificatePath = optional $ strOption (long "tls-certificate-path" <>

86− metavar "TLS_CERTIFICATE_PATH")

87−

88−parseTlsKeyPath :: Parser (Maybe String)

89−parseTlsKeyPath = optional $ strOption (long "tls-key-path" <>

90− metavar "TLS_KEY_PATH")

9174

9275helpOption :: Parser (a -> a)

9376helpOption = abortOption helpText $ mconcat

@@ -97,6 +80,6 @@ helpOption = abortOption helpText $ mconcat

9780 where

9881#if MIN_VERSION_optparse_applicative(0,16,0)

9982 helpText = ShowHelpText Nothing

100−#else

83+#else

10184 helpText = ShowHelpText

10285#endif

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

@@ -22,6 +22,8 @@ import qualified Data.Set as S

2222

2323-- the static optimizer performs optimizations which need not take any specific-relation statistics into account

2424

25+--import Debug.Trace

26+

2527data GraphRefSOptRelationalExprEnv =

2628 GraphRefSOptRelationalExprEnv

2729 {

@@ -177,7 +179,7 @@ fullOptimizeGraphRefRelationalExpr expr = do

177179optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

178180optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e

179181

180−optimizeGraphRefRelationalExpr e@MakeRelationFromExprs{} = pure e

182+optimizeGraphRefRelationalExpr e@(MakeRelationFromExprs _ _) = pure e

181183

182184optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e

183185

@@ -207,8 +209,6 @@ optimizeGraphRefRelationalExpr (Union exprA exprB) = do

207209 case (optExprA, optExprB) of

208210 (Restrict predA (RelationVariable nameA sA),

209211 Restrict predB (RelationVariable nameB sB)) | nameA == nameB && sA == sB -> pure (Restrict (AndPredicate predA predB) (RelationVariable nameA sA))

210− (exprA', exprB') | isEmptyRelationExpr exprA' -> pure exprB'

211− | isEmptyRelationExpr exprB' -> pure exprA'

212212 _ -> if optExprA == optExprB then

213213 pure optExprA

214214 else

@@ -575,4 +575,3 @@ applyStaticRestrictionPushdown expr = case expr of

575575-- no optimizations available

576576optimizeDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextIOExpr

577577optimizeDatabaseContextIOExpr = pure

578−

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

@@ -384,7 +384,7 @@ subGraphOfFirstCommonAncestor origGraph resultHeads currentTrans' goalTrans trav

384384 else do

385385 currentTransChildren <- childTransactions currentTrans' origGraph

386386 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren

387− searchChild start' = pathToTransaction origGraph start' goalTrans (S.insert currentTrans' traverseSet)

387+ searchChild start = pathToTransaction origGraph start goalTrans (S.insert currentTrans' traverseSet)

388388 childSearches = map searchChild (S.toList searchChildren)

389389 errors = lefts childSearches

390390 pathsFound = rights childSearches

src/lib/ProjectM36/Tuple.hs+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+8−9

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

3838import qualified Data.Vector as V

3939import GHC.Generics

4040import ProjectM36.Atomable

41−import ProjectM36.Attribute as A hiding (null, toList)

41+import ProjectM36.Attribute hiding (null)

4242import ProjectM36.Base

4343import ProjectM36.DataTypes.Primitive

4444import ProjectM36.Error

@@ -89,7 +89,7 @@ toInsertExpr vals rvName = do

8989

9090-- | Convert a 'Tupleable' to a create a 'Define' expression which can be used to create an empty relation variable. Use 'toInsertExpr' to insert the actual tuple data. This function is typically used with 'Data.Proxy'.

9191toDefineExpr :: forall a proxy. Tupleable a => proxy a -> RelVarName -> DatabaseContextExpr

92−toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList (attributesVec attrs)))

92+toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList attrs))

9393 where

9494 attrs = toAttributes (Proxy :: Proxy a)

9595

@@ -228,12 +228,11 @@ instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) whe

228228 toTupleG opts (M1 v) = RelationTuple attrs atoms

229229 where

230230 attrsToCheck = toAttributesG opts v

231− counter = V.generate (arity attrsToCheck) id

232− attrs = attributesFromList (V.toList attrsV)

233− attrsV = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

231+ counter = V.generate (V.length attrsToCheck) id

232+ attrs = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

234233 Attribute ("attr" <> T.pack (show (num + 1))) typ

235234 else

236− attr) counter (attributesVec attrsToCheck)

235+ attr) counter attrsToCheck

237236 atoms = V.fromList (toAtomsG v)

238237 toAttributesG opts (M1 v) = toAttributesG opts v

239238 fromTupleG opts tup = M1 <$> fromTupleG opts tup

@@ -242,7 +241,7 @@ instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) whe

242241-- product types

243242instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

244243 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

244+ toAttributesG opts ~(x :*: y) = toAttributesG opts x V.++ toAttributesG opts y --a bit of extra laziness prevents whnf so that we can use toAttributes (undefined :: Test2T Int Int) without throwing an exception

246245 fromTupleG opts tup = (:*:) <$> fromTupleG opts tup <*> fromTupleG opts processedTuple

247246 where

248247 processedTuple = if isRecordTypeG (undefined :: a x) then

@@ -254,7 +253,7 @@ instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

254253--selector/record

255254instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

256255 toTupleG = error "toTupleG"

257− toAttributesG opts m@(M1 v) = A.singleton (Attribute modifiedName aType)

256+ toAttributesG opts m@(M1 v) = V.singleton (Attribute modifiedName aType)

258257 where

259258 name = T.pack (selName m)

260259 modifiedName = if T.null name then

@@ -269,7 +268,7 @@ instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

269268 val <- atomv atom

270269 pure (M1 val)

271270 where

272− expectedAtomType = atomType (V.head (attributesVec (toAttributesG opts (undefined :: M1 S c a x))))

271+ expectedAtomType = atomType (V.head (toAttributesG opts (undefined :: M1 S c a x)))

273272 atomv atom = maybe (Left (AtomTypeMismatchError

274273 expectedAtomType

275274 (atomTypeForAtom atom)

src/lib/ProjectM36/WithNameExpr.hs+2−4

@@ -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+48

@@ -0,0 +1,48 @@

1+# This file was automatically generated by stack init

2+# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

4+# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5+resolver: lts-8.5

7+# Local packages, usually specified by relative directory name

8+packages:

9+- '.'

10+# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11+extra-deps:

12+- git: https://github.com/agentm/curryer.git

13+ commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

14+- data-accessor-transformers-0.2.1.7

15+- data-interval-1.2.0

16+- extended-reals-0.2.1.0

17+- gnuplot-0.5.4.1

18+- text-1.2.2.1

19+- aeson-1.2.1.00

20+- deferred-folds-0.6.12

21+- rset-1.0.0

22+

23+# Override default flag values for local packages and extra-deps

24+flags: {}

25+

26+# Extra package databases containing global packages

27+extra-package-dbs: []

28+

29+# Control whether we use the GHC we find on the path

30+# system-ghc: true

31+

32+# Require a specific version of stack, using version ranges

33+# require-stack-version: -any # Default

34+# require-stack-version: >= 1.0.0

35+

36+# Override the architecture used by stack, especially useful on Windows

37+# arch: i386

38+# arch: x86_64

39+

40+# Extra directories used by stack for building

41+# extra-include-dirs: [/path/to/dir]

42+# extra-lib-dirs: [/path/to/dir]

43+

44+# Allow a newer minor version of GHC than the snapshot specifies

45+# compiler-check: newer-minor

46+

47+allow-newer: true

48+

stack.ghc8.10.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.2.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/

4+# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5+resolver: lts-11.20

7+# Local packages, usually specified by relative directory name

8+packages:

9+- '.'

10+

11+# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

12+extra-deps:

13+- git: https://github.com/agentm/curryer.git

14+ commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

15+- data-accessor-transformers-0.2.1.7

16+- data-interval-1.2.0

17+- extended-reals-0.2.1.0

18+- gnuplot-0.5.4.1

19+- text-1.2.2.1

20+- aeson-1.2.1.00

21+- rset-1.0.0

22+

23+# Override default flag values for local packages and extra-deps

24+flags:

25+ project-m36:

26+ stack: true

27+

28+# Extra package databases containing global packages

29+extra-package-dbs: []

30+

31+# Control whether we use the GHC we find on the path

32+# system-ghc: true

33+

34+# Require a specific version of stack, using version ranges

35+# require-stack-version: -any # Default

36+# require-stack-version: >= 1.0.0

37+

38+# Override the architecture used by stack, especially useful on Windows

39+# arch: i386

40+# arch: x86_64

41+

42+# Extra directories used by stack for building

43+# extra-include-dirs: [/path/to/dir]

44+# extra-lib-dirs: [/path/to/dir]

45+

46+# Allow a newer minor version of GHC than the snapshot specifies

47+# compiler-check: newer-minor

48+

49+allow-newer: true

50+

stack.ghc8.4.yamlnew file+46

@@ -0,0 +1,46 @@

1+# This file was automatically generated by stack init

2+# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

4+# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5+resolver: lts-12.26

7+# Local packages, usually specified by relative directory name

8+packages:

9+- '.'

10+# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11+extra-deps:

12+- git: https://github.com/agentm/curryer.git

13+ commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

14+- data-interval-1.3.0

15+- extended-reals-0.2.3.0

16+- rset-1.0.0

17+- hashable-time-0.2.0.2

18+- network-transport-tcp-0.6.0

19+

20+# Override default flag values for local packages and extra-deps

21+flags:

22+ project-m36:

23+ stack: true

24+

25+# Extra package databases containing global packages

26+extra-package-dbs: []

27+

28+# Control whether we use the GHC we find on the path

29+# system-ghc: true

30+

31+# Require a specific version of stack, using version ranges

32+# require-stack-version: -any # Default

33+# require-stack-version: >= 1.0.0

34+

35+# Override the architecture used by stack, especially useful on Windows

36+# arch: i386

37+# arch: x86_64

38+

39+# Extra directories used by stack for building

40+# extra-include-dirs: [/path/to/dir]

41+# extra-lib-dirs: [/path/to/dir]

42+

43+# Allow a newer minor version of GHC than the snapshot specifies

44+# compiler-check: newer-minor

45+

46+allow-newer: true

stack.ghc8.6.yaml+12−25

@@ -2,36 +2,23 @@

22# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

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-14.3

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+- git: https://github.com/agentm/curryer.git

13+ commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

14+- extended-reals-0.2.3.0

15+- data-interval-2.0.1

16+- stm-containers-1.1.0.4

17+- stm-hamt-1.2.0.4

18+- rset-1.0.0

19+- hashable-time-0.2.0.2

20+- network-transport-tcp-0.6.0

21+- megaparsec-7.0.5

3522

3623# Override default flag values for local packages and extra-deps

3724flags:

stack.ghc8.8.yaml+16−24

@@ -6,32 +6,24 @@ resolver: lts-16.4

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+- git: https://github.com/agentm/curryer.git

13+ commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

14+- git: https://github.com/composewell/streamly.git

15+ commit: ac3af8749194f1788704dda8667d0b3807075cc2

16+- extended-reals-0.2.3.0

17+- data-interval-2.0.1

18+- stm-containers-1.1.0.4

19+- stm-hamt-1.2.0.4

20+- rset-1.0.0

21+- hashable-time-0.2.0.2

22+- network-transport-tcp-0.7.0

23+- megaparsec-7.0.5

24+- network-2.8.0.1

25+- primitive-extras-0.8

26+- primitive-unlifted-0.1.3.0

3527

3628# Override default flag values for local packages and extra-deps

3729flags:

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/Relation/Basic.hs+12−13

@@ -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 ()

@@ -63,7 +65,7 @@ validateAttrTypesMatchTupleAttrTypes rel@(Relation attrs tupSet) = foldr (\tuple

6365 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of

6466 Left _ -> False

6567 Right atom -> Right (atomTypeForAtom atom) ==

66− A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributesVec (attributes rel))

68+ A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributes rel)

6769

6870simpleRel :: Relation

6971simpleRel = case mkRelation attrs tupleSet of

@@ -101,19 +103,16 @@ testMkRelationFromExprsBadAttrs = TestCase $ do

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/Tupleable.hs+4−5

@@ -13,7 +13,7 @@

1313import Test.HUnit

1414import ProjectM36.Tupleable.Deriving

1515import ProjectM36.Atomable

16−import ProjectM36.Attribute as A

16+import ProjectM36.Attribute

1717import ProjectM36.Error

1818import ProjectM36.Base

1919import Control.DeepSeq (NFData)

@@ -110,7 +110,7 @@ main = do

110110 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

111111

112112testList :: 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]

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]

114114

115115testADT1 :: Test

116116testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))

@@ -148,7 +148,7 @@ testADT7 :: Test

148148testADT7 = TestCase $ do

149149 let example = Test7C (Test7AC 3)

150150 assertEqual "atom type" (Right example) (fromTuple (toTuple example))

151− let expectedAttrs = A.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))

151+ let expectedAttrs = V.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))

152152 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))

153153

154154testADT8 :: Test

@@ -222,8 +222,7 @@ testDeleteExpr = TestCase $ do

222222testReorderedTuple :: Test

223223testReorderedTuple = TestCase $ do

224224 let tupleRev :: RelationTuple -> RelationTuple

225− tupleRev (RelationTuple v1 v2) = RelationTuple (revAttrs v1) (V.reverse v2)

226− revAttrs attrs = A.attributesFromList (reverse (A.toList attrs))

225+ tupleRev (RelationTuple v1 v2) = RelationTuple (V.reverse v1) (V.reverse v2)

227226 expected = Test2C {attrB = 3,

228227 attrC = 4}

229228 actual = fromTuple . tupleRev . toTuple $ expected

test/Server/Main.hs+4−10

@@ -23,6 +23,8 @@ import System.FilePath

2323import System.Directory

2424#endif

2525

26+import Debug.Trace

27+

2628type Timeout = Int

2729

2830testList :: SessionId -> Connection -> MVar () -> Test

@@ -42,7 +44,7 @@ testList sessionId conn notificationTestMVar = TestList $ serverTests ++ session

4244 testRelationVariableSummary,

4345 testNotification notificationTestMVar

4446 ]

45− serverTests = [testRequestTimeout, testFileDescriptorCount, testClientConnectFail]

47+ serverTests = [testRequestTimeout, testFileDescriptorCount]

4648

4749main :: IO ()

4850main = do

@@ -207,7 +209,7 @@ testRequestTimeout = TestCase $ do

207209 case eTestConn of

208210 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure

209211 Right (session, testConn) -> do

210− res <- catchJust (\exc -> if exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))

212+ res <- catchJust (\exc -> if traceShowId exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))

211213 assertBool "timeout exception was not thrown" (not res)

212214 killThread serverTid

213215

@@ -238,11 +240,3 @@ fdCount = do

238240--pass on non-linux platforms

239241testFileDescriptorCount = TestCase (pure ())

240242#endif

241−

242−testClientConnectFail :: Test

243−testClientConnectFail = TestCase $ do

244− let connInfo = RemoteConnectionInfo "nonexistentdb" "127.0.0.1" "7777" emptyNotificationCallback

245− eConn <- connectProjectM36 connInfo

246− case eConn of

247− Left (IOExceptionError _) -> pure ()

248− _ -> assertFailure "connection failure failed"

test/TutorialD/InterpreterTest.hs → test/TutorialD/Interpreter.hsrenamed+4−10

@@ -87,8 +87,7 @@ main = do

8787simpleRelTests :: Test

8888simpleRelTests = TestCase $ do

8989 (graph, transId) <- freshTransactionGraph dateExamples

90− mapM_ (\(tutd, expected) ->

91− assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups

90+ mapM_ (\(tutd, expected) -> assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups

9291 where

9392 testTups = [("x:=true", Right relationTrue),

9493 ("x:=false", Right relationFalse),

@@ -136,8 +135,7 @@ simpleRelTests = TestCase $ do

136135dateExampleRelTests :: Test

137136dateExampleRelTests = TestCase $ do

138137 (graph, transId) <- freshTransactionGraph dateExamples

139− mapM_ (\(tutd, expected) ->

140− assertTutdEqual dateExamples transId graph expected tutd) testTups

138+ mapM_ (\(tutd, expected) -> assertTutdEqual dateExamples transId graph expected tutd) testTups

141139 where

142140 simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]

143141 maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)

@@ -362,7 +360,7 @@ testComments :: Test

362360testComments = TestCase $ do

363361 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

364362 mapM_ (executeTutorialD sessionId dbconn) [

365− ":branch testbranch --test comment",

363+ ":branch testbranch --test comment\n",

366364 ":jumphead {- test comment -} master"]

367365

368366-- create a graph and query from two disparate contexts

@@ -545,7 +543,7 @@ testListConstructedAtom = TestCase $ do

545543testTypeChecker :: Test

546544testTypeChecker = TestCase $ do

547545 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

548− let err1 = "AtomFunctionTypeError \"max\" 1"

546+ let err1 = "AtomFunctionTypeError \"max\" 1 (RelationAtomType [Attribute \"_\" IntegerAtomType]) IntegerAtomType"

549547 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"

550548

551549--exercise expression parser

@@ -665,10 +663,6 @@ testWithClause = TestCase $ do

665663 executeTutorialD sessionId dbconn "x:=with (x as s) x"

666664 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

667665 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

672666

673667 let err1 = "RelVarAlreadyDefinedError"

674668 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"

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+ $ TupleExprs () [TupleExpr (M.fromList [("a", NakedAtomExpr $ IntegerAtom 5),

24+ ("b", NakedAtomExpr $ TextAtom "spam")])]),

25+ Assign "y" (MakeRelationFromExprs Nothing

26+ $ TupleExprs () [TupleExpr (M.fromList [("b", NakedAtomExpr (TextAtom "漢字"))])])]

27+ imported <- importTutorialD tempPath

28+ assertEqual "import tutd" (Right expectedExpr) imported

29+

test/TutorialD/Interpreter/Import/httpimporttest.tutddeleted−2

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

1−x:=true;

2−y:=false;

test/TutorialD/PrinterTest.hs → test/TutorialD/Printer.hsrenamed

The content is the same.

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

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