master..da70d10 · project-m36

git.iko.soy/project-m36

71 files changed+979−1693

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.8.4 STACK_YAML=stack.ghc8.8.yaml

20+ compiler: ": #stack 8.8.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−4

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

51# 2020-12-27 (v0.9.0)

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

README.markdown+2−1

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

cabal.project−3

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

11packages: project-m36.cabal

3−package *

4− split-sections: True

5−

63--high-performance streaming library

74source-repository-package

85 type: git

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

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

2828### Load the Canonical Chris Date Example

2929

3030```

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

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

3232```

3333

3434```: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_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−57

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

11Cabal-Version: 2.2

22Name: project-m36

3−Version: 0.9.3

3+Version: 0.9.0

44License: 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

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

66Build-Type: Simple

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

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

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

3535 Default: True

3636

3737Library

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

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.3, winery, curryer-rpc, network, async, vector-instances

3939 if flag(haskell-scripting)

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

4141 CPP-Options: -DPM36_HASKELL_SCRIPTING

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

6363 ProjectM36.AtomFunction,

6464 ProjectM36.AtomFunctionError,

6565 ProjectM36.ScriptSession,

66− ProjectM36.Shortcuts,

6766 ProjectM36.DatabaseContextFunction,

6867 ProjectM36.DatabaseContextFunctionError,

6968 ProjectM36.DatabaseContextFunctionUtils,

@@ -136,14 +135,14 @@ Library

136135 Other-Modules: ProjectM36.Win32Handle

137136 else

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

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

138+ GHC-Options: -rdynamic

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

141140 Build-Depends: unix

142141 CC-Options: -fPIC

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

144143 Default-Language: Haskell2010

145144 Default-Extensions: OverloadedStrings, CPP

146− if !flag(stack)

145+ if !flag(stack)

147146 Build-Depends: deferred-folds

148147

149148Executable tutd

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

175174 directory,

176175 filepath,

177176 temporary,

178− megaparsec >= 5.2.0 && < 10,

177+ megaparsec >= 5.2.0 && < 9,

179178 haskeline,

180179 random, MonadRandom,

181180 base64-bytestring,

@@ -185,13 +184,7 @@ Executable tutd

185184 list-t,

186185 parser-combinators,

187186 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

187+ prettyprinter

195188 Other-Modules: TutorialD.Interpreter,

196189 TutorialD.Interpreter.Base,

197190 TutorialD.Interpreter.DatabaseContextExpr,

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

237230 optparse-applicative,

238231 hashable-time,

239232 time,

233+ vector-binary-instances,

240234 text,

241235 deepseq-generics,

242236 mtl,

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

258252Executable bigrel

259253 Default-Language: Haskell2010

260254 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

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

262256 Other-Modules: TutorialD.Interpreter.Base,

263257 TutorialD.Interpreter.DatabaseContextExpr,

264258 TutorialD.Interpreter.RelationalExpr,

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

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

271265

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

267+ Default-Language: Haskell2010

268+ 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-rpc, prettyprinter, base64-bytestring

275269 Default-Extensions: OverloadedStrings

276270 GHC-Options: -Wall -threaded

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

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

278272

279273Benchmark basic-benchmark

280274 Default-Language: Haskell2010

@@ -287,7 +281,7 @@ Benchmark basic-benchmark

287281 if flag(profiler)

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

289283

290−--benchmark inserts, updates, deletes for a basic use-case to shake out any space leaks

284+--benchmark inserts, updates, deletes for a basic use-case to shake out any space leaks

291285Benchmark update-exprs

292286 Default-Language: Haskell2010

293287 Default-Extensions: OverloadedStrings

@@ -297,69 +291,69 @@ Benchmark update-exprs

297291 GHC-Options: -Wall -threaded -rtsopts

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

299293 if flag(profiler)

300− GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall -fexternal-interpreter

294+ GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

301295

302296Test-Suite test-tutoriald

303297 import: commontest

304298 type: exitcode-stdio-1.0

305− main-is: TutorialD/InterpreterTest.hs

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

306300 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

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

308302

309303Test-Suite test-tutoriald-atomfunctionscript

310304 import: commontest

311305 type: exitcode-stdio-1.0

312306 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

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

314308

315309Test-Suite test-tutoriald-databasecontextfunctionscript

316310 import: commontest

317311 type: exitcode-stdio-1.0

318312 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

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

320314

321315Test-Suite test-relation

322316 import: commontest

323317 type: exitcode-stdio-1.0

324− main-is: Relation/Basic.hs

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

325319

326320Test-Suite test-static-optimizer

327321 import: commontest

328322 type: exitcode-stdio-1.0

329− main-is: Relation/StaticOptimizer.hs

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

330324

331325Test-Suite test-transactiongraph-persist

332326 import: commontest

333327 type: exitcode-stdio-1.0

334− main-is: TransactionGraph/Persist.hs

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

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

336330

337331Test-Suite test-relation-import-csv

338332 import: commontest

339333 type: exitcode-stdio-1.0

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

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

341335

342336Test-Suite test-tutoriald-import-tutoriald

343337 import: commontest

344338 type: exitcode-stdio-1.0

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

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

346340 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

347341

348342Test-Suite test-relation-export-csv

349343 import: commontest

350344 type: exitcode-stdio-1.0

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

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

352346

353347Test-Suite test-transactiongraph-merge

354348 import: commontest

355349 type: exitcode-stdio-1.0

356− main-is: TransactionGraph/Merge.hs

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

357351

358352

359353Test-Suite test-prettyprinter

360354 import: commontest

361355 type: exitcode-stdio-1.0

362− main-is: TutorialD/PrinterTest.hs

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

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

364358

365359benchmark bench

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

370364Test-Suite test-server

371365 import: commontest

372366 type: exitcode-stdio-1.0

373− main-is: Server/Main.hs

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

374368

375369

376370Executable Example-SimpleClient

377371 Default-Language: Haskell2010

378372 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

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

380374 Main-Is: examples/SimpleClient.hs

381375 GHC-Options: -Wall -threaded

382376

383377Executable Example-OutOfTheTarpit

384378 Default-Language: Haskell2010

385379 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

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

387381 Main-Is: examples/out_of_the_tarpit.hs

388382 GHC-Options: -Wall -threaded

389383

390384Executable Example-Blog

391385 Default-Language: Haskell2010

392386 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

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

394388 Main-Is: examples/blog.hs

395389 GHC-Options: -Wall -threaded

396390

397391Executable Example-Hair

398392 Default-Language: Haskell2010

399393 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

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

401395 Main-Is: examples/hair.hs

402396 GHC-Options: -Wall -threaded

403397

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−

411398Executable Example-CustomTupleable

412399 Default-Language: Haskell2010

413400 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

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

415402 Main-Is: examples/CustomTupleable.hs

416403 GHC-Options: -Wall -threaded

417404

@@ -428,12 +415,12 @@ Executable Example-DerivingCustomTupleable

428415Test-Suite test-scripts

429416 import: commontest

430417 type: exitcode-stdio-1.0

431− main-is: scripts.hs

418+ main-is: test/scripts.hs

432419 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

433420

434421Executable project-m36-websocket-server

435422 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

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

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

438425 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

439426 GHC-Options: -Wall -threaded

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

443430Test-Suite test-websocket-server

444431 import: commontest

445432 type: exitcode-stdio-1.0

446− main-is: Server/WebSocket.hs

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

447434 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

448435

449436Test-Suite test-isomorphic-schemas

450437 import: commontest

451438 type: exitcode-stdio-1.0

452− main-is: IsomorphicSchema.hs

439+ main-is: test/IsomorphicSchema.hs

453440

454441Test-Suite test-atomable

455442 import: commontest

456443 type: exitcode-stdio-1.0

457− main-is: Relation/Atomable.hs

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

458445 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

459446

460447Test-Suite test-multiprocess-access

461448 import: commontest

462449 type: exitcode-stdio-1.0

463− main-is: MultiProcessDatabaseAccess.hs

450+ main-is: test/MultiProcessDatabaseAccess.hs

464451

465452Test-Suite test-transactiongraph-automerge

466453 import: commontest

467454 type: exitcode-stdio-1.0

468− main-is: TransactionGraph/Automerge.hs

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

469456 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

470457

471458Test-Suite test-tupleable

472459 import: commontest

473460 type: exitcode-stdio-1.0

474− main-is: Relation/Tupleable.hs

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

475462

476463Test-Suite test-client-simple

477464 import: commontest

478− Main-Is: Client/Simple.hs

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

479466 type: exitcode-stdio-1.0

480467

481468-- test for file handle leaks

482469Executable handles

483470 Default-Language: Haskell2010

484471 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

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

486473 main-is: benchmark/Handles.hs

487474 Other-Modules: TutorialD.Interpreter,

488475 TutorialD.Interpreter.Base,

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

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

507494 if flag(profiler)

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

509−

496+

510497Test-Suite test-dataframe

511498 import: commontest

512499 type: exitcode-stdio-1.0

513− Main-Is: DataFrame.hs

500+ Main-Is: test/DataFrame.hs

514501 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+108−16

@@ -1,30 +1,122 @@

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;

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

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

11+ streamly-master = pkgs.fetchFromGitHub {

12+ owner = "composewell";

13+ repo = "streamly";

14+ rev = "ac3af8749194f1788704dda8667d0b3807075cc2";

15+ sha256 = "04d8fk654vawdfs0dfidmq2awwgwi8x44iv8r7vqz70zkcsd5fij";

16+ };

1317

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

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

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

21+ in

22+ haskellPackages.callCabal2nixWithOptions pkg (pkgs.fetchzip {

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

24+ inherit sha256;

25+ }) options;

26+

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

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

29+ rank1dynamic =

30+ distProcessPkg (self.callHackageDirect {

31+ pkg = "rank1dynamic";

32+ ver = "0.4.0";

33+ sha256 = "1x6p9z53s7xwp93jp4n1lq6m5xspcn6w62p461v8vqnp9600328b";

34+}{});

35+ stm-hamt =

36+ self.callHackageDirect {

37+ pkg = "stm-hamt";

38+ ver = "1.2.0.3";

39+ sha256 = "1i8j7q8nhx3l7gydrjlsyhkvllr6bppgrjf0hp38zpm7p6xcv2bb";

40+ }{};

41+

42+ stm-containers =

43+ self.callHackageDirect {

44+ pkg = "stm-containers";

45+ ver = "1.1.0.4";

46+ sha256 = "0h9z6lawdm44minx9spvdb7sp645l36ri5cnxvhrcxwzr64s7qb5";

47+ }{};

48+

49+ data-interval =

50+ self.callHackageDirect {

51+ pkg = "data-interval";

52+ ver = "2.0.1";

53+ sha256 = "085j4yjr8wimxampxqdrg47p577whwg2mjxgfdl44yfck52fb6an";

54+ }{};

55+

56+ curryer-rpc =

57+ self.callHackageDirect {

58+ pkg = "curryer-rpc";

59+ ver = "0.1";

60+ sha256 = "0vb7q68g4zjm20simnqpjdpvcvh4g8cwlc5b6zjdjpg1rargri41";

61+ }{};

62+

63+ streamly = self.callCabal2nix "streamly" streamly-master {};

64+

65+ fusion-plugin-types =

66+ self.callHackageDirect {

67+ pkg = "fusion-plugin-types";

68+ ver = "0.1.0";

69+ sha256 = "17211b80p4zqisghs2j8flm4dj788f9glx2id6nh8f223q4cigc9";

70+ }{};

71+

72+ winery =

73+ self.callHackageDirect {

74+ pkg = "winery";

75+ ver = "1.3.2";

76+ sha256 = "1jc7q8m0zd8bziwa3mra44j518ckc566akk7r5hqpf8x5ng0n4vv";

77+ }{};

78+

79+ barbies-th =

80+ self.callHackageDirect {

81+ pkg = "barbies-th";

82+ ver = "0.1.7";

83+ sha256 = "0gf39kcn6lwqhz888qm3iypma76yrp3zwmif1niry647qq27xp4j";

84+ }{};

85+

86+ barbies =

87+ self.callHackageDirect {

88+ pkg = "barbies";

89+ ver = "2.0.2.0";

90+ sha256 = "0753rd8pw0x1cgasz8a6633kg83jngwzncp9khbimllvcdqzardh";

91+ }{};

92+

93+ prettyprinter =

94+ self.callHackageDirect {

95+ pkg = "prettyprinter";

96+ ver = "1.7.0";

97+ sha256 = "17byy08brwcsl5rqdhibq3pcpgx085shizb2ap6s4xy3izdia3cc";

98+ }{};

99+

100+ prettyprinter-ansi-terminal =

101+ self.callHackageDirect {

102+ pkg = "prettyprinter-ansi-terminal";

103+ ver = "1.1.2";

104+ sha256 = "0lwcqndppw3jc55rlnn6sp76zmjx2yzl21g9jhg27k2rdnjwd7md";

105+ }{};

106+

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

108+

19109 };

20110 };

111+

112+ project = haskellPackages.project-m36;

21113in

22114{

23− project = haskellPackages.project-m36;

115+ project = project;

24116

25117 shell = haskellPackages.shellFor {

26− packages = p: [

27− p.project-m36

118+ packages = p: with p; [

119+ project

28120 ];

29121 buildInputs = [

30122 haskellPackages.ghcid

@@ -33,4 +125,4 @@ in

33125 ];

34126 withHoogle = true;

35127 };

36−}

128+}

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

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

164164instance ToJSON MergeError

165165instance FromJSON MergeError

166166

167−instance ToJSON ImportError'

168−instance FromJSON ImportError'

169−

170167instance ToJSON DatabaseContextFunctionError

171168instance FromJSON DatabaseContextFunctionError

172169

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

@@ -17,7 +17,7 @@ import ProjectM36.Relation

1717import ProjectM36.DataFrame

1818

1919#if MIN_VERSION_megaparsec(6,0,0)

20−import Text.Megaparsec.Char

20+import Text.Megaparsec.Char

2121import qualified Text.Megaparsec.Char.Lexer as Lex

2222import Text.Megaparsec

2323import Data.Void

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

@@ -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/lib/ProjectM36/Attribute.hs+26−58

@@ -20,10 +20,7 @@ instance Semigroup Attributes where

2020 Right attrs' -> attrs'

2121

2222instance Monoid Attributes where

23− mempty = Attributes {

24− attributesVec = mempty

25− --,attributeSet = mempty

26− }

23+ mempty = Attributes mempty mempty

2724

2825emptyAttributes :: Attributes

2926emptyAttributes = mempty

@@ -32,19 +29,13 @@ null :: Attributes -> Bool

3229null a = V.null (attributesVec a)

3330

3431singleton :: Attribute -> Attributes

35−singleton attr = Attributes {

36− attributesVec = V.singleton attr

37− --,attributesSet = HS.singleton attr

38− }

32+singleton attr = Attributes (V.singleton attr) (HS.singleton attr)

3933

4034toList :: Attributes -> [Attribute]

4135toList attrs = V.toList (attributesVec attrs)

4236

4337attributesFromList :: [Attribute] -> Attributes

44−attributesFromList attrsL = Attributes {

45− attributesVec = vec

46− --,attributesSet = hset

47− }

38+attributesFromList attrsL = Attributes vec hset

4839 where

4940 vec = if length attrsL == HS.size hset then

5041 --fast path- no duplicates

@@ -87,22 +78,19 @@ joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length

8778 overlappingAttributes = V.filter (`V.elem` attrs2) attrs1

8879-}

8980joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes

90−joinAttributes attrs1 attrs2

91− | S.size overlappingNames == 0 = -- fast path, no overlapping names

81+joinAttributes attrs1 attrs2 =

82+ if S.size overlappingNames == 0 then -- fast path, no overlapping names

9283 pure (concated id)

93− | attributesForNames overlappingNames attrs1 == attributesForNames overlappingNames attrs2 = -- that atomtypes match

84+ else if attributesForNames overlappingNames attrs1 == attributesForNames overlappingNames attrs2 then -- check that atomtypes match

9485 pure (concated vectorUniqueify)

95− | otherwise =

86+ else

9687 --special handling to validate that overlapping names have the same atom types

9788 Left (TupleAttributeTypeMismatchError (attributesForNames overlappingNames attrs1))

9889 where

9990 nameSet1 = attributeNameSet attrs1

10091 nameSet2 = attributeNameSet attrs2

10192 overlappingNames = S.intersection nameSet1 nameSet2

102− concated f = Attributes {

103− attributesVec = f (attributesVec attrs1 <> attributesVec attrs2)

104− --,attributesSet = attributesSet attrs1 <> attributesSet attrs2

105− }

93+ concated f = Attributes (f (attributesVec attrs1 <> attributesVec attrs2)) (attributesSet attrs1 <> attributesSet attrs2)

10694

10795addAttributes :: Attributes -> Attributes -> Attributes

10896addAttributes = (<>)

@@ -111,25 +99,23 @@ member :: Attribute -> Attributes -> Bool

11199member attr attrs = HS.member attr (attributesSet attrs)

112100

113101deleteAttributeName :: AttributeName -> Attributes -> Attributes

114−deleteAttributeName attrName = deleteAttributeNames (S.singleton attrName)

102+deleteAttributeName attrName attrs = deleteAttributeNames (S.singleton attrName) attrs

115103

116104deleteAttributeNames :: S.Set AttributeName -> Attributes -> Attributes

117−deleteAttributeNames attrNames attrs = Attributes {

118− attributesVec = vec

119− }

105+deleteAttributeNames attrNames attrs = Attributes vec hset

120106 where

121107 vec = V.filter attrFilter (attributesVec attrs)

108+ hset = HS.filter attrFilter (attributesSet attrs)

122109 attrFilter attr = S.notMember (attributeName attr) attrNames

123110

124111renameAttribute :: AttributeName -> Attribute -> Attribute

125112renameAttribute newAttrName (Attribute _ typeo) = Attribute newAttrName typeo

126113

127114renameAttributes :: AttributeName -> AttributeName -> Attributes -> Attributes

128−renameAttributes oldAttrName newAttrName attrs = Attributes {

129− attributesVec = vec

130− }

115+renameAttributes oldAttrName newAttrName attrs = Attributes vec hset

131116 where

132117 vec = V.map renamer (attributesVec attrs)

118+ hset = HS.map renamer (attributesSet attrs)

133119 renamer attr = if attributeName attr == oldAttrName then

134120 renameAttribute newAttrName attr

135121 else

@@ -159,11 +145,11 @@ projectionAttributesForNames names attrsIn =

159145 missingNames = attributeNamesNotContained names (S.fromList (V.toList (attributeNames attrsIn)))

160146

161147attributesForNames :: S.Set AttributeName -> Attributes -> Attributes

162−attributesForNames attrNameSet attrs = Attributes {

163− attributesVec = vec

164− }

148+attributesForNames attrNameSet attrs = Attributes vec hset

149+

165150 where

166151 vec = V.filter filt (attributesVec attrs)

152+ hset = HS.filter filt (attributesSet attrs)

167153 filt attr = S.member (attributeName attr) attrNameSet

168154

169155attributeNameSet :: Attributes -> S.Set AttributeName

@@ -207,15 +193,12 @@ attributesDifference attrsA attrsB =

207193 if attributesSet attrsA == attributesSet attrsB then

208194 mempty

209195 else

210− Attributes {

211− attributesVec = vec

212− --,attributesSet = hset

213− }

196+ Attributes vec hset

214197 where

215198 hset = HS.difference setA setB <> HS.difference setB setA

216199 setA = attributesSet attrsA

217200 setB = attributesSet attrsB

218− vec = V.filter (`HS.member` hset) (attributesVec attrsA <> attributesVec attrsB)

201+ vec = V.filter (\attr -> HS.member attr hset) (attributesVec attrsA <> attributesVec attrsB)

219202

220203vectorUniqueify :: (Hash.Hashable a, Eq a) => V.Vector a -> V.Vector a

221204vectorUniqueify vecIn = V.fromList $ HS.toList $ HS.fromList $ V.toList vecIn

@@ -230,29 +213,20 @@ verifyAttributes attrs =

230213 where

231214 vecSet = V.foldr' HS.insert HS.empty (attributesVec attrs)

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

216+ diffAttrs = Attributes (V.fromList (HS.toList diffSet)) diffSet

237217

238218--used in Generics derivation for ADTs without named attributes- not to be used elsewhere

239219--drop first n attributes from vector representation

240220drop :: Int -> Attributes -> Attributes

241−drop c attrs = Attributes { attributesVec = vec

242− }

221+drop c attrs = Attributes vec hset

243222 where

223+ droppedAttrs = V.take c (attributesVec attrs)

244224 vec = V.drop c (attributesVec attrs)

245−

225+ hset = HS.filter (`V.notElem` droppedAttrs) hset

246226

247−-- use this in preference to attributesEqual when the attribute ordering matters such as during tuple unions

248−attributesAndOrderEqual :: Attributes -> Attributes -> Bool

249−attributesAndOrderEqual a b = attributesVec a == attributesVec b

250−

251−-- use to determine if the same attributes are contained (but ordering is irrelevant)

227+-- use this in preference to (==) when the attribute ordering matters such as during tuple unions

252228attributesEqual :: Attributes -> Attributes -> Bool

253−attributesEqual attrsA attrsB =

254− attributesVec attrsA == attributesVec attrsB ||

255− attributesSet attrsA == attributesSet attrsB

229+attributesEqual a b = attributesVec a == attributesVec b

256230

257231attributesAsMap :: Attributes -> M.Map AttributeName Attribute

258232attributesAsMap attrs = V.foldr' (\attr acc -> M.insert (attributeName attr) attr acc) mempty (attributesVec attrs)

@@ -260,19 +234,13 @@ attributesAsMap attrs = V.foldr' (\attr acc -> M.insert (attributeName attr) att

260234

261235-- | Left-biased union of attributes.

262236union :: Attributes -> Attributes -> Attributes

263−union attrsA attrsB = Attributes {

264− attributesVec = vec

265− --,attributesSet = hset

266− }

237+union attrsA attrsB = Attributes vec hset

267238 where

268239 hset = HS.union (attributesSet attrsA) (attributesSet attrsB)

269240 vec = HS.foldr (flip V.snoc) mempty hset

270241

271242intersection :: Attributes -> Attributes -> Attributes

272−intersection attrsA attrsB = Attributes {

273− attributesVec = vec

274− --,attributesSet = hset

275− }

243+intersection attrsA attrsB = Attributes vec hset

276244 where

277245 hset = HS.intersection (attributesSet attrsA) (attributesSet attrsB)

278246 vec = HS.foldr (flip V.snoc) mempty hset

src/lib/ProjectM36/Base.hs+17−21

@@ -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,24 @@ 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)

102+data Attributes = Attributes (V.Vector Attribute) (HS.HashSet Attribute)

103+ deriving (NFData, Read, Hashable, Generic, Show)

110104

111−attributesSet :: Attributes -> HS.HashSet Attribute

112−attributesSet = HS.fromList . V.toList . attributesVec

105+{-instance Show Attributes where

106+ show attrs = "attributesFromList [" <> L.intercalate " " (map (\attr -> "(" <> show attr <> ")") (V.toList (attributesVec attrs))) <> "]"

107+-}

108+attributesVec :: Attributes -> V.Vector Attribute

109+attributesVec (Attributes attrsVec _) = attrsVec

113110

114−instance Show Attributes where

115− show attrs = "attributesFromList [" <> L.intercalate ", " (map (\attr -> "(" <> show attr <> ")") (V.toList (attributesVec attrs))) <> "]"

111+attributesSet :: Attributes -> HS.HashSet Attribute

112+attributesSet (Attributes _ hs) = hs

116113

117−--when attribute ordering is irrelevant

118114instance Eq Attributes where

119− attrsA == attrsB =

120− attributesVec attrsA == attributesVec attrsB ||

121− attributesSet attrsA == attributesSet attrsB

115+ (Attributes _ a) == (Attributes _ b) = a == b

122116

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

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

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

125119

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

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

@@ -158,7 +152,7 @@ instance Eq RelationTuple where

158152 tuple1@(RelationTuple attrs1 _) == tuple2@(RelationTuple attrs2 _) =

159153 attrs1 == attrs2 && atomsEqual

160154 where

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

155+ atomForAttribute attr (RelationTuple (Attributes attrs _) tupVec) = case V.findIndex (== attr) attrs of

162156 Nothing -> Nothing

163157 Just index -> tupVec V.!? index

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

@@ -641,6 +635,8 @@ atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap

641635atomTypeVars (TypeVariableType nam) = S.singleton nam

642636

643637unimplemented :: HasCallStack => a

644−unimplemented = error "unimplemented"

638+unimplemented = undefined

639+

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

645641

646−makeBaseFunctor ''RelationalExprBase

642+

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/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+21−16

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

@@ -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/RelationalExpression.hs+301−75

@@ -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,14 +40,14 @@ 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

4946import GHC.Paths

5047#endif

5148

49+import Debug.Trace

50+

5251data DatabaseContextExprDetails = CountUpdatedTuples

5352

5453databaseContextExprDetailsFunc :: DatabaseContextExprDetails -> ResultAccumFunc

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

110109askEnv = R.ask

111110

112111mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

113−mergeTuplesIntoGraphRefRelationalExprEnv tupIn env =

114− env { gre_extra = new_elems }

112+mergeTuplesIntoGraphRefRelationalExprEnv tupIn e =

113+ e{ gre_extra = new_elems }

115114 where

116115 new_elems = Just (Left newTuple)

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

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

118117 newTuple = mkRelationTupleFromMap mergedTupMap

119118

120119mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

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

212211setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv

213212setEnvContext e ctx = e { re_context = ctx }

214213

214+{-

215+--full evaluation down the graph

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

217+eval expr = do

218+ env <- askEnv

219+ eGfExpr <- processRelationalExpr expr

220+ case eGfExpr of

221+ Left err -> pure (Left err)

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

223+-}

224+{-

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

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

227+evalRelationalExpr (RelationVariable name _) = do

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

229+ return $ case M.lookup name relvarTable of

230+ Just res -> Right res

231+ Nothing -> Left $ RelVarNotDefinedError name

232+

233+evalRelationalExpr (Project attrNames expr) = do

234+ eAttrNameSet <- evalAttributeNames attrNames expr

235+ case eAttrNameSet of

236+ Left err -> pure (Left err)

237+ Right attrNameSet -> do

238+ rel <- evalRelationalExpr expr

239+ case rel of

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

241+ Left err -> pure $ Left err

242+

243+evalRelationalExpr (Union exprA exprB) = do

244+ relA <- evalRelationalExpr exprA

245+ relB <- evalRelationalExpr exprB

246+ case relA of

247+ Left err -> return $ Left err

248+ Right relA2 -> case relB of

249+ Left err -> return $ Left err

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

251+

252+evalRelationalExpr (Join exprA exprB) = do

253+ relA <- evalRelationalExpr exprA

254+ relB <- evalRelationalExpr exprB

255+ case relA of

256+ Left err -> return $ Left err

257+ Right relA2 -> case relB of

258+ Left err -> return $ Left err

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

260+

261+evalRelationalExpr (Difference exprA exprB) = do

262+ relA <- evalRelationalExpr exprA

263+ relB <- evalRelationalExpr exprB

264+ case relA of

265+ Left err -> return $ Left err

266+ Right relA2 -> case relB of

267+ Left err -> return $ Left err

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

269+

270+evalRelationalExpr (MakeStaticRelation attributeSet tupleSet) =

271+ case mkRelation attributeSet tupleSet of

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

273+ Left err -> return $ Left err

274+

275+evalRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

276+ currentContext <- fmap envContext askEnv

277+ let tConss = typeConstructorMapping currentContext

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

279+ runExceptT $ do

280+ mAttrs <- case mAttrExprs of

281+ Just _ ->

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

283+ Nothing -> pure Nothing

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

285+ let attrs = fromMaybe firstTupleAttrs mAttrs

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

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

288+ pure (ExistingRelation expr)

289+

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

291+

292+evalRelationalExpr (Rename oldAttrName newAttrName relExpr) = do

293+ evald <- evalRelationalExpr relExpr

294+ case evald of

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

296+ Left err -> return $ Left err

297+

298+evalRelationalExpr (Group oldAttrNames newAttrName relExpr) = do

299+ eOldAttrNameSet <- evalAttributeNames oldAttrNames relExpr

300+ case eOldAttrNameSet of

301+ Left err -> pure (Left err)

302+ Right oldAttrNameSet -> do

303+ evald <- evalRelationalExpr relExpr

304+ case evald of

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

306+ Left err -> return $ Left err

307+

308+evalRelationalExpr (Ungroup attrName relExpr) = do

309+ evald <- evalRelationalExpr relExpr

310+ case evald of

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

312+ Left err -> return $ Left err

313+

314+evalRelationalExpr (Restrict predicateExpr relExpr) = do

315+ evald <- evalRelationalExpr relExpr

316+ pred <- processRestrictionPredicateExpr predicateExpr

317+ case evald of

318+ Left err -> return $ Left err

319+ Right expr ->

320+ pure $ Right (Restrict pred expr)

321+

322+evalRelationalExpr (Equals relExprA relExprB) = do

323+ evaldA <- evalRelationalExpr relExprA

324+ evaldB <- evalRelationalExpr relExprB

325+ case evaldA of

326+ Left err -> return $ Left err

327+ Right exprA -> case evaldB of

328+ Left err -> return $ Left err

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

330+{-

331+evalRelationalExpr (With views mainExpr) = do

332+ rstate <- ask

333+

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

335+ Left (RelVarAlreadyDefinedError vname)

336+ else

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

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

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

340+

341+ case foldM addScopedView (stateElemsContext rstate) views of

342+ Left err -> return $ Left err

343+ Right ctx'' -> do

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

345+ case evalMainExpr mainExpr of

346+ Left err -> return $ Left err

347+ Right rel -> return $ Right rel

348+-}

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

350+evalRelationalExpr (NotEquals relExprA relExprB) = do

351+ evaldA <- evalRelationalExpr relExprA

352+ evaldB <- evalRelationalExpr relExprB

353+ case evaldA of

354+ Left err -> return $ Left err

355+ Right exprA -> case evaldB of

356+ Left err -> return $ Left err

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

358+

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

360+evalRelationalExpr (Extend tupleExpression relExpr) = do

361+ eExpr <- evalRelationalExpr relExpr

362+ case eExpr of

363+ Left err -> pure (Left err)

364+ Right expr -> do

365+ tupProc <- processExtendTupleExpr tupleExpression

366+ pure (Right (Extend tupProc expr))

367+-}

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

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

217370setRelVar relVarName relExpr = do

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

231384 Left err -> dbErr err

232385 Right _ -> putStateContext potentialContext

233386

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−

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

238388deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()

239389deleteRelVar relVarName = do

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

299449

300450evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do

301451 gfExpr <- relVarByName relVarName

302− let optExpr = applyUnionCollapse (Union

303− relExpr

304− gfExpr)

305− evalGraphRefDatabaseContextExpr (Assign relVarName optExpr)

452+ evalGraphRefDatabaseContextExpr (Assign relVarName

453+ (Union

454+ gfExpr

455+ relExpr))

306456

307457evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do

308458 gfExpr <- relVarByName relVarName

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

310− setRelVar relVarName optExpr

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

311460

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

313462evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do

314463 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

323464 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

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

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

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

334468 restrictedPortion = Restrict pred' rvExpr

@@ -642,6 +776,18 @@ evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs

642776 Left err -> pure (Left err)

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

644778

779+{-

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

781+updateTupleWithAtomExprs exprMap context graph tupIn = do

782+ --resolve all atom exprs

783+ let

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

785+ let atom = unimplemented

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

787+ pure (attrName, atom)

788+ ) (M.toList exprMap)

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

790+-}

645791--run verification on all constraints

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

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

@@ -660,6 +806,7 @@ checkConstraints context transId graph@(TransactionGraph graphHeads transSet) =

660806 deps = inclusionDependencies context

661807 -- no optimization available here, really? perhaps the optimizer should be passed down to here or the eval function should be passed through the environment

662808 checkIncDep depName (InclusionDependency subsetExpr supersetExpr) = do

809+ traceShowM ("incdep", subsetExpr, supersetExpr)

663810 let process = runProcessExprM UncommittedContextMarker

664811 gfSubsetExpr = process (processRelationalExpr subsetExpr)

665812 gfSupersetExpr = process (processRelationalExpr supersetExpr)

@@ -670,11 +817,11 @@ checkConstraints context transId graph@(TransactionGraph graphHeads transSet) =

670817 typeSuper <- runGfRel (typeForGraphRefRelationalExpr gfSupersetExpr)

671818 when (typeSub /= typeSuper) (Left (RelationTypeMismatchError (attributes typeSub) (attributes typeSuper)))

672819 let checkExpr = Equals gfSupersetExpr (Union gfSubsetExpr gfSupersetExpr)

673− gfEvald = runGraphRefRelationalExprM gfEnv' (evalGraphRefRelationalExpr checkExpr)

820+ gfEvald = runGraphRefRelationalExprM gfEnv' (evalGraphRefRelationalExpr (traceShow ("checkCon", checkExpr) checkExpr))

674821 gfEnv' = freshGraphRefRelationalExprEnv (Just context) potentialGraph

675822 case gfEvald of

676823 Left err -> Left err

677− Right resultRel -> if resultRel == relationTrue then

824+ Right resultRel -> if traceShow ("result", resultRel, relationTrue) (resultRel == relationTrue) then

678825 pure ()

679826 else

680827 Left (InclusionDependencyCheckError depName)

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

693840 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

694841 lift $ except runGf

695842

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

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

845+{-

846+contextWithEmptyTupleSets :: DatabaseContext -> DatabaseContext

847+contextWithEmptyTupleSets contextIn = contextIn { relationVariables = relVars }

848+ where

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

850+-}

851+

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

697853liftE v = do

698854 y <- lift v

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

8481004 mapM (evalGraphRefAtomExpr tupIn) dConsArgs

8491005 pure (ConstructedAtom dConsName aType argAtoms)

8501006

1007+{-

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

1009+evalAtomExpr tupIn expr =

1010+ -}

1011+{-

1012+

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

1014+ Right atom -> pure (Right atom)

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

1016+ rstate <- ask

1017+ let stateTup = stateTuple rstate

1018+ pure (atomForAttributeName attrName stateTup)

1019+ Left err -> pure (Left err)

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

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

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

1023+ context <- fmap stateElemsContext ask

1024+ runExceptT $ do

1025+ let functions = atomFunctions context

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

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

1028+ actualArgCount = length argTypes

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

1030+ safeInit xs = init xs

1031+ if expectedArgCount /= actualArgCount then

1032+ throwE (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)

1033+ else do

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

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

1036+ actType <- either throwE pure eActType

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

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

1039+ case evalAtomFunction func evaldArgs of

1040+ Left err -> throwE (AtomFunctionUserError err)

1041+ Right result -> do

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

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

1044+ pure result

1045+evalAtomExpr tupIn (RelationAtomExpr relExpr) = do

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

1047+ rstate <- ask

1048+ runExceptT $ do

1049+ let newState = mergeTuplesIntoRelationalExprState tupIn rstate

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

1051+ pure (RelationAtom relAtom)

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

1053+ rstate <- lift ask

1054+ let newState = mergeTuplesIntoRelationalExprState tupIn rstate

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

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

1057+ pure (ConstructedAtom dConsName aType argAtoms)

1058+-}

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

8521060typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

8531061 renv <- askEnv

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

9141122 let handler :: RelationalError -> GraphRefRelationalExprM AtomType

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

9161124 handler err = throwError err

917− verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

1125+ verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

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

9191127 if length funcArgTypes /= length expectedArgTypes - 1 then

9201128 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)

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

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

10181226 pure tup'

10191227

1228+{-

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

1230+evalAttributeNames attrNames expr = do

1231+ eExprType <- typeForRelationalExpr expr

1232+ case eExprType of

1233+ Left err -> throwError err

1234+ Right exprTyp -> do

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

1236+ case attrNames of

1237+ AttributeNames names ->

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

1239+ Left err -> pure (Left err)

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

1241+

1242+ InvertedAttributeNames names -> do

1243+ let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet

1244+ if not (S.null nonExistentAttributeNames) then

1245+ pure (Left (AttributeNamesMismatchError nonExistentAttributeNames))

1246+ else

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

1248+

1249+ UnionAttributeNames namesA namesB -> do

1250+ eNameSetA <- evalAttributeNames namesA expr

1251+ case eNameSetA of

1252+ Left err -> pure (Left err)

1253+ Right nameSetA -> do

1254+ eNameSetB <- evalAttributeNames namesB expr

1255+ case eNameSetB of

1256+ Left err -> pure (Left err)

1257+ Right nameSetB ->

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

1259+

1260+ IntersectAttributeNames namesA namesB -> do

1261+ eNameSetA <- evalAttributeNames namesA expr

1262+ case eNameSetA of

1263+ Left err -> pure (Left err)

1264+ Right nameSetA -> do

1265+ eNameSetB <- evalAttributeNames namesB expr

1266+ case eNameSetB of

1267+ Left err -> pure (Left err)

1268+ Right nameSetB ->

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

1270+

1271+ RelationalExprAttributeNames attrExpr -> do

1272+ eAttrExprType <- typeForRelationalExpr attrExpr

1273+ case eAttrExprType of

1274+ Left err -> pure (Left err)

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

1276+-}

1277+

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

10211279evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation

10221280evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

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

12651523 Left err -> throwError err

12661524 Right rel -> pure rel

12671525

1526+{-

1527+relVarByName :: RelVarName -> GraphRefRelationalExprM GraphRefRelationalExpr

1528+relVarByName = do

1529+ relvars <- relationVariables <$> getStateContext

1530+ case M.lookup relVarName relvars of

1531+ Nothing -> dbErr (RelVarNotDefinedError relVarName)

1532+ Just gfexpr -> pure gfExpr

1533+-}

1534+

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

12691536 getContext :: m DatabaseContext

12701537

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

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

13501617 resolve (ConstructedAtomExpr dConsName atomExprs marker) =

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

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

16+import qualified Data.HashSet as HS

1717

1818deriving via WineryVariant Atom instance Serialise Atom

1919deriving via WineryVariant AtomType instance Serialise AtomType

@@ -77,9 +77,10 @@ instance Serialise Attributes where

7777 schemaGen _ = SVector <$> getSchema (Proxy @Attribute)

7878 toBuilder attrs = varInt (V.length (attributesVec attrs)) <> foldMap toBuilder (V.toList (attributesVec attrs))

7979 extractor =

80− attributesFromList . V.toList <$> extractListBy extractor

80+ let mkAttrs x = Attributes x (HS.fromList (V.toList x)) in

81+ mkAttrs <$> extractListBy extractor

8182

8283 decodeCurrent = do

8384 n <- decodeVarInt

8485 l <- replicateM n decodeCurrent

85− pure (A.attributesFromList l)

86+ pure (Attributes (V.fromList l) (HS.fromList l))

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

@@ -14,6 +14,8 @@ import Control.Monad

1414import Control.Arrow

1515import Data.Maybe

1616

17+import Debug.Trace

18+

1719emptyTuple :: RelationTuple

1820emptyTuple = RelationTuple mempty mempty

1921

@@ -146,23 +148,15 @@ tupleAtomExtend newAttrName atom tupIn = tupleExtend tupIn newTup

146148 where

147149 newTup = RelationTuple (A.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)

148150

149−{-tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

151+--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)]

152+tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

150153tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec

151154 where

152155 deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) (attributesVec attrs)

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

157+ newAttrs = deleteAttributeNames projectAttrs attrs

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

159+

166160--return the attributes and atoms which are equal in both vectors

167161--semi-join

168162tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple

@@ -171,13 +165,9 @@ tupleIntersection tuple1 tuple2 = RelationTuple newAttrs newTupVec

171165 attrs1 = tupleAttributes tuple1

172166 attrs2 = tupleAttributes tuple2

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

168+ matchingIndices = V.findIndices (\attr -> A.member attr intersectAttrs) (attributesVec 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 = deleteAttributeNames (A.attributeNameSet intersectAttrs) attrs1

181171 newTupVec = indexFilter (tupleAtoms tuple1)

182172

183173-- | An optimized form of tuple update which updates vectors efficiently.

@@ -194,7 +184,6 @@ tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList

194184 where

195185 assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed (attributesVec attrs))

196186

197−-- | Validate that the tuple has the correct attributes in the correct order

198187verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

199188verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs

200189 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in

@@ -207,13 +196,13 @@ 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

213202 RelationTuple attrs (V.map mapper (attributesVec 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

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

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

4545import ProjectM36.Tuple

4646import ProjectM36.TupleSet

4747import qualified Data.Set as S

48+import qualified Data.HashSet as HS

4849

4950{-import Data.Binary

5051import Control.DeepSeq

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

229230 where

230231 attrsToCheck = toAttributesG opts v

231232 counter = V.generate (arity attrsToCheck) id

232− attrs = attributesFromList (V.toList attrsV)

233+ attrs = Attributes attrsV (HS.fromList (V.toList attrsV))

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

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

235236 else

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.6.yaml+20−24

@@ -6,32 +6,28 @@ resolver: lts-14.27

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: 28ff1d031078af4a17fa326d43340474571df0c3

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

3531

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

3733flags:

stack.ghc8.8.yaml+22−24

@@ -6,32 +6,30 @@ 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: 28ff1d031078af4a17fa326d43340474571df0c3

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

3533

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

3735flags:

test/Relation/Basic.hs+11−12

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

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