git.iko.soy/project-m36
on 2bc6417 help sign in
44feeff
swap
0 ahead, 1009 behind
283 files changed+8356−24516
since splitsnapshots
unifiedsplit
.appveyor.yml−39 .github/workflows/ci.yaml−69 .gitignore+1−17 Changelog.markdown−130 Database/Persist/ProjectM36.hs+579 ProjectM36/Atom.hs+74 ProjectM36/AtomFunction.hs+34 ProjectM36/AtomFunctionBody.hs+92 ProjectM36/AtomFunctions/Basic.hs+15 ProjectM36/AtomFunctions/Primitive.hs+101 ProjectM36/AtomType.hs+267 ProjectM36/Attribute.hs+123 ProjectM36/AttributeNames.hs+30 ProjectM36/Base.hs+512 ProjectM36/Client.hs+557 src/bin/ProjectM36/Client/Json.hs → ProjectM36/Client/Json.hs+1−4 ProjectM36/ConcreteTypeRep.hs+34 src/lib/ProjectM36/DataConstructorDef.hs → ProjectM36/DataConstructorDef.hs+4−4 ProjectM36/DataTypes/Basic.hs+14 ProjectM36/DataTypes/Day.hs+30 src/lib/ProjectM36/DataTypes/Either.hs → ProjectM36/DataTypes/Either.hs+2−1 ProjectM36/DataTypes/Interval.hs+37 ProjectM36/DataTypes/Maybe.hs+23 ProjectM36/DataTypes/Primitive.hs+36 src/lib/ProjectM36/DatabaseContext.hs → ProjectM36/DatabaseContext.hs+5−27 ProjectM36/DateExamples.hs+89 cbits/DirectoryFsync.c → ProjectM36/DirectoryFsync.c−3 src/lib/ProjectM36/Error.hs → ProjectM36/Error.hs+18−67 ProjectM36/Key.hs+32 ProjectM36/MiscUtils.hs+8 ProjectM36/Notifications.hs+17 src/lib/ProjectM36/Persist.hs → ProjectM36/Persist.hs+13−71 src/lib/ProjectM36/Relation.hs → ProjectM36/Relation.hs+84−85 ProjectM36/Relation/Parse/CSV.hs+54 ProjectM36/Relation/Show/CSV.hs+46 src/lib/ProjectM36/Relation/Show/Gnuplot.hs → ProjectM36/Relation/Show/Gnuplot.hs+12−11 ProjectM36/Relation/Show/HTML.hs+37 src/lib/ProjectM36/Relation/Show/Term.hs → ProjectM36/Relation/Show/Term.hs+39−42 ProjectM36/RelationalExpression.hs+587 ProjectM36/Server.hs+85 ProjectM36/Server/Config.hs+15 ProjectM36/Server/EntryPoints.hs+90 ProjectM36/Server/ParseArgs.hs+43 ProjectM36/Server/RemoteCallTypes.hs+45 ProjectM36/Server/RemoteCallTypes/Json.hs+159 ProjectM36/Server/WebSocket.hs+73 ProjectM36/Server/WebSocket/Main.hs+19 src/bin/ProjectM36/Server/WebSocket/project-m36.js → ProjectM36/Server/WebSocket/project-m36.js+19−108 src/bin/ProjectM36/Server/WebSocket/websocket-client.html → ProjectM36/Server/WebSocket/websocket-client.html+17−48 src/bin/ProjectM36/Server/WebSocket/websocket-client.js → ProjectM36/Server/WebSocket/websocket-client.js+19−124 src/bin/ProjectM36/Server/project-m36-server.hs → ProjectM36/Server/project-m36-server.hs ProjectM36/Session.hs+16 ProjectM36/Sessions.hs+29 ProjectM36/StaticOptimizer.hs+179 ProjectM36/Transaction.hs+34 ProjectM36/Transaction/Persist.hs+147 ProjectM36/TransactionGraph.hs+413 src/lib/ProjectM36/TransactionGraph/Merge.hs → ProjectM36/TransactionGraph/Merge.hs+16−25 ProjectM36/TransactionGraph/Persist.hs+150 src/lib/ProjectM36/TransactionGraph/Show.hs → ProjectM36/TransactionGraph/Show.hs+4−3 src/lib/ProjectM36/TransactionGraph/Show/Dot.hs → ProjectM36/TransactionGraph/Show/Dot.hs+1−1 src/lib/ProjectM36/Tuple.hs → ProjectM36/Tuple.hs+62−82 src/lib/ProjectM36/TupleSet.hs → ProjectM36/TupleSet.hs+4−11 ProjectM36/TypeConstructor.hs+19 src/lib/ProjectM36/TypeConstructorDef.hs → ProjectM36/TypeConstructorDef.hs src/lib/ProjectM36/Win32Handle.hs → ProjectM36/Win32Handle.hs+2−5 README.markdown+7−62 TutorialD/Interpreter.hs+195 TutorialD/Interpreter/Base.hs+120 TutorialD/Interpreter/DataTypes/DateTime.hs+22 TutorialD/Interpreter/DataTypes/Interval.hs+35 TutorialD/Interpreter/DatabaseContextExpr.hs+182 src/bin/TutorialD/Interpreter/Export/Base.hs → TutorialD/Interpreter/Export/Base.hs+1−8 src/bin/TutorialD/Interpreter/Export/CSV.hs → TutorialD/Interpreter/Export/CSV.hs+4−3 TutorialD/Interpreter/Import/Base.hs+17 src/bin/TutorialD/Interpreter/Import/BasicExamples.hs → TutorialD/Interpreter/Import/BasicExamples.hs+3−8 TutorialD/Interpreter/Import/CSV.hs+29 TutorialD/Interpreter/Import/TutorialD.hs+31 src/bin/TutorialD/Interpreter/InformationOperator.hs → TutorialD/Interpreter/InformationOperator.hs+3−8 TutorialD/Interpreter/RODatabaseContextOperator.hs+136 TutorialD/Interpreter/RelationalExpr.hs+259 src/bin/TutorialD/Interpreter/TransactionGraphOperator.hs → TutorialD/Interpreter/TransactionGraphOperator.hs+33−50 TutorialD/Interpreter/Types.hs+49 TutorialD/tutd.hs+89 benchmark/Relation.hs+13 src/bin/benchmark/bigrel.hs → benchmark/bigrel.hs+34−59 cabal.project−10 cbits/darwin_statfs.c−23 default.nix−1 docker.nix−18 docs/15_minute_tutorial.markdown+89−86 docs/acid_assessment.markdown+2−2 docs/atomfunctions.markdown−75 docs/basic_benchmarks.html−1230 docs/commits_in_constant_time.markdown−134 docs/data_independence.markdown−109 docs/database_context_functions.markdown−167 docs/dataframes.markdown−53 docs/filesystem-persistence.markdown−128 docs/import_export_csv.markdown−65 docs/index.markdown+1 docs/introduction_to_projectm36.markdown+13−39 docs/introduction_to_the_relational_algebra.markdown+13−44 docs/isomorphic_schemas.markdown−176 docs/javascript_driver.markdown−21 docs/jupyter_kernel.markdown−49 docs/merge_transactions.markdown+8−8 docs/merkle_transaction_graph.markdown−33 docs/new_datatypes.markdown+10−70 docs/on_null.markdown+5−5 docs/persistent_library_driver.markdown+18 docs/projectm36_client_library.markdown+1−15 docs/reaching_out_of_the_tarpit.markdown+9−8 docs/replication.markdown−30 docs/sample_session.asciinema.json−698 docs/server_mode.markdown+2−2 docs/simple_api.markdown−42 docs/transaction_graph_operators.markdown+25−47 docs/transgraphrelationalexpr.markdown−61 docs/tupleable.markdown−68 docs/tutd_cheatsheet.markdown−99 docs/tutd_tutorial.markdown+213−369 docs/using_notifications.markdown+25−29 docs/websocket_server.markdown+3−3 examples/CustomTupleable.hs−67 examples/DerivingCustomTupleable.hs−54 examples/DynamicAtomFunctions.hs−12 examples/DynamicDatabaseContextFunctions.hs−26 examples/Hospital.hs+5−5 examples/PersistClient.hs+55 examples/Plantfarm.hs−446 examples/SimpleClient.hs+16−14 examples/blog.hs−221 examples/hair.hs−44 examples/out_of_the_tarpit.hs+59−239 examples/out_of_the_tarpit.tutd+4−4 h2svg.sh−1 hp2svg.sh−2 install_tools.sh−3 jupyter/TutorialD Notebook Walkthrough.ipynb−794 jupyter/itutd/ITutorialDKernel.py−179 jupyter/itutd/__init__.py−1 jupyter/itutd/__main__.py−4 jupyter/kernel.json−5 jupyter/setup.py−19 nix/sources.json−50 nix/sources.nix−171 posts/2015-12-07-tu-quoque.html−44 project-m36.cabal+483−321 release.nix−36 runghcid.sh−2 scripts/DateExamples.tutd+5−26 scripts/multiline.tutd−2 shell.nix−1 src/bin/ProjectM36/Server/RemoteCallTypes/Json.hs−185 src/bin/ProjectM36/Server/WebSocket.hs−146 src/bin/ProjectM36/Server/WebSocket/websocket-config.js−5 src/bin/ProjectM36/Server/WebSocket/websocket-server.hs−63 src/bin/TutorialD/Interpreter.hs−272 src/bin/TutorialD/Interpreter/Base.hs−245 src/bin/TutorialD/Interpreter/DatabaseContextExpr.hs−219 src/bin/TutorialD/Interpreter/DatabaseContextIOOperator.hs−50 src/bin/TutorialD/Interpreter/Import/Base.hs−32 src/bin/TutorialD/Interpreter/Import/CSV.hs−29 src/bin/TutorialD/Interpreter/Import/TutorialD.hs−86 src/bin/TutorialD/Interpreter/RODatabaseContextOperator.hs−210 src/bin/TutorialD/Interpreter/RelationalExpr.hs−284 src/bin/TutorialD/Interpreter/SchemaOperator.hs−77 src/bin/TutorialD/Interpreter/TransGraphRelationalOperator.hs−46 src/bin/TutorialD/Interpreter/Types.hs−61 src/bin/TutorialD/Printer.hs−165 src/bin/TutorialD/tutd.hs−110 src/bin/benchmark/Basic.hs−106 src/bin/benchmark/Handles.hs−97 src/bin/benchmark/Relation.hs−27 src/lib/ProjectM36/Arbitrary.hs−127 src/lib/ProjectM36/Atom.hs−46 src/lib/ProjectM36/AtomFunction.hs−101 src/lib/ProjectM36/AtomFunctionBody.hs−7 src/lib/ProjectM36/AtomFunctionError.hs−17 src/lib/ProjectM36/AtomFunctionUtils.hs−4 src/lib/ProjectM36/AtomFunctions/Basic.hs−29 src/lib/ProjectM36/AtomFunctions/Primitive.hs−99 src/lib/ProjectM36/AtomType.hs−456 src/lib/ProjectM36/Atomable.hs−286 src/lib/ProjectM36/Attribute.hs−278 src/lib/ProjectM36/AttributeExpr.hs−7 src/lib/ProjectM36/AttributeNames.hs−11 src/lib/ProjectM36/Base.hs−646 src/lib/ProjectM36/Client.hs−1095 src/lib/ProjectM36/Client/Simple.hs−129 src/lib/ProjectM36/DataFrame.hs−183 src/lib/ProjectM36/DataTypes/Basic.hs−19 src/lib/ProjectM36/DataTypes/ByteString.hs−18 src/lib/ProjectM36/DataTypes/DateTime.hs−14 src/lib/ProjectM36/DataTypes/Day.hs−17 src/lib/ProjectM36/DataTypes/Interval.hs−146 src/lib/ProjectM36/DataTypes/List.hs−53 src/lib/ProjectM36/DataTypes/Maybe.hs−38 src/lib/ProjectM36/DataTypes/NonEmptyList.hs−53 src/lib/ProjectM36/DataTypes/Primitive.hs−45 src/lib/ProjectM36/DataTypes/Sorting.hs−31 src/lib/ProjectM36/DatabaseContextFunction.hs−91 src/lib/ProjectM36/DatabaseContextFunctionError.hs−8 src/lib/ProjectM36/DatabaseContextFunctionUtils.hs−22 src/lib/ProjectM36/DateExamples.hs−90 src/lib/ProjectM36/DisconnectedTransaction.hs−17 src/lib/ProjectM36/FSType.hs−102 src/lib/ProjectM36/FileLock.hs−96 src/lib/ProjectM36/FunctionalDependency.hs−20 src/lib/ProjectM36/GraphRefRelationalExpr.hs−45 src/lib/ProjectM36/InclusionDependency.hs−19 src/lib/ProjectM36/IsomorphicSchema.hs−333 src/lib/ProjectM36/Key.hs−69 src/lib/ProjectM36/MerkleHash.hs−9 src/lib/ProjectM36/MiscUtils.hs−15 src/lib/ProjectM36/NormalizeExpr.hs−132 src/lib/ProjectM36/Notifications.hs−22 src/lib/ProjectM36/Relation/Parse/CSV.hs−165 src/lib/ProjectM36/Relation/Show/CSV.hs−47 src/lib/ProjectM36/Relation/Show/HTML.hs−63 src/lib/ProjectM36/RelationalExpression.hs−1392 src/lib/ProjectM36/ScriptSession.hs−275 src/lib/ProjectM36/Serialise/AtomFunctionError.hs−7 src/lib/ProjectM36/Serialise/Base.hs−85 src/lib/ProjectM36/Serialise/DataFrame.hs−13 src/lib/ProjectM36/Serialise/DatabaseContextFunctionError.hs−7 src/lib/ProjectM36/Serialise/Error.hs−15 src/lib/ProjectM36/Serialise/IsomorphicSchema.hs−7 src/lib/ProjectM36/Serialise/MergeError.hs−1 src/lib/ProjectM36/Server.hs−217 src/lib/ProjectM36/Server/Config.hs−30 src/lib/ProjectM36/Server/EntryPoints.hs−146 src/lib/ProjectM36/Server/EntryPoints/Json.hs src/lib/ProjectM36/Server/ParseArgs.hs−102 src/lib/ProjectM36/Server/RemoteCallTypes.hs−103 src/lib/ProjectM36/Session.hs−44 src/lib/ProjectM36/Sessions.hs−49 src/lib/ProjectM36/Shortcuts.hs−247 src/lib/ProjectM36/StaticOptimizer.hs−578 src/lib/ProjectM36/TransGraphRelationalExpression.hs−180 src/lib/ProjectM36/Transaction.hs−54 src/lib/ProjectM36/Transaction/Persist.hs−264 src/lib/ProjectM36/Transaction/Type.hs−8 src/lib/ProjectM36/TransactionDiffs.hs−12 src/lib/ProjectM36/TransactionGraph.hs−635 src/lib/ProjectM36/TransactionGraph/Persist.hs−228 src/lib/ProjectM36/TransactionGraph/Types.hs−12 src/lib/ProjectM36/TransactionInfo.hs−12 src/lib/ProjectM36/Tupleable.hs−287 src/lib/ProjectM36/Tupleable/Deriving.hs−229 src/lib/ProjectM36/TypeConstructor.hs−17 src/lib/ProjectM36/WCWidth.hs−425 src/lib/ProjectM36/WithNameExpr.hs−86 stack.ghc8.10.yaml−19 stack.ghc8.6.yaml−62 stack.ghc8.8.yaml → stack.yaml+9−30 test/Client/Simple.hs−72 test/DataFrame.hs−61 test/IsomorphicSchema.hs−138 test/MultiProcessDatabaseAccess.hs−45 test/Relation/Atomable.hs−209 test/Relation/Basic.hs+15−39 test/Relation/Export/CSV.hs+22−87 test/Relation/Import/CSV.hs+9−9 test/Relation/StaticOptimizer.hs+20−157 test/Relation/Tupleable.hs−380 test/Server/Main.hs+66−149 test/Server/WebSocket.hs+22−42 test/TransactionGraph/Automerge.hs−94 test/TransactionGraph/Merge.hs+57−136 test/TransactionGraph/Persist.hs+16−123 test/TutorialD/Interpreter.hs+328 test/TutorialD/Interpreter/AtomFunctionScript.hs−122 test/TutorialD/Interpreter/DatabaseContextFunctionScript.hs−65 test/TutorialD/Interpreter/Import/ImportTest.hs−47 test/TutorialD/Interpreter/Import/TutorialD.hs+22 test/TutorialD/Interpreter/Import/httpimporttest.tutd−2 test/TutorialD/Interpreter/TestBase.hs−57 test/TutorialD/InterpreterTest.hs−732 test/TutorialD/PrinterTest.hs−47 test/persistent-driver/test.hs+175 test/scripts.hs+2−5
.appveyor.ymldeleted−39
@@ -1,39 +0,0 @@
1−build: off
2−
3−version: 1.0.{build}-{branch}
4−
5−image: Visual Studio 2017
6−
7−before_test:
8−# http://help.appveyor.com/discussions/problems/6312-curl-command-not-found
9−- set PATH=C:\Program Files\Git\mingw64\bin;%PATH%
10−
11−- curl -sS -ostack.zip -L --insecure http://www.stackage.org/stack/windows-x86_64
12−- 7z x stack.zip stack.exe
13−
14−clone_folder: "c:\\project-m36"
15−clone_depth: 2
16−environment:
17− global:
18− STACK_ROOT: "c:\\sr"
19− matrix:
20− - YAML: "stack.ghc8.6.yaml"
21−
22−platform:
23− - x64
24−
25−cache:
26− - "c:\\sr"
27− - "%LocalAppData%\\Programs\\stack"
28−# - ".stack-work" # send us over the 1 GB limit
29−
30−test_script:
31− - stack setup > nul
32−# The ugly echo "" hack is to avoid complaints about 0 being an invalid file
33−# descriptor
34− - echo "" | stack --stack-yaml %YAML% --no-terminal test
35−# - 7z.exe a -t7z -m0=lzma -mx=9 -mfb=64 -md=32m -ms=on project-m36.7z .stack-work\install\*\bin\project-m36-server.exe .stack-work\install\*\bin\project-m36-websocket-server.exe .stack-work\install\*\bin\tutd.exe .stack-work\install\*\bin\project-m36-server.exe
36−
37−#artifacts:
38−# - path: project-m36.7z
39−# name: project-m36.7z
.github/workflows/ci.yamldeleted−69
@@ -1,69 +0,0 @@
1−name: "CI"
2−on:
3− pull_request:
4− push:
5−jobs:
6− dockerimage:
7− runs-on: ubuntu-latest
8− steps:
9− - uses: actions/checkout@v2.3.1
10− - uses: cachix/install-nix-action@v12
11− with:
12− nix_path: nixpkgs=channel:nixos-unstable
13− - uses: cachix/cachix-action@v8
14− with:
15− name: project-m36
16− signingKey: "${{ secrets.CACHIX_SIGNING_KEY }}"
17− - run: cachix use iohk
18− - name: docker load
19− run: docker load < $(nix-build docker.nix)
20− - name: docker login
21− if: ${{ github.ref == 'refs/heads/master' }}
22− run: echo ${{secrets.DOCKERHUB_PASSWORD}} | docker login --username ${{secrets.DOCKERHUB_USER}} --password-stdin
23− - name: docker tag with version
24− run: docker tag project-m36:latest projectm36/project-m36:$(awk '/^Version:/ {print $2}' project-m36.cabal)
25− if: ${{ github.ref == 'refs/heads/master' }}
26− - name: docker tag latest
27− run: docker tag project-m36:latest projectm36/project-m36:latest
28− if: ${{ github.ref == 'refs/heads/master' }}
29− - run: docker push projectm36/project-m36
30− if: ${{ github.ref == 'refs/heads/master' }}
31−
32− stack-build:
33− runs-on: ${{ matrix.os }}
34− strategy:
35− matrix:
36− os: [ubuntu-latest]
37− ghc:
38− - ghc8.10
39− - ghc8.8
40− - ghc8.6
41− include:
42− - os: macos-latest
43− ghc: ghc8.10
44− env:
45− STACK_YAML: stack.${{ matrix.ghc }}.yaml
46− steps:
47− - uses: actions/checkout@v2
48− - name: Cache
49− uses: actions/cache@v1
50− with:
51− path: ~/.stack
52− key: ${{ runner.os }}-build-stack-${{ matrix.ghc }}-${{ hashFiles(env.STACK_YAML) }}-${{ hashFiles('**/*.cabal') }}
53− restore-keys: |
54− ${{ runner.os }}-build-stack-${{ matrix.ghc }}-${{ hashFiles(env.STACK_YAML) }}
55− ${{ runner.os }}-build-stack-${{ matrix.ghc }}
56− - name: Fix macOS cache bug
57− run: rm -rf ~/.stack/setup-exe-cache
58− - name: Build
59− run: stack build --ghc-options -O2 --local-bin-path out --copy-bins
60− - name: Test
61− run: stack test --stack-yaml=${{ env.STACK_YAML }}
62− - name: HLint
63− run: curl -sSL https://raw.github.com/ndmitchell/hlint/master/misc/run.sh | sh -s .
64− - name: Haddock
65− run: stack --no-install-ghc --system-ghc --no-haddock-deps haddock
66− - uses: actions/upload-artifact@v2
67− with:
68− name: project-m36-${{ matrix.os }}-${{ matrix.ghc }}
69− path: out/
.gitignore+1−17
@@ -4,20 +4,4 @@
44dist/
55.cabal-sandbox/
66cabal.sandbox.config
7−.stack-work
8−dist-newstyle/
9−dist_build/
10−NOTES
11−RelatedPapers/
12−_shake
13−nextsteps
14−\#*\#
15−view-system-notes
16−persistence-notes
17−*.pyc
18−jupyter/itutd.egg-info
19−jupyter/build
20−juyter/dist
21−.ipynb_checkpoints
22−project-m36.nix
23−stack.yaml
7+.stack-work
Changelog.markdowndeleted−130
@@ -1,130 +0,0 @@
1−# 2021-04-01 (v0.9.3)
2−
3−* add new ":importtutd <URI> <SHA256 hash>" feature to import TutorialD from a local file or a HTTP/HTTPS URI
4−
5−# 2020-12-27 (v0.9.0)
6−
7−* replace unmaintained distributed-process-client-server RPC package with new curryer RPC package
8−* drop support for GHC 8.2 and GHC 8.4 due to dependency on DerivingVia extension
9−
10−# 2020-11-21 (v0.8.2)
11−
12−* support multiple extend expressions in TutorialD
13−* fix parsing of Bool atoms in TutorialD
14−* fix database context expressions which include self-references such as `s:=s union s`
15−* show constraints as TutorialD when using tutd console
16−* add `RelationalExprAtom` data type useful for storing `RelationalExpr` within the database
17−
18−# 2020-10-05 (v0.8.1)
19−
20−* support GHC 8.10
21−
22−# 2020-05-25 (v0.8)
23−
24−* refactor backend to maximize laziness: [An Architecture for Data Independence](docs/data_independence.markdown)
25−
26−# 2019-09-07 (v0.7)
27−
28−* fix case sensitivity issue with relation variables in tutd
29−* fix multibyte escaping in data frames
30−* fix broken instances of `Atomable [a]`
31−* fix `TypeConstructor` validation of argument count
32−* add help option to executables
33−
34−# 2019-01-08 (v0.6)
35−
36−* fix atom type parsing to support more complex data types
37−* add [data frames](docs/dataframes.markdown) to support server-side sort ordering, limits, and offsets
38−
39−# 2018-10-03 (v0.5.1)
40−
41−* fix atom function type validation
42−* add support for GHC 8.4 (now we support GHC 8.0, 8.2, and 8.4)
43−
44−# 2018-08-10 (v0.5)
45−
46−* fix critical type bug which allowed unresolved types to be used
47−* add full support for GHC 8.2 with stack or cabal (delayed for a long time by dependency version boundaries)
48−* drop support for GHC 7.10
49−* add support for `with (relexpr as name,...)` syntax for use as tutd macros
50−* add `NonEmptyList` list data type
51−
52−# 2018-06-04 (v0.4)
53−
54−* add contributed feature to allow users to [create arbitrary relations](https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown#arbitrary-relation-variables)
55−* fix type validation bug allowing concrete type with type variables in relations
56−* improve usability of `Interval a` data type
57−* allow `Integer` to be parsed as negative in `tutd` console
58−* support precompiled (Haskell) [`AtomFunction`s](https://github.com/agentm/project-m36/blob/master/docs/atomfunctions.markdown#pre-compiled-atom-functions) and [`DatabaseContextFunction`s](https://github.com/agentm/project-m36/blob/master/docs/database_context_functions.markdown#loading-precompiled-modules)
59−* make TutorialD scripts read from the filesystem unconditionally read as UTF-8
60−* improve support for display of multibyte characters in `tutd` console, especially Chinese
61−* fix file descriptor leak in file sychronization
62−* improve reliability by allowing fast-forward commits when using `autoMergeToHead`
63−* add [`semijoin` and `anitjoin`](https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown#join) support to `tutd`
64−* added various new static optimizations
65−
66−# 2017-11-14
67−
68−* alter websocket server API to allow for multiple representations (JSON, text, or HTML) to be selected and returned simultaneously
69−* add jupyter kernel for TutorialD interpreter
70−* fix warnings suggested by new hlint 2.0.10
71−
72−# 2017-10-08 (v0.3)
73−
74−* replaced overuse of `undefined` with `Proxy` in `Tupleable` and `Atomable` typeclasses
75−* allow notifications to return query results from before *and* after the commit which triggered the notification
76−* alert users in `tutd` console before a transaction graph expression is evaluated which would throw out their changes
77−* drastically-improved CSV import/export now supports all possible types except `RelationAtom`
78−* fix serious file handle leaks when using on-disk persistence
79−* fix case where invalid number of arguments to `ConstructedAtom` did not result in an error
80−* add support for `IntegerAtom` (previously, only `IntAtom` was supported)
81−
82−# 2017-09-16 (v0.2)
83−
84−* a new [simple client API](https://github.com/agentm/project-m36/blob/master/docs/simple_api.markdown) with a monadic transaction manager
85−* complete hlint compliance
86−* the generics-based [Tupleable typeclass]( https://github.com/agentm/project-m36/blob/master/docs/tupleable.markdown
87−) which makes it easy to marshal Haskell data types to-and-from the database
88−* timestamps attached to transactions to allow specific point-in-time travel
89−* autoMergeToHead, a variant of commit which attempts to merge and commit to the latest head transaction to reduce incidents of TransactionNotAHeadErrors
90−* interval data types
91−* transaction dirtiness detection which allows the client to determine if an update expression actually changed the database state
92−
93−# 2017-08-01
94−
95−## autoMergeToHead
96−
97−In preparation for the simpler monad client API, ProjectM36.Client now includes a server-side merge for new transactions called "[automerge](https://github.com/agentm/project-m36/issues/33)". This feature should reduce head contention in cases where new transactions can be simply merged to the head without additional processing. The trade-off is reduced ```TransactionIsNotAHeadError```s but an increased chance of merge errors. The feature operates similarly to a server-side git rebase.
98−
99−## critical bug in merging
100−
101−Successfully merged transactions did not have their constraints validated. Fixed.
102−
103−# 2017-06-12
104−
105−## add file locking
106−
107−This [feature](#102) allows Project:M36 database directories to be shared amongst multiple Project:M36 processes. This is similar to how SQLite operates except that the remote server mode supports the feature as well. This could allow, for example, multi-master, file-based replication across Windows shares or NFS.
108−
109−[Documentation](/docs/replication.markdown)
110−
111−# 2016-11-30
112−
113−## add functional dependency macro
114−
115−Date demonstrates two ways to implement functional dependencies as constraints on page 21 in "Database Design and Relational Theory". A similar macros is now implemented in the tutd interpreter.
116−
117−```funcdep sname_status (sname) -> (status) s```
118−
119−[Documentation](/docs/tutd_tutorial.markdown#functional-dependencies)
120−
121−# 2016-09-07
122−
123−## add TransGraphRelationalExpr
124−
125−The TransGraphRelationalExpr allows queries against all past states of the database.
126−
127−The following example executes a query against two different committed transactions using syntax similar to that of git for graph traversal:
128−```:showtransgraphexpr s@master~ join sp@master```
129−
130−[Documentation](/docs/transgraphrelationalexpr.markdown)
Database/Persist/ProjectM36.hsnew file+579
@@ -0,0 +1,579 @@
1+{-# LANGUAGE RankNTypes, TypeFamilies, GeneralizedNewtypeDeriving, FlexibleInstances, FlexibleContexts #-}
2+{-# OPTIONS_GHC -fno-warn-orphans #-}
3+module Database.Persist.ProjectM36 where
4+import Database.Persist hiding (Assign, Update)
5+import qualified Database.Persist as DP
6+import ProjectM36.Base
7+import ProjectM36.Tuple
8+import qualified ProjectM36.Client as C
9+import qualified Data.UUID as U
10+import Data.UUID.V4 (nextRandom)
11+import qualified Data.Vector as V
12+import ProjectM36.Error
13+import ProjectM36.Relation
14+import ProjectM36.AtomFunctions.Primitive
15+import ProjectM36.DataTypes.Primitive
16+import qualified Control.Monad.IO.Class as Trans
17+import Control.Monad.Trans.Class
18+import Control.Monad.Trans.Reader (ask, ReaderT)
19+import Control.Exception (throw, throwIO)
20+import qualified Data.Text as T
21+import ProjectM36.Atom
22+import Data.Aeson (FromJSON(..), ToJSON(..), withText, withObject, (.:))
23+import qualified Data.Map as M
24+import Control.Monad (when)
25+import Data.Maybe (isJust)
26+import Data.Aeson.Types (modifyFailure)
27+import Control.Monad.Reader (runReaderT)
28+import Web.PathPieces (PathPiece (..))
29+import qualified Database.Persist.Sql as Sql
30+import Control.Monad.Trans.Either
31+import qualified Database.Persist.Types as DPT
32+import qualified Data.Set as S
33+import qualified Data.Conduit.List as CL
34+import Data.Typeable (typeRep, typeOf, Proxy(..))
35+import Data.Time.Calendar (Day)
36+import Data.ByteString (ByteString)
37+import Web.HttpApiData (ToHttpApiData(..), FromHttpApiData(..), parseUrlPieceWithPrefix, readTextData)
38+
39+type ProjectM36Backend = (C.SessionId, C.Connection)
40+
41+--convert a PersistEntity to a RelationTuple
42+recordAsTuple :: forall record. (PersistEntity record, PersistEntityBackend record ~ ProjectM36Backend)
43+ => Maybe U.UUID -> record -> Either RelationalError RelationTuple
44+recordAsTuple uuid record = do -- if the uuid is passed in, set the idDBName attribute
45+ let entInfo = zip entFields entValues
46+ entFields = embeddedFields $ toEmbedEntityDef (entityDef $ Just record)
47+ entValues = map toPersistValue $ toPersistFields record
48+ attrVec <- recordAttributes entInfo record
49+ atomVec <- recordAsAtoms uuid attrVec record
50+ return $ RelationTuple attrVec atomVec
51+
52+recordAttributes :: forall record. (PersistEntity record, PersistEntityBackend record ~ ProjectM36Backend)
53+ => [(EmbedFieldDef, PersistValue)] -> record -> Either RelationalError Attributes
54+recordAttributes entInfo record = do
55+ let convertAttr = uncurry fieldDefAsAttribute
56+ idDBName = unDBName $ fieldDB $ entityId (entityDef $ Just record)
57+ attrList <- mapM convertAttr entInfo
58+ return $ V.fromList ([Attribute idDBName textAtomType] ++ attrList)
59+
60+fieldDefAsAttribute :: EmbedFieldDef -> PersistValue -> Either RelationalError Attribute
61+fieldDefAsAttribute fieldDef pVal = case persistValueAtomType pVal of
62+ Nothing -> Left $ AtomTypeNotSupported attrName
63+ Just fType -> Right $ Attribute attrName fType
64+ where
65+ attrName = unDBName $ emFieldDB fieldDef
66+
67+persistValueAtomType :: PersistValue -> Maybe AtomType
68+persistValueAtomType val = do
69+ atom <- persistValueAtom val
70+ return $ atomTypeForAtom atom
71+
72+persistValueAtom :: PersistValue -> Maybe Atom
73+persistValueAtom val = case val of
74+ PersistText v -> return $ Atom v
75+ PersistInt64 v -> return $ Atom ((fromIntegral v)::Int)
76+ PersistBool v -> return $ Atom v
77+ PersistDay v -> return $ Atom v
78+ _ -> Nothing
79+
80+atomAsPersistValue :: Atom -> PersistValue
81+--constructed atoms are written as text to the database
82+atomAsPersistValue atom@(ConstructedAtom _ _ _) = PersistText (atomToText atom)
83+atomAsPersistValue atom@(Atom atomv) = if typeRep (Proxy :: Proxy Int) == typeOf atomv then
84+ PersistInt64 (fromIntegral ((unsafeCast atom) :: Int))
85+ else if typeRep (Proxy :: Proxy T.Text) == typeOf atomv then
86+ PersistText (unsafeCast atom)
87+ else if typeRep (Proxy :: Proxy Bool) == typeOf atomv then
88+ PersistBool (unsafeCast atom)
89+ else if typeRep (Proxy :: Proxy Day) == typeOf atomv then
90+ PersistDay (unsafeCast atom)
91+ else if typeRep (Proxy :: Proxy ByteString) == typeOf atomv then
92+ PersistByteString (unsafeCast atom)
93+ else
94+ error "missing conversion"
95+
96+recordAsAtoms :: forall record. (PersistEntity record, PersistEntityBackend record ~ ProjectM36Backend)
97+ => Maybe U.UUID -> Attributes -> record -> Either RelationalError (V.Vector Atom)
98+recordAsAtoms freshUUID _ record = do
99+ let pValues = map toPersistValue $ toPersistFields record
100+ valAtom val = case persistValueAtom val of
101+ Nothing -> Left $ AtomTypeNotSupported ""
102+ Just atom -> Right atom
103+ atoms <- mapM valAtom pValues
104+ return $ V.fromList $ case freshUUID of
105+ Nothing -> atoms
106+ Just uuid -> [Atom $ T.pack (U.toString uuid)] ++ atoms
107+
108+--used by insert operations
109+recordsAsRelation :: forall record. (PersistEntity record, PersistEntityBackend record ~ ProjectM36Backend) =>
110+ [(Maybe U.UUID, record)] -> Either RelationalError Relation
111+recordsAsRelation [] = Left EmptyTuplesError
112+recordsAsRelation recordZips = do
113+ tupleList <- mapM (uncurry recordAsTuple) recordZips
114+ let oneTuple = head tupleList
115+ mkRelation (tupleAttributes oneTuple) (RelationTupleSet tupleList)
116+
117+keyFromValuesOrDie :: (Trans.MonadIO m,
118+ PersistEntity record,
119+ PersistEntityBackend record ~ ProjectM36Backend
120+ ) => [PersistValue] -> m (Key record)
121+keyFromValuesOrDie val = case keyFromValues val of
122+ Right k -> return k
123+ Left _ -> Trans.liftIO $ throwIO $ PersistError "key pooped"
124+
125+insertNewRecords :: (Trans.MonadIO m,
126+ PersistEntity record,
127+ PersistEntityBackend record ~ ProjectM36Backend) =>
128+ [U.UUID] -> [record] -> ReaderT ProjectM36Backend m [Key record]
129+insertNewRecords uuids records = do
130+ let recordsZip = zip (map Just uuids) records
131+ insertExpr = Insert (relVarNameFromRecord $ head records)
132+ case recordsAsRelation recordsZip of
133+ Left err -> throw $ PersistError (T.pack $ show err)
134+ Right rel -> do
135+ (sessionId, conn) <- ask
136+ Trans.liftIO $ executeDatabaseContextExpr sessionId conn (insertExpr (ExistingRelation rel))
137+ mapM (\uuid -> keyFromValuesOrDie [PersistText $ T.pack (U.toString uuid)]) uuids
138+
139+throwIOPersistError :: (Trans.MonadIO m) => String -> m a
140+throwIOPersistError msg = Trans.liftIO $ throwIO $ PersistError (T.pack msg)
141+
142+lookupByKey :: forall record m.
143+ (Trans.MonadIO m,
144+ PersistEntity record,
145+ PersistEntityBackend record ~ ProjectM36Backend)
146+ => Key record -> ReaderT ProjectM36Backend m (Maybe (Entity record))
147+lookupByKey key = do
148+ (relVarName, restrictionPredicate) <- commonKeyQueryProperties key
149+ let query = Restrict restrictionPredicate (RelationVariable relVarName)
150+ (sessionId, conn) <- ask
151+ resultRel <- Trans.liftIO $ C.executeRelationalExpr sessionId conn query
152+ case resultRel of
153+ Left err -> throwIOPersistError ("executeRelationExpr error: " ++ show err)
154+ Right resultRel' -> case singletonTuple resultRel' of
155+ Nothing -> return Nothing --no match on key
156+ Just tuple -> do
157+ let entityInfo = entityDefFromKey key
158+ entity <- fromPersistValuesThrow entityInfo tuple --correct, one match
159+ return $ Just entity
160+
161+fromPersistValuesThrow :: (Trans.MonadIO m,
162+ PersistEntity record,
163+ PersistEntityBackend record ~ ProjectM36Backend) => EntityDef -> RelationTuple -> m (Entity record)
164+fromPersistValuesThrow entDef tuple = do
165+ let body = fromPersistValues $ map getValue (entityFields entDef)
166+ getValue field = case atomForAttributeName (unDBName (fieldDB field)) tuple of
167+ Right atom -> atomAsPersistValue atom
168+ Left err -> throw $ PersistError ("missing field: " `T.append` (T.pack $ show err))
169+ keyAtom = atomForAttributeName (unDBName (fieldDB (entityId entDef))) tuple
170+ case keyAtom of
171+ Left err -> throwIOPersistError ("missing key atom" ++ show err)
172+ Right keyAtom' -> case keyFromValues [atomAsPersistValue keyAtom'] of
173+ Left err -> throw $ PersistError ("key failure" `T.append` (T.pack $ show err))
174+ Right key -> case body of
175+ Left err -> throwIOPersistError (show err)
176+ Right body' -> return $ Entity key body'
177+
178+commonKeyQueryProperties :: (Trans.MonadIO m, PersistEntityBackend val ~ ProjectM36Backend, PersistEntity val) => Key val -> ReaderT ProjectM36Backend m (RelVarName, RestrictionPredicateExpr)
179+commonKeyQueryProperties key = do
180+ let matchUUID = keyToUUID key
181+ keyAttributeName = unDBName (fieldDB $ entityId entityInfo)
182+ relVarName = unDBName $ entityDB entityInfo
183+ matchUUIDText = T.pack $ U.toString matchUUID
184+ entityInfo = entityDefFromKey key
185+ restrictionPredicate = AttributeEqualityPredicate keyAttributeName (NakedAtomExpr (Atom matchUUIDText))
186+ return (relVarName, restrictionPredicate)
187+
188+deleteByKey :: (Trans.MonadIO m, PersistEntityBackend val ~ ProjectM36Backend, PersistEntity val) => Key val -> ReaderT ProjectM36Backend m (Bool)
189+deleteByKey key = do
190+ (relVarName, restrictionPredicate) <- commonKeyQueryProperties key
191+ let query = Delete relVarName restrictionPredicate
192+ (sessionId, conn) <- ask
193+ maybeErr <- Trans.liftIO $ C.executeDatabaseContextExpr sessionId conn query
194+ return $ isJust maybeErr
195+
196+--convert persistent update list to ProjectM36 Update map
197+updatesToUpdateMap :: (Trans.MonadIO m,
198+ PersistEntityBackend val ~ ProjectM36Backend,
199+ PersistEntity val) =>
200+ [DP.Update val] -> ReaderT ProjectM36Backend m (M.Map AttributeName AtomExpr)
201+updatesToUpdateMap updates = do
202+ let convertMap upd = case updateUpdate upd of
203+ DP.Assign -> let attrName = unDBName $ fieldDB $ updateFieldDef upd
204+ newAttrValue = persistValueAtom (updatePersistValue upd) in
205+ case newAttrValue of
206+ Nothing -> Trans.liftIO $ throwIO $ PersistError "atom conversion failed"
207+ Just newAttrValue' -> return (attrName, NakedAtomExpr newAttrValue')
208+ _ -> Trans.liftIO $ throwIO $ PersistError "update type not supported"
209+ updateAtomList <- mapM convertMap updates
210+ return $ M.fromList updateAtomList
211+
212+updateByKey :: (Trans.MonadIO m, PersistEntityBackend val ~ ProjectM36Backend, PersistEntity val) => Key val -> [DP.Update val] -> ReaderT ProjectM36Backend m ()
213+updateByKey key updates = do
214+ (relVarName, restrictionPredicate) <- commonKeyQueryProperties key
215+ updateMap <- updatesToUpdateMap updates
216+ let query = Update relVarName updateMap restrictionPredicate
217+ (sessionId, conn) <- ask
218+ maybeErr <- Trans.liftIO $ C.executeDatabaseContextExpr sessionId conn query
219+ case maybeErr of
220+ Just err -> throwIOPersistError ("executeDatabaseContextExpr error" ++ show err)
221+ Nothing -> return ()
222+
223+--set the truth unconditionally
224+repsertByKey :: (Trans.MonadIO m, ProjectM36Backend ~ PersistEntityBackend val, PersistEntity val) => Key val -> val -> ReaderT ProjectM36Backend m ()
225+repsertByKey key val = do
226+ _ <- delete key
227+ insertKey key val
228+
229+replaceByKey :: (Trans.MonadIO m, ProjectM36Backend ~ PersistEntityBackend val, PersistEntity val) => Key val -> val -> ReaderT ProjectM36Backend m ()
230+replaceByKey key val = do
231+ deletionSuccess <- deleteByKey key
232+ when (not deletionSuccess) (Trans.liftIO $ throwIO $ PersistError "entity missing during replace")
233+ insertKey key val
234+
235+entityDefFromKey :: PersistEntity record => Key record -> EntityDef
236+entityDefFromKey = entityDef . Just . recordTypeFromKey
237+
238+dummyFromKey :: Key record -> Maybe record
239+dummyFromKey = Just . recordTypeFromKey
240+
241+recordTypeFromKey :: Key record -> record
242+recordTypeFromKey _ = error "dummyFromKey"
243+
244+dummyFromUnique :: Unique v -> Maybe v
245+dummyFromUnique _ = Nothing
246+
247+dummyFromFilter :: Filter v -> Maybe v
248+dummyFromFilter _ = Nothing
249+
250+dummyFromFilters :: [Filter v] -> Maybe v
251+dummyFromFilters _ = Nothing
252+
253+dummyFromUpdate :: DPT.Update v -> Maybe v
254+dummyFromUpdate _ = Nothing
255+
256+keyToUUID:: (PersistEntity record) => Key record -> U.UUID
257+keyToUUID key = case keyToValues key of
258+ ([PersistText uuidText]) -> case U.fromString (T.unpack uuidText) of
259+ Nothing -> error "error reading uuid from text in key construction"
260+ Just uuid -> uuid
261+ _ -> error "unexpected persist value in key construction"
262+
263+instance ToHttpApiData (BackendKey ProjectM36Backend) where
264+ toUrlPiece = T.pack . U.toString . unPM36Key
265+
266+instance FromHttpApiData (BackendKey ProjectM36Backend) where
267+ parseUrlPiece input = do
268+ s <- parseUrlPieceWithPrefix "o" input <!> return input
269+ ProjectM36Key <$> readTextData s
270+ where
271+ infixl 3 <!>
272+ Left _ <!> y = y
273+ x <!> _ = x
274+
275+instance PersistStore ProjectM36Backend where
276+ newtype BackendKey ProjectM36Backend = ProjectM36Key { unPM36Key :: U.UUID }
277+ deriving (Show, Read, Eq, Ord, PersistField)
278+
279+ insertMany [] = return []
280+ insertMany records = do
281+ freshUUIDs <- Trans.liftIO $ mapM (\_-> nextRandom) records
282+ insertNewRecords freshUUIDs records
283+
284+ insert record = do
285+ keys <- insertMany [record]
286+ return $ head keys
287+
288+ --insertEntityMany [] = return []
289+ --insertKey :: (Trans.MonadIO m, backend ~ PersistEntityBackend val, PersistEntity val) => Key val -> val -> ReaderT backend m ()
290+ insertKey key record = do
291+ let uuid = keyToUUID key
292+ _ <- insertNewRecords [uuid] [record]
293+ return ()
294+
295+ --get :: (MonadIO m, backend ~ PersistEntityBackend val, PersistEntity val) => Key val -> ReaderT backend m (Maybe val)
296+ get key = do
297+ ent <- lookupByKey key
298+ case ent of
299+ Nothing -> return Nothing
300+ Just (Entity _ val) -> return $ Just val
301+
302+ repsert = repsertByKey
303+ --delete followed by insert "set the record as the truth
304+
305+ delete key = deleteByKey key >> return ()
306+
307+ replace = replaceByKey
308+
309+ --update :: (MonadIO m, PersistEntity val, backend ~ PersistEntityBackend val) => Key val -> [Update val] -> ReaderT backend m ()
310+ update = updateByKey
311+
312+instance FromJSON (BackendKey ProjectM36Backend) where
313+ parseJSON = withText "ProjectM36Key" $ \t -> maybe (fail "Invalid UUID") (return . ProjectM36Key) (U.fromString (T.unpack t))
314+
315+instance ToJSON (BackendKey ProjectM36Backend) where
316+ toJSON (ProjectM36Key uuid) = toJSON $ U.toString uuid
317+
318+--wrapped version which throws exceptions
319+executeDatabaseContextExpr :: C.SessionId -> C.Connection -> DatabaseContextExpr -> IO ()
320+executeDatabaseContextExpr sessionId conn expr = do
321+ res <- C.executeDatabaseContextExpr sessionId conn expr
322+ case res of
323+ Nothing -> return ()
324+ Just err -> throwIO (PersistError $ T.pack (show err))
325+
326+relVarNameFromRecord :: (PersistEntity record, PersistEntityBackend record ~ ProjectM36Backend)
327+ => record -> RelVarName
328+relVarNameFromRecord = unDBName . entityDB . entityDef . Just
329+
330+{- unfortunately copy-pasted from Database.Persist.Sql.Orphan.PersistStore -}
331+updateFieldDef :: PersistEntity v => DP.Update v -> FieldDef
332+updateFieldDef (DP.Update f _ _) = persistFieldDef f
333+updateFieldDef (BackendUpdate {}) = error "updateFieldDef did not expect BackendUpdate"
334+
335+updatePersistValue :: DP.Update v -> PersistValue
336+updatePersistValue (DP.Update _ v _) = toPersistValue v
337+updatePersistValue (BackendUpdate {}) = error "updatePersistValue did not expect BackendUpdate"
338+
339+instance PersistField U.UUID where
340+ toPersistValue val = PersistText $ T.pack (U.toString val)
341+ fromPersistValue (PersistText uuidText) = case U.fromString $ T.unpack uuidText of
342+ Nothing -> Left "uuid text read failure"
343+ Just uuid -> Right uuid
344+ fromPersistValue _ = Left $ T.pack "expected PersistObjectId"
345+
346+instance FromJSON C.ConnectionInfo where
347+ parseJSON v = modifyFailure ("Persistent: error loading ProjectM36 conf: " ++) $
348+ flip (withObject "ProjectM36Conf") v $ \o -> do
349+ ctype <- parseJSON =<< ( o .: "connectionType")
350+ return ctype
351+
352+instance PersistConfig C.ConnectionInfo where
353+ --- | Hold onto a connection as well a default session.
354+ type PersistConfigBackend C.ConnectionInfo = ReaderT ProjectM36Backend
355+ type PersistConfigPool C.ConnectionInfo = ProjectM36Backend
356+
357+ loadConfig = parseJSON
358+ applyEnv = return -- no environment variables are used
359+ createPoolConfig conf = do
360+ connErr <- C.connectProjectM36 conf
361+ case connErr of
362+ Left err -> throwIO $ PersistError ("Failed to create connection: " `T.append` (T.pack $ show err))
363+ Right conn -> do
364+ eSession <- C.createSessionAtHead "master" conn
365+ case eSession of
366+ Left err -> throwIO $ PersistError ("Failed to create session: " `T.append` (T.pack $ show err))
367+ Right sessionId -> pure (sessionId, conn)
368+ --runPool :: (MonadBaseControl IO m, MonadIO m) => c -> PersistConfigBackend c m a -> PersistConfigPool c -> m a
369+ runPool _ r = runReaderT r
370+
371+withProjectM36Conn :: (Monad m, Trans.MonadIO m) => C.ConnectionInfo -> (ProjectM36Backend -> m a) -> m a
372+withProjectM36Conn conf connReader = do
373+ backend <- Trans.liftIO $ createPoolConfig conf
374+ connReader backend
375+
376+runProjectM36Conn :: (Trans.MonadIO m) => ReaderT ProjectM36Backend m a -> (C.SessionId, C.Connection) -> m a
377+runProjectM36Conn m1 (sessionId, conn) = runReaderT m1 (sessionId, conn)
378+
379+instance PathPiece (BackendKey ProjectM36Backend) where
380+ toPathPiece (ProjectM36Key uuid) = U.toText uuid
381+ fromPathPiece txt = do
382+ uuid <- U.fromText txt
383+ return $ ProjectM36Key uuid
384+
385+instance Sql.PersistFieldSql U.UUID where
386+ sqlType _ = Sql.SqlOther "doesn't make much sense for ProjectM36"
387+
388+instance Sql.PersistFieldSql (BackendKey ProjectM36Backend) where
389+ sqlType _ = Sql.SqlOther "doesn't make much sense for ProjectM36"
390+
391+persistUniqueToRestrictionPredicate :: PersistEntity record => Unique record -> Either RelationalError RestrictionPredicateExpr
392+persistUniqueToRestrictionPredicate unique = do
393+ atoms <- mapM (\v -> maybe (Left $ AtomTypeNotSupported "") Right $ persistValueAtom v) $ persistUniqueToValues unique
394+ let attrNames = map (unDBName . snd) $ persistUniqueToFieldNames unique
395+ andify [] = TruePredicate
396+ andify ((attrName, atom):xs) = AndPredicate (AttributeEqualityPredicate attrName (NakedAtomExpr atom)) $ andify xs
397+ return $ andify (zip attrNames atoms)
398+
399+instance PersistUnique ProjectM36Backend where
400+ getBy unique = do
401+ (sessionId, conn) <- ask
402+ let predicate = persistUniqueToRestrictionPredicate unique
403+ relVarName = unDBName $ entityDB entDef
404+ entDef = entityDef $ dummyFromUnique unique
405+ throwRelErr err = Trans.liftIO $ throwIO (PersistError (T.pack $ show err))
406+ case predicate of
407+ Left err -> throwRelErr err
408+ Right predicate' -> do
409+ let restrictExpr = Restrict predicate' (RelationVariable relVarName)
410+ singletonRel <- Trans.liftIO $ C.executeRelationalExpr sessionId conn restrictExpr
411+ case singletonRel of
412+ Left err -> throwRelErr err
413+ Right singletonRel' -> do
414+ if cardinality singletonRel' == Finite 0 then
415+ return Nothing
416+ else if cardinality singletonRel' > Finite 1 then
417+ Trans.liftIO $ throwIO (PersistError "getBy returned more than one tuple")
418+ else -- exactly one tuple
419+ case singletonTuple singletonRel' of
420+ Nothing -> Trans.liftIO $ throwIO (PersistMarshalError "singletonTuple failure")
421+ Just tuple -> do
422+ newEnt <- Trans.liftIO $ fromPersistValuesThrow entDef tuple
423+ return $ Just newEnt
424+ deleteBy unique = do
425+ (sessionId, conn) <- ask
426+ let predicate = persistUniqueToRestrictionPredicate unique
427+ relVarName = unDBName $ entityDB entDef
428+ entDef = entityDef $ dummyFromUnique unique
429+ throwRelErr err = Trans.liftIO $ throwIO (PersistError (T.pack $ show err))
430+ case predicate of
431+ Left err -> throwRelErr err
432+ Right predicate' -> do
433+ let deleteExpr = Delete relVarName predicate'
434+ maybeErr <- Trans.liftIO $ C.executeDatabaseContextExpr sessionId conn deleteExpr
435+ case maybeErr of
436+ Just err -> throwRelErr err
437+ Nothing -> return ()
438+
439+multiFilterAsRestrictionPredicate :: (PersistEntity val, PersistEntityBackend val ~ ProjectM36Backend) => Bool -> [Filter val] -> Either RelationalError RestrictionPredicateExpr
440+multiFilterAsRestrictionPredicate _ [] = Right $ TruePredicate
441+multiFilterAsRestrictionPredicate andOr (x:xs) = do
442+ let predicate = if andOr then AndPredicate else OrPredicate
443+ filtHead <- filterAsRestrictionPredicate x
444+ filtTail <- multiFilterAsRestrictionPredicate andOr xs
445+ return $ predicate filtHead filtTail
446+
447+filterValueToPersistValues :: forall a. PersistField a => Either a [a] -> [PersistValue]
448+filterValueToPersistValues v = map toPersistValue $ either return id v
449+
450+filterAsRestrictionPredicate :: (PersistEntity val, PersistEntityBackend val ~ ProjectM36Backend) => Filter val -> Either RelationalError RestrictionPredicateExpr
451+filterAsRestrictionPredicate filterIn = case filterIn of
452+ FilterAnd filters -> multiFilterAsRestrictionPredicate True filters
453+ FilterOr filters -> multiFilterAsRestrictionPredicate False filters
454+ BackendFilter _ -> error "BackendFilter not supported"
455+ Filter field value pfilter -> let attrName = unDBName $ fieldDB (persistFieldDef field) in
456+ case value of
457+ Left val -> let atom = persistValueAtom $ toPersistValue val in
458+ case pfilter of
459+ Eq -> case atom of
460+ Nothing -> Left $ AtomTypeNotSupported attrName
461+ Just atom' -> Right $ AttributeEqualityPredicate attrName (NakedAtomExpr atom')
462+ Ne -> case atom of
463+ Nothing -> Left $ AtomTypeNotSupported attrName
464+ Just atom' -> Right $ NotPredicate (AttributeEqualityPredicate attrName (NakedAtomExpr atom'))
465+ op -> Left $ AtomOperatorNotSupported $ T.pack (show op)
466+ Right _ -> Left $ AtomTypeNotSupported attrName
467+
468+updateToUpdateTuple :: (PersistEntity val, PersistEntityBackend val ~ ProjectM36Backend) => DPT.Update val -> Either RelationalError (AttributeName, AtomExpr)
469+updateToUpdateTuple (BackendUpdate _) = error "BackendUpdate not supported"
470+updateToUpdateTuple (DPT.Update field value op) = let attrName = unDBName $ fieldDB (persistFieldDef field)
471+ atom = persistValueAtom $ toPersistValue value
472+ in case op of
473+ DPT.Assign -> case atom of
474+ Nothing -> Left $ AtomTypeNotSupported attrName
475+ Just atom' -> Right $ (attrName, NakedAtomExpr atom')
476+ op' -> Left $ AtomOperatorNotSupported $ T.pack (show op')
477+
478+selectionFromRestriction :: (PersistEntity val, PersistEntityBackend val ~ backend, Trans.MonadIO m, backend ~ ProjectM36Backend) => [Filter val] -> ReaderT backend m (Either RelationalError RelationalExpr)
479+selectionFromRestriction filters = do
480+ runEitherT $ do
481+ restrictionPredicate <- hoistEither $ multiFilterAsRestrictionPredicate True filters
482+ let entDef = entityDef $ dummyFromFilters filters
483+ relVarName = unDBName $ entityDB entDef
484+ right $ Restrict restrictionPredicate (RelationVariable relVarName)
485+
486+
487+instance PersistQuery ProjectM36Backend where
488+ updateWhere _ [] = return ()
489+ updateWhere filters updates = do
490+ (sessionId, conn) <- ask
491+ e <- runEitherT $ do
492+ restrictionPredicate <- hoistEither $ multiFilterAsRestrictionPredicate True filters
493+ tuples <- hoistEither $ mapM updateToUpdateTuple updates
494+ let updateMap = M.fromList tuples
495+ entDef = entityDef $ dummyFromUpdate (head updates)
496+ relVarName = unDBName $ entityDB entDef
497+ updateExpr = Update relVarName updateMap restrictionPredicate
498+ maybeErr <- Trans.liftIO $ C.executeDatabaseContextExpr sessionId conn updateExpr
499+ case maybeErr of
500+ Just err -> left err
501+ Nothing -> right ()
502+ case e of
503+ Left err -> throwIOPersistError ("updateWhere failure: " ++ show err)
504+ Right () -> return ()
505+
506+ deleteWhere filters = do
507+ (sessionId, conn) <- ask
508+ e <- runEitherT $ do
509+ restrictionPredicate <- hoistEither $ multiFilterAsRestrictionPredicate True filters
510+ let entDef = entityDef $ dummyFromFilters filters
511+ relVarName = unDBName $ entityDB entDef
512+ deleteExpr = Delete relVarName restrictionPredicate
513+ maybeErr <- Trans.liftIO $ C.executeDatabaseContextExpr sessionId conn deleteExpr
514+ case maybeErr of
515+ Just err -> left err
516+ Nothing -> right ()
517+ case e of
518+ Left err -> throwIOPersistError ("deleteWhere failure: " ++ show err)
519+ Right () -> return ()
520+
521+ count filters = do
522+ (sessionId, conn) <- ask
523+ e <- runEitherT $ do
524+ restrictionPredicate <- hoistEither $ multiFilterAsRestrictionPredicate True filters
525+ let entDef = entityDef $ dummyFromFilters filters
526+ relVarName = unDBName $ entityDB entDef
527+ allAttrNamesList = map (unDBName . fieldDB) (entityFields entDef) ++ [unDBName (fieldDB (entityId entDef))]
528+ allAttrNames = AttributeNames $ S.fromList allAttrNamesList
529+ groupExpr = Group allAttrNames "persistcountrel" (Restrict restrictionPredicate (RelationVariable relVarName))
530+ tupleExpr = AttributeExtendTupleExpr "persistcount" (FunctionAtomExpr "count" [AttributeAtomExpr "persistcountrel"])
531+ countExpr = Extend tupleExpr groupExpr
532+ rel <- Trans.liftIO $ C.executeRelationalExpr sessionId conn countExpr
533+ case rel of
534+ Left err -> left err
535+ Right rel' -> case singletonTuple rel' of
536+ Nothing -> Trans.liftIO $ throwIO $ PersistError "failed to get count tuple"
537+ Just tuple -> case atomForAttributeName "persistcount" tuple of
538+ (Right c) -> return (castInt c)
539+ Left err -> left err
540+ case e of
541+ Left err -> throwIOPersistError ("count failure: " ++ show err)
542+ Right c -> return c
543+
544+ --no select options currently supported (sorting, limiting)
545+ selectSourceRes _ (_:_) = Trans.liftIO $ throwIO $ PersistError "select options not yet supported"
546+ selectSourceRes filters [] = do
547+ (sessionId, conn) <- ask
548+ entities <- runEitherT $ do
549+ restrictionExpr <- (lift $ selectionFromRestriction filters) >>= hoistEither
550+ --restrictionExpr' <- hoistEither restrictionExpr
551+ let entDef = entityDef $ dummyFromFilters filters
552+ let tupleMapper tuple = Trans.liftIO $ fromPersistValuesThrow entDef tuple
553+ rel <- Trans.liftIO $ C.executeRelationalExpr sessionId conn restrictionExpr
554+ case rel of
555+ Left err -> Trans.liftIO $ throwIO $ PersistError (T.pack (show err))
556+ Right (Relation _ tupleSet) -> mapM tupleMapper $ asList tupleSet --refactor to use some relation accessors- here we convert a relation to a matrix, effectively (especially to support future sorting)
557+ case entities of
558+ Left err -> Trans.liftIO $ throwIO $ PersistError (T.pack $ show err)
559+ Right entities' -> return $ return $ CL.sourceList entities'
560+
561+ selectKeysRes _ (_:_) = Trans.liftIO $ throwIO $ PersistError "select options not yet supported"
562+ selectKeysRes filters [] = do
563+ (sessionId, conn) <- ask
564+ keys <- runEitherT $ do
565+ restrictionExpr <- (lift $ selectionFromRestriction filters) >>= hoistEither
566+ let keyAttrNames = ["id"] --no support for multi-attribute keys yet
567+ keyExpr = Project (AttributeNames $ S.fromList keyAttrNames) restrictionExpr
568+ (Relation _ tupleSet) <- (Trans.liftIO $ C.executeRelationalExpr sessionId conn keyExpr) >>= hoistEither
569+ let keyMapper :: (PersistEntity record, Trans.MonadIO m) => RelationTuple -> EitherT RelationalError (ReaderT ProjectM36Backend m) (Key record)
570+ keyMapper tuple = do
571+ atoms <- hoistEither (atomsForAttributeNames (V.fromList keyAttrNames) tuple)
572+ case keyFromValues (map atomAsPersistValue (V.toList atoms)) of
573+ Left err -> throwIOPersistError ("keyFromValues failure: " ++ show err)
574+ Right key -> right key
575+ mapM keyMapper $ asList tupleSet
576+ case keys of
577+ Left err -> throwIOPersistError ("keyFromValues failure2: " ++ show err)
578+ Right keys' -> return $ return (CL.sourceList keys')
579+
ProjectM36/Atom.hsnew file+74
@@ -0,0 +1,74 @@
1+module ProjectM36.Atom where
2+import ProjectM36.Base
3+import ProjectM36.Error
4+import Data.Typeable
5+import ProjectM36.ConcreteTypeRep
6+import qualified Data.Text as T
7+import Data.Time.Calendar (Day)
8+import Data.Time.Clock
9+import Data.ByteString (ByteString)
10+
11+relationForAtom :: Atom -> Either RelationalError Relation
12+relationForAtom (Atom atom) = case cast atom of
13+ Just rel@(Relation _ _) -> Right rel
14+ Nothing -> Left $ AttributeIsNotRelationValuedError ""
15+relationForAtom (ConstructedAtom _ _ _) = Left $ AttributeIsNotRelationValuedError ""
16+
17+--another hard-coded typerep dispatch table :/
18+makeAtomFromText :: AttributeName -> AtomType -> T.Text -> Either RelationalError Atom
19+makeAtomFromText _ (AtomType cTypeRep) textIn = if
20+ unCTR cTypeRep == typeRep (Proxy :: Proxy Int) then
21+ either (Left . ParseError . T.pack) (Right . Atom) (fromText textIn :: Either String Int)
22+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy Double) then
23+ either (Left . ParseError . T.pack) (Right . Atom) (fromText textIn :: Either String Double)
24+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy T.Text) then
25+ either (Left . ParseError . T.pack) (Right . Atom) (fromText textIn :: Either String T.Text)
26+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy Day) then
27+ either (Left . ParseError . T.pack) (Right . Atom) (fromText textIn :: Either String Day)
28+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy UTCTime) then
29+ either (Left . ParseError . T.pack) (Right . Atom) (fromText textIn :: Either String UTCTime)
30+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy ByteString) then
31+ either (Left . ParseError . T.pack) (Right . Atom) (fromText textIn :: Either String ByteString)
32+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy Bool) then
33+ either (Left . ParseError . T.pack) (Right . Atom) (fromText textIn :: Either String Bool)
34+ else
35+ Left $ ParseError textIn
36+makeAtomFromText attrName _ _ = Left $ AtomTypeNotSupported attrName
37+
38+textAtom :: T.Text -> Atom
39+textAtom t = Atom t
40+
41+--intAtom shortcut
42+intAtom :: Int -> Atom
43+intAtom i = Atom i
44+
45+doubleAtom :: Double -> Atom
46+doubleAtom d = Atom d
47+
48+byteStringAtom :: ByteString -> Atom
49+byteStringAtom b = Atom b
50+
51+boolAtom :: Bool -> Atom
52+boolAtom b = Atom b
53+
54+--not safe to use without upfront type-checking
55+castRelation :: Atom -> Relation
56+castRelation (ConstructedAtom _ _ _) = error "castRelation attempt on ConstructedAtom"
57+castRelation (Atom atom) = case cast atom of
58+ Just rel -> rel
59+ Nothing -> error "castRelation attempt on non-relation-typed Atom"
60+
61+{-
62+basicAtomTypes :: AtomTypes
63+basicAtomTypes = M.union primitiveAtomTypes moreTypes
64+ where
65+ moreTypes = M.fromList [("Day", (dateAtomType,
66+ AtomConstructor (M.singleton "Day" ["Int"])))
67+ ]
68+-}
69+atomToText :: Atom -> T.Text
70+atomToText (Atom atom) = toText atom
71+atomToText (ConstructedAtom dConsName _ atoms) = dConsName `T.append` T.intercalate " " (map atomToText atoms)
72+
73+
74+
ProjectM36/AtomFunction.hsnew file+34
@@ -0,0 +1,34 @@
1+module ProjectM36.AtomFunction where
2+import ProjectM36.Base
3+import ProjectM36.Error
4+import qualified ProjectM36.Attribute as A
5+import qualified Data.HashSet as HS
6+
7+foldAtomFuncType :: AtomType -> AtomType -> [AtomType]
8+foldAtomFuncType foldType returnType = [RelationAtomType (A.attributesFromList [Attribute "_" foldType]), returnType]
9+
10+atomFunctionForName :: AtomFunctionName -> AtomFunctions -> Either RelationalError AtomFunction
11+atomFunctionForName funcName funcSet = if HS.null foundFunc then
12+ Left $ NoSuchTupleExprFunctionError funcName
13+ else
14+ Right $ head $ HS.toList foundFunc
15+ where
16+ foundFunc = HS.filter (\(AtomFunction name _ _) -> name == funcName) funcSet
17+
18+-- | Create a junk named atom function for use with searching for an already existing function in the AtomFunctions HashSet.
19+emptyAtomFunction :: AtomFunctionName -> AtomFunction
20+emptyAtomFunction name = AtomFunction { atomFuncName = name,
21+ atomFuncType = [AnyAtomType, AnyAtomType],
22+ atomFuncBody = AtomFunctionBody Nothing (\(x:_) -> x) }
23+
24+
25+-- | AtomFunction constructor for compiled-in functions.
26+compiledAtomFunction :: AtomFunctionName -> [AtomType] -> AtomFunctionBodyType -> AtomFunction
27+compiledAtomFunction name aType body = AtomFunction { atomFuncName = name,
28+ atomFuncType = aType,
29+ atomFuncBody = AtomFunctionBody Nothing body }
30+
31+--the atom function really should offer some way to return an error
32+evalAtomFunction :: AtomFunction -> [Atom] -> Atom
33+evalAtomFunction func args = case atomFuncBody func of
34+ (AtomFunctionBody _ f) -> f args
ProjectM36/AtomFunctionBody.hsnew file+92
@@ -0,0 +1,92 @@
1+{-# LANGUAGE ScopedTypeVariables #-}
2+--tools to execute an atom function body
3+module ProjectM36.AtomFunctionBody where
4+import ProjectM36.Base
5+import ProjectM36.Error
6+
7+import Control.Monad.IO.Class
8+import Control.Exception
9+import Data.Dynamic
10+import Data.Text
11+
12+import GHC
13+import GHC.Paths (libdir)
14+import DynFlags
15+import Outputable hiding ((<>))
16+import PprTyThing
17+import Type hiding (pprTyThing)
18+import TysWiredIn
19+
20+type ScriptSession = HscEnv
21+
22+-- | Configure a GHC environment/session which we will use for all script compilation.
23+initScriptSession :: IO ScriptSession
24+initScriptSession = runGhc (Just libdir) $ do
25+ liftIO $ putStrLn "Setting up HscEnv"
26+ dflags <- getSessionDynFlags
27+ let dflags' = dflags { hscTarget = HscInterpreted ,
28+ ghcLink = LinkInMemory,
29+ safeHaskell = Sf_Safe,
30+ safeInfer = True,
31+ safeInferred = True
32+ }
33+ `xopt_set` Opt_ExtendedDefaultRules
34+ --`xopt_unset` Opt_ImplicitPrelude
35+ `gopt_set` Opt_DistrustAllPackages
36+ `gopt_set` Opt_PackageTrust
37+ `gopt_set` Opt_ImplicitImportQualified
38+ _ <- setSessionDynFlags dflags'
39+ setContext [ IIDecl $ simpleImportDecl (mkModuleName "Prelude") ]
40+ env <- getSession
41+ return env
42+
43+addImport :: String -> Ghc ()
44+addImport moduleNam = do
45+ ctx <- getContext
46+ setContext ( (IIDecl $ simpleImportDecl (mkModuleName moduleNam)) : ctx )
47+
48+showType :: DynFlags -> Type -> String
49+showType dflags ty = showSDocForUser dflags alwaysQualify (pprTypeForUser ty)
50+
51+-- | Typecheck and validate the
52+typeCheckAtomFunctionScript :: AtomFunctionBodyScript -> Ghc (Maybe AtomFunctionBodyCompilationError)
53+typeCheckAtomFunctionScript inp = do
54+ dflags <- getSessionDynFlags
55+ --catch exception for SyntaxError
56+ funcType <- GHC.exprType (unpack inp)
57+
58+ let expectedType = atomFunctionBodyGhcType
59+
60+ if eqType funcType expectedType then
61+ pure Nothing
62+ else
63+ pure (Just (TypeCheckCompilationError (showType dflags expectedType) (showType dflags funcType)))
64+
65+atomFunctionBodyGhcType :: Type
66+atomFunctionBodyGhcType = Type.mkFunTy intTy intTy
67+
68+-- | After compiling the script, it must accept a list of Atoms and return an Atom, otherwise an AtomFunctionBodyCompilationError is returned
69+compileAtomFunctionScript :: AtomFunctionBodyScript -> Ghc (Either AtomFunctionBodyCompilationError AtomFunctionBodyType)
70+compileAtomFunctionScript script = do
71+ let sScript = unpack script
72+ mErr <- typeCheckAtomFunctionScript script
73+ case mErr of
74+ Just err -> pure (Left err)
75+ Nothing -> do
76+ --catch exception here
77+ --we could potentially wrap the script with Atom pattern matching so that the script doesn't have to do it, but the change to an Atom ADT should make it easier. Still, it would be nice if the script didn't have to handle a list of arguments, for example.
78+ mDyn <- fromDynamic <$> dynCompileExpr sScript
79+ case mDyn of
80+ Nothing -> pure $ Left (TypeCheckCompilationError "" "") --this really shouldn't happen
81+ Just funcBody -> pure $ Right funcBody
82+
83+catchCompileException :: MonadIO m => IO a -> m (Either AtomFunctionBodyCompilationError a)
84+catchCompileException m = liftIO $ do
85+ mres <- try m
86+ case mres of
87+ Left (err :: SomeException) -> do
88+ pure (Left (OtherScriptCompilationError (show err)))
89+ Right res -> pure (Right res)
90+
91+compiledAtomFunctionBody :: AtomFunctionBodyType -> AtomFunctionBody
92+compiledAtomFunctionBody func = AtomFunctionBody Nothing func
ProjectM36/AtomFunctions/Basic.hsnew file+15
@@ -0,0 +1,15 @@
1+--atom functions on primitive atom values plus the basic atom functions
2+module ProjectM36.AtomFunctions.Basic where
3+import ProjectM36.Base
4+import ProjectM36.DataTypes.Day
5+import ProjectM36.DataTypes.Either
6+import ProjectM36.DataTypes.Maybe
7+import ProjectM36.AtomFunctions.Primitive
8+import qualified Data.HashSet as HS
9+
10+basicAtomFunctions :: AtomFunctions
11+basicAtomFunctions = HS.unions [primitiveAtomFunctions,
12+ dayAtomFunctions,
13+ eitherAtomFunctions,
14+ maybeAtomFunctions]
15+
ProjectM36/AtomFunctions/Primitive.hsnew file+101
@@ -0,0 +1,101 @@
1+module ProjectM36.AtomFunctions.Primitive where
2+import ProjectM36.Atom
3+import ProjectM36.Base
4+import ProjectM36.Relation (relFold)
5+import ProjectM36.Tuple
6+import ProjectM36.AtomFunction
7+import ProjectM36.DataTypes.Primitive
8+import qualified Data.HashSet as HS
9+import Data.Typeable (cast)
10+import qualified Data.Vector as V
11+import qualified Data.ByteString.Base64 as B64
12+import qualified Data.Text.Encoding as TE
13+import qualified Data.Text as T
14+
15+primitiveAtomFunctions :: AtomFunctions
16+primitiveAtomFunctions = HS.fromList [
17+ --match on any relation type
18+ AtomFunction { atomFuncName = "add",
19+ atomFuncType = [intAtomType, intAtomType, intAtomType],
20+ atomFuncBody = body (\(i1:i2:_) -> Atom $ ((unsafeCast i1)::Int) + unsafeCast i2)},
21+ AtomFunction { atomFuncName = "id",
22+ atomFuncType = [AnyAtomType, AnyAtomType],
23+ atomFuncBody = body (\(x:_) -> x)},
24+ AtomFunction { atomFuncName = "sum",
25+ atomFuncType = foldAtomFuncType intAtomType intAtomType,
26+ atomFuncBody = body (\(relAtom:_) -> relationSum $ unsafeCast relAtom)},
27+ AtomFunction { atomFuncName = "count",
28+ atomFuncType = foldAtomFuncType AnyAtomType intAtomType,
29+ atomFuncBody = body (\((relIn):_) -> relationCount (castRelation relIn))},
30+ AtomFunction { atomFuncName = "max",
31+ atomFuncType = foldAtomFuncType intAtomType intAtomType,
32+ atomFuncBody = body (\((relIn):_) -> relationMax (castRelation relIn))},
33+ AtomFunction { atomFuncName = "min",
34+ atomFuncType = foldAtomFuncType intAtomType intAtomType,
35+ atomFuncBody = body (\((relIn):_) -> relationMin (castRelation relIn))},
36+ AtomFunction { atomFuncName = "lt",
37+ atomFuncType = [intAtomType, intAtomType, boolAtomType],
38+ atomFuncBody = body $ intAtomFuncLessThan False},
39+ AtomFunction { atomFuncName = "lte",
40+ atomFuncType = [intAtomType, intAtomType, boolAtomType],
41+ atomFuncBody = body $ intAtomFuncLessThan True},
42+ AtomFunction { atomFuncName = "gte",
43+ atomFuncType = [intAtomType, intAtomType, boolAtomType],
44+ atomFuncBody = body $ boolAtomNot . (:[]) . intAtomFuncLessThan False},
45+ AtomFunction { atomFuncName = "gt",
46+ atomFuncType = [intAtomType, intAtomType, boolAtomType],
47+ atomFuncBody = body $ boolAtomNot . (:[]) . intAtomFuncLessThan True},
48+ AtomFunction { atomFuncName = "not",
49+ atomFuncType = [boolAtomType, boolAtomType],
50+ atomFuncBody = body boolAtomNot},
51+ AtomFunction { atomFuncName = "makeByteString",
52+ atomFuncType = [textAtomType, byteStringAtomType],
53+ --I need a proper error-handling scheme for AtomFunctions!
54+ atomFuncBody = body $ \(textIn:_) -> Atom $ (B64.decodeLenient . TE.encodeUtf8) ((unsafeCast textIn)::T.Text) }
55+ ]
56+ where
57+ body = AtomFunctionBody Nothing
58+
59+unsafeCast :: (Atomable a) => Atom -> a
60+unsafeCast (ConstructedAtom _ _ _) = error "unsafeCast attempt on ConstructedAtom"
61+unsafeCast (Atom atom) = case cast atom of
62+ Just x -> x
63+ Nothing -> error "unsafeCast failed"
64+
65+intAtomFuncLessThan :: Bool -> [Atom] -> Atom
66+intAtomFuncLessThan equality (iatom1:iatom2:_) = (\i1 i2 -> Atom $ ((unsafeCast i1)::Int) `op` unsafeCast i2) iatom1 iatom2
67+ where
68+ op = if equality then (<=) else (<)
69+intAtomFuncLessThan _ _= Atom False
70+
71+boolAtomNot :: [Atom] -> Atom
72+boolAtomNot (bool:_) = Atom $ not (unsafeCast bool)
73+boolAtomNot _ = Atom False
74+
75+--used by sum atom function
76+relationSum :: Relation -> Atom
77+relationSum relIn = Atom $ relFold (\tupIn acc -> acc + (newVal tupIn)) 0 relIn
78+ where
79+ --extract Int from Atom
80+ newVal :: RelationTuple -> Int
81+ newVal tupIn = castInt $ (tupleAtoms tupIn) V.! 0
82+
83+relationCount :: Relation -> Atom
84+relationCount relIn = Atom $ relFold (\_ acc -> acc + 1) (0::Int) relIn
85+
86+relationMax :: Relation -> Atom
87+relationMax relIn = Atom $ relFold (\tupIn acc -> max acc (newVal tupIn)) minBound relIn
88+ where
89+ newVal tupIn = castInt $ (tupleAtoms tupIn) V.! 0
90+
91+relationMin :: Relation -> Atom
92+relationMin relIn = Atom $ relFold (\tupIn acc -> min acc (newVal tupIn)) maxBound relIn
93+ where
94+ newVal tupIn = castInt $ (tupleAtoms tupIn) V.! 0
95+
96+castInt :: Atom -> Int
97+castInt (ConstructedAtom _ _ _) = error "castInt attempt on ConstructedAtom"
98+castInt (Atom atom) = case cast atom of
99+ Just i -> i
100+ Nothing -> error "int cast failure" -- the type checker must ensure this can never occur
101+
ProjectM36/AtomType.hsnew file+267
@@ -0,0 +1,267 @@
1+module ProjectM36.AtomType where
2+import ProjectM36.Base
3+import ProjectM36.ConcreteTypeRep
4+import Data.Typeable
5+import qualified ProjectM36.TypeConstructorDef as TCD
6+import qualified ProjectM36.TypeConstructor as TC
7+import qualified ProjectM36.DataConstructorDef as DCD
8+import ProjectM36.MiscUtils
9+import ProjectM36.Error
10+import qualified ProjectM36.Attribute as A
11+import qualified Data.Vector as V
12+import qualified Data.Set as S
13+import qualified Data.List as L
14+import Data.Maybe (isJust)
15+import Data.Either (rights)
16+import Control.Monad.Writer
17+import qualified Data.Map as M
18+import qualified Data.Text as T
19+--import Debug.Trace
20+
21+findDataConstructor :: DataConstructorName -> TypeConstructorMapping -> Maybe (TypeConstructorDef, DataConstructorDef)
22+findDataConstructor dName tConsList = foldr tConsFolder Nothing tConsList
23+ where
24+ tConsFolder (tCons, dConsList) accum = if isJust accum then
25+ accum
26+ else
27+ case findDCons dConsList of
28+ Just dCons -> Just (tCons, dCons)
29+ Nothing -> Nothing
30+ findDCons dConsList = case filter (\dCons -> DCD.name dCons == dName) dConsList of
31+ [] -> Nothing
32+ [dCons] -> Just dCons
33+ _ -> error "More than one data constructor with the same name found"
34+
35+-- | Scan the atom types and return the resultant ConstructedAtomType or error.
36+-- Used in typeFromAtomExpr to validate argument types.
37+atomTypeForDataConstructorName :: DataConstructorName -> [AtomType] -> TypeConstructorMapping -> Either RelationalError AtomType
38+-- search for the data constructor and resolve the types' names
39+atomTypeForDataConstructorName dConsName atomTypesIn tConsList = do
40+ case findDataConstructor dConsName tConsList of
41+ Nothing -> Left (NoSuchDataConstructorError dConsName)
42+ Just (tCons, dCons) -> do
43+ typeVars <- resolveDataConstructorTypeVars dCons atomTypesIn tConsList
44+ pure (ConstructedAtomType (TCD.name tCons) typeVars)
45+
46+atomTypeForDataConstructorDefArg :: DataConstructorDefArg -> AtomType -> TypeConstructorMapping -> Either RelationalError AtomType
47+atomTypeForDataConstructorDefArg (DataConstructorDefTypeConstructorArg tCons) aType tConss =
48+ case isValidAtomTypeForTypeConstructor aType tCons tConss of
49+ Just err -> Left err
50+ Nothing -> Right aType
51+
52+atomTypeForDataConstructorDefArg (DataConstructorDefTypeVarNameArg _) aType _ = Right aType --any type is OK
53+
54+isValidAtomTypeForTypeConstructorArg :: AtomType -> TypeConstructorArg -> TypeConstructorMapping -> Maybe RelationalError
55+isValidAtomTypeForTypeConstructorArg aType (TypeConstructorArg tCons) tConsList = isValidAtomTypeForTypeConstructor aType tCons tConsList
56+isValidAtomTypeForTypeConstructorArg _ (TypeConstructorTypeVarArg _) _ = Nothing
57+
58+--reconcile the atom-in types with the type constructors
59+isValidAtomTypeForTypeConstructor :: AtomType -> TypeConstructor -> TypeConstructorMapping -> Maybe RelationalError
60+isValidAtomTypeForTypeConstructor aType (PrimitiveTypeConstructor _ expectedAType) _ = if expectedAType /= aType then Just (AtomTypeMismatchError expectedAType aType) else Nothing
61+
62+--lookup constructor name and check if the incoming atom types are valid
63+isValidAtomTypeForTypeConstructor (ConstructedAtomType tConsName _) (ADTypeConstructor expectedTConsName _) _ = if tConsName /= expectedTConsName then Just (TypeConstructorNameMismatch expectedTConsName tConsName) else Nothing
64+
65+isValidAtomTypeForTypeConstructor aType tCons _ = Just (AtomTypeTypeConstructorReconciliationError aType (TC.name tCons))
66+
67+-- | Used to determine if the atom arguments can be used with the data constructor.
68+-- | This is the entry point for type-checking from RelationalExpression.hs.
69+atomTypeForDataConstructor :: TypeConstructorMapping -> DataConstructorName -> [AtomType] -> Either RelationalError AtomType
70+atomTypeForDataConstructor tConss dConsName atomArgTypes = do
71+ --lookup the data constructor
72+ case findDataConstructor dConsName tConss of
73+ Nothing -> Left (NoSuchDataConstructorError dConsName)
74+ Just (tCons, dCons) -> do
75+ --validate that the type constructor arguments are fulfilled in the data constructor
76+ typeVars <- resolveDataConstructorTypeVars dCons atomArgTypes tConss
77+ pure (ConstructedAtomType (TCD.name tCons) typeVars)
78+
79+-- | Walks the data and type constructors to extract the type variable map.
80+resolveDataConstructorTypeVars :: DataConstructorDef -> [AtomType] -> TypeConstructorMapping -> Either RelationalError TypeVarMap
81+resolveDataConstructorTypeVars dCons aTypeArgs tConss = do
82+ maps <- mapM (\(dCons',aTypeArg) -> resolveDataConstructorArgTypeVars dCons' aTypeArg tConss) (zip (DCD.fields dCons) aTypeArgs)
83+ --if any two maps have the same key and different values, this indicates a type arg mismatch
84+ let typeVarMapFolder valMap acc = case acc of
85+ Left err -> Left err
86+ Right accMap -> if accMap `M.isSubmapOf` valMap then
87+ Right (M.union accMap valMap)
88+ else
89+ Left (DataConstructorTypeVarsMismatch (DCD.name dCons) accMap valMap)
90+ case foldr typeVarMapFolder (Right M.empty) maps of
91+ Left err -> Left err
92+ Right typeVarMaps -> pure typeVarMaps
93+ --if the data constructor cannot complete a type constructor variables (ex. "Nothing" could be Maybe Int or Maybe Text, etc.), then fill that space with AnyAtomType which is resolved when the relation is constructed- the relation must contain all resolved atom types.
94+
95+
96+-- | Attempt to match the data constructor argument to a type constructor type variable.
97+resolveDataConstructorArgTypeVars :: DataConstructorDefArg -> AtomType -> TypeConstructorMapping -> Either RelationalError TypeVarMap
98+resolveDataConstructorArgTypeVars (DataConstructorDefTypeConstructorArg tCons) aType tConss = resolveTypeConstructorTypeVars tCons aType tConss
99+
100+resolveDataConstructorArgTypeVars (DataConstructorDefTypeVarNameArg pVarName) aType _ = Right (M.singleton pVarName aType)
101+
102+resolveTypeConstructorTypeVars :: TypeConstructor -> AtomType -> TypeConstructorMapping -> Either RelationalError TypeVarMap
103+resolveTypeConstructorTypeVars (PrimitiveTypeConstructor _ pType) aType _ =
104+ if aType /= pType then
105+ Left (AtomTypeMismatchError pType aType)
106+ else
107+ Right M.empty
108+
109+resolveTypeConstructorTypeVars (ADTypeConstructor tConsName _) (ConstructedAtomType tConsName' pVarMap') tConss =
110+ if tConsName /= tConsName' then
111+ Left (TypeConstructorNameMismatch tConsName tConsName')
112+ else
113+ case findTypeConstructor tConsName tConss of
114+ Nothing -> Left (NoSuchTypeConstructorName tConsName)
115+ Just (tConsDef, _) -> let expectedPVarNames = S.fromList (TCD.typeVars tConsDef) in
116+ if M.keysSet pVarMap' `S.isSubsetOf` expectedPVarNames then
117+ Right pVarMap' -- I wish we could actually resolve this- we are creating temporary AtomTypes which are actually invalid until they are resolved with a second pass of type resolution- not great
118+ else
119+ Left (TypeConstructorTypeVarsMismatch expectedPVarNames (M.keysSet pVarMap'))
120+resolveTypeConstructorTypeVars _ _ _ = error "Unhandled type vars"
121+
122+-- check that type vars on the right also appear on the left
123+-- check that the data constructor names are unique
124+validateTypeConstructorDef :: TypeConstructorDef -> [DataConstructorDef] -> [RelationalError]
125+validateTypeConstructorDef tConsDef dConsList = execWriter $ do
126+ let duplicateDConsNames = dupes (L.sort (map DCD.name dConsList))
127+ mapM_ tell [map DataConstructorNameInUseError duplicateDConsNames]
128+ let leftSideVars = S.fromList (TCD.typeVars tConsDef)
129+ rightSideVars = S.unions (map DCD.typeVars dConsList)
130+ varsDiff = S.difference leftSideVars rightSideVars
131+ mapM_ tell [map DataConstructorUsesUndeclaredTypeVariable (S.toList varsDiff)]
132+ pure ()
133+
134+
135+-- | Create an atom type iff all type variables are provided.
136+-- Either Int Text -> ConstructedAtomType "Either" {Int , Text}
137+atomTypeForTypeConstructor :: TypeConstructor -> TypeConstructorMapping -> Either RelationalError AtomType
138+atomTypeForTypeConstructor (PrimitiveTypeConstructor _ aType) _ = Right aType
139+atomTypeForTypeConstructor tCons tConss = case findTypeConstructor (TC.name tCons) tConss of
140+ Nothing -> Left (NoSuchTypeConstructorError (TC.name tCons))
141+ Just (tConsDef, _) -> do
142+ tConsArgTypes <- mapM ((flip atomTypeForTypeConstructorArg) tConss) (TC.arguments tCons)
143+ let pVarNames = TCD.typeVars tConsDef
144+ tConsArgs = M.fromList (zip pVarNames tConsArgTypes)
145+ Right (ConstructedAtomType (TC.name tCons) tConsArgs)
146+
147+atomTypeForTypeConstructorArg :: TypeConstructorArg -> TypeConstructorMapping -> Either RelationalError AtomType
148+atomTypeForTypeConstructorArg (TypeConstructorTypeVarArg _) _ = Left IncompletelyDefinedAtomTypeWithConstructorError
149+atomTypeForTypeConstructorArg (TypeConstructorArg tCons) tConsList = atomTypeForTypeConstructor tCons tConsList
150+
151+findTypeConstructor :: TypeConstructorName -> TypeConstructorMapping -> Maybe (TypeConstructorDef, [DataConstructorDef])
152+findTypeConstructor name tConsList = foldr tConsFolder Nothing tConsList
153+ where
154+ tConsFolder (tCons, dConsList) accum = if TCD.name tCons == name then
155+ Just (tCons, dConsList)
156+ else
157+ accum
158+
159+resolveAtomType :: AtomType -> AtomType -> Either RelationalError AtomType
160+resolveAtomType (ConstructedAtomType tConsName resolvedTypeVarMap) (ConstructedAtomType _ unresolvedTypeVarMap) = do
161+ tVarMap <- resolveAtomTypesInTypeVarMap resolvedTypeVarMap unresolvedTypeVarMap
162+ pure (ConstructedAtomType tConsName tVarMap)
163+resolveAtomType typeFromRelation unresolvedType = if typeFromRelation == unresolvedType then
164+ Right typeFromRelation
165+ else
166+ Left (AtomTypeMismatchError typeFromRelation unresolvedType)
167+
168+-- this could be optimized to reduce new tuple creation- if anyatomtype does not appear, just return the original typevarmap
169+resolveAtomTypesInTypeVarMap :: TypeVarMap -> TypeVarMap -> Either RelationalError TypeVarMap
170+resolveAtomTypesInTypeVarMap resolvedTypeMap unresolvedTypeMap = do
171+ {-
172+ let resKeySet = traceShowId $ M.keysSet resolvedTypeMap
173+ unresKeySet = traceShowId $ M.keysSet unresolvedTypeMap
174+ when (resKeySet /= unresKeySet) (Left $ TypeConstructorTypeVarsMismatch resKeySet unresKeySet)
175+
176+
177+ let lookupOrDef key tMap = case M.lookup key tMap of
178+ Nothing -> Left (TypeConstructorTypeVarMissing key)
179+ Just val -> Right val
180+ -}
181+ let resolveTypePair resKey resType = do
182+ -- if the key is missing in the unresolved type map, then fill it in with the value from the resolved map
183+ case M.lookup resKey unresolvedTypeMap of
184+ Just unresType -> case unresType of
185+ --do we need to recurse for RelationAtomType?
186+ subType@(ConstructedAtomType _ _) -> do
187+ resSubType <- resolveAtomType resType subType
188+ pure (resKey, resSubType)
189+ otherType -> pure (resKey, otherType)
190+ Nothing -> do
191+ pure (resKey, resType) --swipe the missing type var from the expected map
192+ tVarList <- mapM (uncurry resolveTypePair) (M.toList resolvedTypeMap)
193+ pure (M.fromList tVarList)
194+
195+-- | See notes at `resolveTypesInTuple`. The typeFromRelation must not include any wildcards.
196+resolveTypeInAtom :: AtomType -> Atom -> Either RelationalError Atom
197+resolveTypeInAtom typeFromRelation atomIn@(ConstructedAtom dConsName _ args) = do
198+ newType <- resolveAtomType typeFromRelation (atomTypeForAtom atomIn)
199+ pure (ConstructedAtom dConsName newType args)
200+resolveTypeInAtom _ atom = Right atom
201+
202+-- | When creating a tuple, the data constructor may not complete the type constructor arguments, so the wildcard "AnyAtomType" fills in the type constructor's argument. The tuple type must be resolved before it can be part of a relation, however.
203+-- Example: "Nothing" does not specify the the argument in "Maybe a", so allow delayed resolution in the tuple before it is added to the relation. Note that this resolution could cause a type error. Hardly a Hindley-Milner system.
204+resolveTypesInTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple
205+resolveTypesInTuple resolvedAttrs (RelationTuple _ tupAtoms) = do
206+ newAtoms <- mapM (\(atom, resolvedType) -> resolveTypeInAtom resolvedType atom) (zip (V.toList tupAtoms) $ (map A.atomType (V.toList resolvedAttrs)))
207+ Right (RelationTuple resolvedAttrs (V.fromList newAtoms))
208+
209+-- | Validate that the type is provided with complete type variables for type constructors.
210+validateAtomType :: AtomType -> TypeConstructorMapping -> Either RelationalError ()
211+validateAtomType typ@(ConstructedAtomType tConsName tVarMap) tConss = do
212+ case findTypeConstructor tConsName tConss of
213+ Nothing -> Left (TypeConstructorAtomTypeMismatch tConsName typ)
214+ Just (tConsDef, _) -> case tConsDef of
215+ ADTypeConstructorDef _ tVarNames -> let expectedTyVarNames = S.fromList tVarNames
216+ actualTyVarNames = M.keysSet tVarMap
217+ diff = S.difference expectedTyVarNames actualTyVarNames in
218+ if not (S.null diff) then
219+ Left $ TypeConstructorTypeVarsMismatch expectedTyVarNames actualTyVarNames
220+ else
221+ Right ()
222+ _ -> Right ()
223+validateAtomType _ _ = Right ()
224+
225+validateTuple :: RelationTuple -> TypeConstructorMapping -> Either RelationalError ()
226+validateTuple (RelationTuple _ atoms) tConss = mapM_ (\a -> validateAtomType (atomTypeForAtom a) tConss) atoms
227+
228+-- | Determine if two types are equal or compatible (including special handling for AnyAtomType).
229+atomTypeVerify :: AtomType -> AtomType -> Either RelationalError AtomType
230+atomTypeVerify AnyAtomType x = Right x
231+atomTypeVerify x AnyAtomType = Right x
232+atomTypeVerify x@(ConstructedAtomType tConsNameA tVarMapA) (ConstructedAtomType tConsNameB tVarMapB) =
233+ if tConsNameA /= tConsNameB then
234+ Left (TypeConstructorNameMismatch tConsNameA tConsNameB)
235+ else if not (typeVarMapsVerify tVarMapA tVarMapB) then
236+ Left (TypeConstructorTypeVarsTypesMismatch tConsNameA tVarMapA tVarMapB)
237+ else
238+ Right x
239+atomTypeVerify x@(RelationAtomType attrs1) y@(RelationAtomType attrs2) = do
240+ _ <- mapM (\(attr1,attr2) -> let name1 = A.attributeName attr1
241+ name2 = A.attributeName attr2 in
242+ if notElem "_" [name1, name2] && name1 /= name2 then
243+ Left $ AtomTypeMismatchError x y
244+ else
245+ atomTypeVerify (A.atomType attr1) (A.atomType attr2)) $ V.toList (V.zip attrs1 attrs2)
246+ return x
247+atomTypeVerify x y = if x == y then
248+ Right x
249+ else
250+ Left $ AtomTypeMismatchError x y
251+
252+-- | Determine if two typeVar
253+typeVarMapsVerify :: TypeVarMap -> TypeVarMap -> Bool
254+typeVarMapsVerify a b = M.keysSet a == M.keysSet b && (length . rights) (map (\((_,v1),(_,v2)) -> atomTypeVerify v1 v2) (zip (M.toAscList a) (M.toAscList b))) == M.size a
255+
256+prettyAtomType :: AtomType -> T.Text
257+prettyAtomType (AtomType primitiveType) = T.pack (tyConName (fst (splitTyConApp (unCTR primitiveType))))
258+prettyAtomType (RelationAtomType attrs) = "relation {" `T.append` T.intercalate "," (map prettyAttribute (V.toList attrs)) `T.append` "}"
259+prettyAtomType (ConstructedAtomType tConsName typeVarMap) = tConsName `T.append` T.concat (map showTypeVars (M.toList typeVarMap))
260+ where
261+ showTypeVars (tyVarName, aType) = " (" `T.append` tyVarName `T.append` "::" `T.append` prettyAtomType aType `T.append` ")"
262+-- it would be nice to have the original ordering, but we don't have access to the type constructor here- maybe the typevarmap should be also positional (ordered map?)
263+prettyAtomType AnyAtomType = "?AnyAtomType?"
264+
265+prettyAttribute :: Attribute -> T.Text
266+prettyAttribute attr = A.attributeName attr `T.append` "::" `T.append` prettyAtomType (A.atomType attr)
267+
ProjectM36/Attribute.hsnew file+123
@@ -0,0 +1,123 @@
1+module ProjectM36.Attribute where
2+import ProjectM36.Base
3+import ProjectM36.Error
4+import qualified Data.Set as S
5+import qualified Data.List as L
6+import qualified Data.Vector as V
7+import qualified Data.Hashable as Hash
8+import qualified Data.HashSet as HS
9+
10+arity :: Attributes -> Int
11+arity = V.length
12+
13+emptyAttributes :: Attributes
14+emptyAttributes = V.empty
15+
16+null :: Attributes -> Bool
17+null = V.null
18+
19+attributesFromList :: [Attribute] -> Attributes
20+attributesFromList = V.fromList -- . L.nub --too expensive
21+
22+attributeName :: Attribute -> AttributeName
23+attributeName (Attribute name _) = name
24+
25+atomType :: Attribute -> AtomType
26+atomType (Attribute _ atype) = atype
27+
28+atomTypes :: Attributes -> V.Vector AtomType
29+atomTypes attrs = V.map atomType attrs
30+
31+--hm- no error-checking here
32+addAttribute :: Attribute -> Attributes -> Attributes
33+addAttribute attr attrs = attrs `V.snoc` attr
34+
35+--if some attribute names overlap but the types do not, then spit back an error
36+joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes
37+joinAttributes attrs1 attrs2 = if V.length (vectorUniqueify overlappingAttributes) /= V.length overlappingAttributes then
38+ Left $ TupleAttributeTypeMismatchError overlappingAttributes
39+ else
40+ Right $ vectorUniqueify (attrs1 V.++ attrs2)
41+ where
42+ overlappingAttributes = V.filter (\attr -> V.elem attr attrs2) attrs1
43+
44+addAttributes :: Attributes -> Attributes -> Attributes
45+addAttributes = (V.++)
46+
47+deleteAttributeName :: AttributeName -> Attributes -> Attributes
48+deleteAttributeName attrName = V.filter (\attr -> attributeName attr /= attrName)
49+
50+renameAttribute :: AttributeName -> Attribute -> Attribute
51+renameAttribute newAttrName (Attribute _ typeo) = Attribute newAttrName typeo
52+
53+renameAttributes :: AttributeName -> AttributeName -> Attributes -> Attributes
54+renameAttributes oldAttrName newAttrName attrs = V.map renamer attrs
55+ where
56+ renamer attr = if attributeName attr == oldAttrName then
57+ renameAttribute newAttrName attr
58+ else
59+ attr
60+
61+atomTypeForAttributeName :: AttributeName -> Attributes -> Either RelationalError AtomType
62+atomTypeForAttributeName attrName attrs = do
63+ (Attribute _ atype) <- attributeForName attrName attrs
64+ return atype
65+
66+attributeForName :: AttributeName -> Attributes -> Either RelationalError Attribute
67+attributeForName attrName attrs = case V.find ((attrName ==) . attributeName) attrs of
68+ Nothing -> Left $ NoSuchAttributeNamesError (S.singleton attrName)
69+ Just attr -> Right attr
70+
71+attributesForNames :: S.Set AttributeName -> Attributes -> Attributes
72+attributesForNames attrNameSet attrs = V.filter filt attrs
73+ where
74+ filt attr = S.member (attributeName attr) attrNameSet
75+
76+attributeNameSet :: Attributes -> S.Set AttributeName
77+attributeNameSet attrVec = S.fromList $ V.toList $ V.map (\(Attribute name _) -> name) attrVec
78+
79+attributeNames :: Attributes -> V.Vector AttributeName
80+attributeNames = V.map attributeName
81+
82+--checks if set s1 is wholly contained in the set s2
83+attributesContained :: Attributes -> Attributes -> Bool
84+attributesContained attrs1 attrs2 = attributeNamesContained (attributeNameSet attrs1) (attributeNameSet attrs2)
85+
86+attributeNamesContained :: S.Set AttributeName -> S.Set AttributeName -> Bool
87+attributeNamesContained attrs1 attrs2 = S.isSubsetOf attrs1 attrs2
88+
89+--returns the disjunction of the AttributeNameSets
90+nonMatchingAttributeNameSet :: S.Set AttributeName -> S.Set AttributeName -> S.Set AttributeName
91+nonMatchingAttributeNameSet a1 a2 = S.difference (S.union a1 a2) (S.intersection a1 a2)
92+
93+matchingAttributeNameSet :: S.Set AttributeName -> S.Set AttributeName -> S.Set AttributeName
94+matchingAttributeNameSet = S.intersection
95+
96+attributeNamesNotContained :: S.Set AttributeName -> S.Set AttributeName -> S.Set AttributeName
97+attributeNamesNotContained subset superset = S.filter (flip S.notMember superset) subset
98+
99+-- this is sorted so the tuples know in which order to output- the ordering is arbitrary
100+sortedAttributeNameList :: S.Set AttributeName -> [AttributeName]
101+sortedAttributeNameList attrNameSet= L.sort $ S.toList attrNameSet
102+
103+-- take two attribute sets and return an attribute set with the attributes which do not match
104+attributesDifference :: Attributes -> Attributes -> Attributes
105+attributesDifference attrsA attrsB = V.fromList $ diff (V.toList attrsA) (V.toList attrsB)
106+ where
107+ diff a b = (a L.\\ b) ++ (b L.\\ a)
108+
109+vectorUniqueify :: (Hash.Hashable a, Eq a) => V.Vector a -> V.Vector a
110+vectorUniqueify vecIn = V.fromList $ HS.toList $ HS.fromList $ V.toList vecIn
111+
112+--check that each attribute only appears once
113+verifyAttributes :: Attributes -> Either RelationalError Attributes
114+verifyAttributes attrs = if collapsedAttrs /= attrs then
115+ Left $ TupleAttributeTypeMismatchError (attributesDifference collapsedAttrs attrs)
116+ else
117+ Right attrs
118+ where
119+ collapsedAttrs = vectorUniqueify attrs
120+
121+attributesEqual :: Attributes -> Attributes -> Bool
122+attributesEqual attrs1 attrs2 = V.null (attributesDifference attrs1 attrs2)
123+
ProjectM36/AttributeNames.hsnew file+30
@@ -0,0 +1,30 @@
1+module ProjectM36.AttributeNames where
2+import qualified ProjectM36.Attribute as A
3+import ProjectM36.Base
4+import ProjectM36.Error
5+import qualified Data.Set as S
6+--AttributeNames is a data structure which can represent inverted projection attributes
7+
8+--check that the attribute names are actually in the attributes
9+projectionAttributesForAttributeNames :: Attributes -> AttributeNames -> Either RelationalError Attributes
10+projectionAttributesForAttributeNames attrs (AttributeNames attrNameSet) = do
11+ let nonExistentAttributeNames = A.attributeNamesNotContained attrNameSet (A.attributeNameSet attrs)
12+ if not $ S.null nonExistentAttributeNames then
13+ Left $ AttributeNamesMismatchError nonExistentAttributeNames
14+ else
15+ return $ A.attributesForNames attrNameSet attrs
16+
17+projectionAttributesForAttributeNames attrs (InvertedAttributeNames unselectedAttrNameSet) = do
18+ let nonExistentAttributeNames = A.attributeNamesNotContained unselectedAttrNameSet (A.attributeNameSet attrs)
19+ if not $ S.null nonExistentAttributeNames then
20+ Left $ AttributeNamesMismatchError nonExistentAttributeNames
21+ else
22+ return $ A.attributesForNames (A.nonMatchingAttributeNameSet unselectedAttrNameSet (A.attributeNameSet attrs)) attrs
23+
24+attributeNameSet :: AttributeNames -> S.Set AttributeName
25+attributeNameSet (AttributeNames nameSet) = nameSet
26+attributeNameSet (InvertedAttributeNames nameSet) = nameSet
27+
28+invertAttributeNames :: AttributeNames -> AttributeNames
29+invertAttributeNames (AttributeNames names) = InvertedAttributeNames names
30+invertAttributeNames (InvertedAttributeNames names) = AttributeNames names
ProjectM36/Base.hsnew file+512
@@ -0,0 +1,512 @@
1+{-# LANGUAGE ExistentialQuantification,BangPatterns,DeriveGeneric,DeriveAnyClass #-}
2+{-# OPTIONS_GHC -fno-warn-orphans #-}
3+module ProjectM36.Base where
4+import qualified Data.Map as M
5+import qualified Data.HashSet as HS
6+import Data.Hashable (Hashable, hashWithSalt)
7+import qualified Data.Set as S
8+import Control.Monad.State (State)
9+import Data.UUID (UUID)
10+import Control.DeepSeq (NFData, rnf)
11+import Control.DeepSeq.Generics (genericRnf)
12+import GHC.Generics (Generic)
13+import qualified Data.Vector as V
14+import qualified Data.List as L
15+import Data.Text (Text,pack,unpack)
16+import Data.Binary
17+import Data.Vector.Binary()
18+import Data.Time.Clock
19+import Data.Time.Clock.POSIX
20+import Data.Time.Calendar (Day,toGregorian,fromGregorian)
21+import Data.Hashable.Time ()
22+import Data.Typeable
23+import Text.Read (readMaybe)
24+import Data.ByteString (ByteString)
25+import ProjectM36.ConcreteTypeRep
26+import qualified Data.Text.Encoding as TE
27+import qualified Data.ByteString.Base64 as BS64
28+import Data.Maybe (isJust)
29+
30+type StringType = Text
31+
32+-- | Any data type represents as an 'Atom' in the database must adhere to the 'Atomable' typeclass.
33+class (Read a,
34+ Hashable a,
35+ Binary a,
36+ Eq a,
37+ Show a,
38+ Typeable a,
39+ NFData a) => Atomable a where
40+ fromText :: (Atomable a) => Text -> Either String a
41+ fromText t = case readMaybe (unpack t) of
42+ Just v -> Right v
43+ Nothing -> Left ("Parse error: " ++ (unpack t))
44+
45+ toText :: a -> Text
46+ toText a = pack $ show a
47+
48+instance Atomable Int
49+instance Atomable Double
50+instance Atomable Text where
51+instance Atomable Day
52+instance Atomable UTCTime
53+instance Atomable ByteString where
54+ toText bs = TE.decodeUtf8With (\_ _ -> Just '?') (BS64.encode bs)
55+instance Atomable Bool
56+instance Atomable Relation
57+instance (Atomable a) => Atomable (Maybe a)
58+
59+-- | Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.
60+data Atom = forall a. Atomable a => Atom a |
61+ ConstructedAtom DataConstructorName AtomType [Atom]
62+
63+instance Eq Atom where
64+ (Atom a) == (Atom b) = Just a == cast b
65+ (ConstructedAtom dConsNameA aTypeA atomListA) == (ConstructedAtom dConsNameB aTypeB atomListB) = aTypeA == aTypeB &&
66+ atomListA == atomListB &&
67+ dConsNameA == dConsNameB
68+ _ == _ = False
69+
70+instance Show Atom where
71+ showsPrec _ (Atom atom) = showString "Atom " . shows atom
72+ showsPrec v (ConstructedAtom dConsName _ atomList) = showParen (v >= 4) showIt
73+ where showIt = showString (unpack dConsName) . showString " " . compose (map (showsPrec 4) atomList)
74+ compose = foldr (.) id
75+
76+instance Binary Atom where
77+ put atom@(Atom val) = put (atomTypeForAtom atom) >> put val
78+ put (ConstructedAtom dConsName aType atomList) = put aType >> put dConsName >> put atomList
79+ get = do
80+ atomtype <- get
81+ --not-so-great for this to be hardcoded here- it would be nicer to have a dispatch table linked to the instances themselves
82+ --http://stackoverflow.com/questions/8101067/binary-instance-for-an-existential
83+ case atomtype of
84+ AnyAtomType -> error "unsupported serialization AnyAtomType"
85+ caType@(ConstructedAtomType _ _) -> ConstructedAtom <$> (get :: Get DataConstructorName) <*> pure caType <*> (get :: Get [Atom]) --we really should verify the type with the atoms
86+ (RelationAtomType _) -> Atom <$> (get :: Get Relation)
87+ (AtomType cTypeRep) -> if unCTR cTypeRep == typeRep (Proxy :: Proxy Int) then
88+ Atom <$> (get :: Get Int)
89+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy Text) then
90+ Atom <$> (get :: Get Text)
91+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy Double) then
92+ Atom <$> (get :: Get Double)
93+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy Day) then
94+ Atom <$> (get :: Get Day)
95+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy ByteString) then
96+ Atom <$> (get :: Get ByteString)
97+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy Bool) then
98+ Atom <$> (get :: Get Bool)
99+ else
100+ error "unsupported typerep serialization"
101+
102+instance NFData Atom where
103+ rnf !(Atom a) = rnf a
104+ rnf !(ConstructedAtom dConsName aType atomList) = rnf (dConsName, atomList, aType)
105+
106+instance Hashable Atom where
107+ hashWithSalt salt (Atom a) = hashWithSalt salt a
108+ hashWithSalt salt (ConstructedAtom dConsName _ atomList) = salt `hashWithSalt` atomList
109+ `hashWithSalt` dConsName --AtomType is not hashable
110+
111+-- | Return the type of an 'Atom'.
112+atomTypeForAtom :: Atom -> AtomType
113+atomTypeForAtom (Atom atom) = case cast atom of
114+ Just (Relation attrs _) -> RelationAtomType attrs
115+ Nothing -> AtomType $ CTR (typeOf atom)
116+atomTypeForAtom (ConstructedAtom _ aType _) = aType
117+
118+instance Binary UTCTime where
119+ put utc = put $ toRational (utcTimeToPOSIXSeconds utc)
120+ get = do
121+ r <- get :: Get Rational
122+ return (posixSecondsToUTCTime (fromRational r))
123+
124+instance Binary Day where
125+ put day = put $ toGregorian day
126+ get = do
127+ (y,m,d) <- get :: Get (Integer, Int, Int)
128+ return (fromGregorian y m d)
129+
130+-- I suspect the definition of ConstructedAtomType with its name alone is insufficient to disambiguate the cases; for example, one could create a type named X, remove a type named X, and re-add it using different constructors. However, as long as requests are served from only one DatabaseContext at-a-time, the type name is unambiguous. This will become a problem for time-travel, however.
131+-- | The AtomType must uniquely identify the type of a atom.
132+data AtomType = AtomType ConcreteTypeRep |
133+ RelationAtomType Attributes |
134+ ConstructedAtomType TypeConstructorName TypeVarMap |
135+ AnyAtomType
136+ --wildcard used in Atom Functions and tuples for data constructors which don't provide all arguments to the type constructor
137+ deriving (Eq,NFData,Generic,Binary, Show)
138+
139+type TypeVarMap = M.Map TypeVarName AtomType
140+
141+-- | Return True iff the atom type argument is relation-valued. If True, this indicates that the Atom contains a relation.
142+isRelationAtomType :: AtomType -> Bool
143+isRelationAtomType (RelationAtomType _) = True
144+isRelationAtomType _ = False
145+
146+-- | The AttributeName is the name of an attribute in a relation.
147+type AttributeName = StringType
148+
149+-- | A relation's type is composed of attribute names and types.
150+data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Generic)
151+
152+instance Hashable Attribute where
153+ hashWithSalt salt (Attribute attrName _) = hashWithSalt salt attrName
154+
155+instance NFData Attribute where rnf = genericRnf
156+
157+instance Binary Attribute
158+
159+-- | 'Attributes' represent the head of a relation.
160+type Attributes = V.Vector Attribute
161+
162+-- | Equality function for a set of attributes.
163+attributesEqual :: Attributes -> Attributes -> Bool
164+attributesEqual attrs1 attrs2 = attrsAsSet attrs1 == attrsAsSet attrs2
165+ where
166+ attrsAsSet = HS.fromList . V.toList
167+
168+sortedAttributesIndices :: Attributes -> [(Int, Attribute)]
169+sortedAttributesIndices attrs = L.sortBy (\(_, (Attribute name1 _)) (_,(Attribute name2 _)) -> compare name1 name2) $ V.toList (V.indexed attrs)
170+
171+-- | The relation's tuple set is the body of the relation.
172+newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic, Binary)
173+
174+instance Read Relation where
175+ readsPrec = error "relation read not supported"
176+
177+instance Eq RelationTupleSet where
178+ set1 == set2 = hset set1 == hset set2
179+ where
180+ hset = HS.fromList . asList
181+
182+instance NFData RelationTupleSet where rnf = genericRnf
183+
184+--the same hash must be generated for equal tuples so that the hashset equality works
185+instance Hashable RelationTuple where
186+ --sanity check the tuple for attribute and tuple counts
187+ --this bit me when tuples were being hashed before being verified
188+ hashWithSalt salt (RelationTuple attrs tupVec) = if V.length attrs /= V.length tupVec then
189+ error "invalid tuple: attributes and tuple count mismatch"
190+ else
191+ salt `hashWithSalt`
192+ sortedAttrs `hashWithSalt`
193+ (V.toList sortedTupVec)
194+ where
195+ sortedAttrsIndices = sortedAttributesIndices attrs
196+ sortedAttrs = map snd sortedAttrsIndices
197+ sortedTupVec = V.map (\(index, _) -> tupVec V.! index) $ V.fromList sortedAttrsIndices
198+
199+-- | A tuple is a set of attributes mapped to their 'Atom' values.
200+data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Generic)
201+
202+instance Binary RelationTuple
203+
204+instance Eq RelationTuple where
205+ (==) tuple1@(RelationTuple attrs1 _) tuple2@(RelationTuple attrs2 _) = attributesEqual attrs1 attrs2 && atomsEqual
206+ where
207+ atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) attrs of
208+ Nothing -> Nothing
209+ Just index -> tupVec V.!? index
210+ atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) attrs1
211+
212+instance NFData RelationTuple where rnf = genericRnf
213+
214+data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)
215+
216+instance Eq Relation where
217+ Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attributesEqual attrs1 attrs2 && tupSet1 == tupSet2
218+
219+instance NFData Relation where rnf = genericRnf
220+
221+instance Hashable Relation where
222+ hashWithSalt salt (Relation attrs tupSet) = salt `hashWithSalt`
223+ sortedAttrs `hashWithSalt`
224+ asList tupSet
225+ where
226+ sortedAttrs = map snd (sortedAttributesIndices attrs)
227+
228+instance Binary Relation
229+
230+data RelationCardinality = Countable | Finite Int deriving (Eq, Show, Generic, Ord)
231+
232+-- | Relation variables are identified by their names.
233+type RelVarName = StringType
234+
235+-- | A relational expression represents query (read) operations on a database.
236+data RelationalExpr =
237+ --- | Create a relation from tuple expressions.
238+ MakeRelationFromExprs (Maybe [AttributeExpr]) [TupleExpr] |
239+ --- | Create and reference a relation from attributes and a tuple set.
240+ MakeStaticRelation Attributes RelationTupleSet |
241+ --- | Reference an existing relation in Haskell-space.
242+ ExistingRelation Relation |
243+ --MakeFunctionalRelation (creates a relation from a tuple-generating function, potentially infinite)
244+ --in Tutorial D, relational variables pick up the type of the first relation assigned to them
245+ --relational variables should also be able to be explicitly-typed like in Haskell
246+ --- | Reference a relation variable by its name.
247+ RelationVariable RelVarName |
248+ --- | Create a projection over attribute names. (Note that the 'AttributeNames' structure allows for the names to be inverted.)
249+ Project AttributeNames RelationalExpr |
250+ --- | Create a union of two relational expressions. The expressions should have identical attributes.
251+ Union RelationalExpr RelationalExpr |
252+ --- | Create a join of two relational expressions. The join occurs on attributes which are identical. If the expressions have no overlapping attributes, the join becomes a cross-product of both tuple sets.
253+ Join RelationalExpr RelationalExpr |
254+ --- | Rename an attribute (first argument) to another (second argument).
255+ Rename AttributeName AttributeName RelationalExpr |
256+ --- | Return a relation containing all tuples of the first argument which do not appear in the second argument (minus).
257+ Difference RelationalExpr RelationalExpr |
258+ --- | Create a sub-relation composed of the first argument's attributes which will become an attribute of the result expression. The unreferenced attributes are not altered in the result but duplicate tuples in the projection of the expression minus the attribute names are compressed into one. For more information, <https://github.com/agentm/project-m36/blob/master/docs/introduction_to_the_relational_algebra.markdown#group read the relational algebra tutorial.>
259+ Group AttributeNames AttributeName RelationalExpr |
260+ --- | Create an expression to unwrap a sub-relation contained within at an attribute's name. Note that this is not always an inverse of a group operation.
261+ Ungroup AttributeName RelationalExpr |
262+ --- | Filter the tuples of the relational expression to only retain the tuples which evaluate against the restriction predicate to true.
263+ Restrict RestrictionPredicateExpr RelationalExpr |
264+ --- | Returns the true relation iff
265+ Equals RelationalExpr RelationalExpr |
266+ NotEquals RelationalExpr RelationalExpr |
267+ Extend ExtendTupleExpr RelationalExpr
268+ --Summarize :: AtomExpr -> AttributeName -> RelationalExpr -> RelationalExpr -> RelationalExpr -- a special case of Extend
269+ deriving (Show, Eq, Generic, Binary)
270+
271+type NotificationName = StringType
272+type Notifications = M.Map NotificationName Notification
273+
274+-- | When the changeExpr returns a different result in the database context, then the reportExpr is triggered and sent asynchronously to all clients.
275+data Notification = Notification {
276+ changeExpr :: RelationalExpr,
277+ reportExpr :: RelationalExpr
278+ }
279+ deriving (Show, Eq, Binary, Generic)
280+
281+type TypeVarName = StringType
282+
283+-- | "data Either a b"
284+data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |
285+ PrimitiveTypeConstructorDef TypeConstructorName AtomType
286+ deriving (Show, Generic, Binary, Eq, NFData)
287+
288+-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int
289+data TypeConstructor = ADTypeConstructor TypeConstructorName [TypeConstructorArg] |
290+ PrimitiveTypeConstructor TypeConstructorName AtomType
291+ deriving (Show, Generic, Binary, Eq, NFData)
292+
293+data TypeConstructorArg = TypeConstructorArg TypeConstructor |
294+ TypeConstructorTypeVarArg TypeVarName
295+ deriving (Show, Generic, Binary, Eq, NFData)
296+
297+type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]
298+
299+type TypeConstructorName = StringType
300+type TypeConstructorArgName = StringType
301+type DataConstructorName = StringType
302+type AtomTypeName = StringType
303+
304+-- | Used to define a data constructor in a type constructor context. (Left a | Right b)
305+data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Binary, Generic)
306+
307+type DataConstructorDefs = [DataConstructorDef]
308+
309+data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |
310+ DataConstructorDefTypeVarNameArg TypeVarName
311+ deriving (Show, Generic, Binary, Eq, NFData)
312+
313+type InclusionDependencies = M.Map IncDepName InclusionDependency
314+type RelationVariables = M.Map RelVarName Relation
315+
316+-- | The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time.
317+data DatabaseContext = DatabaseContext {
318+ inclusionDependencies :: InclusionDependencies,
319+ relationVariables :: RelationVariables,
320+ atomFunctions :: AtomFunctions,
321+ notifications :: Notifications,
322+ typeConstructorMapping :: TypeConstructorMapping
323+ } deriving (Show, Generic)
324+
325+type IncDepName = StringType
326+
327+-- | Inclusion dependencies represent every possible database constraints. Constraints enforce specific, arbitrarily-complex rules to which the database context must adhere.
328+data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic)
329+
330+instance Binary InclusionDependency
331+
332+-- | Database context expressions modify the database context.
333+data DatabaseContextExpr =
334+ NoOperation |
335+ Define RelVarName [AttributeExpr] |
336+ Undefine RelVarName | --forget existence of relvar X
337+ Assign RelVarName RelationalExpr |
338+ Insert RelVarName RelationalExpr |
339+ Delete RelVarName RestrictionPredicateExpr |
340+ Update RelVarName (M.Map AttributeName AtomExpr) RestrictionPredicateExpr |
341+
342+ AddInclusionDependency IncDepName InclusionDependency |
343+ RemoveInclusionDependency IncDepName |
344+
345+ AddNotification NotificationName RelationalExpr RelationalExpr |
346+ RemoveNotification NotificationName |
347+
348+ AddTypeConstructor TypeConstructorDef [DataConstructorDef] |
349+ RemoveTypeConstructor TypeConstructorName |
350+
351+ --adding an AtomFunction is not a pure operation (required loading GHC modules)
352+ RemoveAtomFunction AtomFunctionName |
353+
354+ MultipleExpr [DatabaseContextExpr]
355+ deriving (Show, Eq, Binary, Generic)
356+
357+-- | Adding an atom function should be nominally a DatabaseExpr except for the fact that it cannot be performed purely. Thus, we create the DatabaseContextIOExpr.
358+data DatabaseContextIOExpr = AddAtomFunction AtomFunctionName [TypeConstructor] AtomFunctionBodyScript
359+ deriving (Show, Eq, Generic, Binary)
360+
361+type DatabaseState a = State DatabaseContext a
362+
363+-- | Restriction predicate are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.
364+data RestrictionPredicateExpr =
365+ TruePredicate |
366+ AndPredicate RestrictionPredicateExpr RestrictionPredicateExpr |
367+ OrPredicate RestrictionPredicateExpr RestrictionPredicateExpr |
368+ NotPredicate RestrictionPredicateExpr |
369+ RelationalExprPredicate RelationalExpr | --type must be same as true and false relations (no attributes)
370+ AtomExprPredicate AtomExpr | --atom must evaluate to boolean
371+ AttributeEqualityPredicate AttributeName AtomExpr -- relationalexpr must result in relation with single tuple
372+ deriving (Show, Eq, Generic)
373+
374+instance Binary RestrictionPredicateExpr
375+
376+-- child + parent links
377+-- | A transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.
378+type HeadName = StringType
379+
380+type TransactionHeads = M.Map HeadName Transaction
381+
382+-- | The transaction graph is the global database's state which references every committed transaction.
383+data TransactionGraph = TransactionGraph TransactionHeads (S.Set Transaction)
384+ deriving (Show, Eq)
385+
386+transactionsForGraph :: TransactionGraph -> S.Set Transaction
387+transactionsForGraph (TransactionGraph _ t) = t
388+
389+transactionHeadsForGraph :: TransactionGraph -> TransactionHeads
390+transactionHeadsForGraph (TransactionGraph heads _) = heads
391+
392+-- | Every transaction has context-specific information attached to it.
393+data TransactionInfo = TransactionInfo TransactionId (S.Set TransactionId) | -- 1 parent + n children
394+ MergeTransactionInfo TransactionId TransactionId (S.Set TransactionId) -- 2 parents, n children
395+ deriving(Show, Generic)
396+
397+instance Binary TransactionInfo
398+
399+-- | Every set of modifications made to the database are atomically committed to the transaction graph as a transaction.
400+type TransactionId = UUID
401+
402+data Transaction = Transaction TransactionId TransactionInfo DatabaseContext -- self uuid
403+ deriving (Show, Generic)
404+
405+--instance Binary Transaction
406+
407+-- | The disconnected transaction represents an in-progress workspace used by sessions before changes are committed. This is similar to git's "index". After a transaction is committed, it is "connected" in the transaction graph and can no longer be modified.
408+data DisconnectedTransaction = DisconnectedTransaction TransactionId DatabaseContext --parentID, context
409+
410+transactionId :: Transaction -> TransactionId
411+transactionId (Transaction tid _ _) = tid
412+
413+transactionContext :: Transaction -> DatabaseContext
414+transactionContext (Transaction _ _ context) = context
415+
416+transactionInfo :: Transaction -> TransactionInfo
417+transactionInfo (Transaction _ info _) = info
418+
419+instance Eq Transaction where
420+ (Transaction uuidA _ _) == (Transaction uuidB _ _) = uuidA == uuidB
421+
422+instance Ord Transaction where
423+ compare (Transaction uuidA _ _) (Transaction uuidB _ _) = compare uuidA uuidB
424+
425+-- | An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.
426+data AtomExpr = AttributeAtomExpr AttributeName |
427+ NakedAtomExpr Atom |
428+ FunctionAtomExpr AtomFunctionName [AtomExpr] |
429+ RelationAtomExpr RelationalExpr |
430+ ConstructedAtomExpr DataConstructorName [AtomExpr]
431+ deriving (Eq,Show,Generic)
432+
433+instance Binary AtomExpr
434+
435+-- | Used in tuple creation when creating a relation.
436+data ExtendTupleExpr = AttributeExtendTupleExpr AttributeName AtomExpr
437+ deriving (Show, Eq, Binary, Generic)
438+
439+--enumerates the list of functions available to be run as part of tuple expressions
440+type AtomFunctions = HS.HashSet AtomFunction
441+
442+type AtomFunctionName = StringType
443+
444+type AtomFunctionBodyScript = StringType
445+
446+type AtomFunctionBodyType = [Atom] -> Atom
447+
448+data AtomFunctionBody = AtomFunctionBody (Maybe AtomFunctionBodyScript) AtomFunctionBodyType
449+
450+instance Show AtomFunctionBody where
451+ show (AtomFunctionBody mScript _) = case mScript of
452+ Just script -> show (unpack script)
453+ Nothing -> "<compiled>"
454+
455+-- | An AtomFunction has a name, a type, and a function body to execute when called.
456+data AtomFunction = AtomFunction {
457+ atomFuncName :: AtomFunctionName,
458+ atomFuncType :: [AtomType],
459+ atomFuncBody :: AtomFunctionBody
460+ }
461+
462+instance Hashable AtomFunction where
463+ hashWithSalt salt func = salt `hashWithSalt` (atomFuncName func)
464+
465+instance Eq AtomFunction where
466+ f1 == f2 = let (AtomFunctionBody mScript1 _) = atomFuncBody f1
467+ (AtomFunctionBody mScript2 _) = atomFuncBody f2 in
468+ if atomFuncName f1 == atomFuncName f2 then
469+ if isJust mScript1 then
470+ if mScript1 == mScript2 then
471+ True
472+ else
473+ False
474+ else
475+ True
476+ else
477+ False
478+
479+instance Show AtomFunction where
480+ show aFunc = unpack (atomFuncName aFunc) ++ "::" ++ showArgTypes ++ "; " ++ body
481+ where
482+ body = show (atomFuncBody aFunc)
483+ showArgTypes = concat (L.intersperse "->" $ map show (atomFuncType aFunc))
484+
485+-- | The 'AttributeNames' structure represents a set of attribute names or the same set of names but inverted in the context of a relational expression. For example, if a relational expression has attributes named "a", "b", and "c", the 'InvertedAttributeNames' of ("a","c") is ("b").
486+data AttributeNames = AttributeNames (S.Set AttributeName) |
487+ InvertedAttributeNames (S.Set AttributeName)
488+ deriving (Eq, Show, Generic)
489+
490+instance Binary AttributeNames
491+
492+-- | The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.
493+data PersistenceStrategy = NoPersistence | -- ^ no filesystem persistence/memory-only database
494+ MinimalPersistence FilePath | -- ^ fsync off, not crash-safe
495+ CrashSafePersistence FilePath -- ^ full fsync to disk (flushes kernel and physical drive buffers to ensure that the transaction is on non-volatile storage)
496+ deriving (Show, Read)
497+
498+data AttributeExpr = AttributeAndTypeNameExpr AttributeName TypeConstructor |
499+ NakedAttributeExpr Attribute
500+ deriving (Eq, Show, Generic, Binary)
501+
502+data TupleExpr = TupleExpr (M.Map AttributeName AtomExpr)
503+ deriving (Eq, Show, Generic, Binary)
504+
505+data MergeStrategy =
506+ -- | After a union merge, the merge transaction is a result of union'ing relvars of the same name, introducing all uniquely-named relvars, union of constraints, union of atom functions, notifications, and types (unless the names and definitions collide, e.g. two types of the same name with different definitions)
507+ UnionMergeStrategy |
508+ -- | Similar to a union merge, but, on conflict, prefer the unmerged section (relvar, function, etc.) from the branch named as the argument.
509+ UnionPreferMergeStrategy HeadName |
510+ -- | Similar to the our/theirs merge strategy in git, the merge transaction's context is identical to that of the last transaction in the selected branch.
511+ SelectedBranchMergeStrategy HeadName
512+ deriving (Eq, Show, Binary, Generic, NFData)
ProjectM36/Client.hsnew file+557
@@ -0,0 +1,557 @@
1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}
2+module ProjectM36.Client
3+ (ConnectionInfo(..),
4+ Connection(..),
5+ Port,
6+ Hostname,
7+ DatabaseName,
8+ ConnectionError,
9+ connectProjectM36,
10+ close,
11+ executeRelationalExpr,
12+ executeDatabaseContextExpr,
13+ executeDatabaseContextIOExpr,
14+ executeGraphExpr,
15+ commit,
16+ rollback,
17+ typeForRelationalExpr,
18+ inclusionDependencies,
19+ planForDatabaseContextExpr,
20+ processPersistence,
21+ transactionGraphAsRelation,
22+ relationVariablesAsRelation,
23+ headName,
24+ remoteDBLookupName,
25+ defaultServerPort,
26+ headTransactionId,
27+ defaultDatabaseName,
28+ defaultRemoteConnectionInfo,
29+ defaultHeadName,
30+ PersistenceStrategy(..),
31+ RelationalExpr(..),
32+ DatabaseContextExpr(..),
33+ Attribute(..),
34+ attributesFromList,
35+ createNodeId,
36+ createSessionAtCommit,
37+ createSessionAtHead,
38+ closeSession,
39+ addClientNode,
40+ RelationCardinality(..),
41+ TransactionGraphOperator(..),
42+ Atomable,
43+ NodeId(..),
44+ Atom(..),
45+ Session,
46+ SessionId,
47+ NotificationCallback,
48+ emptyNotificationCallback,
49+ EvaluatedNotification(..),
50+ atomTypesAsRelation,
51+ AttributeExpr(..),
52+ TypeConstructor(..),
53+ AtomType(..)) where
54+import ProjectM36.Base hiding (inclusionDependencies) --defined in this module as well
55+import qualified ProjectM36.Base as B
56+import ProjectM36.Error
57+import ProjectM36.StaticOptimizer
58+import Control.Monad.State
59+import qualified ProjectM36.RelationalExpression as RE
60+import ProjectM36.DatabaseContext (basicDatabaseContext)
61+import ProjectM36.TransactionGraph
62+import ProjectM36.TransactionGraph.Persist
63+import ProjectM36.Attribute hiding (atomTypes)
64+import ProjectM36.Persist (DiskSync(..))
65+import ProjectM36.Notifications
66+import ProjectM36.Server.RemoteCallTypes
67+import ProjectM36.Relation (typesAsRelation)
68+import ProjectM36.AtomFunctionBody (initScriptSession, ScriptSession)
69+import qualified ProjectM36.Relation as R
70+import Network.Transport.TCP (createTransport, defaultTCPParameters, encodeEndPointAddress)
71+import Control.Distributed.Process.Node (newLocalNode, initRemoteTable, runProcess, LocalNode, forkProcess)
72+import Control.Distributed.Process.Extras.Internal.Types (whereisRemote)
73+import Control.Distributed.Process.ManagedProcess.Client (call, safeCall)
74+import Control.Distributed.Process (NodeId(..))
75+
76+import Data.UUID.V4 (nextRandom)
77+import Control.Concurrent.STM
78+import Data.Word
79+import Control.Distributed.Process (ProcessId, Process, receiveWait, send, match)
80+import Control.Exception (IOException)
81+import Control.Concurrent.MVar
82+import qualified Data.Map as M
83+import Control.Distributed.Process.Serializable (Serializable)
84+--import Control.Distributed.Process.Debug
85+import qualified STMContainers.Map as STMMap
86+import qualified STMContainers.Set as STMSet
87+import ProjectM36.Session
88+import ProjectM36.Sessions
89+import ListT
90+import Data.Binary (Binary)
91+import GHC.Generics (Generic)
92+--import Debug.Trace
93+
94+type Hostname = String
95+
96+type Port = Word16
97+
98+type DatabaseName = String
99+
100+-- | The type for notifications callbacks in the client. When a registered notification fires due to a changed relational expression evaluation, the server propagates the notifications to the clients in the form of the callback.
101+type NotificationCallback = NotificationName -> EvaluatedNotification -> IO ()
102+
103+-- | The empty notification callback ignores all callbacks.
104+emptyNotificationCallback :: NotificationCallback
105+emptyNotificationCallback _ _ = pure ()
106+
107+-- | Construct a 'ConnectionInfo' to describe how to make the 'Connection'.
108+data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCallback |
109+ RemoteProcessConnectionInfo DatabaseName NodeId NotificationCallback
110+
111+type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification
112+
113+-- | Used for callbacks from the server when monitored changes have been made.
114+data NotificationMessage = NotificationMessage EvaluatedNotifications
115+ deriving (Binary, Eq, Show, Generic)
116+
117+-- | When a notification is fired, the 'reportExpr' is evaluated in the commit's context, so that is returned along with the original notification.
118+data EvaluatedNotification = EvaluatedNotification {
119+ notification :: Notification,
120+ reportRelation :: Either RelationalError Relation
121+ }
122+ deriving(Binary, Eq, Show, Generic)
123+
124+createNodeId :: Hostname -> Port -> NodeId
125+createNodeId host port = NodeId $ encodeEndPointAddress host (show port) 0
126+
127+defaultServerPort :: Port
128+defaultServerPort = 6543
129+
130+defaultDatabaseName :: DatabaseName
131+defaultDatabaseName = "base"
132+
133+defaultHeadName :: HeadName
134+defaultHeadName = "master"
135+
136+defaultRemoteConnectionInfo :: ConnectionInfo
137+defaultRemoteConnectionInfo = RemoteProcessConnectionInfo defaultDatabaseName (createNodeId "127.0.0.1" defaultServerPort) emptyNotificationCallback
138+
139+-- | The 'Connection' represents either local or remote access to a database. All operations flow through the connection.
140+type ClientNodes = STMSet.Set ProcessId
141+
142+data Connection = InProcessConnection PersistenceStrategy ClientNodes Sessions (TVar TransactionGraph) ScriptSession |
143+ RemoteProcessConnection LocalNode ProcessId
144+
145+-- | There are several reasons why a connection can fail.
146+data ConnectionError = SetupDatabaseDirectoryError PersistenceError |
147+ IOExceptionError IOException |
148+ NoSuchDatabaseByNameError DatabaseName |
149+ LoginError
150+ deriving (Show, Eq, Generic)
151+
152+remoteDBLookupName :: DatabaseName -> String
153+remoteDBLookupName = (++) "db-"
154+
155+
156+commonLocalNode :: IO (Either ConnectionError LocalNode)
157+commonLocalNode = do
158+ eLocalTransport <- createTransport "127.0.0.1" "0" defaultTCPParameters
159+ case eLocalTransport of
160+ Left err -> pure (Left $ IOExceptionError err)
161+ Right localTransport -> newLocalNode localTransport initRemoteTable >>= pure . Right
162+
163+notificationListener :: NotificationCallback -> Process ()
164+notificationListener callback = do
165+ --pid <- getSelfPid
166+ --liftIO $ putStrLn $ "LISTENER THREAD START " ++ show pid
167+ _ <- forever $ do
168+ receiveWait [
169+ match (\(NotificationMessage eNots) -> do
170+ --say $ "NOTIFICATION: " ++ show eNots
171+ liftIO $ mapM_ (uncurry callback) (M.toList eNots)
172+ )
173+ ]
174+ --say "LISTENER THREAD EXIT"
175+ pure ()
176+
177+startNotificationListener :: NotificationCallback -> IO (ProcessId)
178+startNotificationListener callback = do
179+ eLocalNode <- commonLocalNode
180+ case eLocalNode of
181+ Left err -> error ("Failed to start local notification listener: " ++ show err)
182+ Right localNode -> forkProcess localNode (notificationListener callback)
183+
184+-- | To create a 'Connection' to a remote or local database, create a connectionInfo and call 'connectProjectM36'.
185+connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)
186+--create a new in-memory database/transaction graph
187+connectProjectM36 (InProcessConnectionInfo strat notificationCallback) = do
188+ freshId <- nextRandom
189+ let bootstrapContext = basicDatabaseContext
190+ freshGraph = bootstrapTransactionGraph freshId bootstrapContext
191+ case strat of
192+ --create date examples graph for now- probably should be empty context in the future
193+ NoPersistence -> do
194+ graphTvar <- newTVarIO freshGraph
195+ clientNodes <- STMSet.newIO
196+ sessions <- STMMap.newIO
197+ notificationPid <- startNotificationListener notificationCallback
198+ interpreterSession <- initScriptSession
199+ let conn = InProcessConnection strat clientNodes sessions graphTvar interpreterSession
200+ addClientNode conn notificationPid
201+ pure (Right conn)
202+ MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback
203+ CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback
204+
205+connectProjectM36 (RemoteProcessConnectionInfo databaseName serverNodeId notificationCallback) = do
206+ connStatus <- newEmptyMVar
207+ eLocalNode <- commonLocalNode
208+ notificationListenerPid <- startNotificationListener notificationCallback
209+ let dbName = remoteDBLookupName databaseName
210+ putStrLn $ show serverNodeId ++ " " ++ dbName
211+ case eLocalNode of
212+ Left err -> pure (Left err)
213+ Right localNode -> do
214+ runProcess localNode $ do
215+ mServerProcessId <- whereisRemote serverNodeId dbName
216+ case mServerProcessId of
217+ Nothing -> liftIO $ putMVar connStatus $ Left (NoSuchDatabaseByNameError databaseName)
218+ Just serverProcessId -> do
219+ loginConfirmation <- call serverProcessId (Login notificationListenerPid)
220+ if not loginConfirmation then
221+ liftIO $ putMVar connStatus (Left LoginError)
222+ else do
223+ liftIO $ putMVar connStatus (Right $ RemoteProcessConnection localNode serverProcessId)
224+ status <- takeMVar connStatus
225+ pure status
226+
227+connectPersistentProjectM36 :: PersistenceStrategy ->
228+ DiskSync ->
229+ FilePath ->
230+ TransactionGraph ->
231+ NotificationCallback ->
232+ IO (Either ConnectionError Connection)
233+connectPersistentProjectM36 strat sync dbdir freshGraph notificationCallback = do
234+ err <- setupDatabaseDir sync dbdir freshGraph
235+ case err of
236+ Just err' -> return $ Left (SetupDatabaseDirectoryError err')
237+ Nothing -> do
238+ graph <- transactionGraphLoad dbdir emptyTransactionGraph
239+ case graph of
240+ Left err' -> return $ Left (SetupDatabaseDirectoryError err')
241+ Right graph' -> do
242+ tvarGraph <- newTVarIO graph'
243+ sessions <- STMMap.newIO
244+ clientNodes <- STMSet.newIO
245+ scriptSession <- initScriptSession
246+ let conn = InProcessConnection strat clientNodes sessions tvarGraph scriptSession
247+ notificationPid <- startNotificationListener notificationCallback
248+ addClientNode conn notificationPid
249+ pure (Right conn)
250+
251+-- | Create a new session at the transaction id and return the session's Id.
252+createSessionAtCommit :: TransactionId -> Connection -> IO (Either RelationalError SessionId)
253+createSessionAtCommit commitId conn@(InProcessConnection _ _ _ _ _) = do
254+ newSessionId <- nextRandom
255+ atomically $ do
256+ createSessionAtCommit_ commitId newSessionId conn
257+createSessionAtCommit uuid conn@(RemoteProcessConnection _ _) = remoteCall conn (CreateSessionAtCommit uuid)
258+
259+createSessionAtCommit_ :: TransactionId -> SessionId -> Connection -> STM (Either RelationalError SessionId)
260+createSessionAtCommit_ commitId newSessionId (InProcessConnection _ _ sessions graphTvar _) = do
261+ graph <- readTVar graphTvar
262+ case transactionForId commitId graph of
263+ Left err -> pure (Left err)
264+ Right transaction -> do
265+ let freshDiscon = DisconnectedTransaction commitId (transactionContext transaction)
266+ keyDuplication <- STMMap.lookup newSessionId sessions
267+ case keyDuplication of
268+ Just _ -> pure $ Left (SessionIdInUseError newSessionId)
269+ Nothing -> do
270+ STMMap.insert (Session freshDiscon) newSessionId sessions
271+ pure $ Right newSessionId
272+createSessionAtCommit_ _ _ (RemoteProcessConnection _ _) = error "createSessionAtCommit_ called on remote connection"
273+
274+-- | Call 'createSessionAtHead' with a transaction graph's head's name to create a new session pinned to that head. This function returns a 'SessionId' which can be used in other function calls to reference the point in the transaction graph.
275+createSessionAtHead :: HeadName -> Connection -> IO (Either RelationalError SessionId)
276+createSessionAtHead headn conn@(InProcessConnection _ _ _ graphTvar _) = do
277+ newSessionId <- nextRandom
278+ atomically $ do
279+ graph <- readTVar graphTvar
280+ case transactionForHead headn graph of
281+ Nothing -> pure $ Left (NoSuchHeadNameError headn)
282+ Just trans -> createSessionAtCommit_ (transactionId trans) newSessionId conn
283+createSessionAtHead headn conn@(RemoteProcessConnection _ _) = remoteCall conn (CreateSessionAtHead headn)
284+
285+-- | Used internally for server connections to keep track of remote nodes for the purpose of sending notifications later.
286+addClientNode :: Connection -> ProcessId -> IO ()
287+addClientNode (RemoteProcessConnection _ _) _ = error "addClientNode called on remote connection"
288+addClientNode (InProcessConnection _ clientNodes _ _ _) newProcessId = atomically (STMSet.insert newProcessId clientNodes)
289+
290+-- | Discards a session, eliminating any uncommitted changes present in the session.
291+closeSession :: SessionId -> Connection -> IO ()
292+closeSession sessionId (InProcessConnection _ _ sessions _ _) = do
293+ atomically $ STMMap.delete sessionId sessions
294+closeSession sessionId conn@(RemoteProcessConnection _ _) = remoteCall conn (CloseSession sessionId)
295+-- | 'close' cleans up the database access connection. Note that sessions persist even after the connection is closed.
296+close :: Connection -> IO ()
297+close (InProcessConnection _ _ sessions _ _) = atomically $ do
298+ traverse_ (\(k,_) -> STMMap.delete k sessions) (STMMap.stream sessions)
299+ pure ()
300+
301+close (RemoteProcessConnection localNode serverProcessId) = do
302+ runProcessResult localNode $ do
303+ call serverProcessId Logout
304+
305+runProcessResult :: LocalNode -> Process a -> IO a
306+runProcessResult localNode proc = do
307+ ret <- newEmptyMVar
308+ runProcess localNode $ do
309+ val <- proc
310+ liftIO $ putMVar ret val
311+ takeMVar ret
312+
313+remoteCall :: (Serializable a, Serializable b) => Connection -> a -> IO b
314+remoteCall (InProcessConnection _ _ _ _ _) _ = error "remoteCall called on local connection"
315+remoteCall (RemoteProcessConnection localNode serverProcessId) arg = runProcessResult localNode $ do
316+ ret <- safeCall serverProcessId arg
317+ case ret of
318+ Left err -> error (show err)
319+ Right ret' -> pure ret'
320+
321+sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)
322+sessionForSessionId sessionId sessions = do
323+ maybeSession <- STMMap.lookup sessionId sessions
324+ pure $ maybe (Left $ NoSuchSessionError sessionId) Right maybeSession
325+
326+-- | Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.
327+executeRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)
328+executeRelationalExpr sessionId (InProcessConnection _ _ sessions _ _) expr = atomically $ do
329+ eSession <- sessionForSessionId sessionId sessions
330+ case eSession of
331+ Left err -> pure $ Left err
332+ Right (Session (DisconnectedTransaction _ context)) -> pure $ evalState (RE.evalRelationalExpr expr) context
333+executeRelationalExpr sessionId conn@(RemoteProcessConnection _ _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)
334+
335+-- | Execute a database context expression in the context of the session and connection. Database expressions modify the current session's disconnected transaction but cannot modify the transaction graph.
336+executeDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Maybe RelationalError)
337+executeDatabaseContextExpr sessionId (InProcessConnection _ _ sessions _ _) expr = atomically $ do
338+ eSession <- sessionForSessionId sessionId sessions
339+ case eSession of
340+ Left err -> pure $ Just err
341+ Right session -> case runState (RE.evalContextExpr expr) (sessionContext session) of
342+ (Just err,_) -> return $ Just err
343+ (Nothing, context') -> do
344+ let newDiscon = DisconnectedTransaction (sessionParentId session) context'
345+ newSession = Session newDiscon
346+ STMMap.insert newSession sessionId sessions
347+ return Nothing
348+executeDatabaseContextExpr sessionId conn@(RemoteProcessConnection _ _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)
349+
350+-- | Execute a database context IO-monad-based expression for the given session and connection. `DatabaseContextIOExpr` modify the DatabaseContext but cannot be purely implemented.
351+--this is almost completely identical to executeDatabaseContextExpr above
352+executeDatabaseContextIOExpr :: SessionId -> Connection -> DatabaseContextIOExpr -> IO (Maybe RelationalError)
353+executeDatabaseContextIOExpr sessionId (InProcessConnection _ _ sessions _ scriptSession) expr = do
354+ eSession <- atomically $ sessionForSessionId sessionId sessions --potentially race condition due to interleaved IO?
355+ case eSession of
356+ Left err -> pure $ Just err
357+ Right session -> do
358+ res <- RE.evalDatabaseContextIOExpr scriptSession (sessionContext session) expr
359+ case res of
360+ Left err -> pure (Just err)
361+ Right context' -> do
362+ let newDiscon = DisconnectedTransaction (sessionParentId session) context'
363+ newSession = Session newDiscon
364+ atomically $ STMMap.insert newSession sessionId sessions
365+ pure Nothing
366+executeDatabaseContextIOExpr sessionId conn@(RemoteProcessConnection _ _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)
367+
368+executeGraphExprSTM_ :: TransactionId -> SessionId -> Sessions -> TransactionGraphOperator -> TVar TransactionGraph -> STM (Either RelationalError TransactionGraph)
369+executeGraphExprSTM_ freshId sessionId sessions graphExpr graphTvar = do
370+ graph <- readTVar graphTvar
371+ eSession <- sessionForSessionId sessionId sessions
372+ case eSession of
373+ Left err -> pure $ Left err
374+ Right (Session discon) -> case evalGraphOp freshId discon graph graphExpr of
375+ Left err -> pure $ Left err
376+ Right (discon', graph') -> do
377+ writeTVar graphTvar graph'
378+ let newSession = Session discon'
379+ STMMap.insert newSession sessionId sessions
380+ pure $ Right graph'
381+
382+-- process notifications for commits
383+executeCommitExprSTM_ :: DatabaseContext -> DatabaseContext -> ClientNodes -> STM (EvaluatedNotifications, ClientNodes)
384+executeCommitExprSTM_ oldContext newContext nodes = do
385+ let nots = notifications oldContext
386+ fireNots = notificationChanges nots oldContext newContext
387+ evaldNots = M.map mkEvaldNot fireNots
388+ mkEvaldNot notif = EvaluatedNotification { notification = notif, reportRelation = evalState (RE.evalRelationalExpr (reportExpr notif)) oldContext }
389+ pure (evaldNots, nodes)
390+
391+
392+-- | Execute a transaction graph expression in the context of the session and connection. Transaction graph operators modify the transaction graph state.
393+executeGraphExpr :: SessionId -> Connection -> TransactionGraphOperator -> IO (Maybe RelationalError)
394+executeGraphExpr sessionId (InProcessConnection strat clientNodes sessions graphTvar _) graphExpr = do
395+ freshId <- nextRandom
396+ manip <- atomically $ do
397+ eSession <- sessionForSessionId sessionId sessions
398+ oldGraph <- readTVar graphTvar
399+ case eSession of
400+ Left err -> pure (Left err)
401+ Right (Session (DisconnectedTransaction parentId currentContext)) -> do
402+ eGraph <- executeGraphExprSTM_ freshId sessionId sessions graphExpr graphTvar
403+ case eGraph of
404+ Left err -> pure (Left err)
405+ Right newGraph -> do
406+ if graphExpr == Commit then
407+ case transactionForId parentId oldGraph of
408+ Left err -> pure $ Left err
409+ Right (Transaction _ _ previousContext) -> do
410+ (evaldNots, nodes) <- executeCommitExprSTM_ previousContext currentContext clientNodes
411+ nodesToNotify <- toList (STMSet.stream nodes)
412+ pure $ Right (evaldNots, nodesToNotify, newGraph)
413+ else
414+ pure $ Right (M.empty, [], newGraph)
415+ case manip of
416+ Left err -> return $ Just err
417+ Right (notsToFire, nodesToNotify, newGraph) -> do
418+ --update filesystem database, if necessary
419+ --this should really grab a lock at the beginning of the method to be threadsafe
420+ processPersistence strat newGraph
421+ sendNotifications nodesToNotify notsToFire
422+ return Nothing
423+executeGraphExpr sessionId conn@(RemoteProcessConnection _ _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)
424+
425+{-
426+commitSTM_ :: UUID -> SessionId -> Sessions -> TVar TransactionGraph -> STM (Maybe RelationalError)
427+commitSTM_ freshUUID sessionId sessions graph = do
428+ mErr <- executeGraphExprSTM_ freshUUID sessionId sessions Commit graph
429+ pure $ case mErr of
430+ Left err -> Just err
431+ Right _ -> Nothing
432+-}
433+
434+-- | After modifying a session, 'commit' the transaction to the transaction graph at the head which the session is referencing. This will also trigger checks for any notifications which need to be propagated.
435+commit :: SessionId -> Connection -> IO (Maybe RelationalError)
436+commit sessionId conn@(InProcessConnection _ _ _ _ _) = executeGraphExpr sessionId conn Commit
437+commit sessionId conn@(RemoteProcessConnection _ _) = remoteCall conn (ExecuteGraphExpr sessionId Commit)
438+
439+sendNotifications :: [ProcessId] -> EvaluatedNotifications -> IO ()
440+sendNotifications pids nots = mapM_ sendNots pids
441+ where
442+ sendNots remoteClientPid = do
443+ eLocalNode <- commonLocalNode
444+ case eLocalNode of
445+ Left err -> error ("Failed to get local node: " ++ show err)
446+ Right localNode -> when (not (M.null nots)) $ runProcess localNode $ send remoteClientPid (NotificationMessage nots)
447+
448+-- | Discard any changes made in the current session. This resets the disconnected transaction to reference the original database context of the parent transaction and is a very cheap operation.
449+rollback :: SessionId -> Connection -> IO (Maybe RelationalError)
450+rollback sessionId conn@(InProcessConnection _ _ _ _ _) = executeGraphExpr sessionId conn Rollback
451+rollback sessionId conn@(RemoteProcessConnection _ _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)
452+
453+processPersistence :: PersistenceStrategy -> TransactionGraph -> IO ()
454+processPersistence NoPersistence _ = return ()
455+processPersistence (MinimalPersistence dbdir) graph = transactionGraphPersist NoDiskSync dbdir graph
456+processPersistence (CrashSafePersistence dbdir) graph = transactionGraphPersist FsyncDiskSync dbdir graph
457+
458+-- | Return a relation whose type would match that of the relational expression if it were executed. This is useful for checking types and validating a relational expression's types.
459+typeForRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)
460+typeForRelationalExpr sessionId conn@(InProcessConnection _ _ _ _ _) relExpr = atomically $ typeForRelationalExprSTM sessionId conn relExpr
461+typeForRelationalExpr sessionId conn@(RemoteProcessConnection _ _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)
462+
463+typeForRelationalExprSTM :: SessionId -> Connection -> RelationalExpr -> STM (Either RelationalError Relation)
464+typeForRelationalExprSTM sessionId (InProcessConnection _ _ sessions _ _) relExpr = do
465+ eSession <- sessionForSessionId sessionId sessions
466+ case eSession of
467+ Left err -> pure $ Left err
468+ Right session -> pure $ evalState (RE.typeForRelationalExpr relExpr) (sessionContext session)
469+
470+typeForRelationalExprSTM _ _ _ = error "typeForRelationalExprSTM called on non-local connection"
471+
472+-- | Return a 'Map' of the database's constraints at the context of the session and connection.
473+inclusionDependencies :: SessionId -> Connection -> IO (Either RelationalError (M.Map IncDepName InclusionDependency))
474+inclusionDependencies sessionId (InProcessConnection _ _ sessions _ _) = do
475+ atomically $ do
476+ eSession <- sessionForSessionId sessionId sessions
477+ case eSession of
478+ Left err -> pure $ Left err
479+ Right session -> pure $ Right (B.inclusionDependencies (sessionContext session))
480+
481+inclusionDependencies sessionId conn@(RemoteProcessConnection _ _) = remoteCall conn (RetrieveInclusionDependencies sessionId)
482+
483+-- | Return an optimized database expression which is logically equivalent to the input database expression. This function can be used to determine which expression will actually be evaluated.
484+planForDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError DatabaseContextExpr)
485+planForDatabaseContextExpr sessionId (InProcessConnection _ _ sessions _ _) dbExpr = do
486+ atomically $ do
487+ eSession <- sessionForSessionId sessionId sessions
488+ case eSession of
489+ Left err -> pure $ Left err
490+ Right session -> pure $ evalState (applyStaticDatabaseOptimization dbExpr) (sessionContext session)
491+planForDatabaseContextExpr sessionId conn@(RemoteProcessConnection _ _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)
492+
493+-- | Return a relation which represents the current state of the global transaction graph. The attributes are
494+-- * current- boolean attribute representing whether or not the current session references this transaction
495+-- * head- text attribute which is a non-empty 'HeadName' iff the transaction references a head.
496+-- * id- id attribute of the transaction
497+-- * parents- a relation-valued attribute which contains a relation of transaction ids which are parent transaction to the transaction
498+transactionGraphAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)
499+transactionGraphAsRelation sessionId (InProcessConnection _ _ sessions tvar _) = do
500+ atomically $ do
501+ eSession <- sessionForSessionId sessionId sessions
502+ case eSession of
503+ Left err -> pure $ Left err
504+ Right (Session discon) -> do
505+ graph <- readTVar tvar
506+ pure $ graphAsRelation discon graph
507+
508+transactionGraphAsRelation sessionId conn@(RemoteProcessConnection _ _) = remoteCall conn (RetrieveTransactionGraph sessionId)
509+
510+relationVariablesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)
511+relationVariablesAsRelation sessionId (InProcessConnection _ _ sessions _ _) = do
512+ atomically $ do
513+ eSession <- sessionForSessionId sessionId sessions
514+ case eSession of
515+ Left err -> pure (Left err)
516+ Right (Session (DisconnectedTransaction _ context)) -> pure $ R.relationVariablesAsRelation (relationVariables context)
517+
518+relationVariablesAsRelation sessionId conn@(RemoteProcessConnection _ _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)
519+
520+-- | Returns the transaction id for the connection's disconnected transaction committed parent transaction.
521+headTransactionId :: SessionId -> Connection -> IO (Maybe TransactionId)
522+headTransactionId sessionId (InProcessConnection _ _ sessions _ _) = do
523+ atomically $ do
524+ eSession <- sessionForSessionId sessionId sessions
525+ case eSession of
526+ Left _ -> pure Nothing
527+ Right session -> pure $ Just (sessionParentId session)
528+headTransactionId sessionId conn@(RemoteProcessConnection _ _) = remoteCall conn (RetrieveHeadTransactionId sessionId)
529+
530+headNameSTM_ :: SessionId -> Sessions -> TVar TransactionGraph -> STM (Maybe HeadName)
531+headNameSTM_ sessionId sessions graphTvar = do
532+ graph <- readTVar graphTvar
533+ eSession <- sessionForSessionId sessionId sessions
534+ case eSession of
535+ Left _ -> pure $ Nothing
536+ Right session -> pure $ case transactionForId (sessionParentId session) graph of
537+ Left _ -> Nothing
538+ Right parentTrans -> headNameForTransaction parentTrans graph
539+
540+-- | Returns Just the name of the head of the current disconnected transaction or Nothing.
541+headName :: SessionId -> Connection -> IO (Maybe HeadName)
542+headName sessionId (InProcessConnection _ _ sessions graphTvar _) = do
543+ atomically (headNameSTM_ sessionId sessions graphTvar)
544+headName sessionId conn@(RemoteProcessConnection _ _) = remoteCall conn (ExecuteHeadName sessionId)
545+
546+atomTypesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)
547+atomTypesAsRelation sessionId (InProcessConnection _ _ sessions _ _) = do
548+ atomically $ do
549+ eSession <- sessionForSessionId sessionId sessions
550+ case eSession of
551+ Left err -> pure (Left err)
552+ Right (Session (DisconnectedTransaction _ context)) -> do
553+ case typesAsRelation (typeConstructorMapping context) of
554+ Left err -> pure (Left err)
555+ Right rel -> pure (Right rel)
556+atomTypesAsRelation sessionId conn@(RemoteProcessConnection _ _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)
557+
src/bin/ProjectM36/Client/Json.hs → ProjectM36/Client/Json.hsrenamed+1−4
@@ -3,7 +3,6 @@ module ProjectM36.Client.Json where
33import Data.Aeson
44import ProjectM36.Server.RemoteCallTypes.Json ()
55import ProjectM36.Client
6−import ProjectM36.TransactionGraph
76import Control.Exception (IOException)
87
98instance ToJSON EvaluatedNotification
@@ -12,6 +11,4 @@ instance FromJSON EvaluatedNotification
1211instance ToJSON ConnectionError
1312
1413instance ToJSON IOException where
15− toJSON err = object ["IOException" .= show err]
16−
17−instance ToJSON MerkleValidationError
14+ toJSON err = object ["IOException" .= show err]
ProjectM36/ConcreteTypeRep.hsnew file+34
@@ -0,0 +1,34 @@
1+{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveGeneric #-}
2+-- adapted from https://hackage.haskell.org/package/concrete-typerep
3+module ProjectM36.ConcreteTypeRep where
4+import Data.Binary
5+import Data.Typeable
6+import Data.Typeable.Internal
7+import Control.DeepSeq (NFData)
8+import GHC.Generics
9+
10+newtype ConcreteTypeRep = CTR { unCTR :: TypeRep } deriving (Eq, Typeable, NFData)
11+
12+newtype SerialRep = SR (TyConRep, [SerialRep]) deriving (Binary, Generic)
13+
14+instance Show ConcreteTypeRep where
15+ show (CTR tRep) = show tRep
16+
17+type TyConRep = (String, String, String)
18+toTyConRep :: TyCon -> TyConRep
19+toTyConRep (TyCon _ pack modul name) = (pack, modul, name)
20+
21+fromTyConRep :: TyConRep -> TyCon
22+fromTyConRep (pack, modul, name) = mkTyCon3 pack modul name
23+
24+toSerial :: ConcreteTypeRep -> SerialRep
25+toSerial (CTR t) = case splitTyConApp t of
26+ (con, args) -> SR (toTyConRep con, map (toSerial . CTR) args)
27+
28+fromSerial :: SerialRep -> ConcreteTypeRep
29+fromSerial (SR (con, args)) = CTR $ mkTyConApp (fromTyConRep con) (map (unCTR . fromSerial) args)
30+
31+instance Binary ConcreteTypeRep where
32+ put = put . toSerial
33+ get = fromSerial <$> get
34+
src/lib/ProjectM36/DataConstructorDef.hs → ProjectM36/DataConstructorDef.hsrenamed+4−4
@@ -1,5 +1,6 @@
11module ProjectM36.DataConstructorDef where
2−import ProjectM36.Base as B
2+import ProjectM36.Base
3+import qualified ProjectM36.TypeConstructor as TC
34import qualified Data.Set as S
45
56emptyDataConstructor :: DataConstructorName -> DataConstructorDef
@@ -15,6 +16,5 @@ typeVars :: DataConstructorDef -> S.Set TypeVarName
1516typeVars (DataConstructorDef _ tConsArgs) = S.unions $ map typeVarsInDefArg tConsArgs
1617
1718typeVarsInDefArg :: DataConstructorDefArg -> S.Set TypeVarName
18−typeVarsInDefArg (DataConstructorDefTypeConstructorArg tCons) = B.typeVars tCons
19−typeVarsInDefArg (DataConstructorDefTypeVarNameArg pVarName) = S.singleton pVarName
20−
19+typeVarsInDefArg (DataConstructorDefTypeConstructorArg tCons) = TC.typeVars tCons
20+typeVarsInDefArg (DataConstructorDefTypeVarNameArg pVarName) = S.singleton pVarName
ProjectM36/DataTypes/Basic.hsnew file+14
@@ -0,0 +1,14 @@
1+-- wraps up primitives plus other basic data types
2+module ProjectM36.DataTypes.Basic where
3+import ProjectM36.DataTypes.Primitive
4+import ProjectM36.DataTypes.Day
5+import ProjectM36.DataTypes.Either
6+import ProjectM36.DataTypes.Maybe
7+import ProjectM36.Base
8+
9+basicTypeConstructorMapping :: TypeConstructorMapping
10+basicTypeConstructorMapping = (primitiveTypeConstructorMapping ++
11+ maybeTypeConstructorMapping ++
12+ eitherTypeConstructorMapping ++
13+ dayTypeConstructorMapping)
14+
ProjectM36/DataTypes/Day.hsnew file+30
@@ -0,0 +1,30 @@
1+module ProjectM36.DataTypes.Day where
2+import ProjectM36.Base
3+import ProjectM36.AtomFunctionBody
4+import ProjectM36.DataTypes.Primitive
5+import ProjectM36.AtomFunctions.Primitive
6+import qualified Data.HashSet as HS
7+import Data.Time.Calendar
8+import qualified Data.Map as M
9+
10+dayAtom :: Day -> Atom
11+dayAtom d = Atom d
12+
13+dayAtomType :: AtomType
14+dayAtomType = ConstructedAtomType "Day" M.empty
15+
16+dayAtomFunctions :: AtomFunctions
17+dayAtomFunctions = HS.fromList [
18+ AtomFunction { atomFuncName = "fromGregorian",
19+ atomFuncType = [intAtomType, intAtomType, intAtomType, dayAtomType],
20+ atomFuncBody = compiledAtomFunctionBody $ \(year:month:day:_) -> ConstructedAtom "Day" dayAtomType [Atom (fromGregorian (fromIntegral (unsafeCast year::Int)) (unsafeCast month) (unsafeCast day))]
21+ },
22+ AtomFunction { atomFuncName = "dayEarlierThan",
23+ atomFuncType = [dayAtomType, dayAtomType, boolAtomType],
24+ atomFuncBody = compiledAtomFunctionBody $ \((ConstructedAtom _ _ (dayA:_)):(ConstructedAtom _ _ (dayB:_)):_) -> Atom (unsafeCast dayA < (unsafeCast dayB :: Day))
25+ }
26+ ]
27+
28+dayTypeConstructorMapping :: TypeConstructorMapping
29+dayTypeConstructorMapping = [(ADTypeConstructorDef "Day" [],
30+ [DataConstructorDef "Day" [DataConstructorDefTypeConstructorArg (PrimitiveTypeConstructor "Int" intAtomType)]])]
src/lib/ProjectM36/DataTypes/Either.hs → ProjectM36/DataTypes/Either.hsrenamed+2−1
@@ -1,5 +1,6 @@
11module ProjectM36.DataTypes.Either where
22import ProjectM36.Base
3+import ProjectM36.DataTypes.Primitive
34import ProjectM36.AtomFunction
45import qualified Data.HashSet as HS
56import qualified Data.Map as M
@@ -14,5 +15,5 @@ eitherTypeConstructorMapping = [(ADTypeConstructorDef "Either" ["a", "b"],
1415
1516eitherAtomFunctions :: AtomFunctions
1617eitherAtomFunctions = HS.fromList [
17− compiledAtomFunction "isLeft" [eitherAtomType (TypeVariableType "a") (TypeVariableType "b"), BoolAtomType] $ \(ConstructedAtom dConsName _ _:_) -> pure (BoolAtom (dConsName == "Left"))
18+ compiledAtomFunction "isLeft" [eitherAtomType AnyAtomType AnyAtomType, boolAtomType] $ \((ConstructedAtom dConsName _ _):_) -> Atom (dConsName == "Left")
1819 ]
ProjectM36/DataTypes/Interval.hsnew file+37
@@ -0,0 +1,37 @@
1+{-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving #-}
2+{-# OPTIONS_GHC -fno-warn-orphans #-}
3+module ProjectM36.DataTypes.Interval where
4+import Data.Interval
5+import ProjectM36.Base hiding (Finite)
6+import Data.Binary
7+import ProjectM36.Atom
8+import Data.Typeable
9+import Data.Time.Clock
10+
11+instance (Atomable a, Ord a) => Atomable (Interval a)
12+
13+instance (Binary a) => Binary (Extended a) where
14+ put ext = case ext of
15+ NegInf -> put (1 :: Int)
16+ PosInf -> put (2 :: Int)
17+ Finite x -> put (3 :: Int) >> put x
18+ get = do
19+ flag <- get :: Get Int
20+ case flag of
21+ 1 -> pure NegInf
22+ 2 -> pure PosInf
23+ 3 -> Finite <$> get
24+ _ -> error "poop"
25+
26+instance (Ord a, Binary a) => Binary (Interval a) where
27+ put interv = put (lowerBound interv) >> put (upperBound interv)
28+ get = interval <$> get <*> get
29+
30+intervalFunctions :: [AtomFunction]
31+intervalFunctions = [AtomFunction { atomFuncName = "interval_dt_member",
32+ atomFuncType = [dateTimeAtomType,
33+ atomTypeForProxy (Proxy :: Proxy (Interval UTCTime)),
34+ boolAtomType],
35+ atomFunc = (\(dt:dtinterval:_) -> Atom $ member ((unsafeCast dt)::UTCTime) ((unsafeCast dtinterval)::(Interval UTCTime)))}
36+
37+ ]
ProjectM36/DataTypes/Maybe.hsnew file+23
@@ -0,0 +1,23 @@
1+module ProjectM36.DataTypes.Maybe where
2+import ProjectM36.Base
3+import ProjectM36.DataTypes.Primitive
4+import qualified Data.HashSet as HS
5+import qualified Data.Map as M
6+
7+maybeAtomType :: AtomType -> AtomType
8+maybeAtomType arg = ConstructedAtomType "Maybe" (M.singleton "a" arg)
9+
10+maybeTypeConstructorMapping :: TypeConstructorMapping
11+maybeTypeConstructorMapping = [(ADTypeConstructorDef "Maybe" ["a"],
12+ [DataConstructorDef "Nothing" [],
13+ DataConstructorDef "Just" [DataConstructorDefTypeVarNameArg "a"]])
14+ ]
15+
16+maybeAtomFunctions :: AtomFunctions
17+maybeAtomFunctions = HS.fromList [
18+ AtomFunction {
19+ atomFuncName ="isJust",
20+ atomFuncType = [maybeAtomType AnyAtomType, boolAtomType],
21+ atomFuncBody = AtomFunctionBody Nothing $ \((ConstructedAtom dConsName _ _):_) -> Atom (dConsName == "Nothing")
22+ }
23+ ]
ProjectM36/DataTypes/Primitive.hsnew file+36
@@ -0,0 +1,36 @@
1+module ProjectM36.DataTypes.Primitive where
2+import ProjectM36.Base
3+import Data.Proxy
4+import Data.Typeable
5+import ProjectM36.ConcreteTypeRep
6+import qualified Data.Text as T
7+import qualified Data.ByteString as BS
8+
9+atomTypeForProxy :: (Atomable a) => Proxy a -> AtomType
10+atomTypeForProxy prox = AtomType $ CTR (typeRep prox)
11+
12+textAtomType :: AtomType
13+textAtomType = atomTypeForProxy (Proxy :: Proxy T.Text)
14+
15+intAtomType :: AtomType
16+intAtomType = atomTypeForProxy (Proxy :: Proxy Int)
17+
18+boolAtomType :: AtomType
19+boolAtomType = atomTypeForProxy (Proxy :: Proxy Bool)
20+
21+doubleAtomType :: AtomType
22+doubleAtomType = atomTypeForProxy (Proxy :: Proxy Double)
23+
24+byteStringAtomType :: AtomType
25+byteStringAtomType = atomTypeForProxy (Proxy :: Proxy BS.ByteString)
26+
27+primitiveTypeConstructorMapping :: TypeConstructorMapping
28+primitiveTypeConstructorMapping = map (\(name, aType) ->
29+ (PrimitiveTypeConstructorDef name aType, [])) prims
30+ where
31+ prims = [("Int", intAtomType),
32+ ("Text", textAtomType),
33+ ("Double", doubleAtomType),
34+ ("Bool", boolAtomType),
35+ ("ByteString", byteStringAtomType)
36+ ]
src/lib/ProjectM36/DatabaseContext.hs → ProjectM36/DatabaseContext.hsrenamed+5−27
@@ -1,54 +1,32 @@
11module ProjectM36.DatabaseContext where
22import ProjectM36.Base
3−import Control.Monad (void)
43import qualified Data.Map as M
54import qualified Data.HashSet as HS
65import ProjectM36.DataTypes.Basic
76import ProjectM36.AtomFunctions.Basic
87import ProjectM36.Relation
9−import qualified Data.ByteString.Lazy as BL
10−import ProjectM36.AtomFunction as AF
11−import ProjectM36.DatabaseContextFunction as DBCF
12−import Codec.Winery
138
149empty :: DatabaseContext
1510empty = DatabaseContext { inclusionDependencies = M.empty,
1611 relationVariables = M.empty,
1712 notifications = M.empty,
1813 atomFunctions = HS.empty,
19− dbcFunctions = HS.empty,
2014 typeConstructorMapping = [] }
21−
22−-- | Remove TransactionId markers on GraphRefRelationalExpr
23−stripGraphRefRelationalExpr :: GraphRefRelationalExpr -> RelationalExpr
24−stripGraphRefRelationalExpr = void
2515
2616-- | convert an existing database context into its constituent expression.
2717databaseContextAsDatabaseContextExpr :: DatabaseContext -> DatabaseContextExpr
2818databaseContextAsDatabaseContextExpr context = MultipleExpr $ relVarsExprs ++ incDepsExprs ++ funcsExprs
2919 where
30− relVarsExprs = map (\(name, rel) -> Assign name (stripGraphRefRelationalExpr rel)) (M.toList (relationVariables context))
20+ relVarsExprs = map (\(name, rel) -> Assign name (ExistingRelation rel)) (M.toList (relationVariables context))
3121 incDepsExprs :: [DatabaseContextExpr]
32− incDepsExprs = map (uncurry AddInclusionDependency) (M.toList (inclusionDependencies context))
33− funcsExprs = [] -- map (\func -> ) (HS.toList funcs) -- there are no databaseExprs to add atom functions yet-}
22+ incDepsExprs = map (\(name, dep) -> AddInclusionDependency name dep) (M.toList (inclusionDependencies context))
23+ funcsExprs = [] -- map (\func -> ) (HS.toList funcs) -- there are no databaseExprs to add atom functions yet
3424
3525basicDatabaseContext :: DatabaseContext
3626basicDatabaseContext = DatabaseContext { inclusionDependencies = M.empty,
37− relationVariables = M.fromList [("true", ExistingRelation relationTrue),
38− ("false", ExistingRelation relationFalse)],
27+ relationVariables = M.fromList [("true", relationTrue),
28+ ("false", relationFalse)],
3929 atomFunctions = basicAtomFunctions,
40− dbcFunctions = basicDatabaseContextFunctions,
4130 notifications = M.empty,
4231 typeConstructorMapping = basicTypeConstructorMapping
4332 }
44−
45−--for building the Merkle hash
46−hashBytes :: DatabaseContext -> BL.ByteString
47−hashBytes ctx = BL.fromChunks [incDeps, rvs, nots, tConsMap] <> atomFs <> dbcFs
48− where
49− incDeps = serialise (inclusionDependencies ctx)
50− rvs = serialise (relationVariables ctx)
51− atomFs = HS.foldr (mappend . AF.hashBytes) mempty (atomFunctions ctx)
52− dbcFs = HS.foldr (mappend . DBCF.hashBytes) mempty (dbcFunctions ctx)
53− nots = serialise (notifications ctx)
54− tConsMap = serialise (typeConstructorMapping ctx)
ProjectM36/DateExamples.hsnew file+89
@@ -0,0 +1,89 @@
1+module ProjectM36.DateExamples where
2+import ProjectM36.Base
3+import ProjectM36.Atom
4+import qualified ProjectM36.Attribute as A
5+import ProjectM36.Key
6+import ProjectM36.AtomFunctions.Basic
7+import ProjectM36.DataTypes.Basic
8+import ProjectM36.DatabaseContext
9+import ProjectM36.DataTypes.Primitive
10+import ProjectM36.Relation
11+import qualified Data.Map as M
12+import qualified Data.Set as S
13+
14+dateExamples :: DatabaseContext
15+dateExamples = DatabaseContext { inclusionDependencies = dateIncDeps,
16+ relationVariables = M.union (relationVariables basicDatabaseContext) dateRelVars,
17+ notifications = M.empty,
18+ atomFunctions = basicAtomFunctions,
19+ typeConstructorMapping = basicTypeConstructorMapping }
20+ where -- these must be lower case now that data constructors are in play
21+ dateRelVars = M.fromList [("s", suppliers),
22+ ("p", products),
23+ ("sp", supplierProducts)]
24+ suppliers = suppliersRel
25+ products = productsRel
26+ supplierProducts = supplierProductsRel
27+ dateIncDeps = M.fromList [("s_pkey", simplePKey ["s#"] "s"),
28+ ("p_pkey", simplePKey ["p#"] "p"),
29+ ("sp_pkey", simplePKey ["s#", "p#"] "sp")
30+ ]
31+ simplePKey attrNames relvarName = inclusionDependencyForKey (AttributeNames $ S.fromList attrNames) (RelationVariable relvarName)
32+
33+suppliersRel :: Relation
34+suppliersRel = case mkRelationFromList attrs atomMatrix of
35+ Left _ -> undefined
36+ Right rel -> rel
37+ where
38+ attrs = A.attributesFromList [Attribute "s#" textAtomType,
39+ Attribute "sname" textAtomType,
40+ Attribute "status" intAtomType,
41+ Attribute "city" textAtomType]
42+ atomMatrix = [
43+ [textAtom "S1", textAtom "Smith", intAtom 20, textAtom "London"],
44+ [textAtom "S2", textAtom "Jones", intAtom 10, textAtom "Paris"],
45+ [textAtom "S3", textAtom "Blake", intAtom 30, textAtom "Paris"],
46+ [textAtom "S4", textAtom "Clark", intAtom 20, textAtom "London"],
47+ [textAtom "S5", textAtom "Adams", intAtom 30, textAtom "Athens"]]
48+
49+supplierProductsRel :: Relation
50+supplierProductsRel = case mkRelationFromList attrs matrix of
51+ Left _ -> undefined
52+ Right rel -> rel
53+ where
54+ attrs = A.attributesFromList [Attribute "s#" textAtomType,
55+ Attribute "p#" textAtomType,
56+ Attribute "qty" intAtomType]
57+ matrix = [
58+ [textAtom "S1", textAtom "P1", intAtom 300],
59+ [textAtom "S1", textAtom "P2", intAtom 200],
60+ [textAtom "S1", textAtom "P3", intAtom 400],
61+ [textAtom "S1", textAtom "P4", intAtom 200],
62+ [textAtom "S1", textAtom "P5", intAtom 100],
63+ [textAtom "S1", textAtom "P6", intAtom 100],
64+ [textAtom "S2", textAtom "P1", intAtom 300],
65+ [textAtom "S2", textAtom "P2", intAtom 400],
66+ [textAtom "S3", textAtom "P2", intAtom 200],
67+ [textAtom "S4", textAtom "P2", intAtom 200],
68+ [textAtom "S4", textAtom "P4", intAtom 300],
69+ [textAtom "S4", textAtom "P5", intAtom 400]
70+ ]
71+
72+productsRel :: Relation
73+productsRel = case mkRelationFromList attrs matrix of
74+ Left _ -> undefined
75+ Right rel -> rel
76+ where
77+ attrs = A.attributesFromList [Attribute "p#" textAtomType,
78+ Attribute "pname" textAtomType,
79+ Attribute "color" textAtomType,
80+ Attribute "weight" intAtomType,
81+ Attribute "city" textAtomType]
82+ matrix = [
83+ [textAtom "P1", textAtom "Nut", textAtom "Red", intAtom 12, textAtom "London"],
84+ [textAtom "P2", textAtom "Bolt", textAtom "Green", intAtom 17, textAtom "Paris"],
85+ [textAtom "P3", textAtom "Screw", textAtom "Blue", intAtom 17, textAtom "Oslo"],
86+ [textAtom "P4", textAtom "Screw", textAtom "Red", intAtom 14, textAtom "London"],
87+ [textAtom "P5", textAtom "Cam", textAtom "Blue", intAtom 12, textAtom "Paris"],
88+ [textAtom "P6", textAtom "Cog", textAtom "Red", intAtom 19, textAtom "London"]
89+ ]
cbits/DirectoryFsync.c → ProjectM36/DirectoryFsync.crenamed−3
@@ -24,13 +24,11 @@ int cDirectoryFsync(char *path)
2424 ret = fstat(fd,&fdstat);
2525 if(ret < 0)
2626 {
27− close(fd);
2827 return errno;
2928 }
3029
3130 if(!S_ISDIR(fdstat.st_mode))
3231 {
33− close(fd);
3432 return ENOTDIR;
3533 }
3634
@@ -41,7 +39,6 @@ int cDirectoryFsync(char *path)
4139#else
4240 ret = fsync(fd);
4341#endif
44− close(fd);
4542 if(ret < 0)
4643 {
4744 return errno;
src/lib/ProjectM36/Error.hs → ProjectM36/Error.hsrenamed+18−67
@@ -1,21 +1,16 @@
11{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}
22module ProjectM36.Error where
33import ProjectM36.Base
4−import ProjectM36.MerkleHash
5−import ProjectM36.DatabaseContextFunctionError
6−import ProjectM36.AtomFunctionError
74import qualified Data.Set as S
85import Control.DeepSeq (NFData, rnf)
96import Control.DeepSeq.Generics (genericRnf)
107import GHC.Generics (Generic)
118import qualified Data.Text as T
9+import Data.Binary
1210import Data.Typeable
13−import Control.Exception
1411
1512data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)
1613 | TupleAttributeCountMismatchError Int --attribute name
17− | EmptyAttributesError
18− | DuplicateAttributeNamesError (S.Set AttributeName)
1914 | TupleAttributeTypeMismatchError Attributes
2015 | AttributeCountMismatchError Int
2116 | AttributeNamesMismatchError (S.Set AttributeName)
@@ -24,7 +19,7 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)
2419 | CouldNotInferAttributes
2520 | RelVarNotDefinedError RelVarName
2621 | RelVarAlreadyDefinedError RelVarName
27− | RelationTypeMismatchError Attributes Attributes --expected, found
22+ | RelVarAssignmentTypeMismatchError Attributes Attributes --expected, found
2823 | InclusionDependencyCheckError IncDepName
2924 | InclusionDependencyNameInUseError IncDepName
3025 | InclusionDependencyNameNotInUseError IncDepName
@@ -35,9 +30,7 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)
3530 | RootTransactionTraversalError
3631 | HeadNameSwitchingHeadProhibitedError HeadName
3732 | NoSuchHeadNameError HeadName
38− | UnknownHeadError
3933 | NewTransactionMayNotHaveChildrenError TransactionId
40− | ParentCountTraversalError Int Int --maximum, requested
4134 | NewTransactionMissingParentError TransactionId
4235 | TransactionIsNotAHeadError TransactionId
4336 | TransactionGraphCycleError TransactionId
@@ -45,7 +38,7 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)
4538 | NoSuchSessionError TransactionId
4639 | FailedToFindTransactionError TransactionId
4740 | TransactionIdInUseError TransactionId
48− | NoSuchFunctionError AtomFunctionName
41+ | NoSuchTupleExprFunctionError AtomFunctionName
4942 | NoSuchTypeConstructorName TypeConstructorName
5043 | TypeConstructorAtomTypeMismatch TypeConstructorName AtomType
5144 | AtomTypeMismatchError AtomType AtomType
@@ -57,17 +50,11 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)
5750 | TypeConstructorTypeVarMissing TypeVarName
5851 | TypeConstructorTypeVarsTypesMismatch TypeConstructorName TypeVarMap TypeVarMap
5952 | DataConstructorTypeVarsMismatch DataConstructorName TypeVarMap TypeVarMap
60− | AtomFunctionTypeVariableResolutionError AtomFunctionName TypeVarName
61− | AtomFunctionTypeVariableMismatch TypeVarName AtomType AtomType
6253 | AtomTypeNameInUseError AtomTypeName
6354 | IncompletelyDefinedAtomTypeWithConstructorError
6455 | AtomTypeNameNotInUseError AtomTypeName
65− | AttributeNotSortableError Attribute
66− | FunctionNameInUseError AtomFunctionName
67− | FunctionNameNotInUseError AtomFunctionName
68− | EmptyCommitError
69− | FunctionArgumentCountMismatchError Int Int
70− | ConstructedAtomArgumentCountMismatchError Int Int
56+ | AtomFunctionNameInUseError AtomFunctionName
57+ | AtomFunctionNameNotInUseError AtomFunctionName
7158 | NoSuchDataConstructorError DataConstructorName
7259 | NoSuchTypeConstructorError TypeConstructorName
7360 | InvalidAtomTypeName AtomTypeName
@@ -76,41 +63,21 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)
7663 | EmptyTuplesError -- used by persistent driver
7764 | AtomTypeCountError [AtomType] [AtomType]
7865 | AtomFunctionTypeError AtomFunctionName Int AtomType AtomType --arg number
79− | AtomFunctionUserError AtomFunctionError
80− | PrecompiledFunctionRemoveError AtomFunctionName -- pre-compiled atom functions cannot be serialized, so they cannot change over time- they are referred to in perpetuity
8166 | RelationValuedAttributesNotSupportedError [AttributeName]
8267 | NotificationNameInUseError NotificationName
8368 | NotificationNameNotInUseError NotificationName
84− | ImportError ImportError'
69+ | ImportError T.Text -- really? This should be broken out into some other error type- this has nothing to do with relational algebra
8570 | ExportError T.Text
86− | UnhandledExceptionError String
8771 | MergeTransactionError MergeError
88− | ScriptError ScriptCompilationError
89− | LoadFunctionError
90− | DatabaseContextFunctionUserError DatabaseContextFunctionError
91− | DatabaseLoadError PersistenceError
92−
93− | SubschemaNameInUseError SchemaName
94− | SubschemaNameNotInUseError SchemaName
95−
96− | SchemaCreationError SchemaError
97−
98− | ImproperDatabaseStateError
99−
100− | NonConcreteSchemaPlanError
101−
102− | NoUncommittedContextInEvalError
103− | TupleExprsReferenceMultipleMarkersError
104−
105− | MerkleHashValidationError TransactionId MerkleHash MerkleHash
106−
72+ | AtomFunctionBodyScriptError AtomFunctionBodyCompilationError
10773 | MultipleErrors [RelationalError]
108− deriving (Show,Eq,Generic,Typeable, NFData)
74+ deriving (Show,Eq,Generic,Binary,Typeable)
10975
76+instance NFData RelationalError where rnf = genericRnf
77+
11078data PersistenceError = InvalidDirectoryError FilePath |
111− MissingTransactionError TransactionId |
112− WrongDatabaseFormatVersionError String String
113− deriving (Show, Eq, Generic, NFData)
79+ MissingTransactionError TransactionId
80+ deriving (Show, Eq, Generic)
11481
11582--collapse list of errors into normal error- if there is just one, just return one
11683someErrors :: [RelationalError] -> RelationalError
@@ -128,28 +95,12 @@ data MergeError = SelectedHeadMismatchMergeError |
12895 StrategyViolatesComponentMergeError | --failed merge in inc deps, relvars, etc.
12996 StrategyViolatesRelationVariableMergeError |
13097 StrategyViolatesTypeConstructorMergeError
131− deriving (Show, Eq, Generic, Typeable)
98+ deriving (Show, Eq, Generic, Binary, Typeable)
13299
133100instance NFData MergeError where rnf = genericRnf
134101
135−data ScriptCompilationError = TypeCheckCompilationError String String | --expected, got
136− SyntaxErrorCompilationError String |
137− ScriptCompilationDisabledError |
138− OtherScriptCompilationError String
139− deriving (Show, Eq, Generic, Typeable, NFData)
140−
141−instance Exception ScriptCompilationError
142−
143−data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |
144− RelVarInReferencedMoreThanOnce RelVarName |
145− RelVarOutReferencedMoreThanOnce RelVarName
146− deriving (Show, Eq, Generic, Typeable, NFData)
147−
148−
149−data ImportError' = InvalidSHA256Error T.Text
150− | SHA256MismatchError T.Text T.Text
151− | InvalidFileURIError T.Text
152− | ImportFileDecodeError T.Text
153− | ImportFileError T.Text
154− | ImportDownloadError T.Text
155− deriving (Show, Eq, Generic, Typeable, NFData)
102+data AtomFunctionBodyCompilationError = TypeCheckCompilationError String String | --expected, got
103+ SyntaxErrorCompilationError String |
104+ OtherScriptCompilationError String
105+ deriving (Show,Eq, Generic, Binary, Typeable, NFData)
106+
ProjectM36/Key.hsnew file+32
@@ -0,0 +1,32 @@
1+module ProjectM36.Key where
2+import ProjectM36.Base
3+import ProjectM36.Relation
4+import qualified Data.Set as S
5+
6+{-
7+keys can be implemented using inclusion dependencies as well: the count of the projection of the keys' attributes must be equal to the count of the tuples- p. 120 Database in Depth
8+
9+example:
10+:showexpr ((relation{tuple{}}:{a:=S}):{b:=count(@a)}){b}
11+┌─┐
12+│b│
13+├─┤
14+│5│
15+└─┘
16+((relation{tuple{}}:{a:=S{S#}}):{b:=count(@a)}){b}
17+┌─┐
18+│b│
19+├─┤
20+│5│
21+└─┘
22+-}
23+inclusionDependencyForKey :: AttributeNames -> RelationalExpr -> InclusionDependency
24+inclusionDependencyForKey attrNames relExpr = --InclusionDependency name (exprCount relExpr) (exprCount (projectedOnKeys relExpr))
25+ InclusionDependency equalityExpr (ExistingRelation relationFalse)
26+ where
27+ projectedOnKeys expr = Project attrNames expr
28+ exprAsSubRelation expr = Extend (AttributeExtendTupleExpr "a" (RelationAtomExpr expr)) (ExistingRelation relationTrue)
29+ exprCount expr = projectionForCount (Extend (AttributeExtendTupleExpr "b" (FunctionAtomExpr "count" [AttributeAtomExpr "a"])) (exprAsSubRelation expr))
30+ projectionForCount expr = Project (AttributeNames $ S.fromList ["b"]) expr
31+ equalityExpr = NotEquals (exprCount relExpr) (exprCount (projectedOnKeys relExpr))
32+
ProjectM36/MiscUtils.hsnew file+8
@@ -0,0 +1,8 @@
1+module ProjectM36.MiscUtils where
2+
3+--returns duplicates of a pre-sorted list
4+dupes :: Eq a => [a] -> [a]
5+dupes [] = []
6+dupes (_:[]) = []
7+dupes (x:y:[]) = if x == y then [x] else []
8+dupes (x:y:xs) = dupes(x:[y]) ++ dupes(xs)
ProjectM36/Notifications.hsnew file+17
@@ -0,0 +1,17 @@
1+module ProjectM36.Notifications where
2+import ProjectM36.Base
3+import ProjectM36.RelationalExpression
4+import Control.Monad.State
5+import qualified Data.Map as M
6+import Data.Either (isRight)
7+
8+-- | Returns the notifications which should be triggered based on the transition from the first 'DatabaseContext' to the second 'DatabaseContext'.
9+notificationChanges :: Notifications -> DatabaseContext -> DatabaseContext -> Notifications
10+notificationChanges nots context1 context2 = M.filter notificationFilter nots
11+ where
12+ notificationFilter (Notification chExpr _) = let oldChangeEval = evalChangeExpr chExpr context1
13+ newChangeEval = evalChangeExpr chExpr context2 in
14+ oldChangeEval /= newChangeEval && isRight oldChangeEval
15+ evalChangeExpr chExpr = evalState (evalRelationalExpr chExpr)
16+
17+
src/lib/ProjectM36/Persist.hs → ProjectM36/Persist.hsrenamed+13−71
@@ -2,42 +2,21 @@
22--this module is related to persisting Project:M36 structures to disk and not related to the persistent library
33module ProjectM36.Persist (writeFileSync,
44 writeBSFileSync,
5− renameSync,
6− printFdCount,
5+ renameSync,
76 DiskSync(..)) where
87-- on Windows, use FlushFileBuffers and MoveFileEx
9−import qualified Data.Text as T
10−
11−#if defined(linux_HOST_OS)
12−# define FDCOUNTSUPPORTED 1
13−# define FDDIR "/proc/self/fd"
14−#elif defined(darwin_HOST_OS)
15−# define FDCOUNTSUPPORTED 1
16−# define FDDIR "/dev/fd"
17−#else
18−# define FDCOUNTSUPPORTED 0
19−#endif
20−
21−#if FDCOUNTSUPPORTED
22−import System.Directory
23−#endif
248
259#if defined(mingw32_HOST_OS)
2610import qualified System.Win32 as Win32
2711#else
2812import qualified System.Posix as Posix
29−#if defined(linux_HOST_OS)
3013import System.Posix.Unistd (fileSynchroniseDataOnly)
31−#else
32−import System.Posix.Unistd (fileSynchronise)
33−#endif
34−import System.Posix.IO (handleToFd, closeFd)
14+import System.Posix.IO (handleToFd)
3515import Foreign.C
3616#endif
3717
38−import System.IO (withFile, IOMode(WriteMode), Handle)
39−import qualified Data.ByteString as BS'
40−import qualified Data.Text.Encoding as TE
18+import System.IO (withFile, IOMode(WriteMode), hPutStr, Handle)
19+import qualified Data.ByteString.Lazy as BS
4120
4221#if defined(mingw32_HOST_OS)
4322import ProjectM36.Win32Handle
@@ -47,12 +26,11 @@ foreign import ccall unsafe "cDirectoryFsync" cHSDirectoryFsync :: CString -> IO
4726
4827data DiskSync = NoDiskSync | FsyncDiskSync
4928
50−--using withFile here is OK because we use a WORM strategy- the file is written but not read until after the handle is synced, closed, and unhidden (moved from ".X" to "X") at the top level in the transaction directory
51−writeFileSync :: DiskSync -> FilePath -> T.Text -> IO()
29+writeFileSync :: DiskSync -> FilePath -> String -> IO()
5230writeFileSync sync path strOut = withFile path WriteMode handler
5331 where
5432 handler handle = do
55− BS'.hPut handle (TE.encodeUtf8 strOut)
33+ hPutStr handle strOut
5634 syncHandle sync handle
5735
5836renameSync :: DiskSync -> FilePath -> FilePath -> IO ()
@@ -61,48 +39,31 @@ renameSync sync srcPath dstPath = do
6139 syncDirectory sync dstPath
6240
6341-- System.Directory's renameFile/renameDirectory almost do exactly what we want except that it needlessly differentiates between directories and files
64−{-# ANN atomicRename ("HLint: ignore Eta reduce" :: String) #-}
6542atomicRename :: FilePath -> FilePath -> IO ()
66−atomicRename srcPath dstPath =
43+atomicRename srcPath dstPath = do
6744#if defined(mingw32_HOST_OS)
68−#if MIN_VERSION_Win32(2,6,0)
69− let dst = Just dstPath
70−#else
71− let dst = dstPath
72−#endif
73− in
74− Win32.moveFileEx srcPath dst Win32.mOVEFILE_REPLACE_EXISTING
45+ Win32.moveFileEx srcPath dstPath Win32.mOVEFILE_REPLACE_EXISTING
7546#else
7647 Posix.rename srcPath dstPath
7748#endif
7849
7950syncHandle :: DiskSync -> Handle -> IO ()
80−syncHandle FsyncDiskSync handle =
51+syncHandle FsyncDiskSync handle = do
8152#if defined(mingw32_HOST_OS)
8253 withHandleToHANDLE handle (\h -> Win32.flushFileBuffers h)
83−#elif defined(linux_HOST_OS)
84− do
85− --fdatasync doesn't exist on macOS
86− fd <- handleToFd handle
87− fileSynchroniseDataOnly fd
88− closeFd fd
8954#else
90− do
91− fd <- handleToFd handle
92− fileSynchronise fd
93− closeFd fd
55+ handleToFd handle >>= fileSynchroniseDataOnly
9456#endif
95−
9657syncHandle NoDiskSync _ = pure ()
9758
9859syncDirectory :: DiskSync -> FilePath -> IO ()
9960syncDirectory FsyncDiskSync path = directoryFsync path
10061syncDirectory NoDiskSync _ = pure ()
10162
102−writeBSFileSync :: DiskSync -> FilePath -> BS'.ByteString -> IO ()
103−writeBSFileSync sync path bstring =
63+writeBSFileSync :: DiskSync -> FilePath -> BS.ByteString -> IO ()
64+writeBSFileSync sync path bstring = do
10465 withFile path WriteMode $ \handle -> do
105− BS'.hPut handle bstring
66+ BS.hPut handle bstring
10667 syncHandle sync handle
10768
10869directoryFsync :: FilePath -> IO ()
@@ -112,22 +73,3 @@ directoryFsync _ = pure () -- on Windows directory metadata cannot be synchroniz
11273directoryFsync path = throwErrnoIfMinus1Retry_ "directoryFsync" (withCString path $ \cpath -> cHSDirectoryFsync cpath)
11374#endif
11475
115−--prints out number of consumed file descriptors
116−printFdCount :: IO ()
117−printFdCount =
118−#if FDCOUNTSUPPORTED
119− do
120− fdc <- fdCount
121− putStrLn ("Fd count: " ++ show fdc)
122− --getLine >> pure ()
123−#else
124− putStrLn "Fd count not supported on this OS."
125−#endif
126−
127−#if FDCOUNTSUPPORTED
128−fdCount :: IO Int
129−fdCount = do
130− fds <- getDirectoryContents FDDIR
131− pure ((length fds) - 2)
132−--not supported on non-linux
133−#endif
src/lib/ProjectM36/Relation.hs → ProjectM36/Relation.hsrenamed+84−85
@@ -4,18 +4,22 @@ import qualified Data.Set as S
44import qualified Data.HashSet as HS
55import Control.Monad
66import qualified Data.Vector as V
7+import qualified Data.Map as M
8+import ProjectM36.Atom
9+import ProjectM36.AtomType
710import ProjectM36.Base
811import ProjectM36.Tuple
12+import ProjectM36.DataTypes.Primitive
913import qualified ProjectM36.Attribute as A
14+import qualified ProjectM36.AttributeNames as AS
1015import ProjectM36.TupleSet
1116import ProjectM36.Error
12−--import qualified Control.Parallel.Strategies as P
17+import qualified Control.Parallel.Strategies as P
1318import qualified ProjectM36.TypeConstructorDef as TCD
1419import qualified ProjectM36.DataConstructorDef as DCD
1520import qualified Data.Text as T
1621import Data.Either (isRight)
17−import System.Random.Shuffle
18−import Control.Monad.Random
22+--import Debug.Trace
1923
2024attributes :: Relation -> Attributes
2125attributes (Relation attrs _ ) = attrs
@@ -34,18 +38,16 @@ atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrNam
3438
3539mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation
3640mkRelationFromList attrs atomMatrix = do
37− Relation attrs <$> mkTupleSetFromList attrs atomMatrix
38−
39−emptyRelationWithAttrs :: Attributes -> Relation
40−emptyRelationWithAttrs attrs = Relation attrs emptyTupleSet
41+ tupSet <- mkTupleSetFromList attrs atomMatrix
42+ return $ Relation attrs tupSet
4143
4244mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation
43−mkRelation attrs tupleSet =
44− --check that all tuples have the same keys
45− --check that all tuples have keys (1-N) where N is the attribute count
46− case verifyTupleSet attrs tupleSet of
47− Left err -> Left err
48− Right verifiedTupleSet -> return $ Relation attrs verifiedTupleSet
45+mkRelation attrs tupleSet = do
46+ --check that all tuples have the same keys
47+ --check that all tuples have keys (1-N) where N is the attribute count
48+ case verifyTupleSet attrs tupleSet of
49+ Left err -> Left err
50+ Right verifiedTupleSet -> return $ Relation attrs verifiedTupleSet
4951
5052--less safe version of mkRelation skips verifyTupleSet
5153--useful for infinite or thunked tuple sets
@@ -55,10 +57,6 @@ mkRelationDeferVerify :: Attributes -> RelationTupleSet -> Either RelationalErro
5557mkRelationDeferVerify attrs tupleSet = return $ Relation attrs (RelationTupleSet (filter tupleFilter (asList tupleSet)))
5658 where
5759 tupleFilter tuple = isRight (verifyTuple attrs tuple)
58−
59−--return a relation of the same type except without any tuples
60−relationWithEmptyTupleSet :: Relation -> Relation
61−relationWithEmptyTupleSet (Relation attrs _) = emptyRelationWithAttrs attrs
6260
6361mkRelationFromTuples :: Attributes -> [RelationTuple] -> Either RelationalError Relation
6462mkRelationFromTuples attrs tupleSetList = do
@@ -78,7 +76,6 @@ singletonTuple rel@(Relation _ tupleSet) = if cardinality rel == Finite 1 then
7876 else
7977 Nothing
8078
81−-- this is still unncessarily expensive for (bigx union bigx) because each tuple is hashed and compared for equality (when the hashes match), but the major expense is attributesEqual, but we already know that all tuple attributes are equal (it's a precondition)
8279union :: Relation -> Relation -> Either RelationalError Relation
8380union (Relation attrs1 tupSet1) (Relation attrs2 tupSet2) =
8481 if not (A.attributesEqual attrs1 attrs2)
@@ -86,25 +83,32 @@ union (Relation attrs1 tupSet1) (Relation attrs2 tupSet2) =
8683 else
8784 Right $ Relation attrs1 newtuples
8885 where
89− newtuples = tupleSetUnion attrs1 tupSet1 tupSet2
86+ newtuples = RelationTupleSet $ HS.toList . HS.fromList $ (asList tupSet1) ++ (map (reorderTuple attrs1) (asList tupSet2))
9087
91−project :: S.Set AttributeName -> Relation -> Either RelationalError Relation
92−project attrNames rel@(Relation _ tupSet) = do
93− newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)
94− newTupleList <- mapM (tupleProject newAttrs) (asList tupSet)
95− pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))
88+project :: AttributeNames -> Relation -> Either RelationalError Relation
89+project projectionAttrNames rel =
90+ case AS.projectionAttributesForAttributeNames (attributes rel) projectionAttrNames of
91+ Left err -> Left err
92+ Right newAttrs -> relFold (folder newAttrs) (Right $ Relation newAttrs emptyTupleSet) rel
93+ where
94+ folder newAttrs tupleToProject acc = case acc of
95+ Left err -> Left err
96+ Right acc2 -> union acc2 (Relation newAttrs (RelationTupleSet [tupleProject (A.attributeNameSet newAttrs) tupleToProject]))
9697
9798rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation
98−rename oldAttrName newAttrName rel@(Relation oldAttrs oldTupSet)
99− | not attributeValid = Left $ AttributeNamesMismatchError (S.singleton oldAttrName)
100− | newAttributeInUse = Left $ AttributeNameInUseError newAttrName
101− | otherwise = mkRelation newAttrs newTupSet
99+rename oldAttrName newAttrName rel@(Relation oldAttrs oldTupSet) =
100+ if not attributeValid
101+ then Left $ AttributeNamesMismatchError (S.singleton oldAttrName)
102+ else if newAttributeInUse
103+ then Left $ AttributeNameInUseError newAttrName
104+ else
105+ mkRelation newAttrs newTupSet
102106 where
103107 newAttributeInUse = A.attributeNamesContained (S.singleton newAttrName) (attributeNames rel)
104108 attributeValid = A.attributeNamesContained (S.singleton oldAttrName) (attributeNames rel)
105109 newAttrs = A.renameAttributes oldAttrName newAttrName oldAttrs
106110 newTupSet = RelationTupleSet $ map tupsetmapper (asList oldTupSet)
107− tupsetmapper = tupleRenameAttribute oldAttrName newAttrName
111+ tupsetmapper tuple = tupleRenameAttribute oldAttrName newAttrName tuple
108112
109113--the algebra should return a relation of one attribute and one row with the arity
110114arity :: Relation -> Int
@@ -139,16 +143,16 @@ group groupAttrNames newAttrName rel@(Relation oldAttrs tupleSet) = do
139143-}
140144
141145--algorithm: self-join with image relation
142−group :: S.Set AttributeName -> AttributeName -> Relation -> Either RelationalError Relation
146+group :: AttributeNames -> AttributeName -> Relation -> Either RelationalError Relation
143147group groupAttrNames newAttrName rel = do
144− let nonGroupAttrNames = A.nonMatchingAttributeNameSet groupAttrNames (S.fromList (V.toList (A.attributeNames (attributes rel))))
145− nonGroupProjectionAttributes <- A.projectionAttributesForNames nonGroupAttrNames (attributes rel)
146− groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)
148+ let nonGroupAttrNames = AS.invertAttributeNames groupAttrNames
149+ nonGroupProjectionAttributes <- AS.projectionAttributesForAttributeNames (attributes rel) nonGroupAttrNames
150+ groupProjectionAttributes <- AS.projectionAttributesForAttributeNames (attributes rel) groupAttrNames
147151 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)
148152 matchingRelTuple tupIn = case imageRelationFor tupIn rel of
149− Right rel2 -> RelationTuple (A.singleton groupAttr) (V.singleton (RelationAtom rel2))
153+ Right rel2 -> RelationTuple (V.singleton groupAttr) (V.singleton (Atom rel2))
150154 Left _ -> undefined
151− mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))
155+ mogrifier tupIn = tupleExtend tupIn (matchingRelTuple tupIn)
152156 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes
153157 nonGroupProjection <- project nonGroupAttrNames rel
154158 relMogrify mogrifier newAttrs nonGroupProjection
@@ -157,11 +161,10 @@ group groupAttrNames newAttrName rel = do
157161--help restriction function
158162--returns a subrelation of
159163restrictEq :: RelationTuple -> Relation -> Either RelationalError Relation
160−restrictEq tuple = restrict rfilter
164+restrictEq tuple rel = restrict rfilter rel
161165 where
162− rfilter :: RelationTuple -> Either RelationalError Bool
163− rfilter tupleIn = do
164− pure (tupleIntersection tuple tupleIn == tuple)
166+ rfilter :: RelationTuple -> Bool
167+ rfilter tupleIn = tupleIntersection tuple tupleIn == tuple
165168
166169-- unwrap relation-valued attribute
167170-- return error if relval attrs and nongroup attrs overlap
@@ -177,19 +180,19 @@ ungroup relvalAttrName rel = case attributesForRelval relvalAttrName rel of
177180 Left err -> Left err
178181 Right accRel -> do
179182 ungrouped <- tupleUngroup relvalAttrName newAttrs tupleIn
180− accRel `union` ungrouped
183+ union accRel ungrouped
181184
182185--take an relval attribute name and a tuple and ungroup the relval
183186tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation
184187tupleUngroup relvalAttrName newAttrs tuple = do
185188 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])
192189 relFold folder (Right $ Relation newAttrs emptyTupleSet) relvalRelation
190+ where
191+ nonGroupTupleProjection = tupleProject nonGroupAttrNames tuple
192+ nonGroupAttrNames = A.attributeNameSet newAttrs
193+ folder tupleIn acc = case acc of
194+ Left err -> Left err
195+ Right accRel -> union accRel $ Relation newAttrs (RelationTupleSet [tupleExtend nonGroupTupleProjection tupleIn])
193196
194197attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes
195198attributesForRelval relvalAttrName (Relation attrs _) = do
@@ -198,11 +201,11 @@ attributesForRelval relvalAttrName (Relation attrs _) = do
198201 (RelationAtomType relAttrs) -> Right relAttrs
199202 _ -> Left $ AttributeIsNotRelationValuedError relvalAttrName
200203
201−type RestrictionFilter = RelationTuple -> Either RelationalError Bool
202−restrict :: RestrictionFilter -> Relation -> Either RelationalError Relation
203−restrict rfilter (Relation attrs tupset) = do
204− tuples <- filterM rfilter (asList tupset)
205− Right $ Relation attrs (RelationTupleSet tuples)
204+restrict :: (RelationTuple -> Bool) -> Relation -> Either RelationalError Relation
205+--restrict rfilter (Relation attrs tupset) = Right $ Relation attrs $ HS.filter rfilter tupset
206+restrict rfilter (Relation attrs tupset) = Right $ Relation attrs processedTupSet
207+ where
208+ processedTupSet = RelationTupleSet ((filter rfilter (asList tupset)) `P.using` (P.parListChunk 1000 P.rdeepseq))
206209
207210--joins on columns with the same name- use rename to avoid this- base case: cartesian product
208211--after changing from string atoms, there needs to be a type-checking step!
@@ -214,7 +217,8 @@ join (Relation attrs1 tupSet1) (Relation attrs2 tupSet2) = do
214217 joinedTupSet <- singleTupleSetJoin newAttrs tuple1 tupSet2
215218 return $ joinedTupSet ++ accumulator
216219 newTupSetList <- foldM tupleSetJoiner [] (asList tupSet1)
217− Relation newAttrs <$> mkTupleSet newAttrs newTupSetList
220+ newTupSet <- mkTupleSet newAttrs newTupSetList
221+ return $ Relation newAttrs newTupSet
218222
219223-- | Difference takes two relations of the same type and returns a new relation which contains only tuples which appear in the first relation but not the second.
220224difference :: Relation -> Relation -> Either RelationalError Relation
@@ -227,11 +231,11 @@ difference relA relB =
227231 where
228232 attrsA = attributes relA
229233 attrsB = attributes relB
230− rfilter tupInA = relFold (\tupInB acc -> if acc == Right False then pure False else pure (tupInB /= tupInA)) (Right True) relB
234+ rfilter tupInA = relFold (\tupInB acc -> if acc == False then False else if tupInB == tupInA then False else True) True relB
231235
232236--a map should NOT change the structure of a relation, so attributes should be constant
233237relMap :: (RelationTuple -> Either RelationalError RelationTuple) -> Relation -> Either RelationalError Relation
234−relMap mapper (Relation attrs tupleSet) =
238+relMap mapper (Relation attrs tupleSet) = do
235239 case forM (asList tupleSet) typeMapCheck of
236240 Right remappedTupleSet -> mkRelation attrs (RelationTupleSet remappedTupleSet)
237241 Left err -> Left err
@@ -240,24 +244,17 @@ relMap mapper (Relation attrs tupleSet) =
240244 remappedTuple <- mapper tupleIn
241245 if tupleAttributes remappedTuple == tupleAttributes tupleIn
242246 then Right remappedTuple
243− else Left (TupleAttributeTypeMismatchError (A.attributesDifference (tupleAttributes tupleIn) attrs))
247+ else Left $ TupleAttributeTypeMismatchError (A.attributesDifference (tupleAttributes tupleIn) attrs)
244248
245−relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation
249+relMogrify :: (RelationTuple -> RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation
246250relMogrify mapper newAttributes (Relation _ tupSet) = do
247− newTuples <- mapM (fmap (reorderTuple newAttributes) . mapper) (asList tupSet)
248−
249− mkRelationFromTuples newAttributes newTuples
251+ mkRelationFromTuples newAttributes newTuples
252+ where
253+ newTuples = map mapper (asList tupSet)
250254
251255relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a
252256relFold folder acc (Relation _ tupleSet) = foldr folder acc (asList tupleSet)
253257
254−-- | Generate a randomly-ordered list of tuples from the relation.
255−toList :: Relation -> IO [RelationTuple]
256−toList rel = do
257− gen <- newStdGen
258− let rel' = evalRand (randomizeTupleOrder rel) gen
259− pure (relFold (:) [] rel')
260−
261258--image relation as defined by CJ Date
262259--given tupleA and relationB, return restricted relation where tuple attributes are not the attribues in tupleA but are attributes in relationB and match the tuple's value
263260
@@ -265,7 +262,7 @@ toList rel = do
265262imageRelationFor :: RelationTuple -> Relation -> Either RelationalError Relation
266263imageRelationFor matchTuple rel = do
267264 restricted <- restrictEq matchTuple rel --restrict across matching tuples
268− let projectionAttrNames = A.nonMatchingAttributeNameSet (attributeNames rel) (tupleAttributeNameSet matchTuple)
265+ let projectionAttrNames = AttributeNames $ A.nonMatchingAttributeNameSet (attributeNames rel) (tupleAttributeNameSet matchTuple)
269266 project projectionAttrNames restricted --project across attributes not in rel
270267
271268--returns a relation-valued attribute image relation for each tuple in rel1
@@ -285,28 +282,30 @@ imageRelationJoin rel1@(Relation attrNameSet1 tupSet1) rel2@(Relation attrNameSe
285282typesAsRelation :: TypeConstructorMapping -> Either RelationalError Relation
286283typesAsRelation types = mkRelationFromTuples attrs tuples
287284 where
288− attrs = A.attributesFromList [Attribute "TypeConstructor" TextAtomType,
285+ attrs = A.attributesFromList [Attribute "TypeConstructor" textAtomType,
289286 Attribute "DataConstructors" dConsType]
290− subAttrs = A.attributesFromList [Attribute "DataConstructor" TextAtomType]
287+ subAttrs = A.attributesFromList [Attribute "DataConstructor" textAtomType]
291288 dConsType = RelationAtomType subAttrs
292289 tuples = map mkTypeConsDescription types
293290
294− mkTypeConsDescription (tCons, dConsList) =
295− RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])
291+ mkTypeConsDescription (tCons, dConsList) = RelationTuple attrs (V.fromList [textAtom (TCD.name tCons), mkDataConsRelation dConsList])
296292
297− 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
293+ 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
298294 Left err -> error ("mkRelationFromTuples pooped " ++ show err)
299− Right rel -> RelationAtom rel
295+ Right rel -> Atom rel
296+
297+-- | Return a Relation describing the relation variables.
298+relationVariablesAsRelation :: M.Map RelVarName Relation -> Either RelationalError Relation
299+relationVariablesAsRelation relVarMap = mkRelationFromList attrs tups
300+ where
301+ subrelAttrs = A.attributesFromList [Attribute "attribute" textAtomType, Attribute "type" textAtomType]
302+ attrs = A.attributesFromList [Attribute "name" textAtomType,
303+ Attribute "attributes" (RelationAtomType subrelAttrs)]
304+ tups = map relVarToAtomList (M.toList relVarMap)
305+ relVarToAtomList (rvName, rel) = [textAtom rvName, attributesToRel (attributes rel)]
306+ attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of
307+ Left err -> error ("relationVariablesAsRelation pooped " ++ show err)
308+ Right rel -> Atom rel
309+ attrAtoms a = [textAtom (A.attributeName a), textAtom (prettyAtomType (A.atomType a))]
300310
301−-- | Randomly resort the tuples. This is useful for emphasizing that two relations are equal even when they are printed to the console in different orders.
302−randomizeTupleOrder :: MonadRandom m => Relation -> m Relation
303−randomizeTupleOrder (Relation attrs tupSet) =
304− Relation attrs . RelationTupleSet <$> shuffleM (asList tupSet)
305−
306−-- returns a tuple from the tupleset- this is useful for priming folds over the tuples
307−oneTuple :: Relation -> Maybe RelationTuple
308−oneTuple (Relation _ (RelationTupleSet [])) = Nothing
309−oneTuple (Relation _ (RelationTupleSet (x:_))) = Just x
310−
311−tuplesList :: Relation -> [RelationTuple]
312−tuplesList (Relation _ tupleSet) = asList tupleSet
311+
ProjectM36/Relation/Parse/CSV.hsnew file+54
@@ -0,0 +1,54 @@
1+module ProjectM36.Relation.Parse.CSV where
2+--parse Relations from CSV
3+import Data.Csv.Parser
4+import qualified Data.Vector as V
5+import Data.Char (ord)
6+import qualified Data.ByteString.Lazy as BS
7+import ProjectM36.Base
8+import ProjectM36.Relation
9+import ProjectM36.DataTypes.Primitive
10+import ProjectM36.Error
11+import Data.Text.Encoding (decodeUtf8)
12+import qualified ProjectM36.Attribute as A
13+import qualified Data.Set as S
14+import Data.HashMap.Lazy as HM
15+import qualified Data.List as L
16+import qualified Data.Text as T
17+import Data.Attoparsec.ByteString.Lazy
18+import ProjectM36.Atom
19+
20+data CsvImportError = CsvParseError String |
21+ AttributeMappingError RelationalError |
22+ HeaderAttributeMismatchError (S.Set AttributeName)
23+ deriving (Show)
24+
25+csvDecodeOptions :: DecodeOptions
26+csvDecodeOptions = DecodeOptions {decDelimiter = fromIntegral (ord ',')}
27+
28+--special case from Text- outer quotes are *not* required in CSV, so we have to add them to make it parseable
29+makeAtomFromCSVText :: AttributeName -> AtomType -> T.Text -> Either RelationalError Atom
30+makeAtomFromCSVText attrName aType textIn = makeAtomFromText attrName aType $ if aType == textAtomType then
31+ ("\"" `T.append` textIn `T.append` "\"")
32+ else
33+ textIn
34+
35+csvAsRelation :: BS.ByteString -> Attributes -> Either CsvImportError Relation
36+csvAsRelation inString attrs = case parse (csvWithHeader csvDecodeOptions) inString of
37+ Fail _ _ err -> Left (CsvParseError err)
38+ Done _ (headerRaw,vecMapsRaw) -> do
39+ let strHeader = V.map decodeUtf8 headerRaw
40+ strMapRecords = V.map convertMap vecMapsRaw
41+ convertMap hmap = HM.fromList $ L.map (\(k,v) -> (decodeUtf8 k, (T.unpack . decodeUtf8) v)) (HM.toList hmap)
42+ attrNames = V.map A.attributeName attrs
43+ attrNameSet = S.fromList (V.toList attrNames)
44+ headerSet = S.fromList (V.toList strHeader)
45+ makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]
46+ makeTupleList tupMap = V.toList $ V.map (\attr -> either (Left . AttributeMappingError) Right $ makeAtomFromCSVText (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! (A.attributeName attr))) attrs
47+ case attrNameSet == headerSet of
48+ False -> Left $ HeaderAttributeMismatchError (S.difference attrNameSet headerSet)
49+ True -> do
50+ tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)
51+ case mkRelationFromList attrs tupleList of
52+ Left err -> Left (AttributeMappingError err)
53+ Right rel -> Right rel
54+
ProjectM36/Relation/Show/CSV.hsnew file+46
@@ -0,0 +1,46 @@
1+{-# OPTIONS_GHC -fno-warn-orphans #-}
2+module ProjectM36.Relation.Show.CSV where
3+import ProjectM36.Base
4+import Data.Typeable (cast)
5+import ProjectM36.Attribute
6+import Data.Csv
7+import ProjectM36.Tuple
8+import qualified Data.ByteString.Lazy as BS
9+import qualified Data.Vector as V
10+import ProjectM36.Error
11+import qualified Data.Text.Encoding as TE
12+import qualified Data.Text as T
13+
14+--spit out error for relations without attributes (since relTrue and relFalse cannot be distinguished then as CSV) and for relations with relation-valued attributes
15+relationAsCSV :: Relation -> Either RelationalError BS.ByteString
16+relationAsCSV (Relation attrs tupleSet) = if relValAttrs /= [] then --check for relvalued attributes
17+ Left $ RelationValuedAttributesNotSupportedError (map attributeName relValAttrs)
18+ else if V.length attrs == 0 then --check that there is at least one attribute
19+ Left $ TupleAttributeCountMismatchError 0
20+ else
21+ Right $ encodeByName bsAttrNames $ map RecordRelationTuple (asList tupleSet)
22+ where
23+ relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) attrs
24+ bsAttrNames = V.map (TE.encodeUtf8 . attributeName) attrs
25+
26+{-
27+instance ToRecord RelationTuple where
28+ toRecord tuple = toRecord $ map toField (V.toList $ tupleAtoms tuple)
29+-}
30+
31+newtype RecordRelationTuple = RecordRelationTuple {unTuple :: RelationTuple}
32+
33+instance ToNamedRecord RecordRelationTuple where
34+ toNamedRecord rTuple = namedRecord $ map (\(k,v) -> TE.encodeUtf8 k .= (RecordAtom v)) (tupleAssocs $ unTuple rTuple)
35+
36+instance DefaultOrdered RecordRelationTuple where
37+ headerOrder (RecordRelationTuple tuple) = V.map (TE.encodeUtf8 . attributeName) (tupleAttributes tuple)
38+
39+newtype RecordAtom = RecordAtom {unAtom :: Atom}
40+
41+instance ToField RecordAtom where
42+ toField (RecordAtom (ConstructedAtom dConsName _ atomList)) = TE.encodeUtf8 $ dConsName `T.append` T.intercalate " " (map (\(Atom x) -> toText x) atomList)
43+ toField (RecordAtom (Atom atomVal)) = case cast atomVal of
44+ Just texto -> TE.encodeUtf8 texto --squelch extraneous quotes for text type- the CSV library will add them if necessary
45+ Nothing -> (TE.encodeUtf8 . toText) atomVal
46+
src/lib/ProjectM36/Relation/Show/Gnuplot.hs → ProjectM36/Relation/Show/Gnuplot.hsrenamed+12−11
@@ -2,6 +2,7 @@ module ProjectM36.Relation.Show.Gnuplot where
22import ProjectM36.Base
33import ProjectM36.Relation
44import ProjectM36.Tuple
5+import ProjectM36.DataTypes.Primitive
56import ProjectM36.AtomFunctions.Primitive
67import qualified ProjectM36.Attribute as A
78import qualified Data.Vector as V
@@ -23,14 +24,14 @@ data PlotError = InvalidAttributeCountError |
2324
2425--plotRelation :: Relation -> Either PlotError
2526
26−intFromAtomIndex :: Int -> RelationTuple -> Int --warning- clips or overflows Integer -> Int
27−intFromAtomIndex index tup = fromIntegral $ castInt $ tupleAtoms tup V.! index
27+intFromAtomIndex :: Int -> RelationTuple -> Int
28+intFromAtomIndex index tup = (\i -> castInt i) $ (tupleAtoms tup) V.! index
2829
2930graph1DRelation :: Relation -> Plot2D.T Int Int
3031graph1DRelation rel = Plot2D.list Graph2D.listPoints $ points1DRelation rel
3132
3233points1DRelation :: Relation -> [Int]
33−points1DRelation = relFold folder []
34+points1DRelation rel = relFold folder [] rel
3435 where
3536 folder tup acc = intFromAtomIndex 0 tup : acc
3637
@@ -38,16 +39,16 @@ graph2DRelation :: Relation -> Plot2D.T Int Int
3839graph2DRelation rel = Plot2D.list Graph2D.points (points2DRelation rel)
3940
4041points2DRelation :: Relation -> [(Int, Int)]
41−points2DRelation = relFold folder []
42+points2DRelation rel = relFold folder [] rel
4243 where
4344 folder tup acc = (intFromAtomIndex 0 tup, intFromAtomIndex 1 tup) : acc
4445
4546graph3DRelation :: Relation -> Plot3D.T Int Int Int
46−graph3DRelation rel =
47+graph3DRelation rel = do
4748 Plot3D.cloud Graph3D.points $ points3DRelation rel
4849
4950points3DRelation :: Relation -> [(Int, Int, Int)]
50−points3DRelation = relFold folder []
51+points3DRelation rel = relFold folder [] rel
5152 where
5253 folder tup acc = (intFromAtomIndex 0 tup, intFromAtomIndex 1 tup, intFromAtomIndex 2 tup) : acc
5354
@@ -69,14 +70,14 @@ sample3DRelation = case mkRelationFromList (A.attributesFromList [Attribute "x"
6970-}
7071
7172plotRelation :: Relation -> IO (Maybe PlotError)
72−plotRelation rel = let attrTypes = V.replicate (arity rel) IntAtomType in
73+plotRelation rel = let attrTypes = V.replicate (arity rel) intAtomType in
7374 if attrTypes /= A.atomTypes (attributes rel) then
7475 return $ Just InvalidAttributeTypeError
75− else
76+ else do
7677 case arity rel of
77− 1 -> GPA.plotDefault (graph1DRelation rel) >> return Nothing
78− 2 -> GPA.plotDefault (graph2DRelation rel) >> return Nothing
79− 3 -> GPA.plotDefault (graph3DRelation rel) >> return Nothing
78+ 1 -> (GPA.plotDefault $ graph1DRelation rel) >> return Nothing
79+ 2 -> (GPA.plotDefault $ graph2DRelation rel) >> return Nothing
80+ 3 -> (GPA.plotDefault $ graph3DRelation rel) >> return Nothing
8081 _ -> return $ Just InvalidAttributeCountError
8182
8283
ProjectM36/Relation/Show/HTML.hsnew file+37
@@ -0,0 +1,37 @@
1+module ProjectM36.Relation.Show.HTML where
2+import ProjectM36.Base
3+import ProjectM36.Relation
4+import ProjectM36.Tuple
5+import ProjectM36.Atom
6+import qualified Data.List as L
7+import ProjectM36.Attribute
8+import Data.Text (append, Text, pack)
9+import qualified Data.Text as T
10+import qualified Data.Text.IO as TIO
11+
12+attributesAsHTML :: Attributes -> Text
13+attributesAsHTML attrs = "<tr>" `append` (T.concat $ map oneAttrHTML attrNameList) `append` "</tr>"
14+ where
15+ oneAttrHTML attrName = "<th>" `append` attrName `append` "</th>"
16+ attrNameList = sortedAttributeNameList (attributeNameSet attrs)
17+
18+relationAsHTML :: Relation -> Text
19+relationAsHTML rel@(Relation attrNameSet tupleSet) = "<table border=\"1\">" `append` (attributesAsHTML attrNameSet) `append` (tupleSetAsHTML tupleSet) `append` "<tfoot>" `append` tablefooter `append` "</tfoot></table>"
20+ where
21+ tablefooter = "<tr><td colspan=\"100%\">" `append` (pack $ show (cardinality rel)) `append` " tuples</td></tr>"
22+
23+writeHTML :: Text -> IO ()
24+writeHTML = TIO.writeFile "/home/agentm/rel.html"
25+
26+writeRel :: Relation -> IO ()
27+writeRel = writeHTML . relationAsHTML
28+
29+tupleAsHTML :: RelationTuple -> Text
30+tupleAsHTML tuple = "<tr>" `append` T.concat (L.map tupleFrag (tupleSortedAssocs tuple)) `append` "</tr>"
31+ where
32+ tupleFrag tup = "<td>" `append` atomToText (snd tup) `append` "</td>"
33+
34+tupleSetAsHTML :: RelationTupleSet -> Text
35+tupleSetAsHTML tupSet = foldr folder "" (asList tupSet)
36+ where
37+ folder tuple acc = acc `append` tupleAsHTML tuple
src/lib/ProjectM36/Relation/Show/Term.hs → ProjectM36/Relation/Show/Term.hsrenamed+39−42
@@ -1,20 +1,14 @@
11--writes Relation to a String suitable for terminal output
22module ProjectM36.Relation.Show.Term where
33import ProjectM36.Base
4−import ProjectM36.Atom
54import ProjectM36.AtomType
65import ProjectM36.Tuple
76import ProjectM36.Relation
8−import ProjectM36.Attribute hiding (null)
7+import ProjectM36.Attribute
98import qualified Data.List as L
109import qualified Data.Text as T
11−import Control.Arrow hiding (left)
12−import Data.ByteString.Base64 as B64
13−import qualified Data.Text.Encoding as TE
14−#if __GLASGOW_HASKELL__ < 804
15−import Data.Monoid
16−#endif
17−import ProjectM36.WCWidth --guess the width that the character will appear as in the terminal
10+import qualified Data.Vector as V
11+import Data.Typeable
1812
1913boxV :: StringType
2014boxV = "│"
@@ -42,6 +36,16 @@ boxBB = "┴"
4236boxC :: StringType
4337boxC = "┼"
4438
39+dboxH :: StringType
40+dboxH = "═"
41+dboxL :: StringType
42+dboxL = "╞"
43+dboxR :: StringType
44+dboxR = "╡"
45+
46+class TermSize a where
47+ termLength :: a -> Int
48+
4549--represent a relation as a table similar to those drawn by Date
4650type Cell = StringType
4751type Table = ([Cell], [[Cell]]) --header, body
@@ -56,10 +60,10 @@ cellLocations tab@(header, _) = (maxWidths, maxHeights)
5660 where
5761 cellSizeMatrix = cellSizes tab
5862 maxWidths = foldl mergeMax (baseSize (length header)) (map fst cellSizeMatrix)
59− baseSize num = replicate num 0
63+ baseSize num = take num (repeat 0)
6064 rowHeights = map snd cellSizeMatrix
61− maxHeights = map (\l -> if null l then 0 else L.maximum l) rowHeights
62− mergeMax = zipWith max
65+ maxHeights = map (\l -> if length l == 0 then 0 else L.maximumBy compare l) rowHeights
66+ mergeMax a b = map (\(c,d) -> max c d) (zip a b)
6367
6468--the normal "lines" function returns an empty list for an empty string which is not what we want
6569breakLines :: StringType -> [StringType]
@@ -67,20 +71,20 @@ breakLines "" = [""]
6771breakLines x = T.lines x
6872
6973cellSizes :: Table -> [([Int], [Int])]
70−cellSizes (header, body) = map (map maxRowWidth &&& map (length . breakLines)) allRows
74+cellSizes (header, body) = map (\row -> (map maxRowWidth row, map (length . breakLines) row)) allRows
7175 where
72− maxRowWidth row = if null (lengths row) then
76+ maxRowWidth row = if length (lengths row) == 0 then
7377 0
7478 else
75− L.maximum (lengths row)
76− lengths row = map stringDisplayLength (breakLines row)
77− allRows = header : body
79+ L.maximumBy compare (lengths row)
80+ lengths row = map T.length (breakLines row)
81+ allRows = [header] ++ body
7882
7983relationAsTable :: Relation -> Table
8084relationAsTable rel@(Relation _ tupleSet) = (header, body)
8185 where
82− oAttrs = orderedAttributes (attributes rel)
83− oAttrNames = orderedAttributeNames (attributes rel)
86+ oAttrs = orderedAttributes rel
87+ oAttrNames = orderedAttributeNames rel
8488 header = map prettyAttribute oAttrs
8589 body :: [[Cell]]
8690 body = L.foldl' tupleFolder [] (asList tupleSet)
@@ -96,11 +100,10 @@ showParens predicate f = if predicate then
96100 f
97101
98102showAtom :: Int -> Atom -> StringType
99−showAtom _ (RelationAtom rel) = renderTable $ relationAsTable rel
100−showAtom level (ConstructedAtom dConsName _ atoms) = showParens (level >= 1 && not (null atoms)) $ T.concat (L.intersperse " " (dConsName : map (showAtom 1) atoms))
101−showAtom _ (TextAtom t) = "\"" <> t <> "\""
102−showAtom _ (ByteStringAtom bs) = TE.decodeUtf8 (B64.encode bs)
103−showAtom _ atom = atomToText atom
103+showAtom _ (Atom atom) = case cast atom of
104+ Just rel -> renderTable $ relationAsTable rel
105+ Nothing -> toText atom
106+showAtom level (ConstructedAtom dConsName _ atoms) = showParens (level >= 1 && length atoms >= 1) $ T.concat (L.intersperse " " (dConsName : (map (showAtom 1) atoms)))
104107
105108renderTable :: Table -> StringType
106109renderTable table = renderHeader table (fst cellLocs) `T.append` renderBody (snd table) cellLocs
@@ -110,27 +113,26 @@ renderTable table = renderHeader table (fst cellLocs) `T.append` renderBody (snd
110113renderHeader :: Table -> [Int] -> StringType
111114renderHeader (header, body) columnLocations = renderTopBar `T.append` renderHeaderNames `T.append` renderBottomBar
112115 where
113− renderTopBar = boxTL `T.append` T.concat (L.intersperse boxTB (map (`repeatString` boxH) columnLocations)) `T.append` boxTR `T.append` "\n"
116+ renderTopBar = boxTL `T.append` T.concat (L.intersperse boxTB (map (\x -> repeatString x boxH) columnLocations)) `T.append` boxTR `T.append` "\n"
114117 renderHeaderNames = renderRow header columnLocations 1 boxV
115− renderBottomBar = if null body then ""
118+ renderBottomBar = if length body == 0 then ""
116119 else renderHBar boxLB boxC boxRB columnLocations `T.append` "\n"
117120
118121renderHBar :: StringType -> StringType -> StringType -> [Int] -> StringType
119−renderHBar left middle end columnLocations = left `T.append` T.concat (L.intersperse middle (map (`repeatString` boxH) columnLocations)) `T.append` end
122+renderHBar left middle end columnLocations = left `T.append` T.concat (L.intersperse middle (map (\x -> repeatString x boxH) columnLocations)) `T.append` end
120123
121−--pad a block of potentially multi-lined text
122124leftPaddedString :: Int -> Int -> StringType -> StringType
123125leftPaddedString lineNum size str = if lineNum > length paddedLines -1 then
124126 repeatString size " "
125127 else
126128 paddedLines !! lineNum
127129 where
128− paddedLines = map (\line -> line `T.append` repeatString (size - stringDisplayLength line) " ") (breakLines str)
130+ paddedLines = map (\line -> line `T.append` repeatString (size - T.length line) " ") (breakLines str)
129131
130132renderRow :: [Cell] -> [Int] -> Int -> StringType -> StringType
131133renderRow cells columnLocations rowHeight interspersed = T.unlines $ map renderOneLine [0..rowHeight-1]
132134 where
133− renderOneLine lineNum = boxV `T.append` T.concat (L.intersperse interspersed (zipWith (leftPaddedString lineNum) columnLocations cells)) `T.append` boxV
135+ renderOneLine lineNum = boxV `T.append` T.concat (L.intersperse interspersed (map (\(size, value) -> leftPaddedString lineNum size value) (zip columnLocations cells))) `T.append` boxV
134136
135137renderBody :: [[Cell]] -> ([Int],[Int]) -> StringType
136138renderBody cellMatrix cellLocs = renderRows `T.append` renderBottomBar
@@ -141,19 +143,14 @@ renderBody cellMatrix cellLocs = renderRows `T.append` renderBottomBar
141143 rowHeightMatrix = zip cellMatrix (tail rowLocations)
142144 renderBottomBar = renderHBar boxBL boxBB boxBR columnLocations
143145
146+orderedAttributes :: Relation -> [Attribute]
147+orderedAttributes rel = L.sortBy (\a b -> attributeName a `compare` attributeName b) (V.toList (attributes rel))
148+
149+orderedAttributeNames :: Relation -> [AttributeName]
150+orderedAttributeNames rel = map attributeName (orderedAttributes rel)
151+
144152repeatString :: Int -> StringType -> StringType
145−repeatString c s = T.concat (replicate c s)
153+repeatString c s = T.concat (take c (repeat s))
146154
147155showRelation :: Relation -> StringType
148156showRelation rel = renderTable (relationAsTable rel)
149−
150−--use wcwidth to guess the string width in the terminal- many CJK characters can take multiple columns in a fixed width font
151−stringDisplayLength :: StringType -> Int
152−stringDisplayLength = T.foldr charSize 0
153− where
154− charSize char accum = let w = wcwidth char in
155− accum + if w < 0 then
156− 1
157− else
158− w
159−
ProjectM36/RelationalExpression.hsnew file+587
@@ -0,0 +1,587 @@
1+{-# LANGUAGE ScopedTypeVariables #-}
2+module ProjectM36.RelationalExpression where
3+import ProjectM36.Relation
4+import ProjectM36.Tuple
5+import ProjectM36.TupleSet
6+import ProjectM36.Base
7+import ProjectM36.Error
8+import ProjectM36.AtomType
9+import ProjectM36.AtomFunctionBody
10+import ProjectM36.DataTypes.Primitive
11+import ProjectM36.AtomFunction
12+import qualified ProjectM36.Attribute as A
13+import qualified Data.Map as M
14+import qualified Data.HashSet as HS
15+import Control.Monad.State hiding (join)
16+import Control.Exception
17+import Data.Maybe
18+import Data.Either
19+import Data.Char (isUpper)
20+import qualified Data.Text as T
21+import qualified Data.Vector as V
22+import qualified ProjectM36.TypeConstructorDef as TCD
23+
24+import GHC
25+import GHC.Paths
26+--import Debug.Trace
27+
28+--relvar state is needed in evaluation of relational expression but only as read-only in order to extract current relvar values
29+evalRelationalExpr :: RelationalExpr -> DatabaseState (Either RelationalError Relation)
30+evalRelationalExpr (RelationVariable name) = do
31+ relvarTable <- liftM relationVariables get
32+ return $ case M.lookup name relvarTable of
33+ Just res -> Right res
34+ Nothing -> Left $ RelVarNotDefinedError name
35+
36+evalRelationalExpr (Project attrNames expr) = do
37+ rel <- evalRelationalExpr expr
38+ case rel of
39+ Right rel2 -> return $ project attrNames rel2
40+ Left err -> return $ Left err
41+
42+evalRelationalExpr (Union exprA exprB) = do
43+ relA <- evalRelationalExpr exprA
44+ relB <- evalRelationalExpr exprB
45+ case relA of
46+ Left err -> return $ Left err
47+ Right relA2 -> case relB of
48+ Left err -> return $ Left err
49+ Right relB2 -> return $ union relA2 relB2
50+
51+evalRelationalExpr (Join exprA exprB) = do
52+ relA <- evalRelationalExpr exprA
53+ relB <- evalRelationalExpr exprB
54+ case relA of
55+ Left err -> return $ Left err
56+ Right relA2 -> case relB of
57+ Left err -> return $ Left err
58+ Right relB2 -> return $ join relA2 relB2
59+
60+evalRelationalExpr (Difference exprA exprB) = do
61+ relA <- evalRelationalExpr exprA
62+ relB <- evalRelationalExpr exprB
63+ case relA of
64+ Left err -> return $ Left err
65+ Right relA2 -> case relB of
66+ Left err -> return $ Left err
67+ Right relB2 -> return $ difference relA2 relB2
68+
69+evalRelationalExpr (MakeStaticRelation attributeSet tupleSet) = do
70+ case mkRelation attributeSet tupleSet of
71+ Right rel -> return $ Right rel
72+ Left err -> return $ Left err
73+
74+evalRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do
75+ currentContext <- get
76+ tConss <- liftM typeConstructorMapping get
77+ -- 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
78+ let eAttrs = map (evalAttrExpr tConss) (fromMaybe [] mAttrExprs)
79+ case lefts eAttrs of
80+ [] -> do
81+ let mAttrs = case mAttrExprs of
82+ Nothing -> Nothing
83+ Just _ -> Just (A.attributesFromList (rights eAttrs))
84+ eTuples = map (evalTupleExpr currentContext mAttrs) tupleExprs
85+ case lefts eTuples of
86+ [] -> do
87+ let attrs = fromMaybe firstTupleAttrs mAttrs
88+ tupList = rights eTuples
89+ firstTupleAttrs = if length tupList == 0 then A.emptyAttributes else tupleAttributes (head tupList)
90+ pure $ mkRelation attrs (RelationTupleSet tupList)
91+ errs -> pure $ Left (someErrors errs)
92+ errs -> pure $ Left (someErrors errs)
93+
94+evalRelationalExpr (ExistingRelation rel) = return (Right rel)
95+
96+evalRelationalExpr (Rename oldAttrName newAttrName relExpr) = do
97+ evald <- evalRelationalExpr relExpr
98+ case evald of
99+ Right rel -> return $ rename oldAttrName newAttrName rel
100+ Left err -> return $ Left err
101+
102+evalRelationalExpr (Group oldAttrNameSet newAttrName relExpr) = do
103+ evald <- evalRelationalExpr relExpr
104+ case evald of
105+ Right rel -> return $ group oldAttrNameSet newAttrName rel
106+ Left err -> return $ Left err
107+
108+evalRelationalExpr (Ungroup attrName relExpr) = do
109+ evald <- evalRelationalExpr relExpr
110+ case evald of
111+ Right rel -> return $ ungroup attrName rel
112+ Left err -> return $ Left err
113+
114+evalRelationalExpr (Restrict predicateExpr relExpr) = do
115+ evald <- evalRelationalExpr relExpr
116+ context <- get
117+ case evald of
118+ Left err -> return $ Left err
119+ Right rel -> case predicateRestrictionFilter context (attributes rel) predicateExpr of
120+ Left err -> return $ Left err
121+ Right filterfunc -> return $ restrict filterfunc rel
122+
123+evalRelationalExpr (Equals relExprA relExprB) = do
124+ evaldA <- evalRelationalExpr relExprA
125+ evaldB <- evalRelationalExpr relExprB
126+ case evaldA of
127+ Left err -> return $ Left err
128+ Right relA -> case evaldB of
129+ Left err -> return $ Left err
130+ Right relB -> return $ Right $ if relA == relB then relationTrue else relationFalse
131+
132+--warning: copy-pasta from above- refactor
133+evalRelationalExpr (NotEquals relExprA relExprB) = do
134+ evaldA <- evalRelationalExpr relExprA
135+ evaldB <- evalRelationalExpr relExprB
136+ case evaldA of
137+ Left err -> return $ Left err
138+ Right relA -> case evaldB of
139+ Left err -> return $ Left err
140+ Right relB -> return $ Right $ if relA /= relB then relationTrue else relationFalse
141+
142+-- extending a relation adds a single attribute with the results of the per-tuple expression evaluated
143+evalRelationalExpr (Extend tupleExpression relExpr) = do
144+ evald <- evalRelationalExpr relExpr
145+ context <- get
146+ case evald of
147+ Left err -> return $ Left err
148+ Right rel -> do
149+ case extendTupleExpressionProcessor rel tupleExpression context of
150+ Left err -> return $ Left err
151+ Right (newAttrs, tupProc) -> return $ relMogrify tupProc newAttrs rel
152+
153+emptyDatabaseContext :: DatabaseContext
154+emptyDatabaseContext = DatabaseContext { inclusionDependencies = M.empty,
155+ relationVariables = M.empty,
156+ atomFunctions = HS.empty,
157+ notifications = M.empty,
158+ typeConstructorMapping = []
159+ }
160+
161+
162+
163+--helper function to process relation variable creation/assignment
164+setRelVar :: RelVarName -> Relation -> DatabaseState (Maybe RelationalError)
165+setRelVar relVarName rel = do
166+ currentContext <- get
167+ let newRelVars = M.insert relVarName rel $ relationVariables currentContext
168+ potentialContext = currentContext { relationVariables = newRelVars }
169+ case checkConstraints potentialContext of
170+ Just err -> return $ Just err
171+ Nothing -> do
172+ put potentialContext
173+ return Nothing
174+
175+-- 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
176+deleteRelVar :: RelVarName -> DatabaseState (Maybe RelationalError)
177+deleteRelVar relVarName = do
178+ currcontext <- get
179+ let newRelVars = M.delete relVarName (relationVariables currcontext)
180+ put $ currcontext { relationVariables = newRelVars }
181+ return Nothing
182+
183+evalContextExpr :: DatabaseContextExpr -> DatabaseState (Maybe RelationalError)
184+evalContextExpr NoOperation = pure Nothing
185+
186+evalContextExpr (Define relVarName attrExprs) = do
187+ relvars <- liftM relationVariables get
188+ tConss <- liftM typeConstructorMapping get
189+ let eAttrs = map (evalAttrExpr tConss) attrExprs
190+ case lefts eAttrs of
191+ err:_ -> pure (Just err)
192+ [] -> case M.member relVarName relvars of
193+ True -> return (Just (RelVarAlreadyDefinedError relVarName))
194+ False -> setRelVar relVarName emptyRelation
195+ where
196+ attrs = A.attributesFromList (rights eAttrs)
197+ emptyRelation = Relation attrs emptyTupleSet
198+
199+evalContextExpr (Undefine relVarName) = do
200+ deleteRelVar relVarName
201+
202+evalContextExpr (Assign relVarName expr) = do
203+ -- in the future, it would be nice to get types from the RelationalExpr instead of needing to evaluate it
204+ relVarTable <- liftM relationVariables get
205+ let existingRelVar = M.lookup relVarName relVarTable
206+ value <- evalRelationalExpr expr
207+ case value of
208+ Left err -> return $ Just err
209+ Right rel -> case existingRelVar of
210+ Nothing -> setRelVar relVarName rel
211+ Just existingRel -> let expectedAttributes = attributes existingRel
212+ foundAttributes = attributes rel in
213+ if A.attributesEqual expectedAttributes foundAttributes then
214+ setRelVar relVarName rel
215+ else
216+ return $ Just (RelVarAssignmentTypeMismatchError expectedAttributes foundAttributes)
217+
218+evalContextExpr (Insert relVarName relExpr) = evalContextExpr $ Assign relVarName (Union relExpr (RelationVariable relVarName))
219+
220+--assign empty rel until restriction is implemented
221+evalContextExpr (Delete relVarName predicate) = do
222+ updatedRel <- evalRelationalExpr (Restrict (NotPredicate predicate) (RelationVariable relVarName))
223+ case updatedRel of
224+ Left err -> return $ Just err
225+ Right rel -> setRelVar relVarName rel
226+
227+--union of restricted+updated portion and the unrestricted+unupdated portion
228+evalContextExpr (Update relVarName atomExprMap restrictionPredicateExpr) = do
229+ context <- get
230+ let relVarTable = relationVariables context
231+ case M.lookup relVarName relVarTable of
232+ Nothing -> return $ Just (RelVarNotDefinedError relVarName)
233+ Just rel -> case predicateRestrictionFilter context (attributes rel) restrictionPredicateExpr of
234+ Left err -> return $ Just err
235+ Right predicateFunc -> do
236+ case makeUpdatedRel rel of
237+ Left err -> return $ Just err
238+ Right updatedRel -> setRelVar relVarName updatedRel
239+ where
240+ makeUpdatedRel relin = do
241+ restrictedPortion <- restrict predicateFunc relin
242+ unrestrictedPortion <- restrict (not . predicateFunc) relin
243+ updatedPortion <- relMap (updateTupleWithAtomExprs atomExprMap context) restrictedPortion
244+ union updatedPortion unrestrictedPortion
245+
246+evalContextExpr (AddInclusionDependency newDepName newDep) = do
247+ currContext <- get
248+ let currDeps = inclusionDependencies currContext
249+ newDeps = M.insert newDepName newDep currDeps
250+ if M.member newDepName currDeps then
251+ return $ Just (InclusionDependencyNameInUseError newDepName)
252+ else do
253+ let potentialContext = currContext { inclusionDependencies = newDeps }
254+ case checkConstraints potentialContext of
255+ Just err -> return $ Just err
256+ Nothing -> do
257+ put potentialContext
258+ return Nothing
259+
260+evalContextExpr (RemoveInclusionDependency depName) = do
261+ currContext <- get
262+ let currDeps = inclusionDependencies currContext
263+ newDeps = M.delete depName currDeps
264+ if M.notMember depName currDeps then
265+ return $ Just (InclusionDependencyNameNotInUseError depName)
266+ else do
267+ put $ currContext {inclusionDependencies = newDeps }
268+ return Nothing
269+
270+-- | Add a notification which will send the resultExpr when triggerExpr changes between commits.
271+evalContextExpr (AddNotification notName triggerExpr resultExpr) = do
272+ currentContext <- get
273+ let nots = notifications currentContext
274+ if M.member notName nots then
275+ return $ Just (NotificationNameInUseError notName)
276+ else do
277+ let newNotifications = M.insert notName newNotification nots
278+ newNotification = Notification { changeExpr = triggerExpr,
279+ reportExpr = resultExpr }
280+ put $ currentContext { notifications = newNotifications }
281+ return Nothing
282+
283+evalContextExpr (RemoveNotification notName) = do
284+ currentContext <- get
285+ let nots = notifications currentContext
286+ if M.notMember notName nots then
287+ return $ Just (NotificationNameNotInUseError notName)
288+ else do
289+ let newNotifications = M.delete notName nots
290+ put $ currentContext { notifications = newNotifications }
291+ return Nothing
292+
293+-- | Adds type and data constructors to the database context.
294+-- validate that the type *and* constructor names are unique! not yet implemented!
295+evalContextExpr (AddTypeConstructor tConsDef dConsDefList) = do
296+ currentContext <- get
297+ let oldTypes = typeConstructorMapping currentContext
298+ tConsName = TCD.name tConsDef
299+ -- validate that the constructor's types exist
300+ case validateTypeConstructorDef tConsDef dConsDefList of
301+ errs@(_:_) -> pure $ Just (someErrors errs)
302+ [] -> do
303+ if T.length tConsName < 1 || not (isUpper (T.head tConsName)) then
304+ pure $ Just (InvalidAtomTypeName tConsName)
305+ else if isJust (findTypeConstructor tConsName oldTypes) then
306+ pure $ Just (AtomTypeNameInUseError tConsName)
307+ else do
308+ let newTypes = oldTypes ++ [(tConsDef, dConsDefList)]
309+ put $ currentContext { typeConstructorMapping = newTypes }
310+ pure Nothing
311+
312+-- | Removing the atom constructor prevents new atoms of the type from being created. Existing atoms of the type remain. Thus, the atomTypes list in the DatabaseContext need not be all-inclusive.
313+evalContextExpr (RemoveTypeConstructor tConsName) = do
314+ currentContext <- get
315+ let oldTypes = typeConstructorMapping currentContext
316+ if findTypeConstructor tConsName oldTypes == Nothing then
317+ pure $ Just (AtomTypeNameNotInUseError tConsName)
318+ else do
319+ let newTypes = filter (\(tCons, _) -> TCD.name tCons /= tConsName) oldTypes
320+ put $ currentContext { typeConstructorMapping = newTypes }
321+ pure Nothing
322+
323+evalContextExpr (MultipleExpr exprs) = do
324+ --the multiple expressions must pass the same context around- not the old unmodified context
325+ evald <- forM exprs evalContextExpr
326+ --some lifting magic needed here
327+ case catMaybes evald of
328+ [] -> return $ Nothing
329+ err:_ -> return $ Just err
330+
331+evalContextExpr (RemoveAtomFunction funcName) = do
332+ currentContext <- get
333+ let atomFuncs = atomFunctions currentContext
334+ dudFunc = emptyAtomFunction funcName -- just for lookup in the hashset
335+ if HS.member dudFunc atomFuncs then do
336+ let updatedFuncs = HS.delete dudFunc atomFuncs
337+ put (currentContext {atomFunctions = updatedFuncs })
338+ pure Nothing
339+ else
340+ pure (Just (AtomFunctionNameNotInUseError funcName))
341+
342+evalDatabaseContextIOExpr :: HscEnv -> DatabaseContext -> DatabaseContextIOExpr -> IO (Either RelationalError DatabaseContext)
343+evalDatabaseContextIOExpr hscEnv currentContext (AddAtomFunction funcName funcType script) = do
344+ res <- try $ runGhc (Just libdir) $ do
345+ setSession hscEnv
346+ let atomFuncs = atomFunctions currentContext
347+ --compile the function
348+ eCompiledFunc <- compileAtomFunctionScript script
349+ pure $ case eCompiledFunc of
350+ Left err -> Left (AtomFunctionBodyScriptError err)
351+ Right compiledFunc -> do
352+ funcAtomType <- mapM (\funcTypeArg -> atomTypeForTypeConstructor funcTypeArg (typeConstructorMapping currentContext)) funcType
353+ let updatedFuncs = HS.insert newAtomFunc atomFuncs
354+ newContext = currentContext { atomFunctions = updatedFuncs }
355+ newAtomFunc = AtomFunction { atomFuncName = funcName,
356+ atomFuncType = funcAtomType,
357+ atomFuncBody = AtomFunctionBody (Just script) compiledFunc }
358+
359+ -- check if the name is already in use
360+ if HS.member newAtomFunc atomFuncs then
361+ Left (AtomFunctionNameInUseError funcName)
362+ else do
363+ Right newContext
364+ case res of
365+ Left (exc :: SomeException) -> pure $ Left (AtomFunctionBodyScriptError (OtherScriptCompilationError (show exc)))
366+ Right eContext -> case eContext of
367+ Left err -> pure (Left err)
368+ Right context' -> pure (Right context')
369+
370+updateTupleWithAtomExprs :: (M.Map AttributeName AtomExpr) -> DatabaseContext -> RelationTuple -> Either RelationalError RelationTuple
371+updateTupleWithAtomExprs exprMap context tupIn = do
372+ --resolve all atom exprs
373+ let (errors, atoms) = M.mapEither (evalAtomExpr tupIn context) exprMap
374+ if length errors > 0 then
375+ Left (MultipleErrors (M.elems errors))
376+ else
377+ Right (updateTupleWithAtoms atoms tupIn)
378+
379+--run verification on all constraints
380+checkConstraints :: DatabaseContext -> Maybe RelationalError
381+checkConstraints context = case failures of
382+ [] -> Nothing
383+ l:_ -> Just l
384+ where
385+ failures = M.elems $ M.mapMaybeWithKey checkIncDep deps
386+ deps = inclusionDependencies context
387+ eval expr = runState (evalRelationalExpr expr) context
388+ checkIncDep depName (InclusionDependency subsetExpr supersetExpr) = case evaldSub of
389+ (Left err, _) -> Just err
390+ (Right relSub, _) -> case evaldSuper of
391+ (Left err, _) -> Just err
392+ (Right relSuper, _) -> case union relSub relSuper of
393+ Left err -> Just err
394+ Right resultRel -> if resultRel == relSuper then
395+ Nothing
396+ else
397+ Just $ InclusionDependencyCheckError depName
398+ where
399+ evaldSub = eval subsetExpr
400+ evaldSuper = eval supersetExpr
401+
402+{-
403+checkConstraint :: InclusionDependency -> DatabaseState (Maybe RelationalError)
404+checkConstraint (InclusionDependency name subDep superDep) = do
405+ evalSub <- evalRelationalExpr subDep
406+ evalSuper <- evalRelationalExpr superDep
407+ case evalSub of
408+ Left err -> Just err
409+ Right relSub
410+ result <- liftM2 union evalSub evalSuper
411+ return $ Nothing
412+-}
413+
414+-- the type of a relational expression is equal to the relation attribute set returned from executing the relational expression; therefore, the type can be cheaply derived by evaluating a relational expression and ignoring and tuple processing
415+-- furthermore, the type of a relational expression is the resultant header of the evaluated empty-tupled relation
416+
417+typeForRelationalExpr :: RelationalExpr -> DatabaseState (Either RelationalError Relation)
418+typeForRelationalExpr expr = do
419+ currstate <- get
420+ --replace the relationVariables context element with a cloned set of relation devoid of tuples
421+ put $ contextWithEmptyTupleSets currstate
422+ evalRelationalExpr expr
423+
424+--returns a database context with all tuples removed
425+--this is useful for type checking and optimization
426+contextWithEmptyTupleSets :: DatabaseContext -> DatabaseContext
427+contextWithEmptyTupleSets contextIn = contextIn { relationVariables = relVars }
428+ where
429+ relVars = M.map (\rel -> Relation (attributes rel) emptyTupleSet) (relationVariables contextIn)
430+
431+{- used for restrictions- take the restrictionpredicate and return the corresponding filter function -}
432+predicateRestrictionFilter :: DatabaseContext -> Attributes -> RestrictionPredicateExpr -> Either RelationalError (RelationTuple -> Bool)
433+predicateRestrictionFilter context attrs (AndPredicate expr1 expr2) = do
434+ expr1v <- predicateRestrictionFilter context attrs expr1
435+ expr2v <- predicateRestrictionFilter context attrs expr2
436+ return $ \x -> expr1v x && expr2v x
437+
438+predicateRestrictionFilter context attrs (OrPredicate expr1 expr2) = do
439+ expr1v <- predicateRestrictionFilter context attrs expr1
440+ expr2v <- predicateRestrictionFilter context attrs expr2
441+ return $ \x -> expr1v x || expr2v x
442+
443+predicateRestrictionFilter _ _ TruePredicate = Right $ \_ -> True
444+
445+predicateRestrictionFilter context attrs (NotPredicate expr) = do
446+ exprv <- predicateRestrictionFilter context attrs expr
447+ return $ \x -> not (exprv x)
448+
449+predicateRestrictionFilter context _ (RelationalExprPredicate relExpr) = case runState (evalRelationalExpr relExpr) context of
450+ (Left err, _) -> Left err
451+ (Right rel, _) -> if rel == relationTrue then
452+ Right $ \_ -> True
453+ else if rel == relationFalse then
454+ Right $ \_ -> False
455+ else
456+ Left $ PredicateExpressionError "Relational restriction filter must evaluate to 'true' or 'false'"
457+
458+predicateRestrictionFilter context attrs (AttributeEqualityPredicate attrName atomExpr) = do
459+ attr <- A.attributeForName attrName attrs
460+ atomExprType <- typeFromAtomExpr attrs context atomExpr
461+ if atomExprType /= A.atomType attr then
462+ Left $ TupleAttributeTypeMismatchError (A.attributesFromList [attr])
463+ else
464+ Right $ \tupleIn -> case atomForAttributeName attrName tupleIn of
465+ Left _ -> False
466+ Right atomIn ->
467+ case evalAtomExpr tupleIn context atomExpr of
468+ Left _ -> False
469+ Right atomCmp -> atomCmp == atomIn
470+
471+-- in the future, it would be useful to do typechecking on the attribute and atom expr filters in advance
472+predicateRestrictionFilter context attrs (AtomExprPredicate atomExpr) = do
473+ aType <- typeFromAtomExpr attrs context atomExpr
474+ if aType /= boolAtomType then
475+ Left $ AtomTypeMismatchError aType boolAtomType
476+ else
477+ Right (\tupleIn -> case evalAtomExpr tupleIn context atomExpr of
478+ Left _ -> False
479+ Right boolAtomValue -> boolAtomValue == Atom True)
480+
481+tupleExprCheckNewAttrName :: AttributeName -> Relation -> Either RelationalError Relation
482+tupleExprCheckNewAttrName attrName rel = if isRight $ attributeForName attrName rel then
483+ Left $ AttributeNameInUseError attrName
484+ else
485+ Right rel
486+
487+extendTupleExpressionProcessor :: Relation -> ExtendTupleExpr -> DatabaseContext -> Either RelationalError (Attributes, RelationTuple -> RelationTuple)
488+extendTupleExpressionProcessor relIn
489+ (AttributeExtendTupleExpr newAttrName atomExpr) context = do
490+ _ <- tupleExprCheckNewAttrName newAttrName relIn
491+ atomExprType <- typeFromAtomExpr (attributes relIn) context atomExpr
492+ _ <- verifyAtomExprTypes relIn context atomExpr atomExprType
493+ let newAttrs = A.attributesFromList [Attribute newAttrName atomExprType]
494+ newAndOldAttrs = A.addAttributes (attributes relIn) newAttrs
495+ return $ (newAndOldAttrs, \tup -> case evalAtomExpr tup context atomExpr of
496+ Left _ -> error "logic failure in extendTupleExpressionProcessor"
497+ Right atom -> tupleAtomExtend newAttrName atom tup)
498+
499+evalAtomExpr :: RelationTuple -> DatabaseContext -> AtomExpr -> Either RelationalError Atom
500+evalAtomExpr tupIn _ (AttributeAtomExpr attrName) = atomForAttributeName attrName tupIn
501+evalAtomExpr _ _ (NakedAtomExpr atom) = Right atom
502+evalAtomExpr tupIn context (FunctionAtomExpr funcName arguments) = do
503+ let functions = atomFunctions context
504+ func <- atomFunctionForName funcName functions
505+ argTypes <- mapM (typeFromAtomExpr (tupleAttributes tupIn) context) arguments
506+ _ <- mapM (uncurry atomTypeVerify) $ init (zip (atomFuncType func) argTypes)
507+ evaldArgs <- mapM (evalAtomExpr tupIn context) arguments
508+ return $ (evalAtomFunction func) evaldArgs
509+evalAtomExpr _ context (RelationAtomExpr relExpr) = do
510+ relAtom <- evalState (evalRelationalExpr relExpr) context
511+ return $ Atom relAtom
512+evalAtomExpr tupIn context cons@(ConstructedAtomExpr dConsName dConsArgs) = do
513+ aType <- typeFromAtomExpr (tupleAttributes tupIn) context cons
514+ argAtoms <- mapM (evalAtomExpr tupIn context) dConsArgs
515+ pure (ConstructedAtom dConsName aType argAtoms)
516+
517+typeFromAtomExpr :: Attributes -> DatabaseContext -> AtomExpr -> Either RelationalError AtomType
518+typeFromAtomExpr attrs _ (AttributeAtomExpr attrName) = A.atomTypeForAttributeName attrName attrs
519+typeFromAtomExpr _ _ (NakedAtomExpr atom) = Right (atomTypeForAtom atom)
520+typeFromAtomExpr _ context (FunctionAtomExpr funcName _) = do
521+ let funcs = atomFunctions context
522+ func <- atomFunctionForName funcName funcs
523+ return $ last (atomFuncType func)
524+typeFromAtomExpr _ context (RelationAtomExpr relExpr) = do
525+ relType <- evalState (typeForRelationalExpr relExpr) context
526+ return $ RelationAtomType (attributes relType)
527+
528+-- grab the type of the data constructor, then validate that the args match the expected types
529+typeFromAtomExpr attrs context (ConstructedAtomExpr dConsName dConsArgs) = do
530+ argsTypes <- mapM (typeFromAtomExpr attrs context) dConsArgs
531+ atomTypeForDataConstructor (typeConstructorMapping context) dConsName argsTypes
532+
533+-- | Validate that the type of the AtomExpr matches the expected type.
534+verifyAtomExprTypes :: Relation -> DatabaseContext -> AtomExpr -> AtomType -> Either RelationalError AtomType
535+verifyAtomExprTypes relIn _ (AttributeAtomExpr attrName) expectedType = do
536+ attrType <- A.atomTypeForAttributeName attrName (attributes relIn)
537+ atomTypeVerify expectedType attrType
538+verifyAtomExprTypes _ _ (NakedAtomExpr atom) expectedType = atomTypeVerify expectedType (atomTypeForAtom atom)
539+verifyAtomExprTypes relIn context (FunctionAtomExpr funcName funcArgExprs) expectedType = do
540+ let functions = atomFunctions context
541+ func <- atomFunctionForName funcName functions
542+ let expectedArgTypes = atomFuncType func
543+ funcArgTypes <- mapM (\(atomExpr,expectedType2,argCount) -> case verifyAtomExprTypes relIn context atomExpr expectedType2 of
544+ Left (AtomTypeMismatchError expSubType actSubType) -> Left $ AtomFunctionTypeError funcName argCount expSubType actSubType
545+ Left err -> Left err
546+ Right x -> Right x
547+ ) $ zip3 funcArgExprs expectedArgTypes [1..]
548+ if length funcArgTypes /= length expectedArgTypes - 1 then
549+ Left $ AtomTypeCountError funcArgTypes expectedArgTypes
550+ else do
551+ atomTypeVerify expectedType (last expectedArgTypes)
552+verifyAtomExprTypes _ context (RelationAtomExpr relationExpr) expectedType = do
553+ case runState (typeForRelationalExpr relationExpr) context of
554+ (Left err, _) -> Left err
555+ (Right relType, _) -> atomTypeVerify expectedType (RelationAtomType (attributes relType))
556+verifyAtomExprTypes rel context cons@(ConstructedAtomExpr _ _) expectedType = do
557+ cType <- typeFromAtomExpr (attributes rel) context cons
558+ atomTypeVerify expectedType cType
559+
560+
561+-- | Look up the type's name and create a new attribute.
562+evalAttrExpr :: TypeConstructorMapping -> AttributeExpr -> Either RelationalError Attribute
563+evalAttrExpr aTypes (AttributeAndTypeNameExpr attrName tCons) = do
564+ aType <- atomTypeForTypeConstructor tCons aTypes
565+ Right (Attribute attrName aType)
566+
567+evalAttrExpr _ (NakedAttributeExpr attr) = Right attr
568+
569+evalTupleExpr :: DatabaseContext -> Maybe Attributes -> TupleExpr -> Either RelationalError RelationTuple
570+evalTupleExpr context attrs (TupleExpr tupMap) = do
571+ -- it's not possible for AtomExprs in tuple constructors to reference other Attributes' atoms due to the necessary order-of-operations (need a tuple to pass to evalAtomExpr)- it may be possible with some refactoring of type usage or delayed evaluation- needs more thought, but not a priority
572+ -- I could adjust this logic so that when the attributes are not specified (Nothing), then I can attempt to extract the attributes from the tuple- the type resolution will blow up if an ambiguous data constructor is used (Left 4) and this should allow simple cases to "relation{tuple{a 4}}" to be processed
573+ attrAtoms <- mapM (\(attrName, aExpr) -> do
574+ newAtom <- evalAtomExpr emptyTuple context aExpr
575+ newAtomType <- typeFromAtomExpr A.emptyAttributes context aExpr
576+ pure $ (attrName, newAtom, newAtomType)
577+ ) (M.toList tupMap)
578+ let tupAttrs = A.attributesFromList $ map (\(attrName, _, aType) -> Attribute attrName aType) attrAtoms
579+ atoms = V.fromList $ map (\(_, atom, _) -> atom) attrAtoms
580+ tup = mkRelationTuple tupAttrs atoms
581+ tConss = typeConstructorMapping context
582+ finalAttrs = fromMaybe tupAttrs attrs
583+ --verify that the attributes match
584+ when (A.attributeNameSet finalAttrs /= A.attributeNameSet tupAttrs) $ Left (TupleAttributeTypeMismatchError tupAttrs)
585+ tup' <- resolveTypesInTuple finalAttrs (reorderTuple finalAttrs tup)
586+ _ <- validateTuple tup' tConss
587+ pure tup'
ProjectM36/Server.hsnew file+85
@@ -0,0 +1,85 @@
1+{-# LANGUAGE ScopedTypeVariables #-}
2+module ProjectM36.Server where
3+
4+import ProjectM36.Client
5+import ProjectM36.Server.EntryPoints
6+import ProjectM36.Server.RemoteCallTypes
7+import ProjectM36.Server.Config (ServerConfig(..))
8+
9+import Control.Monad.IO.Class (liftIO)
10+import Network.Transport.TCP (createTransport, defaultTCPParameters)
11+import Control.Distributed.Process.Node (initRemoteTable, runProcess, newLocalNode)
12+import Control.Distributed.Process.Extras.Time (Delay(..))
13+import Control.Distributed.Process (Process, register, RemoteTable, getSelfPid)
14+import Control.Distributed.Process.ManagedProcess (defaultProcess, UnhandledMessagePolicy(..), ProcessDefinition(..), handleCall, serve, InitHandler, InitResult(..))
15+import System.IO (hPutStrLn, stderr)
16+import qualified Control.Distributed.Process.Extras.Internal.Types as DIT
17+import Control.Concurrent.MVar (putMVar, MVar)
18+
19+-- the state should be a mapping of remote connection to the disconnected transaction- the graph should be the same, so discon must be removed from the stm tuple
20+serverDefinition :: ProcessDefinition Connection
21+serverDefinition = defaultProcess {
22+ apiHandlers = [
23+ handleCall (\conn (ExecuteHeadName sessionId) -> handleExecuteHeadName sessionId conn),
24+ handleCall (\conn (ExecuteRelationalExpr sessionId expr) -> handleExecuteRelationalExpr sessionId conn expr),
25+ handleCall (\conn (ExecuteDatabaseContextExpr sessionId expr) -> handleExecuteDatabaseContextExpr sessionId conn expr),
26+ handleCall (\conn (ExecuteDatabaseContextIOExpr sessionId expr) -> handleExecuteDatabaseContextIOExpr sessionId conn expr),
27+ handleCall (\conn (ExecuteGraphExpr sessionId expr) -> handleExecuteGraphExpr sessionId conn expr),
28+ handleCall (\conn (ExecuteTypeForRelationalExpr sessionId expr) -> handleExecuteTypeForRelationalExpr sessionId conn expr),
29+ handleCall (\conn (RetrieveInclusionDependencies sessionId) -> handleRetrieveInclusionDependencies sessionId conn),
30+ handleCall (\conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> handleRetrievePlanForDatabaseContextExpr sessionId conn dbExpr),
31+ handleCall (\conn (RetrieveHeadTransactionId sessionId) -> handleRetrieveHeadTransactionId sessionId conn),
32+ handleCall (\conn (RetrieveTransactionGraph sessionId) -> handleRetrieveTransactionGraph sessionId conn),
33+ handleCall (\conn (Login procId) -> handleLogin conn procId),
34+ handleCall (\conn (CreateSessionAtHead headn) -> handleCreateSessionAtHead headn conn),
35+ handleCall (\conn (CreateSessionAtCommit commitId) -> handleCreateSessionAtCommit commitId conn),
36+ handleCall (\conn (CloseSession sessionId) -> handleCloseSession sessionId conn),
37+ handleCall (\conn (RetrieveAtomTypesAsRelation sessionId) -> handleRetrieveAtomTypesAsRelation sessionId conn),
38+ handleCall (\conn (RetrieveRelationVariableSummary sessionId) -> handleRetrieveRelationVariableSummary sessionId conn)
39+ ],
40+ unhandledMessagePolicy = Log
41+ }
42+
43+initServer :: InitHandler (Connection, DatabaseName, Maybe (MVar Port), Port) Connection
44+initServer (conn, dbname, mPortMVar, portNum) = do
45+ registerDB dbname
46+ case mPortMVar of
47+ Nothing -> pure ()
48+ Just portMVar -> liftIO $ putMVar portMVar portNum
49+ pure $ InitOk conn Infinity
50+
51+remoteTable :: RemoteTable
52+remoteTable = DIT.__remoteTable initRemoteTable
53+
54+registerDB :: DatabaseName -> Process ()
55+registerDB dbname = do
56+ self <- getSelfPid
57+ let dbname' = remoteDBLookupName dbname
58+ register dbname' self
59+ liftIO $ putStrLn $ "registered " ++ (show self) ++ " " ++ dbname'
60+
61+-- | A notification callback which logs the notification to stderr and does nothing else.
62+loggingNotificationCallback :: NotificationCallback
63+loggingNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received \"" ++ show notName ++ "\": " ++ show evaldNot
64+
65+-- | A synchronous function to start the project-m36 daemon given an appropriate 'ServerConfig'. Note that this function only returns if the server exits. Returns False if the daemon exited due to an error. If the second argument is not Nothing, the port is put after the server is ready to service the port.
66+launchServer :: ServerConfig -> Maybe (MVar Port) -> IO (Bool)
67+launchServer daemonConfig mPortMVar = do
68+ econn <- connectProjectM36 (InProcessConnectionInfo (persistenceStrategy daemonConfig) loggingNotificationCallback)
69+ case econn of
70+ Left err -> do
71+ hPutStrLn stderr ("Failed to create database connection: " ++ show err)
72+ pure False
73+ Right conn -> do
74+ let hostname = bindHost daemonConfig
75+ port = bindPort daemonConfig
76+ etransport <- createTransport hostname (show port) defaultTCPParameters
77+ case etransport of
78+ Left err -> error (show err)
79+ Right transport -> do
80+ localTCPNode <- newLocalNode transport remoteTable
81+ runProcess localTCPNode $ do
82+ serve (conn, databaseName daemonConfig, mPortMVar, port) initServer serverDefinition
83+ liftIO $ putStrLn "serve returned"
84+ pure True
85+
ProjectM36/Server/Config.hsnew file+15
@@ -0,0 +1,15 @@
1+module ProjectM36.Server.Config where
2+import ProjectM36.Client
3+
4+data ServerConfig = ServerConfig { persistenceStrategy :: PersistenceStrategy,
5+ databaseName :: DatabaseName,
6+ bindHost :: Hostname,
7+ bindPort :: Port
8+ }
9+
10+defaultServerConfig :: ServerConfig
11+defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,
12+ databaseName = "base",
13+ bindHost = "127.0.0.1",
14+ bindPort = 6543
15+ }
ProjectM36/Server/EntryPoints.hsnew file+90
@@ -0,0 +1,90 @@
1+module ProjectM36.Server.EntryPoints where
2+import ProjectM36.Base hiding (inclusionDependencies)
3+import ProjectM36.Client
4+import ProjectM36.Error
5+import Control.Distributed.Process (Process, ProcessId)
6+import Control.Distributed.Process.ManagedProcess (ProcessReply)
7+import Control.Distributed.Process.ManagedProcess.Server (reply)
8+import Control.Monad.IO.Class (liftIO)
9+import Data.Map
10+
11+handleExecuteRelationalExpr :: SessionId -> Connection -> RelationalExpr -> Process (ProcessReply (Either RelationalError Relation) Connection)
12+handleExecuteRelationalExpr sessionId conn expr = do
13+ ret <- liftIO $ executeRelationalExpr sessionId conn expr
14+ reply ret conn
15+
16+handleExecuteDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> Process (ProcessReply (Maybe RelationalError) Connection)
17+handleExecuteDatabaseContextExpr sessionId conn dbexpr = do
18+ ret <- liftIO $ executeDatabaseContextExpr sessionId conn dbexpr
19+ reply ret conn
20+
21+handleExecuteDatabaseContextIOExpr :: SessionId -> Connection -> DatabaseContextIOExpr -> Process (ProcessReply (Maybe RelationalError) Connection)
22+handleExecuteDatabaseContextIOExpr sessionId conn dbexpr = do
23+ ret <- executeDatabaseContextIOExpr sessionId conn dbexpr
24+ reply ret conn
25+
26+handleExecuteHeadName :: SessionId -> Connection -> Process (ProcessReply (Maybe HeadName) Connection)
27+handleExecuteHeadName sessionId conn = do
28+ ret <- liftIO $ headName sessionId conn
29+ reply ret conn
30+
31+handleLogin :: Connection -> ProcessId -> Process (ProcessReply Bool Connection)
32+handleLogin conn newClientProcessId = do
33+ liftIO (addClientNode conn newClientProcessId)
34+ reply True conn
35+
36+handleExecuteGraphExpr :: SessionId -> Connection -> TransactionGraphOperator -> Process (ProcessReply (Maybe RelationalError) Connection)
37+handleExecuteGraphExpr sessionId conn graphExpr = do
38+ ret <- liftIO $ executeGraphExpr sessionId conn graphExpr
39+ reply ret conn
40+
41+handleExecuteTypeForRelationalExpr :: SessionId -> Connection -> RelationalExpr -> Process (ProcessReply (Either RelationalError Relation) Connection)
42+handleExecuteTypeForRelationalExpr sessionId conn relExpr = do
43+ ret <- liftIO $ typeForRelationalExpr sessionId conn relExpr
44+ reply ret conn
45+
46+handleRetrieveInclusionDependencies :: SessionId -> Connection -> Process (ProcessReply (Either RelationalError (Map IncDepName InclusionDependency)) Connection)
47+handleRetrieveInclusionDependencies sessionId conn = do
48+ ret <- liftIO $ inclusionDependencies sessionId conn
49+ reply ret conn
50+
51+handleRetrievePlanForDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> Process (ProcessReply (Either RelationalError DatabaseContextExpr) Connection)
52+handleRetrievePlanForDatabaseContextExpr sessionId conn dbExpr = do
53+ ret <- liftIO $ planForDatabaseContextExpr sessionId conn dbExpr
54+ reply ret conn
55+
56+handleRetrieveTransactionGraph :: SessionId -> Connection -> Process (ProcessReply (Either RelationalError Relation) Connection)
57+handleRetrieveTransactionGraph sessionId conn = do
58+ ret <- liftIO $ transactionGraphAsRelation sessionId conn
59+ reply ret conn
60+
61+handleRetrieveHeadTransactionId :: SessionId -> Connection -> Process (ProcessReply (Maybe TransactionId) Connection)
62+handleRetrieveHeadTransactionId sessionId conn = do
63+ ret <- liftIO $ headTransactionId sessionId conn
64+ reply ret conn
65+
66+handleCreateSessionAtCommit :: TransactionId -> Connection -> Process (ProcessReply (Either RelationalError SessionId) Connection)
67+handleCreateSessionAtCommit commitId conn = do
68+ ret <- liftIO $ createSessionAtCommit commitId conn
69+ reply ret conn
70+
71+handleCreateSessionAtHead :: HeadName -> Connection -> Process (ProcessReply (Either RelationalError SessionId) Connection)
72+handleCreateSessionAtHead headn conn = do
73+ ret <- liftIO $ createSessionAtHead headn conn
74+ reply ret conn
75+
76+handleCloseSession :: SessionId -> Connection -> Process (ProcessReply () Connection)
77+handleCloseSession sessionId conn = do
78+ liftIO $ closeSession sessionId conn
79+ reply () conn
80+
81+handleRetrieveAtomTypesAsRelation :: SessionId -> Connection -> Process (ProcessReply (Either RelationalError Relation) Connection)
82+handleRetrieveAtomTypesAsRelation sessionId conn = do
83+ ret <- liftIO $ atomTypesAsRelation sessionId conn
84+ reply ret conn
85+
86+-- | Returns a relation which lists the names of relvars in the current session as well as its types.
87+handleRetrieveRelationVariableSummary :: SessionId -> Connection -> Process (ProcessReply (Either RelationalError Relation) Connection)
88+handleRetrieveRelationVariableSummary sessionId conn = do
89+ ret <- liftIO $ relationVariablesAsRelation sessionId conn
90+ reply ret conn
ProjectM36/Server/ParseArgs.hsnew file+43
@@ -0,0 +1,43 @@
1+module ProjectM36.Server.ParseArgs where
2+import ProjectM36.Base
3+import ProjectM36.Client
4+import Options.Applicative
5+import ProjectM36.Server.Config
6+
7+parseArgs :: Parser ServerConfig
8+parseArgs = ServerConfig <$> parsePersistenceStrategy <*> parseDatabaseName <*> parseHostname <*> parsePort
9+
10+parsePersistenceStrategy :: Parser PersistenceStrategy
11+parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>
12+ MinimalPersistence <$> dbdirOpt <|>
13+ pure NoPersistence
14+ where
15+ dbdirOpt = strOption (short 'd' <>
16+ long "database-directory" <>
17+ metavar "DIRECTORY" <>
18+ showDefaultWith show
19+ )
20+ fsyncOpt = switch (short 'f' <>
21+ long "fsync" <>
22+ help "Fsync all new transactions.")
23+
24+parseDatabaseName :: Parser DatabaseName
25+parseDatabaseName = strOption (short 'n' <>
26+ long "database" <>
27+ metavar "DATABASE_NAME")
28+
29+parseHostname :: Parser Hostname
30+parseHostname = strOption (short 'h' <>
31+ long "hostname" <>
32+ metavar "HOST_NAME" <>
33+ value (bindHost defaultServerConfig))
34+
35+parsePort :: Parser Port
36+parsePort = option auto (short 'p' <>
37+ long "port" <>
38+ metavar "PORT_NUMBER" <>
39+ value (bindPort defaultServerConfig))
40+
41+parseConfig :: IO ServerConfig
42+parseConfig = execParser $ info parseArgs idm
43+
ProjectM36/Server/RemoteCallTypes.hsnew file+45
@@ -0,0 +1,45 @@
1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}
2+module ProjectM36.Server.RemoteCallTypes where
3+import ProjectM36.Base
4+import ProjectM36.TransactionGraph
5+import ProjectM36.Session
6+import GHC.Generics
7+import Data.Binary
8+import Control.Distributed.Process (ProcessId)
9+
10+-- | The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.
11+data Login = Login ProcessId
12+ deriving (Binary, Generic)
13+
14+data Logout = Logout
15+ deriving (Binary, Generic)
16+data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr
17+ deriving (Binary, Generic)
18+data ExecuteDatabaseContextExpr = ExecuteDatabaseContextExpr SessionId DatabaseContextExpr
19+ deriving (Binary, Generic)
20+data ExecuteDatabaseContextIOExpr = ExecuteDatabaseContextIOExpr SessionId DatabaseContextIOExpr
21+ deriving (Binary, Generic)
22+data ExecuteGraphExpr = ExecuteGraphExpr SessionId TransactionGraphOperator
23+ deriving (Binary, Generic)
24+data ExecuteHeadName = ExecuteHeadName SessionId
25+ deriving (Binary, Generic)
26+data ExecuteTypeForRelationalExpr = ExecuteTypeForRelationalExpr SessionId RelationalExpr
27+ deriving (Binary, Generic)
28+data RetrieveInclusionDependencies = RetrieveInclusionDependencies SessionId
29+ deriving (Binary, Generic)
30+data RetrievePlanForDatabaseContextExpr = RetrievePlanForDatabaseContextExpr SessionId DatabaseContextExpr
31+ deriving (Binary, Generic)
32+data RetrieveTransactionGraph = RetrieveTransactionGraph SessionId
33+ deriving (Binary, Generic)
34+data RetrieveHeadTransactionId = RetrieveHeadTransactionId SessionId
35+ deriving (Binary, Generic)
36+data CreateSessionAtCommit = CreateSessionAtCommit TransactionId
37+ deriving (Binary, Generic)
38+data CreateSessionAtHead = CreateSessionAtHead HeadName
39+ deriving (Binary, Generic)
40+data CloseSession = CloseSession SessionId
41+ deriving (Binary, Generic)
42+data RetrieveAtomTypesAsRelation = RetrieveAtomTypesAsRelation SessionId
43+ deriving (Binary, Generic)
44+data RetrieveRelationVariableSummary = RetrieveRelationVariableSummary SessionId
45+ deriving (Binary, Generic)
ProjectM36/Server/RemoteCallTypes/Json.hsnew file+159
@@ -0,0 +1,159 @@
1+--create a bunch of orphan instances for use with the websocket server
2+{-# OPTIONS_GHC -fno-warn-orphans #-}
3+module ProjectM36.Server.RemoteCallTypes.Json where
4+import ProjectM36.Server.RemoteCallTypes
5+import ProjectM36.Base
6+import ProjectM36.ConcreteTypeRep
7+import ProjectM36.Error
8+
9+import Data.Aeson
10+import Data.UUID.Aeson ()
11+import Data.Proxy
12+import Data.Typeable
13+import Data.Text
14+import Data.Time.Calendar
15+import ProjectM36.Atom
16+import ProjectM36.DataTypes.Primitive
17+import ProjectM36.AtomFunctions.Primitive
18+import ProjectM36.DataTypes.Day
19+import Data.ByteString
20+
21+instance ToJSON RelationalExpr
22+instance FromJSON RelationalExpr
23+
24+instance ToJSON TupleExpr
25+instance FromJSON TupleExpr
26+
27+instance ToJSON RestrictionPredicateExpr
28+instance FromJSON RestrictionPredicateExpr
29+
30+instance ToJSON AtomExpr
31+instance FromJSON AtomExpr
32+
33+instance ToJSON RelationTupleSet
34+instance FromJSON RelationTupleSet
35+
36+instance ToJSON RelationTuple
37+instance FromJSON RelationTuple
38+
39+instance ToJSON ExecuteRelationalExpr
40+instance FromJSON ExecuteRelationalExpr
41+
42+instance ToJSON Relation
43+instance FromJSON Relation
44+
45+instance ToJSON Attribute
46+instance FromJSON Attribute
47+
48+instance ToJSON ExtendTupleExpr
49+instance FromJSON ExtendTupleExpr
50+
51+instance ToJSON AttributeNames
52+instance FromJSON AttributeNames
53+
54+instance ToJSON AttributeExpr
55+instance FromJSON AttributeExpr
56+
57+instance ToJSON AtomType
58+instance FromJSON AtomType
59+
60+instance ToJSON TypeConstructor
61+instance FromJSON TypeConstructor
62+
63+instance ToJSON TypeConstructorArg
64+instance FromJSON TypeConstructorArg
65+
66+instance ToJSON SerialRep
67+instance FromJSON SerialRep
68+
69+instance FromJSON ConcreteTypeRep where
70+ parseJSON = withObject "ctr" $ \o -> do
71+ serialRep <- o .: "serialrep"
72+ pure $ fromSerial serialRep
73+
74+instance ToJSON ConcreteTypeRep where
75+ toJSON ctr = object [
76+ "serialrep" .= toSerial ctr
77+ ]
78+
79+instance ToJSON Atom where
80+ toJSON atom@(Atom _) = let atype = atomTypeForAtom atom
81+ in
82+ if atype == intAtomType then
83+ object [
84+ "type" .= atype,
85+ "val" .= ((unsafeCast atom) :: Int)]
86+ else if atype == textAtomType then
87+ object [
88+ "type" .= atype,
89+ "val" .= ((unsafeCast atom) :: Text)]
90+ else if atype == doubleAtomType then
91+ object [
92+ "type" .= atype,
93+ "val" .= ((unsafeCast atom) :: Double)]
94+ else if atype == dayAtomType then
95+ object [
96+ "type" .= atype,
97+ "val" .= ((unsafeCast atom) :: Day)]
98+ else if atype == byteStringAtomType then
99+ object [
100+ "type" .= atype,
101+ "val" .= toText ((unsafeCast atom) :: ByteString)]
102+ else if atype == boolAtomType then
103+ object [
104+ "type" .= atype,
105+ "val" .= ((unsafeCast atom) :: Bool)]
106+ else if isRelationAtomType atype then
107+ object [
108+ "type" .= atype,
109+ "val" .= castRelation atom ]
110+ else error "invalid primitive in ToJSON implementation"
111+
112+ toJSON (ConstructedAtom dConsName atomtype atomlist) = object [
113+ "dataconstructorname" .= dConsName,
114+ "type" .= toJSON atomtype,
115+ "atomlist" .= toJSON atomlist
116+ ]
117+
118+instance FromJSON Atom where
119+ parseJSON = withObject "atom" $ \o -> do
120+ atype <- o .: "type"
121+ case atype of
122+ AnyAtomType -> fail "cannot pass AnyAtomType over the wire"
123+ caType@(ConstructedAtomType _ _) -> ConstructedAtom <$> o .: "dataconstructorname" <*> pure caType <*> o .: "atom"
124+ RelationAtomType _ -> do
125+ rel <- o .: "val"
126+ pure $ Atom (rel :: Relation)
127+ AtomType cTypeRep -> if unCTR cTypeRep == typeRep (Proxy :: Proxy Int) then
128+ intAtom <$> o .: "val"
129+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy Text) then
130+ textAtom <$> o .: "val"
131+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy Double) then
132+ doubleAtom <$> o .: "val"
133+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy Day) then
134+ dayAtom <$> o .: "val"
135+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy ByteString) then do
136+ txt <- (o .: "val")
137+ case (fromText txt) :: Either String ByteString of
138+ Left err -> fail $ "bytestring parse failure: " ++ show err
139+ Right bs -> pure $ byteStringAtom bs
140+ else if unCTR cTypeRep == typeRep (Proxy :: Proxy Bool) then
141+ boolAtom <$> o .: "val"
142+ else
143+ error "unsupported typerep serialization"
144+
145+
146+instance ToJSON Notification
147+instance FromJSON Notification
148+
149+instance ToJSON RelationalError
150+instance FromJSON RelationalError
151+
152+instance ToJSON MergeError
153+instance FromJSON MergeError
154+
155+instance ToJSON MergeStrategy
156+instance FromJSON MergeStrategy
157+
158+instance ToJSON PersistenceError
159+
ProjectM36/Server/WebSocket.hsnew file+73
@@ -0,0 +1,73 @@
1+module ProjectM36.Server.WebSocket where
2+-- while the tutd client performs TutorialD parsing on the client, the websocket server will pass tutd to be parsed and executed on the server- otherwise I have to pull in ghcjs as a dependency to allow client-side parsing- that's not appealing because then the frontend is not language-agnostic, but this could change in the future, perhaps by sending different messages over the websocket
3+-- ideally, the wire protocol should not be exposed to a straight string-based API ala SQL, so we could make perhaps a javascript DSL which compiles to the necessary JSON- anaylyze tradeoffs
4+
5+-- launch the project-m36-server
6+-- proxy all connections to it through ProjectM36.Client
7+import Control.Monad (forever)
8+import qualified Data.Text as T
9+import qualified Network.WebSockets as WS
10+import ProjectM36.Server.RemoteCallTypes.Json ()
11+import ProjectM36.Client.Json ()
12+import Data.Aeson
13+import TutorialD.Interpreter
14+import TutorialD.Interpreter.Base
15+import ProjectM36.Client
16+import Control.Exception
17+
18+-- | Called when the project-m36-server exits.
19+failureHandler :: Either SomeException Bool -> IO ()
20+failureHandler = error "project-m36-server exited unexpectedly"
21+
22+websocketProxyServer :: Port -> Hostname -> WS.ServerApp
23+websocketProxyServer port host pending = do
24+ conn <- WS.acceptRequest pending
25+ let unexpectedMsg = WS.sendTextData conn ("messagenotexpected" :: T.Text)
26+ --phase 1- accept database name for connection
27+ dbmsg <- (WS.receiveData conn) :: IO T.Text
28+ let connectdbmsg = "connectdb:"
29+ if not (connectdbmsg `T.isPrefixOf` dbmsg) then unexpectedMsg >> WS.sendClose conn ("" :: T.Text)
30+ else do
31+ let dbname = T.unpack $ T.drop (T.length connectdbmsg) dbmsg
32+ eDbconn <- createConnection conn dbname port host
33+ case eDbconn of
34+ Left err -> sendError conn err
35+ Right dbconn -> do
36+ eSessionId <- createSessionAtHead "master" dbconn
37+ case eSessionId of
38+ Left err -> sendError conn err
39+ Right sessionId -> do
40+ --phase 2- accept tutoriald commands
41+ _ <- forever $ do
42+ msg <- (WS.receiveData conn) :: IO T.Text
43+ let tutdprefix = "executetutd:"
44+ case msg of
45+ _ | tutdprefix `T.isPrefixOf` msg -> do
46+ let tutdString = T.drop (T.length tutdprefix) msg
47+ case parseTutorialD (T.unpack tutdString) of
48+ Left err -> handleOpResult conn dbconn (DisplayErrorResult ("parse error: " `T.append` T.pack (show err)))
49+ Right parsed -> do
50+ result <- evalTutorialD sessionId dbconn SafeEvaluation parsed
51+ handleOpResult conn dbconn result
52+ _ -> unexpectedMsg
53+ pure ()
54+
55+notificationCallback :: WS.Connection -> NotificationCallback
56+notificationCallback conn notifName evaldNotif = WS.sendTextData conn (encode (object ["notificationname" .= notifName,
57+ "evaldnotification" .= evaldNotif
58+ ]))
59+
60+--this creates a new database for each connection- perhaps not what we want (?)
61+createConnection :: WS.Connection -> DatabaseName -> Port -> Hostname -> IO (Either ConnectionError Connection)
62+createConnection wsconn dbname port host = connectProjectM36 (RemoteProcessConnectionInfo dbname (createNodeId host port) (notificationCallback wsconn))
63+
64+sendError :: (ToJSON a) => WS.Connection -> a -> IO ()
65+sendError conn err = WS.sendTextData conn (encode (object ["displayerror" .= err]))
66+
67+handleOpResult :: WS.Connection -> Connection -> TutorialDOperatorResult -> IO ()
68+handleOpResult conn db QuitResult = WS.sendClose conn ("close" :: T.Text) >> close db
69+handleOpResult conn _ (DisplayResult out) = WS.sendTextData conn (encode (object ["display" .= out]))
70+handleOpResult _ _ (DisplayIOResult ioout) = ioout
71+handleOpResult conn _ (DisplayErrorResult err) = WS.sendTextData conn (encode (object ["displayerror" .= err]))
72+handleOpResult conn _ QuietSuccessResult = WS.sendTextData conn (encode (object ["acknowledged" .= True]))
73+handleOpResult conn _ (DisplayRelationResult rel) = WS.sendTextData conn (encode (object ["displayrelation" .= rel]))
ProjectM36/Server/WebSocket/Main.hsnew file+19
@@ -0,0 +1,19 @@
1+import ProjectM36.Server.WebSocket
2+import ProjectM36.Server.Config
3+import ProjectM36.Server.ParseArgs
4+import ProjectM36.Server
5+import Control.Concurrent
6+import qualified Network.WebSockets as WS
7+
8+main :: IO ()
9+main = do
10+ -- launch normal project-m36-server
11+ portMVar <- newEmptyMVar
12+ serverConfig <- parseConfig
13+ let serverHost = bindHost serverConfig
14+ _ <- forkFinally (launchServer serverConfig (Just portMVar)) failureHandler
15+ --wait for server to be listening
16+ serverPort <- takeMVar portMVar
17+ --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
18+ WS.runServer "0.0.0.0" 8888 (websocketProxyServer serverPort serverHost)
19+
src/bin/ProjectM36/Server/WebSocket/project-m36.js → ProjectM36/Server/WebSocket/project-m36.jsrenamed+19−108
@@ -1,31 +1,9 @@
1−/**
2−* Returns a connection to a Project:M36 database. The connection created relies on websockets and should therefore function from any modern web browser or node server. This API is asynchronous and callback-based.
3−* @param {string} protocol - Choose from "ws://" and "wss://". "wss" is the SSL-wrapped websockets protocol and should therefore be preferred.
4−* @param {string} host - The IP address or name of the host of the database.
5−* @param {string} path - The websocket path where the websocket server is bound. Unless the project-m36-websocket-server is proxied, this is ignored by the server.
6−* @param {string} dbname - The name of the remote database.
7−* @param {openCallback} openCallback - A function to call when the connection is successfully open and ready for queries.
8−* @param {errorCallback} errorCallback - A function called if the connection process encounters an error. This is not called for errors in the queries.
9−* @param {statusCallback} statusCallback - A function called with synchronous and asynchronous status updates such as query errors and query results.
10−* @param {promptCallback} promptCallback - A function called whenever prompt information such as the current schema name and current branch name (if any).
11−* @param {closeCallback} closeCallback - A function called once the connection is closed.
12−*/
13−var ProjectM36Connection = function (protocol, host, port, path, dbname, openCallback, errorCallback, statusCallback, promptCallback, notificationCallback, closeCallback) {
14− this.protocol = protocol;
15− this.host = host;
16− this.port = port;
17− this.path = path;
18− this.dbname = dbname;
19− var connectURL = protocol + '://' + host;
20− if(port)
21− {
22− connectURL = connectURL + ":" + port;
23− }
24− if(path)
25− {
26− connectURL = connectURL + "/" + path;
27− }
28− var socket = new WebSocket(connectURL);
1+var ProjectM36Connection = function (host, port, dbname, openCallback, errorCallback, statusCallback, closeCallback) {
2+ this.host = host
3+ this.port = port
4+ this.dbname = dbname
5+ var connectURL = "ws://" + host + ":" + port + "/";
6+ var socket = new WebSocket("ws://localhost:8888/");
297 var self = this;
308 socket.onopen = function(event) {
319 self.socket.send("connectdb:" + self.dbname);
@@ -43,22 +21,12 @@ var ProjectM36Connection = function (protocol, host, port, path, dbname, openCal
4321 closeCallback(event);
4422 };
4523 this.statuscallback = statusCallback;
46− this.promptcallback = promptCallback;
47− this.notificationcallback = notificationCallback;
4824 this.socket = socket;
4925}
5026
51−/**
52−* The argument returned as part of the 'statusCallback'. Typically, only one of the three status types is populated. These status updates are groups together so that the callback can feed into a user interface update function.
53−* @callback statusCallback
54−* @param {Object} relationResult - The status update containing a relation or null.
55−* @param {Object} acknowledgementresult - The status update containing an acknowledgement that the query was executed or null.
56−* @param {Object} errorResult - The status update containing the error information or null.
57−*/
58−var ProjectM36Status = function (relationResult, dataFrameResult, acknowledgementResult, errorResult)
27+var ProjectM36Status = function (relationResult, acknowledgementResult, errorResult)
5928{
6029 this.relation = relationResult;
61− this.dataframe = dataFrameResult;
6230 this.acknowledgement = acknowledgementResult;
6331 this.error = errorResult;
6432}
@@ -76,25 +44,16 @@ ProjectM36Connection.prototype.readyState = function()
7644ProjectM36Connection.prototype.handleResponse = function(message)
7745{
7846 var relation = message["displayrelation"];
79− var dataframe = message["displaydataframe"];
8047 var acknowledged = message["acknowledged"];
8148 var error = message["displayerror"];
82− var prompt = message["promptInfo"];
83− var notification = message["notificationname"]
84−
8549 if(relation)
8650 {
87− this.statuscallback(new ProjectM36Status(relation['json'], null, null, null));
88− }
89−
90− if(dataframe)
91− {
92− this.statuscallback(new ProjectM36Status(null, dataframe['json'], null, null));
51+ this.statuscallback(new ProjectM36Status(relation, null, null));
9352 }
9453
9554 if(acknowledged)
9655 {
97− this.statuscallback(new ProjectM36Status(null, null, true, null));
56+ this.statuscallback(new ProjectM36Status(null, true, null));
9857 }
9958
10059 if(error)
@@ -103,34 +62,15 @@ ProjectM36Connection.prototype.handleResponse = function(message)
10362 {
10463 error=error.tag; // for error objects
10564 }
106− this.statuscallback(new ProjectM36Status(null, null, null, error['json']));
107− }
108−
109− if(prompt)
110− {
111− this.promptcallback(prompt["headname"], prompt["schemaname"]);
112− }
113−
114− if(notification)
115− {
116− var evaldnotif = message.evaldnotification;
117− this.notificationcallback(message.notificationname, evaldnotif);
65+ this.statuscallback(new ProjectM36Status(null, null, error));
11866 }
11967}
12068
121−/**
122−* Executes a TutorialD string.
123−* @param {string} tutd - The TutorialD string.
124−*/
12569ProjectM36Connection.prototype.executeTutorialD = function(tutd)
12670{
127− this.socket.send("executetutd/json:" + tutd);
71+ this.socket.send("executetutd:" + tutd);
12872}
12973
130−/**
131−* A utitily function which creates and returns a table element representing the relation.
132−* @param {object} - The relation returned from executing a relational expression.
133−*/
13474ProjectM36Connection.prototype.generateRelation = function(relation)
13575{
13676 var table = document.createElement("table");
@@ -168,10 +108,13 @@ ProjectM36Connection.prototype.generateAtomType = function(attr)
168108{
169109 var atomType = attr[1]["tag"];
170110 var attrName = attr[0];
171− var accessory = attr[2];
172111 var element = document.createElement("span");
173112 element.textContent = attrName + "::";
174− if (atomType == "RelationAtomType")
113+ if(atomType == "AtomType")
114+ {
115+ element.textContent += attr[1]["contents"]["serialrep"][0][2];
116+ }
117+ else if (atomType == "RelationAtomType")
175118 {
176119 var table = document.createElement("table");
177120 element.appendChild(table);
@@ -190,14 +133,9 @@ ProjectM36Connection.prototype.generateAtomType = function(attr)
190133 }
191134 else
192135 {
193− var readableType = atomType.slice(0,-8);
194− element.textContent += readableType;
195− }
196− if(accessory)
197− {
198− element.textContent += accessory;
136+ element.textContent = "unknown";
199137 }
200− return element;
138+ return element
201139}
202140
203141ProjectM36Connection.prototype.generateRelationBody = function (body)
@@ -242,33 +180,6 @@ ProjectM36Connection.prototype.generateAtom = function(atom)
242180 return element;
243181}
244182
245−ProjectM36Connection.prototype.generateDataFrame = function(dataframe)
246−{
247− for(var attrIndex=0; attrIndex < dataframe.attributes.length; attrIndex++)
248− {
249− var attr = dataframe.attributes[attrIndex];
250− var ordering = "↕";
251− for(var orderIndex=0; orderIndex < dataframe.orders.length; orderIndex++)
252− {
253− var order = dataframe.orders[orderIndex];
254− if(order[0] == attr[0])
255− {
256− if(order[1] == "AscendingOrder")
257− {
258− ordering = "⬆";
259− }
260− else if(order[1] == "DescendingOrder")
261− {
262− ordering = "⬇";
263− }
264− }
265− }
266− dataframe.attributes[attrIndex].push(ordering);
267− }
268− return this.generateRelation([dataframe.attributes,
269− {asList:dataframe.tuples}]);
270−}
271−
272183//special case to make sure that a table appears for "true" and "false"
273184function mungeEmptyRows()
274185{
@@ -288,4 +199,4 @@ function mungeEmptyRows()
288199 empty.appendChild(dudHeader);
289200 }
290201 }
291−}
202+}
src/bin/ProjectM36/Server/WebSocket/websocket-client.html → ProjectM36/Server/WebSocket/websocket-client.htmlrenamed+17−48
@@ -5,7 +5,6 @@
55<title>Project:M36 WebSocket Client</title>
66<script type="text/javascript" src="project-m36.js"></script>
77<script type="text/javascript" src="websocket-client.js"></script>
8−<script type="text/javascript" src="websocket-config.js"></script>
98<style>
109#sectiontemplate
1110{
@@ -14,6 +13,7 @@
1413
1514.deletesection
1615{
16+ float:right;
1717 border: 1px solid;
1818 padding: 3px;
1919 border-radius: 3px;
@@ -29,7 +29,6 @@ background-image: linear-gradient(to right, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.75
2929
3030.title
3131{
32−font-family: Courier;
3332padding: 3pt;
3433border: 1px solid;
3534border-radius: 3px;
@@ -37,11 +36,6 @@ background-image: linear-gradient(to top, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.1),
3736margin: 3px;
3837}
3938
40−.titlesection
41−{
42−margin-bottom: 5pt;
43−}
44−
4539.result table
4640{
4741 border-collapse: collapse;
@@ -60,19 +54,14 @@ margin-bottom: 5pt;
6054 background-image: linear-gradient(to top, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.1), rgba(0, 0, 0, 0));
6155}
6256
63−#connection #port
64−{
65− width: 50pt;
66−}
67−
6857#connection input
6958{
70− width: 100pt;
59+ width: 100px;
7160}
7261
73−#samples li
62+#samples
7463{
75− font-family: Courier;
64+ display:none;
7665}
7766
7867#samplesouter
@@ -88,45 +77,22 @@ margin-bottom: 5pt;
8877 background-color: #d1d1e0;
8978}
9079
91−#tutd
92−{
93− width: 300pt;
94− height: 50pt;
95−}
96−
9780</style>
9881</head>
99−<body onload="pageload();">
100−<h1><a href="https://github.com/agentm/project-m36">Project:M36</a> WebSocket Client</h1>
101−<p>This page will allow you to try TutorialD straight from your browser. Try some of the sample queries below.</p>
82+<body onload="installSampleHandlers();">
83+<h1>Project:M36 WebSocket Client</h1>
10284<div id="sheet">
10385 <div id="interactor">
10486 <form onsubmit="return connectOrDisconnect(this);" id="connection">
105− <span id="conninfo">Connect to: </span>
106− <select name="protocol">
107− <option value="wss" selected="selected">wss://</option>
108− <option value="ws">ws://</option>
109− </select>
110− <input type="text" name="host" value="localhost" placeholder="Host"/>:
111− <input id="port" type="number" placeholder="Port" name="port" min="0" max="65535" value="8888"/>/
112− <input type="text" name="path" placeholder="path" value=""/>
113− <label>database:</label><input type="text" placeholder="Database Name" name="dbname" value="test"/>
114− <input type="submit" name="connect" value="Connect"/>
115− </form>
116− <form onsubmit="return execTutorialD();">
117− <textarea id="tutd" placeholder="Enter a TutorialD query here."></textarea>
118− <br/>
119− <label id="promptinfo"></label>
120− <input type="submit" id="eval" value="Evaluate TutorialD" disabled="disabled"/>
87+ <label>Connection:</label><input type="text" name="host" value="localhost" placeholder="Host"/>:<input type="number" placeholder="Port" name="port" min="0" max="32767" value="8888"/>/<input type="text" placeholder="Database Name" name="dbname" value="test"/><input type="submit" name="connect" value="Connect"/>
12188 </form>
122− <div id="samplesouter">
123− <span>Try our <a href="https://github.com/agentm/project-m36/blob/master/docs/15_minute_tutorial.markdown">15 minute TutorialD Tutorial</a> or click these sample queries below:</span>
89+ <div onmouseover="toggleSamples(this, true);" onmouseleave="toggleSamples(this, false);" id="samplesouter">
90+ <span>Sample TutorialD: <a href="https://github.com/agentm/project-m36/blob/master/docs/15_minute_tutorial.markdown">15 minute TutorialD Tutorial</a>.</span>
12491</span>
12592 <ul id="samples">
126− <li>:showrelvars</li>
12793 <li>:showexpr true</li>
12894 <li>:showexpr false</li>
129− <li>:importexample cjdate</li>
95+ <li>:importexample date</li>
13096 <li>:showexpr s join sp</li>
13197 <li>update s where city=&quot;Paris&quot; (status:=10)</li>
13298 <li>:showexpr s</li>
@@ -134,12 +100,15 @@ margin-bottom: 5pt;
134100 <li>:showgraph</li>
135101 </ul>
136102 </div>
103+ <form onsubmit="return execTutorialD();">
104+ <input type="text" id="tutd"/>
105+ <input type="submit"/>
106+ </form>
137107 </div>
138108 <div id="sectiontemplate">
139− <div class="titlesection">
140− <span class="deletesection" onclick="return hideResult(this);">-</span>
141− <span class="title"></span>
142− </div>
109+ <span class="title"></span>
110+ <span class="deletesection" onclick="return hideParent(this);">X</span>
111+ <div style="clear: both;"></div>
143112 <div class="result">
144113 </div>
145114 <span class="relinfo"></span>
src/bin/ProjectM36/Server/WebSocket/websocket-client.js → ProjectM36/Server/WebSocket/websocket-client.jsrenamed+19−124
@@ -30,12 +30,6 @@ function updateStatus(status)
3030 appendResult(tutd, relastable);
3131 mungeEmptyRows();
3232 }
33− if(status.dataframe)
34− {
35− var dataframeastable = conn.generateDataFrame(status.dataframe);
36− appendResult(tutd, dataframeastable);
37− mungeEmptyRows();
38− }
3933 if(status.acknowledgement)
4034 {
4135 var ok = document.createElement("span");
@@ -50,87 +44,28 @@ function updateStatus(status)
5044 }
5145}
5246
53−function promptUpdate(headName, schemaName)
54−{
55− document.getElementById("promptinfo").textContent = "Current Branch: (" + headName + ") Schema: (" + schemaName + ")";
56−}
57−
58−function relationErrorAsString(errObj)
59−{
60− return errObj.tag + " " + errObj.contents;
61−}
62−
63−function notificationUpdate(notificationName, evaldNotif)
64−{
65− //generate two tables for display
66− var notifDiv = document.createElement('div');
67− var oldInfo = document.createElement('div');
68− oldInfo.textContent = "Pre-change info: ";
69− var newInfo = document.createElement('div');
70− newInfo.textContent = "Post-change info: ";
71− var status = "Notification received: " + notificationName;
72−
73− if(evaldNotif.reportOldRelation.Left)
74− {
75− var errOld = evaldNotif.reportOldRelation.Left;
76− oldInfo.textContent += relationErrorAsString(errOld);
77− }
78− else if(evaldNotif.reportOldRelation.Right)
79− {
80− oldInfo.appendChild(conn.generateRelation(evaldNotif.reportOldRelation.Right));
81− }
82−
83− if(evaldNotif.reportNewRelation.Left)
84− {
85− var errNew = evaldNotif.reportNewRelation.Left;
86− newInfo.textContent += relationErrorAsString(errNew);
87− }
88− else if(evaldNotif.reportNewRelation.Right)
89− {
90− newInfo.appendChild(conn.generateRelation(evaldNotif.reportNewRelation.Right));
91− }
92−
93− notifDiv.appendChild(oldInfo);
94− notifDiv.appendChild(document.createElement('br'));
95− notifDiv.appendChild(newInfo);
96− appendResult(status,notifDiv);
97− mungeEmptyRows();
98−}
99−
10047var conn;
10148
10249function connectOrDisconnect(form)
10350{
10451 var formin = form.elements;
105− var protocol = formin["protocol"].value;
10652 var host = formin["host"].value;
10753 var port = formin["port"].value;
108− var path = formin["path"].value;
10954 var dbname = formin["dbname"].value;
110−
111− var conninfo = document.getElementById("conninfo");
112− var promptInfo = document.getElementById("promptinfo");
11355
11456 if(window.conn && window.conn.readyState() == 1)
11557 {
11658 //disconnect
11759 window.conn.close();
118− conninfo.textContent = "Connect to:";
119−
12060 toggleConnectionFields(form, true, "Connect");
121− promptInfo.textContent = "";
12261 }
12362 else
12463 {
12564 //connect
126− conninfo.textContent = "Connected to:";
127− window.conn = new ProjectM36Connection(protocol, host, port, path,
128− dbname,
65+ window.conn = new ProjectM36Connection(host, port, dbname,
12966 connectionOpened,
13067 connectionError,
13168 updateStatus,
132− promptUpdate,
133− notificationUpdate,
13469 connectionClosed);
13570 toggleConnectionFields(form, false, "Connecting...");
13671 }
@@ -153,14 +88,7 @@ function connectionClosed(event)
15388function toggleConnectionFields(form, enabled, status)
15489{
15590 form.elements["connect"].value = status;
156− var readonlyElements = [form.elements["host"],
157− form.elements["port"],
158− form.elements["dbname"],
159− form.elements["path"]];
160− var disableElements = [form.elements["protocol"],
161− ]
162− var enableElements = [document.getElementById("eval")];
163−
91+ var readonlyElements = [form.elements["host"], form.elements["port"], form.elements["dbname"]];
16492 for(var ein=0; ein < readonlyElements.length; ein++)
16593 {
16694 var e = readonlyElements[ein];
@@ -173,37 +101,6 @@ function toggleConnectionFields(form, enabled, status)
173101 e.setAttribute("readonly", "readonly");
174102 }
175103 }
176− //also update the eval/submit button
177− for(var ein=0; ein < disableElements.length; ein++)
178− {
179− var e = disableElements[ein];
180− if(enabled)
181− {
182− e.removeAttribute("disabled");
183− }
184− else
185− {
186− e.setAttribute("disabled", "disabled");
187−
188− }
189− }
190−
191− for(var ein=0; ein < enableElements.length; ein++)
192− {
193− var e = enableElements[ein];
194− if(!enabled)
195− {
196− e.removeAttribute("disabled");
197− }
198− else
199− {
200− e.setAttribute("disabled", "disabled");
201−
202− }
203− }
204−
205−
206−
207104}
208105
209106function connectionOpened(event)
@@ -227,10 +124,23 @@ function execTutorialD()
227124 return false;
228125}
229126
230−function hideResult(element)
127+function hideParent(element)
231128{
232− var deleteNode = element.parentNode.parentNode;
233− element.parentNode.parentNode.parentNode.removeChild(deleteNode)
129+ var deleteNode = element.parentNode;
130+ element.parentNode.parentNode.removeChild(deleteNode)
131+}
132+
133+function toggleSamples(element,show)
134+{
135+ var samples = document.getElementById("samples");
136+ if(show)
137+ {
138+ samples.style.display = "block";
139+ }
140+ else
141+ {
142+ samples.style.display = "none";
143+ }
234144}
235145
236146function installSampleHandlers()
@@ -244,19 +154,4 @@ function installSampleHandlers()
244154 tutd.value = el.target.textContent;
245155 }
246156 }
247−}
248−
249−function setupDefaultConfig()
250−{
251− var form = document.getElementById("connection");
252− for(var key in defaultConfig)
253− {
254− form.elements[key].value = defaultConfig[key];
255− }
256−}
257−
258−function pageload()
259−{
260− installSampleHandlers();
261− setupDefaultConfig();
262−}
157+}
src/bin/ProjectM36/Server/project-m36-server.hs → ProjectM36/Server/project-m36-server.hsrenamed

The content is the same.

ProjectM36/Session.hsnew file+16
@@ -0,0 +1,16 @@
1+module ProjectM36.Session where
2+import ProjectM36.Base
3+import Data.UUID
4+
5+type SessionId = UUID
6+
7+--the persistence of a session is as long as the life of the database (not serialized to disk)
8+-- sessions are not associated with connections and have separate lifetimes
9+data Session = Session DisconnectedTransaction
10+
11+sessionContext :: Session -> DatabaseContext
12+sessionContext (Session (DisconnectedTransaction _ context)) = context
13+
14+sessionParentId :: Session -> TransactionId
15+sessionParentId (Session (DisconnectedTransaction parentUUID _)) = parentUUID
16+
ProjectM36/Sessions.hsnew file+29
@@ -0,0 +1,29 @@
1+module ProjectM36.Sessions where
2+import Control.Concurrent.STM
3+import qualified STMContainers.Map as STMMap
4+import ListT
5+import ProjectM36.Attribute
6+import ProjectM36.Base
7+import ProjectM36.DataTypes.Primitive
8+import ProjectM36.Session
9+import ProjectM36.Atom
10+import ProjectM36.Relation
11+import ProjectM36.Error
12+import qualified Data.UUID as U
13+
14+type Sessions = STMMap.Map SessionId Session
15+
16+stmMapToList :: STMMap.Map k v -> STM [(k, v)]
17+stmMapToList = ListT.fold (\l -> return . (:l)) [] . STMMap.stream
18+
19+uuidAtom :: U.UUID -> Atom
20+uuidAtom = textAtom . U.toText
21+
22+sessionsAsRelation :: Sessions -> STM (Either RelationalError Relation)
23+sessionsAsRelation sessions = do
24+ sessionAssocs <- stmMapToList sessions
25+ let atomMatrix = map (\(sessionId, (Session (DisconnectedTransaction parentUUID _))) -> [uuidAtom sessionId, uuidAtom parentUUID]) sessionAssocs
26+ pure $ mkRelationFromList (attributesFromList [Attribute "sessionid" textAtomType,
27+ Attribute "parentCommit" textAtomType]) atomMatrix
28+
29+
ProjectM36/StaticOptimizer.hsnew file+179
@@ -0,0 +1,179 @@
1+module ProjectM36.StaticOptimizer where
2+import ProjectM36.Base
3+import ProjectM36.RelationalExpression
4+import ProjectM36.Relation
5+import ProjectM36.Error
6+import qualified ProjectM36.AttributeNames as AS
7+import ProjectM36.TupleSet
8+import Control.Monad.State hiding (join)
9+import Data.Either (rights, lefts)
10+
11+-- the static optimizer performs optimizations which need not take any specific-relation statistics into account
12+-- apply optimizations which merely remove steps to become no-ops: example: projection of a relation across all of its attributes => original relation
13+
14+--should optimizations offer the possibility to return errors? If they perform the up-front type-checking, maybe so
15+applyStaticRelationalOptimization :: RelationalExpr -> DatabaseState (Either RelationalError RelationalExpr)
16+applyStaticRelationalOptimization e@(MakeStaticRelation _ _) = return $ Right e
17+
18+applyStaticRelationalOptimization e@(MakeRelationFromExprs _ _) = return $ Right e
19+
20+applyStaticRelationalOptimization e@(ExistingRelation _) = return $ Right e
21+
22+applyStaticRelationalOptimization e@(RelationVariable _) = return $ Right e
23+
24+--remove project of attributes which removes no attributes
25+applyStaticRelationalOptimization (Project attrNameSet expr) = do
26+ relType <- typeForRelationalExpr expr
27+ case relType of
28+ Left err -> return $ Left err
29+ Right relType2 -> if attributeNames relType2 == AS.attributeNameSet attrNameSet then
30+ applyStaticRelationalOptimization expr
31+ else do
32+ optimizedSubExpression <- applyStaticRelationalOptimization expr
33+ case optimizedSubExpression of
34+ Left err -> return $ Left err
35+ Right optSubExpr -> return $ Right $ Project attrNameSet optSubExpr
36+
37+applyStaticRelationalOptimization (Union exprA exprB) = do
38+ optExprA <- applyStaticRelationalOptimization exprA
39+ optExprB <- applyStaticRelationalOptimization exprB
40+ case optExprA of
41+ Left err -> return $ Left err
42+ Right optExprAx -> case optExprB of
43+ Left err -> return $ Left err
44+ Right optExprBx -> if optExprAx == optExprBx then
45+ return (Right optExprAx)
46+ else
47+ return $ Right $ Union optExprAx optExprBx
48+
49+applyStaticRelationalOptimization (Join exprA exprB) = do
50+ optExprA <- applyStaticRelationalOptimization exprA
51+ optExprB <- applyStaticRelationalOptimization exprB
52+ case optExprA of
53+ Left err -> return $ Left err
54+ Right optExprA2 -> case optExprB of
55+ Left err -> return $ Left err
56+ Right optExprB2 -> if optExprA == optExprB then --A join A == A
57+ return optExprA
58+ else
59+ return $ Right (Join optExprA2 optExprB2)
60+
61+applyStaticRelationalOptimization (Difference exprA exprB) = do
62+ optExprA <- applyStaticRelationalOptimization exprA
63+ optExprB <- applyStaticRelationalOptimization exprB
64+ case optExprA of
65+ Left err -> return $ Left err
66+ Right optExprA2 -> case optExprB of
67+ Left err -> return $ Left err
68+ Right optExprB2 -> if optExprA == optExprB then do --A difference A == A where false
69+ eEmptyRel <- typeForRelationalExpr optExprA2
70+ case eEmptyRel of
71+ Left err -> pure (Left err)
72+ Right emptyRel -> pure (Right (ExistingRelation emptyRel))
73+ else
74+ return $ Right (Difference optExprA2 optExprB2)
75+
76+applyStaticRelationalOptimization e@(Rename _ _ _) = return $ Right e
77+
78+applyStaticRelationalOptimization (Group oldAttrNames newAttrName expr) = do
79+ return $ Right $ Group oldAttrNames newAttrName expr
80+
81+applyStaticRelationalOptimization (Ungroup attrName expr) = do
82+ return $ Right $ Ungroup attrName expr
83+
84+--remove restriction of nothing
85+applyStaticRelationalOptimization (Restrict predicate expr) = do
86+ optimizedPredicate <- applyStaticPredicateOptimization predicate
87+ case optimizedPredicate of
88+ Left err -> return $ Left err
89+ Right optimizedPredicate2 -> if optimizedPredicate2 == TruePredicate then
90+ applyStaticRelationalOptimization expr
91+ else if optimizedPredicate2 == NotPredicate TruePredicate then do
92+ attributesRel <- typeForRelationalExpr expr
93+ case attributesRel of
94+ Left err -> return $ Left err
95+ Right attributesRelA -> return $ Right $ MakeStaticRelation (attributes attributesRelA) emptyTupleSet
96+ else do
97+ optimizedSubExpression <- applyStaticRelationalOptimization expr
98+ case optimizedSubExpression of
99+ Left err -> return $ Left err
100+ Right optSubExpr -> return $ Right $ Restrict optimizedPredicate2 optSubExpr
101+
102+applyStaticRelationalOptimization e@(Equals _ _) = return $ Right e
103+
104+applyStaticRelationalOptimization e@(NotEquals _ _) = return $ Right e
105+
106+applyStaticRelationalOptimization e@(Extend _ _) = return $ Right e
107+
108+applyStaticDatabaseOptimization :: DatabaseContextExpr -> DatabaseState (Either RelationalError DatabaseContextExpr)
109+applyStaticDatabaseOptimization x@NoOperation = pure $ Right x
110+applyStaticDatabaseOptimization x@(Define _ _) = pure $ Right x
111+
112+applyStaticDatabaseOptimization x@(Undefine _) = pure $ Right x
113+
114+applyStaticDatabaseOptimization (Assign name expr) = do
115+ optimizedExpr <- applyStaticRelationalOptimization expr
116+ case optimizedExpr of
117+ Left err -> return $ Left err
118+ Right optimizedExpr2 -> return $ Right (Assign name optimizedExpr2)
119+
120+applyStaticDatabaseOptimization (Insert name expr) = do
121+ optimizedExpr <- applyStaticRelationalOptimization expr
122+ case optimizedExpr of
123+ Left err -> return $ Left err
124+ Right optimizedExpr2 -> return $ Right (Insert name optimizedExpr2)
125+
126+applyStaticDatabaseOptimization (Delete name predicate) = do
127+ optimizedPredicate <- applyStaticPredicateOptimization predicate
128+ case optimizedPredicate of
129+ Left err -> return $ Left err
130+ Right optimizedPredicate2 -> return $ Right (Delete name optimizedPredicate2)
131+
132+applyStaticDatabaseOptimization (Update name upmap predicate) = do
133+ optimizedPredicate <- applyStaticPredicateOptimization predicate
134+ case optimizedPredicate of
135+ Left err -> return $ Left err
136+ Right optimizedPredicate2 -> return $ Right (Update name upmap optimizedPredicate2)
137+
138+applyStaticDatabaseOptimization dep@(AddInclusionDependency _ _) = return $ Right dep
139+
140+applyStaticDatabaseOptimization (RemoveInclusionDependency name) = return $ Right (RemoveInclusionDependency name)
141+
142+applyStaticDatabaseOptimization (AddNotification name triggerExpr resultExpr) = do
143+ eTriggerExprOpt <- applyStaticRelationalOptimization triggerExpr
144+ case eTriggerExprOpt of
145+ Left err -> pure $ Left err
146+ Right triggerExprOpt -> do
147+ eResultExprOpt <- applyStaticRelationalOptimization resultExpr
148+ case eResultExprOpt of
149+ Left err -> pure $ Left err
150+ Right resultExprOpt -> pure (Right (AddNotification name triggerExprOpt resultExprOpt))
151+
152+applyStaticDatabaseOptimization notif@(RemoveNotification _) = pure (Right notif)
153+
154+applyStaticDatabaseOptimization c@(AddTypeConstructor _ _) = pure (Right c)
155+applyStaticDatabaseOptimization c@(RemoveTypeConstructor _) = pure (Right c)
156+applyStaticDatabaseOptimization c@(RemoveAtomFunction _) = pure (Right c)
157+
158+--optimization: from pgsql lists- check for join condition referencing foreign key- if join projection project away the referenced table, then it does not need to be scanned
159+
160+--applyStaticDatabaseOptimization (MultipleExpr exprs) = return $ Right $ MultipleExpr exprs
161+--for multiple expressions, we must evaluate
162+applyStaticDatabaseOptimization (MultipleExpr exprs) = do
163+ context <- get
164+ let optExprs = evalState substateRunner (contextWithEmptyTupleSets context)
165+ let errors = lefts optExprs
166+ if length errors > 0 then
167+ return $ Left (head errors)
168+ else
169+ return $ Right $ MultipleExpr (rights optExprs)
170+ where
171+ substateRunner = forM exprs $ \expr -> do
172+ --a previous expression could create a relvar, we don't want to miss it, so we clear the tuples and execute the expression to get an empty relation in the relvar
173+ _ <- evalContextExpr expr
174+ applyStaticDatabaseOptimization expr
175+ --this error handling could be improved with some lifting presumably
176+ --restore original context
177+
178+applyStaticPredicateOptimization :: RestrictionPredicateExpr -> DatabaseState (Either RelationalError RestrictionPredicateExpr)
179+applyStaticPredicateOptimization predicate = return $ Right predicate
ProjectM36/Transaction.hsnew file+34
@@ -0,0 +1,34 @@
1+module ProjectM36.Transaction where
2+import ProjectM36.Base
3+import qualified Data.Set as S
4+import qualified Data.UUID as U
5+
6+--create a disconnected transaction with a parent
7+newDisconnectedTransaction :: TransactionId -> DatabaseContext -> DisconnectedTransaction
8+newDisconnectedTransaction parentId context = DisconnectedTransaction parentId context
9+
10+transactionParentIds :: Transaction -> S.Set TransactionId
11+transactionParentIds (Transaction _ (TransactionInfo pId _) _) = S.singleton pId
12+transactionParentIds (Transaction _ (MergeTransactionInfo pId1 pId2 _) _) = S.fromList [pId1, pId2]
13+
14+transactionChildIds :: Transaction -> S.Set TransactionId
15+transactionChildIds (Transaction _ (TransactionInfo _ children) _) = children
16+transactionChildIds (Transaction _ (MergeTransactionInfo _ _ children) _) = children
17+
18+-- | Create a new transaction which is identical to the original except that a new set of child transaction ids is added.
19+transactionSetChildren :: Transaction -> S.Set TransactionId -> Transaction
20+transactionSetChildren t@(Transaction _ (TransactionInfo pId _) _) childIds = Transaction (transactionId t) (TransactionInfo pId childIds) (transactionContext t)
21+transactionSetChildren t@(Transaction _ (MergeTransactionInfo pId1 pId2 _) _) childIds = Transaction (transactionId t) (MergeTransactionInfo pId1 pId2 childIds) (transactionContext t)
22+
23+-- | Return the same transaction but referencing only the specific child transactions. This is useful when traversing a graph and returning a subgraph. This doesn't filter parent transactions because it assumes a head-to-root traversal.
24+filterTransactionInfoTransactions :: S.Set TransactionId -> TransactionInfo -> TransactionInfo
25+filterTransactionInfoTransactions filterIds (TransactionInfo parentId childIds) = TransactionInfo (filterParent parentId filterIds) (S.intersection childIds filterIds)
26+filterTransactionInfoTransactions filterIds (MergeTransactionInfo parentIdA parentIdB childIds) = MergeTransactionInfo (filterParent parentIdA filterIds) (filterParent parentIdB filterIds) (S.intersection childIds filterIds)
27+
28+filterParent :: TransactionId -> S.Set TransactionId -> TransactionId
29+filterParent parentId validIds = if S.member parentId validIds then parentId else U.nil
30+
31+-- | Remove any child or parent transaction references not in the valud UUID set.
32+filterTransaction :: S.Set TransactionId -> Transaction -> Transaction
33+filterTransaction filterIds (Transaction selfId tInfo context) = Transaction selfId (filterTransactionInfoTransactions filterIds tInfo) context
34+
ProjectM36/Transaction/Persist.hsnew file+147
@@ -0,0 +1,147 @@
1+module ProjectM36.Transaction.Persist where
2+import ProjectM36.Base
3+import ProjectM36.Error
4+import ProjectM36.Persist (writeBSFileSync, DiskSync, renameSync)
5+import qualified Data.Map as M
6+import qualified Data.HashSet as HS
7+import qualified Data.Binary as B
8+import qualified Data.ByteString.Lazy as BS
9+import System.FilePath
10+import System.Directory
11+import qualified Data.Text as T
12+import Control.Monad
13+import ProjectM36.AtomFunctions.Basic (basicAtomFunctions)
14+
15+getDirectoryNames :: FilePath -> IO [FilePath]
16+getDirectoryNames path = do
17+ subpaths <- getDirectoryContents path
18+ return $ filter (\n -> n `notElem` ["..", "."]) subpaths
19+
20+tempTransactionDir :: FilePath -> TransactionId -> FilePath
21+tempTransactionDir dbdir transId = dbdir </> "." ++ show transId
22+
23+transactionDir :: FilePath -> TransactionId -> FilePath
24+transactionDir dbdir transId = dbdir </> show transId
25+
26+transactionInfoPath :: FilePath -> FilePath
27+transactionInfoPath transdir = transdir </> "info"
28+
29+relvarsDir :: FilePath -> FilePath
30+relvarsDir transdir = transdir </> "relvars"
31+
32+incDepsDir :: FilePath -> FilePath
33+incDepsDir transdir = transdir </> "incdeps"
34+
35+atomFuncsDir :: FilePath -> FilePath
36+atomFuncsDir transdir = transdir </> "atomfuncs"
37+
38+typeConsPath :: FilePath -> FilePath
39+typeConsPath transdir = transdir </> "typecons"
40+
41+readTransaction :: FilePath -> TransactionId -> IO (Either PersistenceError Transaction)
42+readTransaction dbdir transId = do
43+ let transDir = transactionDir dbdir transId
44+ transDirExists <- doesDirectoryExist transDir
45+ if not transDirExists then
46+ return $ Left $ MissingTransactionError transId
47+ else do
48+ relvars <- readRelVars transDir
49+ transInfo <- liftM B.decode $ BS.readFile (transactionInfoPath transDir)
50+ incDeps <- readIncDeps transDir
51+ typeCons <- readTypeConstructorMapping transDir
52+ --atomFuncs <- readAtomFuncs transDir -- not yet supported since there is no bytecode to serialize yet
53+ let atomFuncs = basicAtomFunctions
54+ let newContext = DatabaseContext { inclusionDependencies = incDeps,
55+ relationVariables = relvars,
56+ typeConstructorMapping = typeCons,
57+ notifications = M.empty,
58+ atomFunctions = atomFuncs }
59+
60+ return $ Right $ Transaction transId transInfo newContext
61+
62+writeTransaction :: DiskSync -> FilePath -> Transaction -> IO ()
63+writeTransaction sync dbdir trans = do
64+ let tempTransDir = tempTransactionDir dbdir (transactionId trans)
65+ finalTransDir = transactionDir dbdir (transactionId trans)
66+ context = transactionContext trans
67+ transDirExists <- doesDirectoryExist finalTransDir
68+ if not transDirExists then do
69+ --create sub directories
70+ mapM_ createDirectory [tempTransDir, relvarsDir tempTransDir, incDepsDir tempTransDir, atomFuncsDir tempTransDir]
71+ writeRelVars sync tempTransDir (relationVariables context)
72+ writeIncDeps sync tempTransDir (inclusionDependencies context)
73+ writeAtomFuncs sync tempTransDir (atomFunctions context)
74+ writeTypeConstructorMapping sync tempTransDir (typeConstructorMapping context)
75+ BS.writeFile (transactionInfoPath tempTransDir) (B.encode $ transactionInfo trans)
76+ --move the temp directory to final location
77+ renameSync sync tempTransDir finalTransDir
78+ else
79+ return ()
80+
81+writeRelVar :: DiskSync -> FilePath -> (RelVarName, Relation) -> IO ()
82+writeRelVar sync transDir (relvarName, rel) = do
83+ let relvarPath = relvarsDir transDir </> T.unpack relvarName
84+ writeBSFileSync sync relvarPath (B.encode rel)
85+
86+writeRelVars :: DiskSync -> FilePath -> (M.Map RelVarName Relation) -> IO ()
87+writeRelVars sync transDir relvars = mapM_ (writeRelVar sync transDir) $ M.toList relvars
88+
89+readRelVars :: FilePath -> IO (M.Map RelVarName Relation)
90+readRelVars transDir = do
91+ let relvarsPath = relvarsDir transDir
92+ relvarNames <- getDirectoryNames relvarsPath
93+ relvars <- mapM (\name -> do
94+ rel <- liftM B.decode $ BS.readFile (relvarsPath </> name)
95+ return (T.pack name, rel)) relvarNames
96+ return $ M.fromList relvars
97+
98+writeAtomFuncs :: DiskSync -> FilePath -> AtomFunctions -> IO ()
99+writeAtomFuncs sync transDir funcs = mapM_ (writeAtomFunc sync transDir) $ HS.toList funcs
100+
101+--all the atom functions are in one file (???)
102+readAtomFuncs :: FilePath -> IO (AtomFunctions)
103+readAtomFuncs transDir = do
104+ funcNames <- getDirectoryNames (atomFuncsDir transDir)
105+ funcs <- mapM (readAtomFunc transDir) (map T.pack funcNames)
106+ return $ HS.fromList funcs
107+
108+--to write the atom functions, we really some bytecode to write (GHCi bytecode?)
109+writeAtomFunc :: DiskSync -> FilePath -> AtomFunction -> IO ()
110+writeAtomFunc sync transDir func = do
111+ let atomFuncPath = atomFuncsDir transDir </> T.unpack (atomFuncName func)
112+ writeBSFileSync sync atomFuncPath BS.empty
113+
114+readAtomFunc :: FilePath -> AtomFunctionName -> IO (AtomFunction)
115+readAtomFunc transDir funcName = do
116+ let atomFuncPath = atomFuncsDir transDir </> T.unpack funcName
117+ _ <- BS.readFile atomFuncPath
118+ return undefined
119+
120+writeIncDep :: DiskSync -> FilePath -> (IncDepName, InclusionDependency) -> IO ()
121+writeIncDep sync transDir (incDepName, incDep) = do
122+ writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ B.encode incDep
123+
124+writeIncDeps :: DiskSync -> FilePath -> M.Map IncDepName InclusionDependency -> IO ()
125+writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toList incdeps
126+
127+readIncDep :: FilePath -> IncDepName -> IO (IncDepName, InclusionDependency)
128+readIncDep transDir incdepName = do
129+ let incDepPath = incDepsDir transDir </> T.unpack incdepName
130+ incDepData <- BS.readFile incDepPath
131+ return $ (incdepName, B.decode incDepData)
132+
133+readIncDeps :: FilePath -> IO (M.Map IncDepName InclusionDependency)
134+readIncDeps transDir = do
135+ let incDepsPath = incDepsDir transDir
136+ incDepNames <- getDirectoryNames incDepsPath
137+ incDeps <- mapM (readIncDep transDir) (map T.pack incDepNames)
138+ return $ M.fromList incDeps
139+
140+writeTypeConstructorMapping :: DiskSync -> FilePath -> TypeConstructorMapping -> IO ()
141+writeTypeConstructorMapping sync path types = let atPath = typeConsPath path in
142+ writeBSFileSync sync atPath $ B.encode types
143+
144+readTypeConstructorMapping :: FilePath -> IO (TypeConstructorMapping)
145+readTypeConstructorMapping path = do
146+ let atPath = typeConsPath path
147+ liftM B.decode (BS.readFile atPath)
ProjectM36/TransactionGraph.hsnew file+413
@@ -0,0 +1,413 @@
1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}
2+module ProjectM36.TransactionGraph where
3+import ProjectM36.Base
4+import ProjectM36.Error
5+import ProjectM36.Transaction
6+import ProjectM36.Relation
7+import ProjectM36.TupleSet
8+import ProjectM36.Tuple
9+import ProjectM36.DataTypes.Primitive
10+import qualified Data.Vector as V
11+import qualified ProjectM36.Attribute as A
12+import qualified Data.UUID as U
13+import qualified Data.Set as S
14+import qualified Data.Map as M
15+import Control.Monad
16+import qualified Data.Text as T
17+import GHC.Generics
18+import Data.Binary
19+import ProjectM36.TransactionGraph.Merge
20+import Data.Either (lefts, rights, isRight)
21+--import Debug.Trace
22+
23+--operators which manipulate a transaction graph
24+data TransactionGraphOperator = JumpToHead HeadName |
25+ JumpToTransaction TransactionId |
26+ Branch HeadName |
27+ MergeTransactions MergeStrategy HeadName HeadName |
28+ Commit |
29+ Rollback
30+ deriving (Eq, Show, Binary, Generic)
31+
32+data ROTransactionGraphOperator = ShowGraph
33+
34+
35+bootstrapTransactionGraph :: TransactionId -> DatabaseContext -> TransactionGraph
36+bootstrapTransactionGraph freshId context = TransactionGraph bootstrapHeads bootstrapTransactions
37+ where
38+ bootstrapHeads = M.singleton "master" freshTransaction
39+ freshTransaction = Transaction freshId (TransactionInfo U.nil S.empty) context
40+ bootstrapTransactions = S.singleton freshTransaction
41+
42+emptyTransactionGraph :: TransactionGraph
43+emptyTransactionGraph = TransactionGraph M.empty S.empty
44+
45+transactionForHead :: HeadName -> TransactionGraph -> Maybe Transaction
46+transactionForHead headName (TransactionGraph heads _) = M.lookup headName heads
47+
48+headNameForTransaction :: Transaction -> TransactionGraph -> Maybe HeadName
49+headNameForTransaction transaction (TransactionGraph heads _) = if M.null matchingTrans then
50+ Nothing
51+ else
52+ Just $ (head . M.keys) matchingTrans
53+ where
54+ matchingTrans = M.filter (transaction ==) heads
55+
56+transactionForId :: TransactionId -> TransactionGraph -> Either RelationalError Transaction
57+transactionForId tid graph = if tid == U.nil then
58+ Left RootTransactionTraversalError
59+ else if S.null matchingTrans then
60+ Left $ NoSuchTransactionError tid
61+ else
62+ Right $ head (S.toList matchingTrans)
63+ where
64+ matchingTrans = S.filter (\(Transaction idMatch _ _) -> idMatch == tid) (transactionsForGraph graph)
65+
66+transactionsForIds :: S.Set TransactionId -> TransactionGraph -> Either RelationalError (S.Set Transaction)
67+transactionsForIds idSet graph = do
68+ transList <- forM (S.toList idSet) ((flip transactionForId) graph)
69+ return (S.fromList transList)
70+
71+isRootTransaction :: Transaction -> TransactionGraph -> Bool
72+isRootTransaction (Transaction _ (TransactionInfo pId _) _) _ = U.null pId
73+isRootTransaction (Transaction _ (MergeTransactionInfo _ _ _) _) _ = False
74+
75+-- the first transaction has no parent - all other do have parents- merges have two parents
76+parentTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)
77+parentTransactions (Transaction _ (TransactionInfo pId _) _) graph = do
78+ trans <- transactionForId pId graph
79+ return (S.singleton trans)
80+
81+parentTransactions (Transaction _ (MergeTransactionInfo pId1 pId2 _) _ ) graph = transactionsForIds (S.fromList [pId1, pId2]) graph
82+
83+
84+childTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)
85+childTransactions (Transaction _ (TransactionInfo _ children) _) = transactionsForIds children
86+childTransactions (Transaction _ (MergeTransactionInfo _ _ children) _) = transactionsForIds children
87+
88+-- create a new commit and add it to the heads
89+-- technically, the new head could be added to an existing commit, but by adding a new commit, the new head is unambiguously linked to a new commit (with a context indentical to its parent)
90+addBranch :: TransactionId -> HeadName -> TransactionId -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)
91+addBranch newId newBranchName branchPointId graph = do
92+ parentTrans <- transactionForId branchPointId graph
93+ let newTrans = Transaction newId (TransactionInfo branchPointId S.empty) (transactionContext parentTrans)
94+ addTransactionToGraph newBranchName newTrans graph
95+
96+--adds a disconnected transaction to a transaction graph at some head
97+addDisconnectedTransaction :: TransactionId -> HeadName -> DisconnectedTransaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)
98+addDisconnectedTransaction newId headName (DisconnectedTransaction parentId context) graph = addTransactionToGraph headName (Transaction newId (TransactionInfo parentId S.empty) context) graph
99+
100+addTransactionToGraph :: HeadName -> Transaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)
101+addTransactionToGraph headName newTrans graph = do
102+ let parentIds = transactionParentIds newTrans
103+ childIds = transactionChildIds newTrans
104+ newId = transactionId newTrans
105+ validateIds ids = mapM (\i -> transactionForId i graph) (S.toList ids)
106+ addChildTransaction trans = transactionSetChildren trans (S.insert newId (transactionChildIds trans))
107+ --validate that the parent transactions are in the graph
108+ _ <- validateIds parentIds
109+ when (S.size parentIds < 1) (Left $ NewTransactionMissingParentError newId)
110+ --if the headName already exists, ensure that it refers to a parent
111+ case transactionForHead headName graph of
112+ Nothing -> pure () -- any headName is OK
113+ Just trans -> when (S.notMember (transactionId trans) parentIds) (Left (HeadNameSwitchingHeadProhibitedError headName))
114+ --validate that the transaction has no children
115+ when (not (S.null childIds)) (Left $ NewTransactionMayNotHaveChildrenError newId)
116+ --validate that the trasaction's id is unique
117+ when (isRight (transactionForId newId graph)) (Left (TransactionIdInUseError newId))
118+ --update the parent transactions to point to the new transaction
119+ parents <- mapM (\tid -> transactionForId tid graph) (S.toList parentIds)
120+ let updatedParents = S.map addChildTransaction (S.fromList parents)
121+ updatedTransSet = S.insert newTrans (S.union updatedParents (transactionsForGraph graph))
122+ updatedHeads = M.insert headName newTrans (transactionHeadsForGraph graph)
123+ pure (newTrans, (TransactionGraph updatedHeads updatedTransSet))
124+
125+validateGraph :: TransactionGraph -> Maybe [RelationalError]
126+validateGraph graph@(TransactionGraph _ transSet) = do
127+ --check that all transaction ids are unique in the graph
128+ --FINISH ME!
129+ --uuids = map transactionId transSet
130+ --check that all heads appear in the transSet
131+ --check that all forward and backward links are in place
132+ _ <- mapM (walkParentTransactions S.empty graph) (S.toList transSet)
133+ mapM (walkChildTransactions S.empty graph) (S.toList transSet)
134+
135+--verify that all parent links exist and that all children exist
136+--maybe verify that all parents end at transaction id nil and all children end at leaves
137+walkParentTransactions :: S.Set TransactionId -> TransactionGraph -> Transaction -> Maybe RelationalError
138+walkParentTransactions seenTransSet graph trans =
139+ let transId = transactionId trans in
140+ if transId == U.nil then
141+ Nothing
142+ else if S.member transId seenTransSet then
143+ Just $ TransactionGraphCycleError transId
144+ else
145+ let parentTransSetOrError = parentTransactions trans graph in
146+ case parentTransSetOrError of
147+ Left err -> Just err
148+ Right parentTransSet -> do
149+ walk <- mapM (walkParentTransactions (S.insert transId seenTransSet) graph) (S.toList parentTransSet)
150+ case walk of
151+ err:_ -> Just err
152+ _ -> Nothing
153+
154+--refactor: needless duplication in these two functions
155+walkChildTransactions :: S.Set TransactionId -> TransactionGraph -> Transaction -> Maybe RelationalError
156+walkChildTransactions seenTransSet graph trans =
157+ let transId = transactionId trans in
158+ if childTransactions trans graph == Right S.empty then
159+ Nothing
160+ else if S.member transId seenTransSet then
161+ Just $ TransactionGraphCycleError transId
162+ else
163+ let childTransSetOrError = childTransactions trans graph in
164+ case childTransSetOrError of
165+ Left err -> Just err
166+ Right childTransSet -> do
167+ walk <- mapM (walkChildTransactions (S.insert transId seenTransSet) graph) (S.toList childTransSet)
168+ case walk of
169+ err:_ -> Just err
170+ _ -> Nothing
171+
172+-- returns the new "current" transaction, updated graph, and tutorial d result
173+-- the current transaction is not part of the transaction graph until it is committed
174+evalGraphOp :: TransactionId -> DisconnectedTransaction -> TransactionGraph -> TransactionGraphOperator -> Either RelationalError (DisconnectedTransaction, TransactionGraph)
175+
176+--affects only disconncted transaction
177+evalGraphOp _ _ graph (JumpToTransaction jumpId) = case transactionForId jumpId graph of
178+ Left err -> Left err
179+ Right parentTrans -> Right (newTrans, graph)
180+ where
181+ newTrans = DisconnectedTransaction jumpId (transactionContext parentTrans)
182+
183+-- switch from one head to another
184+-- affects only disconnectedtransaction
185+evalGraphOp _ _ graph (JumpToHead headName) =
186+ case transactionForHead headName graph of
187+ Just newHeadTransaction -> let disconnectedTrans = newDisconnectedTransaction (transactionId newHeadTransaction) (transactionContext newHeadTransaction) in
188+ Right (disconnectedTrans, graph)
189+ Nothing -> Left $ NoSuchHeadNameError headName
190+-- add new head pointing to branchPoint
191+-- repoint the disconnected transaction to the new branch commit (with a potentially different disconnected context)
192+-- affects transactiongraph and the disconnectedtransaction is recreated based off the branch
193+ {-
194+evalGraphOp newId discon@(DisconnectedTransaction parentId disconContext) graph (Branch newBranchName) = case transactionForId parentId graph of
195+ Nothing -> (discon, graph, DisplayErrorResult "Failed to find parent transaction.")
196+ Just parentTrans -> case addBranch newBranchName parentTrans graph of
197+ Nothing -> (discon, graph, DisplayErrorResult "Failed to add branch.")
198+ Just newGraph -> (newDiscon, newGraph, DisplayResult "Branched.")
199+ where
200+ newDiscon = DisconnectedTransaction (transactionId parentTrans) disconContext
201+-}
202+
203+-- create a new commit and add it to the heads
204+-- technically, the new head could be added to an existing commit, but by adding a new commit, the new head is unambiguously linked to a new commit (with a context indentical to its parent)
205+evalGraphOp newId (DisconnectedTransaction parentId disconContext) graph (Branch newBranchName) = case addBranch newId newBranchName parentId graph of
206+ Left err -> Left err
207+ Right (_, newGraph) -> Right (newDiscon, newGraph)
208+ where
209+ newDiscon = DisconnectedTransaction newId disconContext
210+
211+-- add the disconnected transaction to the graph
212+-- affects graph and disconnectedtransaction- the new disconnectedtransaction's parent is the freshly committed transaction
213+evalGraphOp newTransId discon@(DisconnectedTransaction parentId context) graph Commit = case transactionForId parentId graph of
214+ Left err -> Left err
215+ Right parentTransaction -> case headNameForTransaction parentTransaction graph of
216+ Nothing -> Left $ TransactionIsNotAHeadError parentId
217+ Just headName -> case maybeUpdatedGraph of
218+ Left err-> Left err
219+ Right (_, updatedGraph) -> Right (newDisconnectedTrans, updatedGraph)
220+ where
221+ newDisconnectedTrans = newDisconnectedTransaction newTransId context
222+ maybeUpdatedGraph = addDisconnectedTransaction newTransId headName discon graph
223+
224+-- refresh the disconnected transaction, return the same graph
225+evalGraphOp _ (DisconnectedTransaction parentId _) graph Rollback = case transactionForId parentId graph of
226+ Left err -> Left err
227+ Right parentTransaction -> Right (newDiscon, graph)
228+ where
229+ newDiscon = newDisconnectedTransaction parentId (transactionContext parentTransaction)
230+
231+-- a successful merge should remove a head
232+evalGraphOp newId (DisconnectedTransaction parentId _) graph (MergeTransactions mergeStrategy headNameA headNameB) = mergeTransactions newId parentId mergeStrategy (headNameA, headNameB) graph
233+
234+--present a transaction graph as a relation showing the uuids, parentuuids, and flag for the current location of the disconnected transaction
235+graphAsRelation :: DisconnectedTransaction -> TransactionGraph -> Either RelationalError Relation
236+graphAsRelation (DisconnectedTransaction parentId _) graph@(TransactionGraph _ transSet) = do
237+ tupleMatrix <- mapM tupleGenerator (S.toList transSet)
238+ mkRelationFromList attrs tupleMatrix
239+ where
240+ attrs = A.attributesFromList [Attribute "id" textAtomType,
241+ Attribute "parents" (RelationAtomType parentAttributes),
242+ Attribute "current" boolAtomType,
243+ Attribute "head" textAtomType
244+ ]
245+ parentAttributes = A.attributesFromList [Attribute "id" textAtomType]
246+ tupleGenerator transaction = case transactionParentsRelation transaction graph of
247+ Left err -> Left err
248+ Right parentTransRel -> Right [Atom $ T.pack $ show (transactionId transaction),
249+ Atom parentTransRel,
250+ Atom $ parentId == transactionId transaction,
251+ Atom $ case headNameForTransaction transaction graph of
252+ Just headName -> headName
253+ Nothing -> ""
254+ ]
255+
256+transactionParentsRelation :: Transaction -> TransactionGraph -> Either RelationalError Relation
257+transactionParentsRelation trans graph = do
258+ if isRootTransaction trans graph then do
259+ mkRelation attrs emptyTupleSet
260+ else do
261+ parentTransSet <- parentTransactions trans graph
262+ let tuples = map trans2tuple (S.toList parentTransSet)
263+ mkRelationFromTuples attrs tuples
264+ where
265+ attrs = A.attributesFromList [Attribute "id" textAtomType]
266+ trans2tuple trans2 = mkRelationTuple attrs $ V.singleton (Atom (T.pack (show $ transactionId trans2)))
267+
268+{-
269+--display transaction graph as relation
270+evalROGraphOp :: DisconnectedTransaction -> TransactionGraph -> ROTransactionGraphOperator -> Either RelationalError Relation
271+evalROGraphOp discon graph ShowGraph = do
272+ graphRel <- graphAsRelation discon graph
273+ return graphRel
274+-}
275+
276+-- | Execute the merge strategy against the transactions, returning a new transaction which can be then added to the transaction graph
277+createMergeTransaction :: TransactionId -> MergeStrategy -> TransactionGraph -> (Transaction, Transaction) -> Either MergeError Transaction
278+createMergeTransaction newId (SelectedBranchMergeStrategy selectedBranch) graph t2@(trans1, trans2) = do
279+ selectedTrans <- validateHeadName selectedBranch graph t2
280+ pure $ Transaction newId (MergeTransactionInfo (transactionId trans1) (transactionId trans2) S.empty) (transactionContext selectedTrans)
281+
282+-- merge functions, relvars, individually
283+createMergeTransaction newId strat@UnionMergeStrategy graph t2 = createUnionMergeTransaction newId strat graph t2
284+
285+-- merge function, relvars, but, on error, just take the component from the preferred branch
286+createMergeTransaction newId strat@(UnionPreferMergeStrategy _) graph t2 = createUnionMergeTransaction newId strat graph t2
287+
288+-- | Returns the correct Transaction for the branch name in the graph and ensures that it is one of the two transaction arguments in the tuple.
289+validateHeadName :: HeadName -> TransactionGraph -> (Transaction, Transaction) -> Either MergeError Transaction
290+validateHeadName headName graph (t1, t2) = do
291+ case transactionForHead headName graph of
292+ Nothing -> Left SelectedHeadMismatchMergeError
293+ Just trans -> if trans /= t1 && trans /= t2 then
294+ Left SelectedHeadMismatchMergeError
295+ else
296+ Right trans
297+
298+-- Algorithm: start at one transaction and work backwards up the parents. If there is a node we have not yet visited as a child, then walk that up to its head. If that branch contains the goal transaction, then we have completed a valid subgraph traversal.
299+subGraphOfFirstCommonAncestor :: TransactionGraph -> TransactionHeads -> Transaction -> Transaction -> S.Set Transaction -> Either RelationalError TransactionGraph
300+subGraphOfFirstCommonAncestor origGraph resultHeads currentTrans goalTrans traverseSet = do
301+ let currentid = transactionId currentTrans
302+ goalid = transactionId goalTrans
303+ if currentTrans == goalTrans then
304+ Right (TransactionGraph resultHeads traverseSet) -- add filter
305+ --catch root transaction to improve error?
306+ else do
307+ currentTransChildren <- liftM S.fromList $ mapM (flip transactionForId origGraph) (S.toList (transactionChildIds currentTrans))
308+ let searchChildren = S.difference (S.insert currentTrans traverseSet) currentTransChildren
309+ searchChild start = pathToTransaction origGraph start goalTrans (S.insert currentTrans traverseSet)
310+ childSearches = map searchChild (S.toList searchChildren)
311+ errors = lefts childSearches
312+ pathsFound = rights childSearches
313+ realErrors = filter (/= (FailedToFindTransactionError goalid)) errors
314+ -- report any non-search-related errors
315+ when (not (null realErrors)) (Left (head realErrors))
316+ -- if no paths found, search the parent
317+ if null pathsFound then
318+ case oneParent currentTrans of
319+ Left RootTransactionTraversalError -> Left (NoCommonTransactionAncestorError currentid goalid)
320+ Left err -> Left err
321+ Right currentTransParent -> do
322+ subGraphOfFirstCommonAncestor origGraph resultHeads currentTransParent goalTrans (S.insert currentTrans traverseSet)
323+ else -- we found a path
324+ Right (TransactionGraph resultHeads (S.unions (traverseSet : pathsFound)))
325+ where
326+ oneParent (Transaction _ (TransactionInfo parentId _) _) = transactionForId parentId origGraph
327+ oneParent (Transaction _ (MergeTransactionInfo parentId _ _) _) = transactionForId parentId origGraph
328+
329+-- | Search from a past graph point to all following heads for a specific transaction. If found, return the transaction path, otherwise a RelationalError.
330+pathToTransaction :: TransactionGraph -> Transaction -> Transaction -> S.Set Transaction -> Either RelationalError (S.Set Transaction)
331+pathToTransaction graph currentTransaction targetTransaction accumTransSet = do
332+ let targetId = transactionId targetTransaction
333+ if transactionId targetTransaction == transactionId currentTransaction then do
334+ Right accumTransSet
335+ else do
336+ currentTransChildren <- mapM (flip transactionForId graph) (S.toList (transactionChildIds currentTransaction))
337+ if length currentTransChildren == 0 then
338+ Left (FailedToFindTransactionError targetId)
339+ else do
340+ let searches = map (\t -> pathToTransaction graph t targetTransaction (S.insert t accumTransSet)) currentTransChildren
341+ let realErrors = filter (/= FailedToFindTransactionError targetId) (lefts searches)
342+ paths = rights searches
343+ if length realErrors > 0 then -- found some real errors
344+ Left (head realErrors)
345+ else if length paths == 0 then -- failed to find transaction in all children
346+ Left (FailedToFindTransactionError targetId)
347+ else --we have some paths!
348+ Right (S.unions paths)
349+
350+mergeTransactions :: TransactionId -> TransactionId -> MergeStrategy -> (HeadName, HeadName) -> TransactionGraph -> Either RelationalError (DisconnectedTransaction, TransactionGraph)
351+mergeTransactions newId parentId mergeStrategy (headNameA, headNameB) graph = do
352+ let transactionForHeadErr name = case transactionForHead name graph of
353+ Nothing -> Left (NoSuchHeadNameError name)
354+ Just t -> Right t
355+ transA <- transactionForHeadErr headNameA
356+ transB <- transactionForHeadErr headNameB
357+ disconParent <- transactionForId parentId graph
358+ let subHeads = M.filterWithKey (\k _ -> elem k [headNameA, headNameB]) (transactionHeadsForGraph graph)
359+ subGraph <- subGraphOfFirstCommonAncestor graph subHeads transA transB S.empty
360+ subGraph' <- filterSubGraph subGraph subHeads
361+ case createMergeTransaction newId mergeStrategy subGraph' (transA, transB) of
362+ Left err -> Left (MergeTransactionError err)
363+ Right mergedTrans -> case headNameForTransaction disconParent graph of
364+ Nothing -> Left (TransactionIsNotAHeadError parentId)
365+ Just headName -> do
366+ (newTrans, newGraph) <- addTransactionToGraph headName mergedTrans graph
367+ let newGraph' = TransactionGraph (transactionHeadsForGraph newGraph) (transactionsForGraph newGraph)
368+ newDiscon = newDisconnectedTransaction newId (transactionContext newTrans)
369+ pure (newDiscon, newGraph')
370+
371+--TEMPORARY COPY/PASTE
372+showTransactionStructureX :: Transaction -> TransactionGraph -> String
373+showTransactionStructureX trans graph = headInfo ++ " " ++ show (transactionId trans) ++ " " ++ parentTransactionsInfo
374+ where
375+ headInfo = maybe "" show (headNameForTransaction trans graph)
376+ parentTransactionsInfo = if isRootTransaction trans graph then "root" else case parentTransactions trans graph of
377+ Left err -> show err
378+ Right parentTransSet -> concat $ S.toList $ S.map (show . transactionId) parentTransSet
379+
380+showGraphStructureX :: TransactionGraph -> String
381+showGraphStructureX graph@(TransactionGraph heads transSet) = headsInfo ++ S.foldr folder "" transSet
382+ where
383+ folder trans acc = acc ++ showTransactionStructureX trans graph ++ "\n"
384+ headsInfo = show $ M.map transactionId heads
385+
386+-- | After splicing out a subgraph, run it through this function to remove references to transactions which are not in the subgraph.
387+filterSubGraph :: TransactionGraph -> TransactionHeads -> Either RelationalError TransactionGraph
388+filterSubGraph graph heads = Right $ TransactionGraph newHeads newTransSet
389+ where
390+ validIds = S.map transactionId (transactionsForGraph graph)
391+ newTransSet = S.map (filterTransaction validIds) (transactionsForGraph graph)
392+ newHeads = M.map (filterTransaction validIds) heads
393+
394+--helper function for commonalities in union merge
395+createUnionMergeTransaction :: TransactionId -> MergeStrategy -> TransactionGraph -> (Transaction, Transaction) -> Either MergeError Transaction
396+createUnionMergeTransaction newId strategy graph (t1,t2) = do
397+ let contextA = transactionContext t1
398+ contextB = transactionContext t2
399+
400+ preference <- case strategy of
401+ UnionMergeStrategy -> pure PreferNeither
402+ UnionPreferMergeStrategy preferBranch -> do
403+ case transactionForHead preferBranch graph of
404+ Nothing -> Left (PreferredHeadMissingMergeError preferBranch)
405+ Just preferredTrans -> pure $ if t1 == preferredTrans then PreferFirst else PreferSecond
406+ badStrat -> Left (InvalidMergeStrategyError badStrat)
407+
408+ incDeps <- unionMergeMaps preference (inclusionDependencies contextA) (inclusionDependencies contextB)
409+ relVars <- unionMergeRelVars preference (relationVariables contextA) (relationVariables contextB)
410+ atomFuncs <- unionMergeAtomFunctions preference (atomFunctions contextA) (atomFunctions contextB)
411+ notifs <- unionMergeMaps preference (notifications contextA) (notifications contextB)
412+ types <- unionMergeTypeConstructorMapping preference (typeConstructorMapping contextA) (typeConstructorMapping contextB)
413+ pure (Transaction newId (MergeTransactionInfo (transactionId t1) (transactionId t2) S.empty) (DatabaseContext incDeps relVars atomFuncs notifs types))
src/lib/ProjectM36/TransactionGraph/Merge.hs → ProjectM36/TransactionGraph/Merge.hsrenamed+16−25
@@ -2,43 +2,39 @@
22module ProjectM36.TransactionGraph.Merge where
33import ProjectM36.Base
44import ProjectM36.Error
5−import ProjectM36.RelationalExpression
6−import Control.Monad.Except hiding (join)
75import qualified Data.Set as S
86import qualified Data.Map as M
97import qualified ProjectM36.TypeConstructorDef as TCD
8+import ProjectM36.Relation
109import Control.Monad (foldM)
1110import qualified Data.HashSet as HS
1211
1312data MergePreference = PreferFirst | PreferSecond | PreferNeither
1413
1514-- Check for overlapping keys. If the values differ, try a preference resolution
16−unionMergeMaps :: (Ord k, Eq a) => MergePreference -> M.Map k a -> M.Map k a -> Either MergeError (M.Map k a)
15+unionMergeMaps :: (Ord k, Eq k, Eq a) => MergePreference -> M.Map k a -> M.Map k a -> Either MergeError (M.Map k a)
1716unionMergeMaps prefer mapA mapB = case prefer of
1817 PreferFirst -> pure $ M.union mapA mapB
1918 PreferSecond -> pure $ M.union mapB mapA
2019 PreferNeither -> if M.intersection mapA mapB == M.intersection mapA mapB then
2120 pure $ M.union mapA mapB
2221 else
23− Left StrategyViolatesComponentMergeError
22+ Left $ StrategyViolatesComponentMergeError
2423
2524-- perform the merge even if the attributes are different- is this what we want? Obviously, we need finer-grained merge options.
26−unionMergeRelation :: MergePreference -> GraphRefRelationalExpr -> GraphRefRelationalExpr -> GraphRefRelationalExprM GraphRefRelationalExpr
27−unionMergeRelation prefer relA relB = do
28− let unioned = Union relA relB
29− mergeErr = MergeTransactionError StrategyViolatesRelationVariableMergeError
30− preferredRelVar =
31− case prefer of
32− PreferFirst -> pure relA
33− PreferSecond -> pure relB
34− PreferNeither -> throwError mergeErr
35− handler AttributeNamesMismatchError{} = preferredRelVar
36− handler _err' = throwError mergeErr
37− --typecheck first?
38− (evalGraphRefRelationalExpr unioned >> pure (Union relA relB)) `catchError` handler
25+unionMergeRelation :: MergePreference -> Relation -> Relation -> Either MergeError Relation
26+unionMergeRelation prefer relA relB = case union relA relB of
27+ Right unionRel -> pure unionRel
28+ Left (AttributeNamesMismatchError _) -> preferredRelVar
29+ Left _ -> Left StrategyViolatesRelationVariableMergeError
30+ where
31+ preferredRelVar = case prefer of
32+ PreferFirst -> Right relA
33+ PreferSecond -> Right relB
34+ PreferNeither -> Left StrategyViolatesRelationVariableMergeError
3935
4036--try to execute unions against the relvars contents -- if a relvar only appears in one context, include it
41−unionMergeRelVars :: MergePreference -> RelationVariables -> RelationVariables -> GraphRefRelationalExprM RelationVariables
37+unionMergeRelVars :: MergePreference -> RelationVariables -> RelationVariables -> Either MergeError RelationVariables
4238unionMergeRelVars prefer relvarsA relvarsB = do
4339 let allNames = S.toList (S.union (M.keysSet relvarsA) (M.keysSet relvarsB))
4440 foldM (\acc name -> do
@@ -47,7 +43,7 @@ unionMergeRelVars prefer relvarsA relvarsB = do
4743 lookupA = findRel relvarsA
4844 lookupB = findRel relvarsB
4945 case (lookupA, lookupB) of
50− (Just relA, Just relB) ->
46+ (Just relA, Just relB) -> do
5147 unionMergeRelation prefer relA relB
5248 (Nothing, Just relB) -> pure relB
5349 (Just relA, Nothing) -> pure relA
@@ -69,7 +65,7 @@ unionMergeTypeConstructorMapping prefer typesA typesB = do
6965 foldM (\acc name -> do
7066 let findType tcm = case filter (\(t,_) -> TCD.name t == name) tcm of
7167 [] -> Nothing
72− [x] -> Just x
68+ x:[] -> Just x
7369 _ -> error "multiple names matching in TypeConstructorMapping"
7470 lookupA = findType typesA
7571 lookupB = findType typesB
@@ -87,8 +83,3 @@ unionMergeTypeConstructorMapping prefer typesA typesB = do
8783 PreferNeither -> Left StrategyViolatesTypeConstructorMergeError
8884 ) [] (S.toList allFuncNames)
8985
90−unionMergeDatabaseContextFunctions :: MergePreference -> DatabaseContextFunctions -> DatabaseContextFunctions -> Either MergeError DatabaseContextFunctions
91−unionMergeDatabaseContextFunctions prefer funcsA funcsB = case prefer of
92− PreferFirst -> pure $ HS.union funcsA funcsB
93− PreferSecond -> pure $ HS.union funcsB funcsA
94− PreferNeither -> pure $ HS.union funcsA funcsB
ProjectM36/TransactionGraph/Persist.hsnew file+150
@@ -0,0 +1,150 @@
1+module ProjectM36.TransactionGraph.Persist where
2+import ProjectM36.Error
3+import ProjectM36.TransactionGraph
4+import ProjectM36.Transaction
5+import ProjectM36.Transaction.Persist
6+import ProjectM36.Base
7+import ProjectM36.Persist (writeFileSync, renameSync, DiskSync)
8+import System.Directory
9+import System.FilePath
10+import System.IO.Temp
11+import Data.List
12+import qualified Data.UUID as U
13+import qualified Data.Set as S
14+import qualified Data.Map as M
15+import qualified Data.Text as T
16+import Control.Monad (foldM)
17+import Data.Either (isRight)
18+import Data.Maybe (catMaybes)
19+
20+{-
21+The "m36v1" file at the top-level of the destination directory contains the the transaction graph as a set of transaction ids referencing their parents (1 or more)
22+Each Transaction is written to it own directory named by its transaction id. Partially written transactions ids are prefixed with a "." to indicate incompleteness in the graph.
23+
24+Persistence requires a POSIX-compliant, journaled-metadata filesystem.
25+-}
26+
27+transactionLogPath :: FilePath -> FilePath
28+transactionLogPath dbdir = dbdir </> "m36v1"
29+
30+headsPath :: FilePath -> FilePath
31+headsPath dbdir = dbdir </> "heads"
32+
33+{-
34+verify that the database directory is valid or bootstrap it
35+-note: checking for the existence of every transaction may be prohibitively expensive
36+-}
37+
38+setupDatabaseDir :: DiskSync -> FilePath -> TransactionGraph -> IO (Maybe PersistenceError)
39+setupDatabaseDir sync dbdir bootstrapGraph = do
40+ dbdirExists <- doesDirectoryExist dbdir
41+ m36exists <- doesFileExist (transactionLogPath dbdir)
42+ if dbdirExists && m36exists then
43+ return Nothing
44+ else if not m36exists then do
45+ bootstrapDatabaseDir sync dbdir bootstrapGraph
46+ return Nothing
47+ else
48+ return $ Just (InvalidDirectoryError dbdir)
49+
50+{-
51+initialize a database directory with the graph from which to bootstrap
52+-}
53+bootstrapDatabaseDir :: DiskSync -> FilePath -> TransactionGraph -> IO ()
54+bootstrapDatabaseDir sync dbdir bootstrapGraph = do
55+ createDirectory dbdir
56+ transactionGraphPersist sync dbdir bootstrapGraph
57+ putStrLn "Bootstrapped DB."
58+
59+{-
60+incrementally updates an existing database directory
61+--algorithm:
62+-check that all heads have been written
63+-assume that all non-head transactions have already been written because this is an incremental (and concurrent!) write method
64+--store the head names with a symlink to the transaction under "heads"
65+-}
66+transactionGraphPersist :: DiskSync -> FilePath -> TransactionGraph -> IO ()
67+transactionGraphPersist sync destDirectory graph = do
68+ mapM_ (writeTransaction sync destDirectory) $ M.elems (transactionHeadsForGraph graph)
69+ writeGraphTransactionIdFile sync destDirectory graph
70+ transactionGraphHeadsPersist sync destDirectory graph
71+ return ()
72+
73+{-
74+write graph heads to a file which can be atomically swapped
75+-}
76+--writing the heads in a directory is a synchronization nightmare, so just write the binary to a file and swap atomically
77+transactionGraphHeadsPersist :: DiskSync -> FilePath -> TransactionGraph -> IO ()
78+transactionGraphHeadsPersist sync dbdir graph = do
79+ let headFileStr :: (HeadName, Transaction) -> String
80+ headFileStr (headName, trans) = T.unpack headName ++ " " ++ U.toString (transactionId trans)
81+ withTempDirectory dbdir ".heads.tmp" $ \tempHeadsDir -> do
82+ let tempHeadsPath = tempHeadsDir </> "heads"
83+ headsStrLines = map headFileStr $ M.toList (transactionHeadsForGraph graph)
84+ writeFileSync sync tempHeadsPath $ intercalate "\n" headsStrLines
85+ renameSync sync tempHeadsPath (headsPath dbdir)
86+
87+transactionGraphHeadsLoad :: FilePath -> IO [(HeadName,TransactionId)]
88+transactionGraphHeadsLoad dbdir = do
89+ headsData <- readFile (headsPath dbdir)
90+ let headsAssocs = map (\l -> let headName:uuidStr:[] = words l in
91+ (headName,uuidStr)
92+ ) (lines headsData)
93+ return [(T.pack headName, uuid) | (headName, Just uuid) <- map (\(h,u) -> (h, U.fromString u)) headsAssocs]
94+
95+{-
96+load any transactions which are not already part of the incoming transaction graph
97+-}
98+
99+--ALERT I need to figure out how to manage the transaction heads (branch names)
100+transactionGraphLoad :: FilePath -> TransactionGraph -> IO (Either PersistenceError TransactionGraph)
101+transactionGraphLoad dbdir graphIn = do
102+ --optimization: perform tail-bisection search to find last-recorded transaction in the existing stream- replay the rest
103+ --read in all missing transactions from transaction directories and add to graph
104+ uuidInfo <- readGraphTransactionIdFile dbdir
105+ freshHeadsAssoc <- transactionGraphHeadsLoad dbdir
106+ case uuidInfo of
107+ Left err -> return $ Left err
108+ Right info -> do
109+ let folder = \eitherGraph transId -> case eitherGraph of
110+ Left err -> return $ Left err
111+ Right graph -> readTransactionIfNecessary dbdir transId graph
112+ loadedGraph <- foldM folder (Right graphIn) (map fst info)
113+ case loadedGraph of
114+ Left err -> return $ Left err
115+ Right freshGraph -> do
116+ let maybeTransHeads = [(headName, transactionForId uuid freshGraph) | (headName, uuid) <- freshHeadsAssoc]
117+ freshHeads = M.fromList [(headName,trans) | (headName, Right trans) <- maybeTransHeads]
118+ return $ Right $ TransactionGraph freshHeads (transactionsForGraph freshGraph)
119+
120+{-
121+if the transaction with the TransactionId argument is not yet part of the graph, then read the transaction and add it - this does not update the heads
122+-}
123+readTransactionIfNecessary :: FilePath -> TransactionId -> TransactionGraph -> IO (Either PersistenceError TransactionGraph)
124+readTransactionIfNecessary dbdir transId graphIn = do
125+ if isRight $ transactionForId transId graphIn then
126+ --the transaction is already known and loaded- done
127+ return $ Right graphIn
128+ else do
129+ trans <- readTransaction dbdir transId
130+ case trans of
131+ Left err -> return $ Left err
132+ Right trans' -> return $ Right $ TransactionGraph (transactionHeadsForGraph graphIn) (S.insert trans' (transactionsForGraph graphIn))
133+
134+writeGraphTransactionIdFile :: DiskSync -> FilePath -> TransactionGraph -> IO ()
135+writeGraphTransactionIdFile sync destDirectory (TransactionGraph _ transSet) = writeFileSync sync graphFile uuidInfo
136+ where
137+ graphFile = destDirectory </> "m36v1"
138+ uuidInfo = intercalate "\n" graphLines
139+ graphLines = S.toList $ S.map graphLine transSet
140+ graphLine trans = U.toString (transactionId trans) ++ " " ++ intercalate " " (S.toList (S.map U.toString $ transactionParentIds trans))
141+
142+readGraphTransactionIdFile :: FilePath -> IO (Either PersistenceError [(TransactionId, [TransactionId])])
143+readGraphTransactionIdFile dbdir = do
144+ --read in all transactions' uuids
145+ let grapher line = let tids = catMaybes (map U.fromString (words line)) in
146+ (head tids, tail tids)
147+ --warning: uses lazy IO
148+ graphTransactionIdData <- readFile (transactionLogPath dbdir)
149+ return $ Right (map grapher $ lines graphTransactionIdData)
150+
src/lib/ProjectM36/TransactionGraph/Show.hs → ProjectM36/TransactionGraph/Show.hsrenamed+4−3
@@ -1,16 +1,17 @@
11module ProjectM36.TransactionGraph.Show where
22import ProjectM36.Base
33import ProjectM36.TransactionGraph
4+import ProjectM36.Transaction
45import qualified Data.Set as S
56
67showTransactionStructure :: Transaction -> TransactionGraph -> String
7−showTransactionStructure trans graph = headInfo ++ " " ++ show (transactionId trans) ++ " p" ++ parentTransactionsInfo
8+showTransactionStructure trans graph = headInfo ++ " " ++ show (transactionId trans) ++ " p" ++ parentTransactionsInfo ++ " c" ++ childTransactionsInfo
89 where
910 headInfo = maybe "" show (headNameForTransaction trans graph)
10− parentTransactionsInfo = if isRootTransaction trans then "root" else case parentTransactions trans graph of
11+ parentTransactionsInfo = if isRootTransaction trans graph then "root" else case parentTransactions trans graph of
1112 Left err -> show err
1213 Right parentTransSet -> concat $ S.toList $ S.map (show . transactionId) parentTransSet
13−
14+ childTransactionsInfo = show (S.toList (transactionChildIds trans))
1415
1516showGraphStructure :: TransactionGraph -> String
1617showGraphStructure graph@(TransactionGraph _ transSet) = S.foldr folder "" transSet
src/lib/ProjectM36/TransactionGraph/Show/Dot.hs → ProjectM36/TransactionGraph/Show/Dot.hsrenamed+1−1
@@ -10,7 +10,7 @@ graphAsDot (TransactionGraph heads transSet) = "digraph {" ++ dot ++ headInfo ++
1010 where
1111 dot = S.foldr transactionAsDot "" transSet
1212 transactionAsDot trans acc = acc ++ childArrows trans ++ parentArrows trans
13− arrows trans = S.foldr (\c acc' -> acc' ++ oneArrow trans c) ""
13+ arrows trans idSet = S.foldr (\c acc' -> acc' ++ oneArrow trans c) "" idSet
1414 childArrows trans = arrows trans (transactionChildIds trans)
1515 parentArrows trans = arrows trans (transactionParentIds trans)
1616 transLabel t = tidLabel (transactionId t)
src/lib/ProjectM36/Tuple.hs → ProjectM36/Tuple.hsrenamed+62−82
@@ -1,56 +1,52 @@
11module ProjectM36.Tuple where
22import ProjectM36.Base
33import ProjectM36.Error
4−import ProjectM36.Attribute as A
4+import ProjectM36.Attribute
55import ProjectM36.Atom
6−import ProjectM36.AtomType
7−import ProjectM36.DataTypes.Primitive
86
97import qualified Data.Map as M
108import qualified Data.Set as S
119import qualified Data.Vector as V
1210import Data.Either (rights)
1311import Control.Monad
14−import Control.Arrow
15−import Data.Maybe
1612
1713emptyTuple :: RelationTuple
18−emptyTuple = RelationTuple mempty mempty
14+emptyTuple = RelationTuple V.empty V.empty
1915
2016tupleSize :: RelationTuple -> Int
21−tupleSize (RelationTuple tupAttrs _) = arity tupAttrs
17+tupleSize (RelationTuple tupAttrs _) = V.length tupAttrs
2218
2319tupleAttributeNameSet :: RelationTuple -> S.Set AttributeName
24−tupleAttributeNameSet (RelationTuple tupAttrs _) = attributeNameSet tupAttrs
20+tupleAttributeNameSet (RelationTuple tupAttrs _) = S.fromList $ V.toList $ V.map attributeName tupAttrs
2521
2622tupleAttributes :: RelationTuple -> Attributes
2723tupleAttributes (RelationTuple tupAttrs _) = tupAttrs
2824
2925tupleAssocs :: RelationTuple -> [(AttributeName, Atom)]
30−tupleAssocs (RelationTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)
31−
32−orderedTupleAssocs :: RelationTuple -> [(AttributeName, Atom)]
33−orderedTupleAssocs tup@(RelationTuple attrVec _) = map (\attr -> (attributeName attr, atomForAttr (attributeName attr))) oAttrs
34− where
35− oAttrs = orderedAttributes attrVec
36− atomForAttr nam = case atomForAttributeName nam tup of
37− Left _ -> TextAtom "<?>"
38− Right val -> val
26+tupleAssocs (RelationTuple attrVec tupVec) = V.toList $ V.map (\(k,v) -> (attributeName k, v)) (V.zip attrVec tupVec)
3927
4028-- return atoms in some arbitrary but consistent key order
4129tupleAtoms :: RelationTuple -> V.Vector Atom
4230tupleAtoms (RelationTuple _ tupVec) = tupVec
4331
4432atomForAttributeName :: AttributeName -> RelationTuple -> Either RelationalError Atom
45−atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of
46− Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))
33+atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of
34+ Nothing -> Left $ NoSuchAttributeNamesError (S.singleton attrName)
4735 Just index -> case tupVec V.!? index of
48− Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))
36+ Nothing -> Left $ NoSuchAttributeNamesError (S.singleton attrName)
4937 Just atom -> Right atom
5038
39+{- -- resolve naming clash with Attribute and Relation later
40+atomTypeForAttributeName :: AttributeName -> RelationTuple -> Either RelationalError Atom
41+atomTypeForAttributeName attrName tup = do
42+ atom <- atomForAttributeName attrName tup
43+ return $ atomTypeForAtom atom
44+-}
45+
5146atomsForAttributeNames :: V.Vector AttributeName -> RelationTuple -> Either RelationalError (V.Vector Atom)
52−atomsForAttributeNames attrNames tuple =
53− V.map (\index -> tupleAtoms tuple V.! index) <$> vectorIndicesForAttributeNames attrNames (tupleAttributes tuple)
47+atomsForAttributeNames attrNames tuple = do
48+ vindices <- vectorIndicesForAttributeNames attrNames (tupleAttributes tuple)
49+ return $ V.map (\index -> tupleAtoms tuple V.! index) vindices
5450
5551vectorIndicesForAttributeNames :: V.Vector AttributeName -> Attributes -> Either RelationalError (V.Vector Int)
5652vectorIndicesForAttributeNames attrNameVec attrs = if not $ V.null unknownAttrNames then
@@ -58,9 +54,10 @@ vectorIndicesForAttributeNames attrNameVec attrs = if not $ V.null unknownAttrNa
5854 else
5955 Right $ V.map mapper attrNameVec
6056 where
61− unknownAttrNames = V.filter (`V.notElem` attributeNames attrs) attrNameVec
62− mapper attrName = fromMaybe (error "logic failure in vectorIndicesForAttributeNames") (V.elemIndex attrName (attributeNames attrs))
63−
57+ unknownAttrNames = V.filter ((flip V.notElem) (attributeNames attrs)) attrNameVec
58+ mapper attrName = case V.elemIndex attrName (V.map attributeName attrs) of
59+ Nothing -> error "logic failure in vectorIndicesForAttributeNames"
60+ Just index -> index
6461
6562relationForAttributeName :: AttributeName -> RelationTuple -> Either RelationalError Relation
6663relationForAttributeName attrName tuple = do
@@ -78,22 +75,16 @@ tupleRenameAttribute oldattr newattr (RelationTuple tupAttrs tupVec) = RelationT
7875 newAttrs = renameAttributes oldattr newattr tupAttrs
7976
8077mkRelationTuple :: Attributes -> V.Vector Atom -> RelationTuple
81−mkRelationTuple = RelationTuple
78+mkRelationTuple attrs atoms = RelationTuple attrs atoms
8279
8380mkRelationTuples :: Attributes -> [V.Vector Atom] -> [RelationTuple]
84−mkRelationTuples attrs = map mapper
81+mkRelationTuples attrs atomsVec = map mapper atomsVec
8582 where
8683 mapper = mkRelationTuple attrs
87−
88−mkRelationTupleFromMap :: M.Map AttributeName Atom -> RelationTuple
89−mkRelationTupleFromMap attrMap = RelationTuple (attributesFromList attrs) (V.map (attrMap M.!) (V.fromList attrNames))
90− where
91− attrNames = M.keys attrMap
92− attrs = map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames
9384
9485--return error if attribute names match but their types do not
9586singleTupleSetJoin :: Attributes -> RelationTuple -> RelationTupleSet -> Either RelationalError [RelationTuple]
96−singleTupleSetJoin joinAttrs tup tupSet =
87+singleTupleSetJoin joinAttrs tup tupSet = do
9788 foldM tupleJoiner [] (asList tupSet)
9889 where
9990 tupleJoiner :: [RelationTuple] -> RelationTuple -> Either RelationalError [RelationTuple]
@@ -115,13 +106,13 @@ singleTupleJoin :: Attributes -> RelationTuple -> RelationTuple -> Either Relati
115106singleTupleJoin joinedAttrs tup1@(RelationTuple tupAttrs1 _) tup2@(RelationTuple tupAttrs2 _) = if
116107 V.null keysIntersection || atomsForAttributeNames keysIntersection tup1 /= atomsForAttributeNames keysIntersection tup2
117108 then
118− return Nothing
109+ return $ Nothing
119110 else
120111 return $ Just $ RelationTuple joinedAttrs newVec
121112 where
122113 keysIntersection = V.map attributeName attrsIntersection
123− attrsIntersection = V.filter (`V.elem` attributesVec tupAttrs1) (attributesVec tupAttrs2)
124− newVec = V.map (findAtomForAttributeName . attributeName) (attributesVec joinedAttrs)
114+ attrsIntersection = V.filter (flip V.elem $ tupAttrs1) tupAttrs2
115+ newVec = V.map (findAtomForAttributeName . attributeName) joinedAttrs
125116 --search both tuples for the attribute
126117 findAtomForAttributeName attrName = head $ rights $ fmap (atomForAttributeName attrName) [tup1, tup2]
127118
@@ -138,31 +129,27 @@ vectorUnion v1 v2 = V.foldr folder v1 v2
138129tupleExtend :: RelationTuple -> RelationTuple -> RelationTuple
139130tupleExtend (RelationTuple tupAttrs1 tupVec1) (RelationTuple tupAttrs2 tupVec2) = RelationTuple newAttrs newVec
140131 where
141− newAttrs = tupAttrs1 <> tupAttrs2
142− newVec = tupVec1 <> tupVec2
132+ newAttrs = tupAttrs1 V.++ tupAttrs2
133+ newVec = tupVec1 V.++ tupVec2
143134
144135tupleAtomExtend :: AttributeName -> Atom -> RelationTuple -> RelationTuple
145136tupleAtomExtend newAttrName atom tupIn = tupleExtend tupIn newTup
146137 where
147− newTup = RelationTuple (A.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)
138+ newTup = RelationTuple (V.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)
139+
140+{- sort the associative list to match the header sorting -}
141+tupleSortedAssocs :: RelationTuple -> [(AttributeName, Atom)]
142+tupleSortedAssocs (RelationTuple tupAttrs tupVec) = V.toList $ V.map (\(index,attr) -> (attributeName attr, tupVec V.! index)) $ V.indexed tupAttrs
148143
149−{-tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple
144+--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)]
145+tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple
150146tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec
151147 where
152− deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) (attributesVec attrs)
148+ deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) attrs
153149 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'
150+ newAttrs = indexDeleter attrs
157151 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)
152+
166153--return the attributes and atoms which are equal in both vectors
167154--semi-join
168155tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple
@@ -170,55 +157,48 @@ tupleIntersection tuple1 tuple2 = RelationTuple newAttrs newTupVec
170157 where
171158 attrs1 = tupleAttributes tuple1
172159 attrs2 = tupleAttributes tuple2
173− intersectAttrs = A.intersection attrs1 attrs2
174− matchingIndices = V.findIndices (\attr -> A.member attr intersectAttrs &&
175− atomForAttributeName (attributeName attr) tuple1 ==
176− atomForAttributeName (attributeName attr) tuple2) (attributesVec attrs1)
160+ matchingIndices = V.findIndices (\attr -> V.elem attr attrs2 &&
161+ atomForAttributeName (attributeName attr) tuple1 ==
162+ atomForAttributeName (attributeName attr) tuple2
163+ ) attrs1
177164 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'
165+ newAttrs = indexFilter attrs1
181166 newTupVec = indexFilter (tupleAtoms tuple1)
182167
183−-- | An optimized form of tuple update which updates vectors efficiently.
184−updateTupleWithAtoms :: M.Map AttributeName Atom -> RelationTuple -> RelationTuple
168+ -- | An optimized form of tuple update which updates vectors efficiently.
169+updateTupleWithAtoms :: (M.Map AttributeName Atom) -> RelationTuple -> RelationTuple
185170updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec
186171 where
187172 updateKeysSet = M.keysSet updateMap
188− updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed (attributesVec attrs))
173+ updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed attrs)
189174 newVec = V.update tupVec updateVec
190− updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec
175+ updateVec = V.map (\(index, attr) -> (index, updateMap M.! (attributeName attr))) updateKeysIVec
191176
192−tupleToMap :: RelationTuple -> M.Map AttributeName Atom
177+tupleToMap :: RelationTuple -> (M.Map AttributeName Atom)
193178tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList
194179 where
195− assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed (attributesVec attrs))
180+ assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed attrs)
196181
197−-- | Validate that the tuple has the correct attributes in the correct order
198182verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple
199−verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs
183+verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs
200184 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in
201− if A.arity attrs /= V.length tupleTypes then
185+ if V.length attrs /= V.length tupleTypes then
202186 Left $ TupleAttributeCountMismatchError 0
203− else do
204− mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)
205− Right tuple
187+ else if attrsTypes /= tupleTypes then
188+ -- Left $ traceShow (show attrsTypes ++ "gonk" ++ show tupleTypes ++ "done") $ TupleAttributeTypeMismatchError (attributesDifference attrs (tupleAttributes tuple))
189+ Left $ TupleAttributeTypeMismatchError (attributesDifference attrs (tupleAttributes tuple))
190+ else
191+ Right $ tuple
206192
207193--two tuples can be equal but the vectors of attributes could be out-of-order
208194--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering
209195reorderTuple :: Attributes -> RelationTuple -> RelationTuple
210−reorderTuple attrs tupIn = if attributesAndOrderEqual (tupleAttributes tupIn) attrs then
196+reorderTuple attrs tupIn = if tupleAttributes tupIn == attrs then
211197 tupIn
212− else
213− RelationTuple attrs (V.map mapper (attributesVec attrs))
198+ else do
199+ RelationTuple attrs (V.map mapper attrs)
214200 where
215201 mapper attr = case atomForAttributeName (attributeName attr) tupIn of
216− Left err -> error ("logic bug in reorderTuple: " ++ show err <> show tupIn)
202+ Left _ -> error "logic failure in reorderTuple"
217203 Right atom -> atom
218204
219−--used in Generics derivation for ADTs without named attributes
220−trimTuple :: Int -> RelationTuple -> RelationTuple
221−trimTuple index (RelationTuple attrs vals) =
222− RelationTuple newAttrs (V.drop index vals)
223− where
224− newAttrs = A.drop index attrs
src/lib/ProjectM36/TupleSet.hs → ProjectM36/TupleSet.hsrenamed+4−11
@@ -18,10 +18,10 @@ singletonTupleSet = RelationTupleSet [emptyTuple]
1818verifyTupleSet :: Attributes -> RelationTupleSet -> Either RelationalError RelationTupleSet
1919verifyTupleSet attrs tupleSet = do
2020 --check that all tuples have the same attributes and that the atom types match
21− let tupleList = map (verifyTuple attrs) (asList tupleSet) `P.using` P.parListChunk chunkSize P.r0
22− chunkSize = (length . asList) tupleSet `div` 24
21+ let tupleList = (map (verifyTuple attrs) (asList tupleSet)) `P.using` P.parListChunk chunkSize P.r0
22+ chunkSize = ((length . asList) tupleSet) `div` 24
2323 --let tupleList = P.parMap P.rdeepseq (verifyTuple attrs) (HS.toList tupleSet)
24− if not (null (lefts tupleList)) then
24+ if length (lefts tupleList) > 0 then
2525 Left $ head (lefts tupleList)
2626 else
2727 return $ RelationTupleSet $ (HS.toList . HS.fromList) (rights tupleList)
@@ -30,11 +30,4 @@ mkTupleSet :: Attributes -> [RelationTuple] -> Either RelationalError RelationTu
3030mkTupleSet attrs tuples = verifyTupleSet attrs (RelationTupleSet tuples)
3131
3232mkTupleSetFromList :: Attributes -> [[Atom]] -> Either RelationalError RelationTupleSet
33−mkTupleSetFromList 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)
33+mkTupleSetFromList attrs atomMatrix = mkTupleSet attrs $ map (\atomList -> mkRelationTuple attrs (V.fromList atomList)) atomMatrix
ProjectM36/TypeConstructor.hsnew file+19
@@ -0,0 +1,19 @@
1+module ProjectM36.TypeConstructor where
2+import ProjectM36.Base
3+import qualified Data.Set as S
4+
5+name :: TypeConstructor -> TypeConstructorName
6+name (ADTypeConstructor name' _) = name'
7+name (PrimitiveTypeConstructor name' _) = name'
8+
9+arguments :: TypeConstructor -> [TypeConstructorArg]
10+arguments (ADTypeConstructor _ args) = args
11+arguments (PrimitiveTypeConstructor _ _) = []
12+
13+typeVars :: TypeConstructor -> S.Set TypeVarName
14+typeVars (PrimitiveTypeConstructor _ _) = S.empty
15+typeVars (ADTypeConstructor _ args) = S.unions (map typeVarsForArg args)
16+
17+typeVarsForArg :: TypeConstructorArg -> S.Set TypeVarName
18+typeVarsForArg (TypeConstructorArg arg) = typeVars arg
19+typeVarsForArg (TypeConstructorTypeVarArg pName) = S.singleton pName
src/lib/ProjectM36/TypeConstructorDef.hs → ProjectM36/TypeConstructorDef.hsrenamed

The content is the same.

src/lib/ProjectM36/Win32Handle.hs → ProjectM36/Win32Handle.hsrenamed+2−5
@@ -41,7 +41,7 @@ withHandleToHANDLE haskell_handle action =
4141
4242 -- Get the FD from the algebraic data type
4343#if __GLASGOW_HASKELL__ < 612
44− fd <- haFD <$> readMVar write_handle_mvar
44+ fd <- fmap haFD $ readMVar write_handle_mvar
4545#else
4646 --readMVar write_handle_mvar >>= \(Handle__ { haDevice = dev }) -> print (typeOf dev)
4747 Just fd <- fmap (\(Handle__ { haDevice = dev }) -> fmap fdFD (cast dev)) $ readMVar write_handle_mvar
@@ -53,8 +53,5 @@ withHandleToHANDLE haskell_handle action =
5353 -- Do what the user originally wanted
5454 action windows_handle
5555
56−#if MIN_VERSION_Win32(2,5,1)
57−#else
5856withStablePtr :: a -> (StablePtr a -> IO b) -> IO b
59−withStablePtr value = bracket (newStablePtr value) freeStablePtr
60−#endif
57+withStablePtr value = bracket (newStablePtr value) freeStablePtr
README.markdown+7−62
@@ -1,25 +1,9 @@
1−# Ξ Project:M36 Relational Algebra Engine
2−
3−[![Haskell Programming Language](https://img.shields.io/badge/language-Haskell-blue.svg)](https://www.haskell.org)
4−[![Public Domain](https://img.shields.io/badge/license-Public%20Domain-brightgreen.svg)](http://unlicense.org)
5−[![Hackage](https://img.shields.io/hackage/v/project-m36.svg)](http://hackage.haskell.org/package/project-m36)
6−[![Hackage dependency status](https://img.shields.io/hackage-deps/v/project-m36.svg)](http://packdeps.haskellers.com/feed?needle=project-m36)
7−[![Windows Build status](https://ci.appveyor.com/api/projects/status/q7jyddd6dy1ibqdo/branch/master?svg=true)](https://ci.appveyor.com/project/agentm/project-m36)
8−[![Github Workflow status](https://github.com/agentm/project-m36/workflows/CI/badge.svg)](https://github.com/agentm/project-m36/actions?query=workflow%3ACI)
9−
10−
11−*Software can always be made faster, but rarely can it be made more correct.*
1+# Project:M36 Relational Algebra Engine
122
133## Introduction
144
155Project:M36 implements a relational algebra engine as inspired by the writings of Chris Date.
166
17−## Quick Install
18−
19−Project:M36 can be downloaded and run via docker, which supports Windows 10, macOS, and Linux.
20−
21−Run `docker run -it projectm36/project-m36 tutd` to start the TutorialD command line interface.
22−
237## Description
248
259Unlike most database management systems (DBMS), Project:M36 is opinionated software which adheres strictly to the mathematics of the relational algebra. The purpose of this adherence is to prove that software which implements mathematically-sound design principles reaps benefits in the form of code clarity, consistency, performance, and future-proofing.
@@ -28,10 +12,6 @@ Project:M36 can be used as an in-process or remote DBMS.
2812
2913Project:M36 is written entirely in the [Haskell programming language](https://www.haskell.org/).
3014
31−## Sample Session
32−
33−[![asciicast](https://asciinema.org/a/3syu35c8cydm403292a74l1n5.png)](https://asciinema.org/a/3syu35c8cydm403292a74l1n5)
34−
3515## Use-Cases
3616
3717Project:M36 supports multiple frontends which target different audiences.
@@ -40,71 +20,36 @@ Project:M36 supports multiple frontends which target different audiences.
4020* store and manipulate databases
4121* use Project:M36 as a native Haskell database backend
4222
43−## Community
44−
45−* [Developer's Blog](https://agentm.github.io/project-m36/)
46−* [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−* [Hackage](https://hackage.haskell.org/package/project-m36)
49−* [Diogo Biazus' Project:M36 Video Tutorial](https://www.youtube.com/watch?v=_GC_lxlVEnE)
50−
5123## Documentation
5224
53−### Introductory Materials
54−
55251. [Installation and Introduction to Project:M36](docs/introduction_to_projectm36.markdown)
56261. [Introduction to the Relational Algebra](docs/introduction_to_the_relational_algebra.markdown)
57−1. [TutorialD Cheatsheet](docs/tutd_cheatsheet.markdown)
58−1. [TutorialD via Jupyter Notebook Walkthrough](jupyter/TutorialD%20Notebook%20Walkthrough.ipynb)
59271. [TutorialD Tutorial](docs/tutd_tutorial.markdown)
60281. [15 Minute Tutorial](docs/15_minute_tutorial.markdown)
61−1. [Developer's Change Log](Changelog.markdown)
62−1. [Simple Client API](docs/simple_api.markdown)
63−1. [CSV Import/Export](docs/import_export_csv.markdown)
64−
65−### Database Comparisons
66−
67−1. [ACID Database Properties](docs/acid_assessment.markdown)
68−1. [On NULL (in SQL)](docs/on_null.markdown)
69−1. [Reaching "Out of the Tarpit" with Project:M36](docs/reaching_out_of_the_tarpit.markdown)
70−1. [An Architecture for Data Independence](docs/data_independence.markdown)
71−
72−### Advanced Features
73−
74291. [Transaction Graph Operators](docs/transaction_graph_operators.markdown)
30+1. [On NULL (in SQL)](docs/on_null.markdown)
31+1. [Persistent Library Driver](docs/persistent_library_driver.markdown)
75321. [ProjectM36.Client Library](docs/projectm36_client_library.markdown)
76−1. [Data Frames for Sorting](docs/dataframes.markdown)
77331. [Adding New Data Types](docs/new_datatypes.markdown)
78−1. [Database-Manipulating Functions](docs/database_context_functions.markdown)
34+1. [ACID Database Properties](docs/acid_assessment.markdown)
79351. [Serving Remote ProjectM36 Databases](docs/server_mode.markdown)
80361. [Using Notifications](docs/using_notifications.markdown)
81371. [Merge Transactions](docs/merge_transactions.markdown)
82−1. [Atom (Value) Functions](docs/atomfunctions.markdown)
83−1. [Trans-Graph Relational Expressions](docs/transgraphrelationalexpr.markdown)
84−1. [Isomorphic Schemas](docs/isomorphic_schemas.markdown)
85−1. [Replication](docs/replication.markdown)
86−1. [Basic Operator Benchmarks](https://rawgit.com/agentm/project-m36/master/docs/basic_benchmarks.html)
87−1. [Merkle Transaction Hashes](docs/merkle_transaction_graph.markdown)
88−
89−### Integrations
90−
38+1. [Reaching "Out of the Tarpit" with Project:M36](docs/reaching_out_of_the_tarpit.markdown)
91391. [WebSocket Server](docs/websocket_server.markdown)
92−1. [Jupyter Notebook Kernel](docs/jupyter_kernel.markdown)
93−1. [Persistent Driver](https://github.com/YuMingLiao/persistent-project-m36)
9440
9541## Development
9642
97−Project:M36 is developed in Haskell and compiled with GHC 8.6 or later.
43+Project:M36 is developed in Haskell and compiled with GHC 7.8 or later.
9844
9945## Related Projects
10046
10147* [The Third Manifesto](http://thethirdmanifesto.com/): the philosophical basis for relational algebra engines
10248* [Rel](http://reldb.org/): a TutorialD implementation against a BerkeleyDB backend
10349* [Andl](http://andl.org/): a new database language with SQLite and PostgreSQL backends
104−* [Coddie](https://github.com/scvalencia/Coddie): a python-based relational algebra interpreter
10550
10651## Suggested Reading
10752
108−* [Out of the Tarpit](https://github.com/papers-we-love/papers-we-love/blob/2eb8d21/design/out-of-the-tar-pit.pdf): a proposed software architecture which minimizes state and complexity. Project:M36 implements the requirements of this paper.
53+* [Out of the Tarpit](http://shaffner.us/cs/papers/tarpit.pdf): a proposed software architecture which minimizes state and complexity. Project:M36 implements the requirements of this paper.
10954* [Database Design & Relational Theory: Normal Forms and All That Jazz](http://shop.oreilly.com/product/0636920025276.do): mathematical foundations for the principles of the relational algebra
11055* [Database Explorations: Essays on the Third Manifesto and Related Topics](http://bookstore.trafford.com/Products/SKU-000177853/Database-Explorations.aspx): additional essays and debates on practical approaches to relational algebra engine design
TutorialD/Interpreter.hsnew file+195
@@ -0,0 +1,195 @@
1+{-# LANGUAGE GADTs #-}
2+module TutorialD.Interpreter where
3+import TutorialD.Interpreter.Base
4+import TutorialD.Interpreter.RODatabaseContextOperator
5+import TutorialD.Interpreter.DatabaseContextExpr
6+import TutorialD.Interpreter.TransactionGraphOperator
7+import TutorialD.Interpreter.InformationOperator
8+import TutorialD.Interpreter.DatabaseContextIOOperator
9+
10+import TutorialD.Interpreter.Import.CSV
11+import TutorialD.Interpreter.Import.TutorialD
12+import TutorialD.Interpreter.Import.BasicExamples
13+import TutorialD.Interpreter.Import.Base
14+
15+import TutorialD.Interpreter.Export.CSV
16+import TutorialD.Interpreter.Export.Base
17+
18+import ProjectM36.Base
19+import ProjectM36.Relation.Show.Term
20+import ProjectM36.TransactionGraph
21+import qualified ProjectM36.Client as C
22+import ProjectM36.Relation (attributes)
23+
24+import Text.Parsec
25+import Text.Parsec.String
26+import Control.Monad.State
27+import System.Console.Haskeline
28+import System.Directory (getHomeDirectory)
29+import qualified Data.Text as T
30+import Data.Maybe (fromMaybe)
31+import System.IO (hPutStrLn, stderr)
32+
33+{-
34+context ops are read-only operations which only operate on the database context (relvars and constraints)
35+database ops are read-write operations which change the database context (such as relvar assignment)
36+graph ops are read-write operations which change the transaction graph
37+-}
38+data ParsedOperation = RODatabaseContextOp RODatabaseContextOperator |
39+ DatabaseContextExprOp DatabaseContextExpr |
40+ DatabaseContextIOExprOp DatabaseContextIOExpr |
41+ InfoOp InformationOperator |
42+ GraphOp TransactionGraphOperator |
43+ ROGraphOp ROTransactionGraphOperator |
44+ ImportRelVarOp RelVarDataImportOperator |
45+ ImportDBContextOp DatabaseContextDataImportOperator |
46+ ImportBasicExampleOp ImportBasicExampleOperator |
47+ RelVarExportOp RelVarDataExportOperator
48+
49+interpreterParserP :: Parser ParsedOperation
50+interpreterParserP = safeInterpreterParserP <|>
51+ liftM ImportRelVarOp (importCSVP <* eof) <|>
52+ liftM ImportDBContextOp (tutdImportP <* eof) <|>
53+ liftM RelVarExportOp (exportCSVP <* eof) <|>
54+ liftM DatabaseContextIOExprOp (parseCreateAtomFunctionExpr <* eof)
55+
56+-- the safe interpreter never reads or writes the file system
57+safeInterpreterParserP :: Parser ParsedOperation
58+safeInterpreterParserP = liftM RODatabaseContextOp (roDatabaseContextOperatorP <* eof) <|>
59+ liftM InfoOp (infoOpP <* eof) <|>
60+ liftM GraphOp (transactionGraphOpP <* eof) <|>
61+ liftM ROGraphOp (roTransactionGraphOpP <* eof) <|>
62+ liftM DatabaseContextExprOp (databaseExprOpP <* eof) <|>
63+ liftM ImportBasicExampleOp (importBasicExampleOperatorP <* eof)
64+
65+
66+promptText :: Maybe HeadName -> StringType
67+promptText mHeadName = "TutorialD (" `T.append` transInfo `T.append` "): "
68+ where
69+ transInfo = fromMaybe "<unknown>" mHeadName
70+
71+parseTutorialD :: String -> Either ParseError ParsedOperation
72+parseTutorialD inputString = parse interpreterParserP "" inputString
73+
74+--only parse tutoriald which doesn't result in file I/O
75+safeParseTutorialD :: String -> Either ParseError ParsedOperation
76+safeParseTutorialD inputString = parse safeInterpreterParserP "" inputString
77+
78+data SafeEvaluationFlag = SafeEvaluation | UnsafeEvaluation deriving (Eq)
79+
80+--execute the operation and display result
81+evalTutorialD :: C.SessionId -> C.Connection -> SafeEvaluationFlag -> ParsedOperation -> IO (TutorialDOperatorResult)
82+evalTutorialD sessionId conn safe expr = case expr of
83+
84+ --this does not pass through the ProjectM36.Client library because the operations
85+ --are specific to the interpreter, though some operations may be of general use in the future
86+ (RODatabaseContextOp execOp) -> do
87+ evalRODatabaseContextOp sessionId conn execOp
88+
89+ (DatabaseContextExprOp execOp) -> do
90+ maybeErr <- C.executeDatabaseContextExpr sessionId conn execOp
91+ case maybeErr of
92+ Just err -> barf err
93+ Nothing -> return QuietSuccessResult
94+
95+ (DatabaseContextIOExprOp execOp) -> do
96+ if needsSafe then
97+ unsafeError
98+ else do
99+ mErr <- C.executeDatabaseContextIOExpr sessionId conn execOp
100+ case mErr of
101+ Just err -> barf err
102+ Nothing -> pure QuietSuccessResult
103+
104+ (GraphOp execOp) -> do
105+ maybeErr <- C.executeGraphExpr sessionId conn execOp
106+ case maybeErr of
107+ Just err -> barf err
108+ Nothing -> return QuietSuccessResult
109+
110+ (ROGraphOp execOp) -> do
111+ opResult <- evalROGraphOp sessionId conn execOp
112+ case opResult of
113+ Left err -> barf err
114+ Right rel -> pure (DisplayRelationResult rel)
115+
116+ (ImportRelVarOp execOp@(RelVarDataImportOperator relVarName _ _)) -> do
117+ if needsSafe then
118+ unsafeError
119+ else do
120+ -- collect attributes from relvar name
121+ -- is there a race condition here? The attributes of the relvar may have since changed, no?
122+ eImportType <- C.typeForRelationalExpr sessionId conn (RelationVariable relVarName)
123+ case eImportType of
124+ Left err -> barf err
125+ Right importType -> do
126+ exprErr <- evalRelVarDataImportOperator execOp (attributes importType)
127+ case exprErr of
128+ Left err -> barf err
129+ Right dbexpr -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexpr)
130+
131+ (ImportDBContextOp execOp) -> do
132+ if needsSafe then
133+ unsafeError
134+ else do
135+ mDbexprs <- evalDatabaseContextDataImportOperator execOp
136+ case mDbexprs of
137+ Left err -> barf err
138+ Right dbexprs -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexprs)
139+
140+ (InfoOp execOp) -> do
141+ if needsSafe then
142+ unsafeError
143+ else
144+ case evalInformationOperator execOp of
145+ Left err -> barf err
146+ Right info -> pure (DisplayResult info)
147+
148+ (RelVarExportOp execOp@(RelVarDataExportOperator relExpr _ _)) -> do
149+ --eval relexpr to relation and pass to export function
150+ if needsSafe then
151+ unsafeError
152+ else do
153+ eRel <- C.executeRelationalExpr sessionId conn relExpr
154+ case eRel of
155+ Left err -> barf err
156+ Right rel -> do
157+ exportResult <- evalRelVarDataExportOperator execOp rel
158+ case exportResult of
159+ Just err -> barf err
160+ Nothing -> pure QuietSuccessResult
161+ (ImportBasicExampleOp execOp) -> do
162+ let dbcontextexpr = evalImportBasicExampleOperator execOp
163+ evalTutorialD sessionId conn safe (DatabaseContextExprOp dbcontextexpr)
164+ where
165+ needsSafe = safe == SafeEvaluation
166+ unsafeError = pure $ DisplayErrorResult "File I/O operation prohibited."
167+ barf err = return $ DisplayErrorResult (T.pack (show err))
168+
169+data InterpreterConfig = LocalInterpreterConfig PersistenceStrategy HeadName|
170+ RemoteInterpreterConfig C.NodeId C.DatabaseName HeadName
171+
172+outputNotificationCallback :: C.NotificationCallback
173+outputNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received " ++ show notName ++ ":\n" ++ show (reportExpr (C.notification evaldNot)) ++ "\n" ++ prettyEvaluatedNotification evaldNot
174+
175+prettyEvaluatedNotification :: C.EvaluatedNotification -> String
176+prettyEvaluatedNotification eNotif = case C.reportRelation eNotif of
177+ Left err -> show err
178+ Right reportRel -> T.unpack (showRelation reportRel)
179+
180+reprLoop :: InterpreterConfig -> C.SessionId -> C.Connection -> IO ()
181+reprLoop config sessionId conn = do
182+ homeDirectory <- getHomeDirectory
183+ let settings = defaultSettings {historyFile = Just (homeDirectory ++ "/.tutd_history")}
184+ mHeadName <- C.headName sessionId conn
185+ maybeLine <- runInputT settings $ getInputLine (T.unpack (promptText mHeadName))
186+ case maybeLine of
187+ Nothing -> return ()
188+ Just line -> do
189+ case parseTutorialD line of
190+ Left err -> do
191+ displayOpResult $ DisplayErrorResult (T.pack (show err))
192+ Right parsed -> do
193+ evald <- evalTutorialD sessionId conn UnsafeEvaluation parsed
194+ displayOpResult evald
195+ reprLoop config sessionId conn
TutorialD/Interpreter/Base.hsnew file+120
@@ -0,0 +1,120 @@
1+{-# LANGUAGE DeriveGeneric #-}
2+module TutorialD.Interpreter.Base where
3+import Text.Parsec
4+import Text.Parsec.String
5+import qualified Text.Parsec.Token as Token
6+import Text.Parsec.Language
7+import ProjectM36.Base
8+import qualified Data.Text as T
9+import qualified Data.List as L
10+import qualified Data.Vector as V
11+import qualified Data.Text.IO as TIO
12+import System.IO
13+import ProjectM36.DataTypes.Primitive
14+import ProjectM36.Relation.Show.Term
15+import GHC.Generics
16+
17+lexer :: Token.TokenParser ()
18+lexer = Token.makeTokenParser tutD
19+ where tutD = emptyDef {
20+ Token.reservedOpNames = ["join", "where", "union", "group", "ungroup"],
21+ Token.reservedNames = [],
22+ Token.identStart = letter <|> char '_',
23+ Token.opLetter = oneOf ":!#$%&*+./<=>?\\^|-~", -- remove "@" so it can be used as attribute marker without spaces
24+ Token.identLetter = alphaNum <|> char '_' <|> char '#'} -- # needed for Date examples
25+
26+parens :: Parser a -> Parser a
27+parens = Token.parens lexer
28+
29+reservedOp :: String -> Parser ()
30+reservedOp = Token.reservedOp lexer
31+
32+reserved :: String -> Parser ()
33+reserved = Token.reserved lexer
34+
35+braces :: Parser a -> Parser a
36+braces = Token.braces lexer
37+
38+identifier :: Parser String
39+identifier = Token.identifier lexer
40+
41+symbol :: String -> Parser String
42+symbol = Token.symbol lexer
43+
44+comma :: Parser String
45+comma = Token.comma lexer
46+
47+pipe :: Parser String
48+pipe = Token.symbol lexer "|"
49+
50+arrow :: Parser String
51+arrow = Token.symbol lexer "->"
52+
53+semi :: Parser String
54+semi = Token.semi lexer
55+
56+whiteSpace :: Parser ()
57+whiteSpace = Token.whiteSpace lexer
58+
59+integer :: Parser Integer
60+integer = Token.integer lexer
61+
62+float :: Parser Double
63+float = Token.float lexer
64+
65+capitalizedIdentifier :: Parser String
66+capitalizedIdentifier = do
67+ fletter <- upper
68+ rest <- option "" identifier
69+ spaces
70+ pure $ fletter:rest
71+
72+uncapitalizedIdentifier :: Parser String
73+uncapitalizedIdentifier = do
74+ fletter <- lower
75+ rest <- option "" identifier
76+ spaces
77+ pure (fletter:rest)
78+
79+atomTypeToTutDType :: AtomType -> Maybe T.Text
80+atomTypeToTutDType atomType = case atomType of
81+ aType@(AtomType _) -> lookup aType [(textAtomType, "char"),
82+ (intAtomType, "int"),
83+ (boolAtomType, "bool"),
84+ (doubleAtomType, "double")]
85+ (RelationAtomType attrs) -> Just $ "relation" `T.append` showRelationAttributes attrs
86+ _ -> Nothing
87+
88+showRelationAttributes :: Attributes -> T.Text
89+showRelationAttributes attrs = "{" `T.append` T.concat (L.intersperse ", " $ map showAttribute attrsL) `T.append` "}"
90+ where
91+ showAttribute (Attribute name atomType) = name `T.append` " " `T.append` case atomTypeToTutDType atomType of
92+ Just t -> t
93+ Nothing -> "unknown"
94+ attrsL = V.toList attrs
95+
96+data TutorialDOperatorResult = QuitResult |
97+ DisplayResult StringType |
98+ DisplayIOResult (IO ()) |
99+ DisplayRelationResult Relation |
100+ DisplayErrorResult StringType |
101+ QuietSuccessResult
102+ deriving (Generic)
103+
104+type TransactionGraphWasUpdated = Bool
105+
106+displayOpResult :: TutorialDOperatorResult -> IO ()
107+displayOpResult QuitResult = return ()
108+displayOpResult (DisplayResult out) = TIO.putStrLn out
109+displayOpResult (DisplayIOResult ioout) = ioout
110+displayOpResult (DisplayErrorResult err) = TIO.hPutStrLn stderr ("ERR: " `T.append` err)
111+displayOpResult QuietSuccessResult = return ()
112+displayOpResult (DisplayRelationResult rel) = TIO.putStrLn (showRelation rel)
113+
114+quotedChar :: Parser Char
115+quotedChar = noneOf "\""
116+ <|> try (string "\"\"" >> return '"')
117+
118+quotedString :: Parser String
119+quotedString = string "\"" *> many quotedChar <* string "\"" <* whiteSpace
120+
TutorialD/Interpreter/DataTypes/DateTime.hsnew file+22
@@ -0,0 +1,22 @@
1+module TutorialD.Interpreter.DataTypes.DateTime where
2+import Text.Parsec
3+import ProjectM36.Base
4+import Text.Parsec.String
5+import TutorialD.Interpreter.Base
6+import Data.Time.Clock
7+import Data.Time.Format
8+
9+dateTimeAtomP :: Parser Atom
10+dateTimeAtomP = do
11+ dateTime' <- try $ do
12+ dateTime <- dateTimeStringP
13+ reserved "::datetime"
14+ return dateTime
15+ return $ Atom dateTime'
16+
17+dateTimeStringP :: Parser UTCTime
18+dateTimeStringP = do
19+ dateTimeString <- quotedString
20+ case parseTimeM False defaultTimeLocale "%Y-%m-%d %H:%M:%S" dateTimeString of
21+ Just utctime -> return $ (utctime :: UTCTime)
22+ Nothing -> fail $ "Failed to parse datetime from " ++ dateTimeString
TutorialD/Interpreter/DataTypes/Interval.hsnew file+35
@@ -0,0 +1,35 @@
1+module TutorialD.Interpreter.DataTypes.Interval where
2+import Text.Parsec
3+import Text.Parsec.String
4+import ProjectM36.Base hiding (Finite)
5+import ProjectM36.DataTypes.Interval ()
6+import TutorialD.Interpreter.Base
7+import TutorialD.Interpreter.DataTypes.DateTime
8+import Data.Interval
9+import Data.Time.Clock
10+
11+intervalP :: (Ord a) => Parser (Extended a) -> Parser (Interval a)
12+intervalP unitP = do
13+ lBoundClosed <- string "(" *> return False <|>
14+ string "[" *> return True
15+ lBound <- unitP
16+ reservedOp ","
17+ uBound <- unitP
18+
19+ uBoundClosed <- string ")" *> return False <|>
20+ string "]" *> return True
21+
22+ return $ interval (lBound, lBoundClosed) (uBound, uBoundClosed)
23+
24+intervalDateTimeUnitP :: Parser (Extended UTCTime)
25+intervalDateTimeUnitP = Finite <$> dateTimeStringP <|>
26+ (reserved "inf" *> return PosInf) <|>
27+ (reserved "-inf" *> return NegInf)
28+
29+intervalDateTimeAtomP :: Parser Atom
30+intervalDateTimeAtomP = do
31+ reserved "interval_datetime("
32+ intv <- intervalP intervalDateTimeUnitP
33+ reserved ")"
34+ return $ Atom intv
35+
TutorialD/Interpreter/DatabaseContextExpr.hsnew file+182
@@ -0,0 +1,182 @@
1+module TutorialD.Interpreter.DatabaseContextExpr where
2+import Text.Parsec
3+import Text.Parsec.String
4+import ProjectM36.Base
5+import TutorialD.Interpreter.Base
6+import qualified Data.Text as T
7+import TutorialD.Interpreter.RelationalExpr
8+import TutorialD.Interpreter.Types
9+import qualified Data.Map as M
10+import Control.Monad.State
11+import ProjectM36.StaticOptimizer
12+import ProjectM36.Error
13+import ProjectM36.RelationalExpression
14+import ProjectM36.Key
15+
16+--parsers which create "database expressions" which modify the database context (such as relvar assignment)
17+databaseExprP :: Parser DatabaseContextExpr
18+databaseExprP = choice $ map (\p -> p <* optional commentP) [insertP,
19+ deleteConstraintP,
20+ deleteP,
21+ updateP,
22+ addConstraintP,
23+ keyP,
24+ defineP,
25+ undefineP,
26+ assignP,
27+ addNotificationP,
28+ removeNotificationP,
29+ addTypeConstructorP,
30+ removeTypeConstructorP,
31+ nothingP]
32+
33+commentP :: Parser DatabaseContextExpr
34+commentP = reserved "--" >> manyTill anyChar eof >> pure NoOperation
35+
36+nothingP :: Parser DatabaseContextExpr
37+nothingP = whiteSpace >> pure NoOperation
38+
39+assignP :: Parser DatabaseContextExpr
40+assignP = do
41+ relVarName <- try $ do
42+ relVarName <- identifier
43+ reservedOp ":="
44+ return relVarName
45+ expr <- relExprP
46+ return $ Assign (T.pack relVarName) expr
47+
48+multipleDatabaseContextExprP :: Parser DatabaseContextExpr
49+multipleDatabaseContextExprP = do
50+ exprs <- sepBy1 databaseExprP semi
51+ return $ MultipleExpr exprs
52+
53+insertP :: Parser DatabaseContextExpr
54+insertP = do
55+ reservedOp "insert"
56+ relvar <- identifier
57+ expr <- relExprP
58+ return $ Insert (T.pack relvar) expr
59+
60+defineP :: Parser DatabaseContextExpr
61+defineP = do
62+ relVarName <- try $ do
63+ relVarName <- identifier
64+ reservedOp "::"
65+ return relVarName
66+ attributeSet <- makeAttributeExprsP
67+ return $ Define (T.pack relVarName) attributeSet
68+
69+undefineP :: Parser DatabaseContextExpr
70+undefineP = do
71+ reservedOp "undefine"
72+ relVarName <- identifier
73+ return $ Undefine (T.pack relVarName)
74+
75+deleteP :: Parser DatabaseContextExpr
76+deleteP = do
77+ reservedOp "delete"
78+ relVarName <- identifier
79+ predicate <- option TruePredicate (reservedOp "where" *> restrictionPredicateP)
80+ return $ Delete (T.pack relVarName) predicate
81+
82+updateP :: Parser DatabaseContextExpr
83+updateP = do
84+ reservedOp "update"
85+ relVarName <- identifier
86+ predicate <- option TruePredicate (reservedOp "where" *> restrictionPredicateP <* spaces)
87+ attributeAssignments <- liftM M.fromList $ parens (sepBy attributeAssignmentP comma)
88+ return $ Update (T.pack relVarName) (M.mapKeys T.pack $ attributeAssignments) predicate
89+
90+data IncDepOp = SubsetOp | EqualityOp
91+
92+addConstraintP :: Parser DatabaseContextExpr
93+addConstraintP = do
94+ reservedOp "constraint" <|> reservedOp "foreign key"
95+ constraintName <- identifier
96+ subset <- relExprP
97+ op <- (reservedOp "in" *> pure SubsetOp) <|> (reservedOp "equals" *> pure EqualityOp)
98+ superset <- relExprP
99+ let subsetA = incDepSet constraintName subset superset
100+ subsetB = incDepSet (constraintName ++ "_eqInvert") superset subset --inverted args for equality constraint
101+ incDepSet nam a b = AddInclusionDependency (T.pack nam) (InclusionDependency a b)
102+ case op of
103+ SubsetOp -> pure subsetA
104+ EqualityOp -> pure (MultipleExpr [subsetA, subsetB])
105+
106+
107+
108+deleteConstraintP :: Parser DatabaseContextExpr
109+deleteConstraintP = do
110+ reserved "deleteconstraint"
111+ constraintName <- identifier
112+ return $ RemoveInclusionDependency (T.pack constraintName)
113+
114+-- key <constraint name> {<uniqueness attributes>} <uniqueness relexpr>
115+keyP :: Parser DatabaseContextExpr
116+keyP = do
117+ reserved "key"
118+ keyName <- identifier
119+ uniquenessAttrNames <- braces attributeListP
120+ uniquenessExpr <- relExprP
121+ let newIncDep = inclusionDependencyForKey uniquenessAttrNames uniquenessExpr
122+ return $ AddInclusionDependency (T.pack keyName) newIncDep
123+
124+attributeAssignmentP :: Parser (String, AtomExpr)
125+attributeAssignmentP = do
126+ attrName <- identifier
127+ reservedOp ":="
128+ atomExpr <- atomExprP
129+ return $ (attrName, atomExpr)
130+
131+addNotificationP :: Parser DatabaseContextExpr
132+addNotificationP = do
133+ reserved "notify"
134+ notName <- identifier
135+ triggerExpr <- relExprP
136+ resultExpr <- relExprP
137+ return $ AddNotification (T.pack notName) triggerExpr resultExpr
138+
139+removeNotificationP :: Parser DatabaseContextExpr
140+removeNotificationP = do
141+ reserved "unnotify"
142+ notName <- identifier
143+ return $ RemoveNotification (T.pack notName)
144+
145+-- | data Hair = Bald | Color Text
146+addTypeConstructorP :: Parser DatabaseContextExpr
147+addTypeConstructorP = do
148+ reserved "data"
149+ typeConstructorDef <- typeConstructorDefP
150+ reservedOp "="
151+ dataConstructorDefs <- sepBy1 dataConstructorDefP pipe
152+ pure (AddTypeConstructor typeConstructorDef dataConstructorDefs)
153+
154+removeTypeConstructorP :: Parser DatabaseContextExpr
155+removeTypeConstructorP = do
156+ reserved "undata"
157+ RemoveTypeConstructor <$> liftM T.pack identifier
158+
159+databaseExprOpP :: Parser DatabaseContextExpr
160+databaseExprOpP = multipleDatabaseContextExprP
161+
162+evalDatabaseContextExpr :: Bool -> DatabaseContext -> DatabaseContextExpr -> Either RelationalError DatabaseContext
163+evalDatabaseContextExpr useOptimizer context expr = do
164+ optimizedExpr <- evalState (applyStaticDatabaseOptimization expr) context
165+ case runState (evalContextExpr (if useOptimizer then optimizedExpr else expr)) context of
166+ (Nothing, context') -> Right context'
167+ (Just err, _) -> Left err
168+
169+
170+interpretDatabaseContextExpr :: DatabaseContext -> String -> Either RelationalError DatabaseContext
171+interpretDatabaseContextExpr context tutdstring = case parse databaseExprOpP "" tutdstring of
172+ Left err -> Left $ ParseError (T.pack (show err))
173+ Right parsed -> evalDatabaseContextExpr True context parsed
174+
175+{-
176+--no optimization
177+interpretNO :: DatabaseContext -> String -> (Maybe RelationalError, DatabaseContext)
178+interpretNO context tutdstring = case parseString tutdstring of
179+ Left err -> (Just err, context)
180+ Right parsed -> runState (evalContextExpr parsed) context
181+-}
182+
src/bin/TutorialD/Interpreter/Export/Base.hs → TutorialD/Interpreter/Export/Base.hsrenamed+1−8
@@ -1,16 +1,9 @@
1−{-# LANGUAGE CPP #-}
21module TutorialD.Interpreter.Export.Base where
32import ProjectM36.Base
43import ProjectM36.Error
5−#if __GLASGOW_HASKELL__ < 804
6−import Data.Monoid
7−#endif
84
95data RelVarDataExportOperator = RelVarDataExportOperator RelationalExpr FilePath (RelVarDataExportOperator -> Relation -> IO (Maybe RelationalError))
106
11−instance Show RelVarDataExportOperator where
12− show (RelVarDataExportOperator expr path _) = "RelVarDataExportOperator " <> show expr <> " " <> path
13−
147evalRelVarDataExportOperator :: RelVarDataExportOperator -> Relation -> IO (Maybe RelationalError)
15−evalRelVarDataExportOperator op@(RelVarDataExportOperator _ _ exportFunc) = exportFunc op
8+evalRelVarDataExportOperator op@(RelVarDataExportOperator _ _ exportFunc) rel = exportFunc op rel
169
src/bin/TutorialD/Interpreter/Export/CSV.hs → TutorialD/Interpreter/Export/CSV.hsrenamed+4−3
@@ -2,9 +2,10 @@ module TutorialD.Interpreter.Export.CSV where
22import ProjectM36.Relation.Show.CSV
33import TutorialD.Interpreter.Export.Base
44import TutorialD.Interpreter.RelationalExpr
5−import TutorialD.Interpreter.Base hiding (try)
5+import TutorialD.Interpreter.Base
66import ProjectM36.Base
77import ProjectM36.Error
8+import Text.Parsec.String
89import qualified Data.ByteString.Lazy as BS
910import Control.Exception (try)
1011import qualified Data.Text as T
@@ -14,10 +15,10 @@ exportCSVP = do
1415 reserved ":exportcsv"
1516 exportExpr <- relExprP
1617 path <- quotedString
17− return $ RelVarDataExportOperator exportExpr (T.unpack path) exportRelationCSV
18+ return $ RelVarDataExportOperator exportExpr path exportRelationCSV
1819
1920exportRelationCSV :: RelVarDataExportOperator -> Relation -> IO (Maybe RelationalError)
20−exportRelationCSV (RelVarDataExportOperator _ pathOut _) rel =
21+exportRelationCSV (RelVarDataExportOperator _ pathOut _) rel = do
2122 case relationAsCSV rel of
2223 Left err -> return $ Just err
2324 Right csvData -> do
TutorialD/Interpreter/Import/Base.hsnew file+17
@@ -0,0 +1,17 @@
1+module TutorialD.Interpreter.Import.Base where
2+import ProjectM36.Base
3+import ProjectM36.Error
4+
5+-- | import data into a relation variable
6+data RelVarDataImportOperator = RelVarDataImportOperator RelVarName FilePath (RelVarName -> Attributes -> FilePath -> IO (Either RelationalError DatabaseContextExpr))
7+
8+-- | import data into a database context
9+data DatabaseContextDataImportOperator = DatabaseContextDataImportOperator FilePath (FilePath -> IO (Either RelationalError DatabaseContextExpr))
10+
11+-- perhaps create a structure to import a whole transaction graph section in the future
12+
13+evalRelVarDataImportOperator :: RelVarDataImportOperator -> Attributes -> IO (Either RelationalError DatabaseContextExpr)
14+evalRelVarDataImportOperator (RelVarDataImportOperator relVarName path importFunc) attrs = importFunc relVarName attrs path
15+
16+evalDatabaseContextDataImportOperator :: DatabaseContextDataImportOperator -> IO (Either RelationalError DatabaseContextExpr)
17+evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator path importFunc) = importFunc path
src/bin/TutorialD/Interpreter/Import/BasicExamples.hs → TutorialD/Interpreter/Import/BasicExamples.hsrenamed+3−8
@@ -1,17 +1,12 @@
1−{-# LANGUAGE CPP #-}
21--includes some hardcoded examples which can be imported even during safe evaluation (no file I/O)
32module TutorialD.Interpreter.Import.BasicExamples where
43import ProjectM36.DateExamples
54import ProjectM36.Base
65import ProjectM36.DatabaseContext
76import TutorialD.Interpreter.Base
8−
9−#if !MIN_VERSION_megaparsec(6,0,0)
10−import Text.Megaparsec.Text
11−#endif
7+import Text.Parsec.String
128
139data ImportBasicExampleOperator = ImportBasicDateExampleOperator
14− deriving (Show)
1510
1611evalImportBasicExampleOperator :: ImportBasicExampleOperator -> DatabaseContextExpr
1712evalImportBasicExampleOperator ImportBasicDateExampleOperator = databaseContextAsDatabaseContextExpr dateExamples
@@ -20,8 +15,8 @@ importBasicExampleOperatorP :: Parser ImportBasicExampleOperator
2015importBasicExampleOperatorP = do
2116 reservedOp ":importexample"
2217 example <- identifier
23− if example == "cjdate" then
18+ if example == "date" then
2419 pure ImportBasicDateExampleOperator
2520 else
2621 fail "Unknown example name"
27−
22+
TutorialD/Interpreter/Import/CSV.hsnew file+29
@@ -0,0 +1,29 @@
1+module TutorialD.Interpreter.Import.CSV where
2+import TutorialD.Interpreter.Import.Base
3+import ProjectM36.Base
4+import ProjectM36.Error
5+import ProjectM36.Relation.Parse.CSV
6+import qualified Data.ByteString.Lazy as BS
7+import qualified Data.Text as T
8+import Text.Parsec.String
9+import TutorialD.Interpreter.Base
10+import Control.Exception
11+
12+importCSVRelation :: RelVarName -> Attributes -> FilePath -> IO (Either RelationalError DatabaseContextExpr)
13+importCSVRelation relVarName attrs pathIn = do
14+ --TODO: handle filesystem errors
15+ csvData <- try (BS.readFile pathIn) :: IO (Either IOError BS.ByteString)
16+ case csvData of
17+ Left err -> return $ Left (ImportError $ T.pack (show err))
18+ Right csvData' -> case csvAsRelation csvData' attrs of
19+ Left err -> return $ Left (ParseError $ T.pack (show err))
20+ Right csvRel -> return $ Right (Insert relVarName (ExistingRelation csvRel))
21+
22+importCSVP :: Parser RelVarDataImportOperator
23+importCSVP = do
24+ reserved ":importcsv"
25+ path <- quotedString
26+ whiteSpace
27+ relVarName <- identifier
28+ return $ RelVarDataImportOperator (T.pack relVarName) path importCSVRelation
29+
TutorialD/Interpreter/Import/TutorialD.hsnew file+31
@@ -0,0 +1,31 @@
1+module TutorialD.Interpreter.Import.TutorialD where
2+import ProjectM36.Base
3+import TutorialD.Interpreter.Import.Base
4+import TutorialD.Interpreter.Base
5+import TutorialD.Interpreter.DatabaseContextExpr
6+import Text.Parsec.String
7+import Text.Parsec hiding (try)
8+import ProjectM36.Error
9+import Data.Either
10+import qualified Data.Text as T
11+import Control.Exception
12+--import a file containing TutorialD database context expressions
13+
14+importTutorialD :: FilePath -> IO (Either RelationalError DatabaseContextExpr)
15+importTutorialD pathIn = do
16+ tutdData <- try (readFile pathIn) :: IO (Either IOError String)
17+ case tutdData of
18+ Left err -> return $ Left (ImportError $ T.pack (show err))
19+ Right tutdData' -> do
20+ let dbexprsErr = map (parse databaseExprP "import") (lines tutdData')
21+ errs = lefts dbexprsErr
22+ case errs of
23+ err2:_ -> return $ Left (ParseError (T.pack (show err2)))
24+ [] -> return $ Right (MultipleExpr (rights dbexprsErr))
25+
26+tutdImportP :: Parser DatabaseContextDataImportOperator
27+tutdImportP = do
28+ reserved ":importtutd"
29+ path <- quotedString
30+ whiteSpace
31+ return $ DatabaseContextDataImportOperator path importTutorialD
src/bin/TutorialD/Interpreter/InformationOperator.hs → TutorialD/Interpreter/InformationOperator.hsrenamed+3−8
@@ -1,19 +1,14 @@
11{-# LANGUAGE CPP #-}
22module TutorialD.Interpreter.InformationOperator where
33import Data.Text
4−import Text.Megaparsec
4+import Text.Parsec
5+import Text.Parsec.String
56import TutorialD.Interpreter.Base
6−-- older versions of stack fail to
7−#if !defined(VERSION_project_m36)
8−# warning Failed to discover proper version from cabal_macros.h
9−# define VERSION_project_m36 "<unknown>"
10−#endif
117
128-- this module provides information about the current interpreter
139
1410data InformationOperator = HelpOperator |
1511 GetVersionOperator
16− deriving (Show)
1712
1813infoOpP :: Parser InformationOperator
1914infoOpP = helpOpP <|> getVersionP
@@ -25,7 +20,7 @@ getVersionP :: Parser InformationOperator
2520getVersionP = reserved ":version" >> pure GetVersionOperator
2621
2722evalInformationOperator :: InformationOperator -> Either Text Text
28−evalInformationOperator GetVersionOperator = Right ("tutd " `append` VERSION_project_m36)
23+evalInformationOperator GetVersionOperator = Right ("tutd " `append` PROJECTM36_VERSION)
2924-- display generic help
3025evalInformationOperator HelpOperator = Right $ intercalate "\n" help
3126 where
TutorialD/Interpreter/RODatabaseContextOperator.hsnew file+136
@@ -0,0 +1,136 @@
1+{-# LANGUAGE GADTs #-}
2+module TutorialD.Interpreter.RODatabaseContextOperator where
3+import ProjectM36.Base
4+import qualified ProjectM36.Client as C
5+import Text.Parsec
6+import Text.Parsec.String
7+import TutorialD.Interpreter.Base
8+import TutorialD.Interpreter.RelationalExpr
9+import TutorialD.Interpreter.DatabaseContextExpr
10+import Control.Monad.State
11+import qualified Data.Text as T
12+import ProjectM36.Relation.Show.Gnuplot
13+import qualified Data.Map as M
14+import Data.Maybe
15+
16+--operators which only rely on database context reading
17+data RODatabaseContextOperator where
18+ ShowRelation :: RelationalExpr -> RODatabaseContextOperator
19+ PlotRelation :: RelationalExpr -> RODatabaseContextOperator
20+ ShowRelationType :: RelationalExpr -> RODatabaseContextOperator
21+ ShowConstraint :: StringType -> RODatabaseContextOperator
22+ ShowPlan :: DatabaseContextExpr -> RODatabaseContextOperator
23+ ShowTypes :: RODatabaseContextOperator
24+ ShowRelationVariables :: RODatabaseContextOperator
25+ Quit :: RODatabaseContextOperator
26+ deriving (Show)
27+
28+typeP :: Parser RODatabaseContextOperator
29+typeP = do
30+ reservedOp ":type"
31+ expr <- relExprP
32+ return $ ShowRelationType expr
33+
34+showRelP :: Parser RODatabaseContextOperator
35+showRelP = do
36+ reservedOp ":showexpr"
37+ expr <- relExprP
38+ return $ ShowRelation expr
39+
40+showPlanP :: Parser RODatabaseContextOperator
41+showPlanP = do
42+ reservedOp ":showplan"
43+ expr <- databaseExprP
44+ return $ ShowPlan expr
45+
46+showTypesP :: Parser RODatabaseContextOperator
47+showTypesP = reserved ":showtypes" >> pure ShowTypes
48+
49+showRelationVariables :: Parser RODatabaseContextOperator
50+showRelationVariables = reserved ":showrelvars" >> pure ShowRelationVariables
51+
52+quitP :: Parser RODatabaseContextOperator
53+quitP = do
54+ reservedOp ":quit"
55+ return Quit
56+
57+showConstraintsP :: Parser RODatabaseContextOperator
58+showConstraintsP = do
59+ reservedOp ":constraints"
60+ constraintName <- option "" identifier
61+ return $ ShowConstraint (T.pack constraintName)
62+
63+plotRelExprP :: Parser RODatabaseContextOperator
64+plotRelExprP = do
65+ reserved ":plotexpr"
66+ expr <- relExprP
67+ return $ PlotRelation expr
68+
69+roDatabaseContextOperatorP :: Parser RODatabaseContextOperator
70+roDatabaseContextOperatorP = typeP
71+ <|> showRelP
72+ <|> showRelationVariables
73+ <|> plotRelExprP
74+ <|> showConstraintsP
75+ <|> showPlanP
76+ <|> showTypesP
77+ <|> quitP
78+
79+--logically, these read-only operations could happen purely, but not if a remote call is required
80+evalRODatabaseContextOp :: C.SessionId -> C.Connection -> RODatabaseContextOperator -> IO TutorialDOperatorResult
81+evalRODatabaseContextOp sessionId conn (ShowRelationType expr) = do
82+ res <- C.typeForRelationalExpr sessionId conn expr
83+ case res of
84+ Left err -> pure $ DisplayErrorResult $ T.pack (show err)
85+ Right rel -> pure $ DisplayRelationResult rel
86+
87+evalRODatabaseContextOp sessionId conn (ShowRelation expr) = do
88+ res <- C.executeRelationalExpr sessionId conn expr
89+ case res of
90+ Left err -> pure $ DisplayErrorResult $ T.pack (show err)
91+ Right rel -> pure $ DisplayRelationResult rel
92+
93+evalRODatabaseContextOp sessionId conn (PlotRelation expr) = do
94+ res <- C.executeRelationalExpr sessionId conn expr
95+ pure $ case res of
96+ Left err -> DisplayErrorResult $ T.pack (show err)
97+ Right rel -> DisplayIOResult $ do
98+ err <- plotRelation rel
99+ when (isJust err) $ putStrLn (show err)
100+
101+evalRODatabaseContextOp sessionId conn (ShowConstraint name) = do
102+ eIncDeps <- C.inclusionDependencies sessionId conn
103+ pure $ case eIncDeps of
104+ Left err -> DisplayErrorResult $ T.pack (show err)
105+ Right incDeps -> case name of
106+ "" -> DisplayResult $ T.pack (show incDeps)
107+ depName -> case M.lookup depName incDeps of
108+ Nothing -> DisplayErrorResult "No such constraint."
109+ Just dep -> DisplayResult $ T.pack (show dep)
110+
111+evalRODatabaseContextOp sessionId conn (ShowPlan dbExpr) = do
112+ plan <- C.planForDatabaseContextExpr sessionId conn dbExpr
113+ pure $ case plan of
114+ Left err -> DisplayErrorResult (T.pack (show err))
115+ Right optDbExpr -> DisplayResult $ T.pack (show optDbExpr)
116+
117+evalRODatabaseContextOp sessionId conn ShowTypes = do
118+ eRel <- C.atomTypesAsRelation sessionId conn
119+ case eRel of
120+ Left err -> pure $ DisplayErrorResult (T.pack (show err))
121+ Right rel -> evalRODatabaseContextOp sessionId conn (ShowRelation (ExistingRelation rel))
122+
123+evalRODatabaseContextOp sessionId conn ShowRelationVariables = do
124+ eRel <- C.relationVariablesAsRelation sessionId conn
125+ case eRel of
126+ Left err -> pure $ DisplayErrorResult (T.pack (show err))
127+ Right rel -> evalRODatabaseContextOp sessionId conn (ShowRelation (ExistingRelation rel))
128+
129+evalRODatabaseContextOp _ _ (Quit) = pure QuitResult
130+
131+interpretRODatabaseContextOp :: C.SessionId -> C.Connection -> String -> IO TutorialDOperatorResult
132+interpretRODatabaseContextOp sessionId conn tutdstring = case parse roDatabaseContextOperatorP "" tutdstring of
133+ Left err -> pure $ DisplayErrorResult (T.pack (show err))
134+ Right parsed -> evalRODatabaseContextOp sessionId conn parsed
135+
136+
TutorialD/Interpreter/RelationalExpr.hsnew file+259
@@ -0,0 +1,259 @@
1+module TutorialD.Interpreter.RelationalExpr where
2+import Text.Parsec
3+import Text.Parsec.Expr
4+import ProjectM36.Base
5+import Text.Parsec.String
6+import TutorialD.Interpreter.Base
7+import TutorialD.Interpreter.Types
8+import qualified Data.Text as T
9+import qualified Data.Set as S
10+import qualified Data.Map as M
11+import Data.List (sort)
12+import Data.Functor.Identity (Identity)
13+import Control.Applicative (liftA)
14+import ProjectM36.MiscUtils
15+
16+--used in projection
17+attributeListP :: Parser AttributeNames
18+attributeListP = do
19+ but <- try (string "all but " <* whiteSpace) <|> string ""
20+ let constructor = if but == "" then AttributeNames else InvertedAttributeNames
21+ attrs <- sepBy identifier comma
22+ return $ constructor (S.fromList (map T.pack attrs))
23+
24+makeRelationP :: Parser RelationalExpr
25+makeRelationP = do
26+ reserved "relation"
27+ attrExprs <- try (liftA Just makeAttributeExprsP) <|> pure Nothing
28+ tupleExprs <- braces (sepBy tupleExprP comma) <|> pure []
29+ pure $ MakeRelationFromExprs attrExprs tupleExprs
30+
31+--used in relation creation
32+makeAttributeExprsP :: Parser [AttributeExpr]
33+makeAttributeExprsP = braces (sepBy attributeAndTypeNameP comma)
34+
35+attributeAndTypeNameP :: Parser AttributeExpr
36+attributeAndTypeNameP = do
37+ attrName <- identifier
38+ --convert type name into type
39+ typeCons <- typeConstructorP
40+ return $ AttributeAndTypeNameExpr (T.pack attrName) typeCons
41+
42+--abstract data type parser- in this context, the type constructor must not include any type arguments
43+--Either Text Int
44+adTypeConstructorP :: Parser TypeConstructor
45+adTypeConstructorP = do
46+ tConsName <- capitalizedIdentifier
47+ tConsArgs <- many typeConstructorArgP
48+ pure $ ADTypeConstructor (T.pack tConsName) tConsArgs
49+
50+tupleExprP :: Parser TupleExpr
51+tupleExprP = do
52+ reservedOp "tuple"
53+ attrAssocs <- braces (sepBy tupleAtomExprP comma)
54+ --detect duplicate attribute names
55+ let dupAttrNames = dupes (sort (map fst attrAssocs))
56+ if length dupAttrNames /= 0 then
57+ fail ("Attribute names duplicated: " ++ show dupAttrNames)
58+ else
59+ pure (TupleExpr (M.fromList attrAssocs))
60+
61+tupleAtomExprP :: Parser (AttributeName, AtomExpr)
62+tupleAtomExprP = do
63+ attributeName <- identifier
64+ atomExpr <- atomExprP
65+ return $ (T.pack attributeName, atomExpr)
66+
67+projectP :: Parser (RelationalExpr -> RelationalExpr)
68+projectP = do
69+ attrs <- braces attributeListP
70+ return $ Project attrs
71+
72+renameClauseP :: Parser (String, String)
73+renameClauseP = do
74+ oldAttr <- identifier
75+ reservedOp "as"
76+ newAttr <- identifier
77+ return $ (oldAttr, newAttr)
78+
79+renameP :: Parser (RelationalExpr -> RelationalExpr)
80+renameP = do
81+ reservedOp "rename"
82+ (oldAttr, newAttr) <- braces renameClauseP
83+ return $ Rename (T.pack oldAttr) (T.pack newAttr)
84+
85+whereClauseP :: Parser (RelationalExpr -> RelationalExpr)
86+whereClauseP = do
87+ reservedOp "where"
88+ boolExpr <- restrictionPredicateP
89+ return $ Restrict boolExpr
90+
91+groupClauseP :: Parser (AttributeNames, String)
92+groupClauseP = do
93+ attrs <- braces attributeListP
94+ reservedOp "as"
95+ newAttrName <- identifier
96+ return $ (attrs, newAttrName)
97+
98+groupP :: Parser (RelationalExpr -> RelationalExpr)
99+groupP = do
100+ reservedOp "group"
101+ (groupAttrList, groupAttrName) <- parens groupClauseP
102+ return $ Group groupAttrList (T.pack groupAttrName)
103+
104+--in "Time and Relational Theory" (2014), Date's Tutorial D grammar for ungroup takes one attribute, while in previous books, it take multiple arguments. Let us assume that nested ungroups are the same as multiple attributes.
105+ungroupP :: Parser (RelationalExpr -> RelationalExpr)
106+ungroupP = do
107+ reservedOp "ungroup"
108+ rvaAttrName <- identifier
109+ return $ Ungroup (T.pack rvaAttrName)
110+
111+extendP :: Parser (RelationalExpr -> RelationalExpr)
112+extendP = do
113+ reservedOp ":"
114+ tupleExpr <- braces extendTupleExpressionP
115+ return $ Extend tupleExpr
116+
117+relOperators :: [[Operator String () Identity RelationalExpr]]
118+relOperators = [
119+ [Postfix projectP],
120+ [Postfix renameP],
121+ [Postfix whereClauseP],
122+ [Postfix groupP],
123+ [Postfix ungroupP],
124+ [Infix (reservedOp "join" >> return Join) AssocLeft],
125+ [Infix (reservedOp "union" >> return Union) AssocLeft],
126+ [Infix (reservedOp "minus" >> return Difference) AssocLeft],
127+ [Infix (reservedOp "=" >> return Equals) AssocNone],
128+ [Postfix extendP]
129+ ]
130+
131+relExprP :: Parser RelationalExpr
132+relExprP = buildExpressionParser relOperators relTerm
133+
134+relVarP :: Parser RelationalExpr
135+relVarP = liftA (RelationVariable . T.pack) identifier
136+
137+relTerm :: Parser RelationalExpr
138+relTerm = parens relExprP
139+ <|> makeRelationP
140+ <|> relVarP
141+
142+restrictionPredicateP :: Parser RestrictionPredicateExpr
143+restrictionPredicateP = buildExpressionParser predicateOperators predicateTerm
144+ where
145+ predicateOperators = [
146+ [Prefix (reservedOp "not" >> return NotPredicate)],
147+ [Infix (reservedOp "and" >> return AndPredicate) AssocLeft],
148+ [Infix (reservedOp "or" >> return OrPredicate) AssocLeft]
149+ ]
150+ predicateTerm = parens restrictionPredicateP
151+ <|> try restrictionAtomExprP
152+ <|> try restrictionAttributeEqualityP
153+ <|> try relationalBooleanExprP
154+
155+
156+relationalBooleanExprP :: Parser RestrictionPredicateExpr
157+relationalBooleanExprP = do
158+ relexpr <- relExprP
159+ return $ RelationalExprPredicate relexpr
160+
161+restrictionAttributeEqualityP :: Parser RestrictionPredicateExpr
162+restrictionAttributeEqualityP = do
163+ attributeName <- identifier
164+ reservedOp "="
165+ atomexpr <- atomExprP
166+ return $ AttributeEqualityPredicate (T.pack attributeName) atomexpr
167+
168+restrictionAtomExprP :: Parser RestrictionPredicateExpr --atoms which are of type "boolean"
169+restrictionAtomExprP = do
170+ _ <- char '^' -- not ideal, but allows me to continue to use a context-free grammar
171+ AtomExprPredicate <$> atomExprP
172+
173+multiTupleExpressionP :: Parser [ExtendTupleExpr]
174+multiTupleExpressionP = sepBy extendTupleExpressionP comma
175+
176+extendTupleExpressionP :: Parser ExtendTupleExpr
177+extendTupleExpressionP = attributeExtendTupleExpressionP
178+
179+attributeExtendTupleExpressionP :: Parser ExtendTupleExpr
180+attributeExtendTupleExpressionP = do
181+ newAttr <- identifier
182+ reservedOp ":="
183+ atom <- atomExprP
184+ return $ AttributeExtendTupleExpr (T.pack newAttr) atom
185+
186+atomExprP :: Parser AtomExpr
187+atomExprP = consumeAtomExprP True
188+
189+consumeAtomExprP :: Bool -> Parser AtomExpr
190+consumeAtomExprP consume = try functionAtomExprP <|>
191+ try (parens (constructedAtomExprP True)) <|>
192+ constructedAtomExprP consume <|>
193+ attributeAtomExprP <|>
194+ nakedAtomExprP <|>
195+ relationalAtomExprP
196+
197+attributeAtomExprP :: Parser AtomExpr
198+attributeAtomExprP = do
199+ _ <- string "@"
200+ attrName <- identifier
201+ return $ AttributeAtomExpr (T.pack attrName)
202+
203+nakedAtomExprP :: Parser AtomExpr
204+nakedAtomExprP = NakedAtomExpr <$> atomP
205+
206+constructedAtomExprP :: Bool -> Parser AtomExpr
207+constructedAtomExprP consume = do
208+ dConsName <- capitalizedIdentifier
209+ dConsArgs <- if consume then sepBy (consumeAtomExprP False) spaces else pure []
210+ pure $ ConstructedAtomExpr (T.pack dConsName) dConsArgs
211+
212+-- used only for primitive type parsing ?
213+atomP :: Parser Atom
214+atomP = stringAtomP <|>
215+ doubleAtomP <|>
216+ intAtomP <|>
217+ boolAtomP
218+
219+functionAtomExprP :: Parser AtomExpr
220+functionAtomExprP = do
221+ funcName <- identifier
222+ argList <- parens (sepBy atomExprP comma)
223+ return $ FunctionAtomExpr (T.pack funcName) argList
224+
225+relationalAtomExprP :: Parser AtomExpr
226+relationalAtomExprP = RelationAtomExpr <$> relExprP
227+
228+stringAtomP :: Parser Atom
229+stringAtomP = liftA (Atom . T.pack) quotedString
230+
231+--until polymorphic type constructors and algebraic data types are properly supported, such constructs must be unfortunately hard-coded
232+maybeTextAtomP :: Parser Atom
233+maybeTextAtomP = do
234+ maybeText <- try $ ((Just . T.pack <$> (reserved "Just" *> quotedString)) <|>
235+ (reserved "Nothing" *> return Nothing)) <* reserved "::maybe char"
236+ return $ Atom maybeText
237+
238+--refactor to use polymorphic runtime constructors
239+maybeIntAtomP :: Parser Atom
240+maybeIntAtomP = do
241+ maybeInt <- try $ ((Just . fromIntegral <$> (reserved "Just" *> integer)) <|>
242+ (reserved "Nothing" *> return Nothing)) <* reserved "::maybe int"
243+ return $ Atom (maybeInt :: Maybe Int)
244+
245+doubleAtomP :: Parser Atom
246+doubleAtomP = Atom <$> (try float)
247+
248+intAtomP :: Parser Atom
249+intAtomP = do
250+ i <- integer
251+ return $ Atom ((fromIntegral i) :: Int)
252+
253+boolAtomP :: Parser Atom
254+boolAtomP = do
255+ val <- char 't' <|> char 'f'
256+ return $ Atom (val == 't')
257+
258+relationAtomExprP :: Parser AtomExpr
259+relationAtomExprP = RelationAtomExpr <$> makeRelationP
src/bin/TutorialD/Interpreter/TransactionGraphOperator.hs → TutorialD/Interpreter/TransactionGraphOperator.hsrenamed+33−50
@@ -1,94 +1,85 @@
11{-# LANGUAGE GADTs #-}
22module TutorialD.Interpreter.TransactionGraphOperator where
33import TutorialD.Interpreter.Base
4−import ProjectM36.TransactionGraph hiding (autoMergeToHead)
5−import ProjectM36.Client as C
4+import Text.Parsec
5+import Text.Parsec.String
6+import qualified Data.UUID as U
7+import qualified Data.Text as T
8+import ProjectM36.TransactionGraph
9+import ProjectM36.Client
10+import ProjectM36.Error
611import ProjectM36.Base
7−import ProjectM36.Relation (relationTrue)
8−import Data.Functor
9−
10−data ConvenienceTransactionGraphOperator = AutoMergeToHead MergeStrategy HeadName
11− deriving (Show)
12−
13−convenienceTransactionGraphOpP :: Parser ConvenienceTransactionGraphOperator
14−convenienceTransactionGraphOpP = autoMergeToHeadP
15−
16−autoMergeToHeadP :: Parser ConvenienceTransactionGraphOperator
17−autoMergeToHeadP = do
18− reserved ":automergetohead"
19− AutoMergeToHead <$> mergeTransactionStrategyP <*> identifier
2012
2113jumpToHeadP :: Parser TransactionGraphOperator
2214jumpToHeadP = do
2315 reservedOp ":jumphead"
24− JumpToHead <$> identifier
16+ headid <- identifier
17+ return $ JumpToHead (T.pack headid)
2518
2619jumpToTransactionP :: Parser TransactionGraphOperator
2720jumpToTransactionP = do
2821 reservedOp ":jump"
29− JumpToTransaction <$> uuidP
30−
31−walkBackToTimeP :: Parser TransactionGraphOperator
32−walkBackToTimeP = do
33− reservedOp ":walkbacktotime"
34− WalkBackToTime <$> utcTimeP
22+ uuid <- uuidP
23+ return $ JumpToTransaction uuid
3524
3625branchTransactionP :: Parser TransactionGraphOperator
3726branchTransactionP = do
3827 reservedOp ":branch"
39− Branch <$> identifier
40−
41−deleteBranchP :: Parser TransactionGraphOperator
42−deleteBranchP = do
43− reserved ":deletebranch"
44− DeleteBranch <$> identifier
28+ branchName <- identifier
29+ return $ Branch (T.pack branchName)
4530
4631commitTransactionP :: Parser TransactionGraphOperator
4732commitTransactionP = do
4833 reservedOp ":commit"
49− pure Commit
34+ return $ Commit
5035
5136rollbackTransactionP :: Parser TransactionGraphOperator
5237rollbackTransactionP = do
5338 reservedOp ":rollback"
54− return Rollback
39+ return $ Rollback
5540
5641showGraphP :: Parser ROTransactionGraphOperator
5742showGraphP = do
5843 reservedOp ":showgraph"
59− return ShowGraph
44+ return $ ShowGraph
6045
6146mergeTransactionStrategyP :: Parser MergeStrategy
62−mergeTransactionStrategyP = (reserved "union" $> UnionMergeStrategy) <|>
47+mergeTransactionStrategyP = (reserved "union" *> pure UnionMergeStrategy) <|>
6348 (do
6449 reserved "selectedbranch"
65− SelectedBranchMergeStrategy <$> identifier) <|>
50+ branch <- identifier
51+ pure (SelectedBranchMergeStrategy (T.pack branch))) <|>
6652 (do
6753 reserved "unionpreferbranch"
68− UnionPreferMergeStrategy <$> identifier)
54+ branch <- identifier
55+ pure (UnionPreferMergeStrategy (T.pack branch)))
6956
7057mergeTransactionsP :: Parser TransactionGraphOperator
7158mergeTransactionsP = do
7259 reservedOp ":mergetrans"
73− MergeTransactions <$> mergeTransactionStrategyP <*> identifier <*> identifier
74−
75−validateMerkleHashesP :: Parser ROTransactionGraphOperator
76−validateMerkleHashesP = reservedOp ":validatemerklehashes" $> ValidateMerkleHashes
60+ strategy <- mergeTransactionStrategyP
61+ headA <- identifier
62+ headB <- identifier
63+ pure (MergeTransactions strategy (T.pack headA) (T.pack headB))
7764
7865transactionGraphOpP :: Parser TransactionGraphOperator
79−transactionGraphOpP =
66+transactionGraphOpP = do
8067 jumpToHeadP
8168 <|> jumpToTransactionP
82− <|> walkBackToTimeP
8369 <|> branchTransactionP
84− <|> deleteBranchP
8570 <|> commitTransactionP
8671 <|> rollbackTransactionP
8772 <|> mergeTransactionsP
8873
8974roTransactionGraphOpP :: Parser ROTransactionGraphOperator
90−roTransactionGraphOpP = showGraphP <|> validateMerkleHashesP
75+roTransactionGraphOpP = showGraphP
9176
77+uuidP :: Parser U.UUID
78+uuidP = do
79+ uuidStr <- many (alphaNum <|> char '-')
80+ case U.fromString uuidStr of
81+ Nothing -> fail "Invalid uuid string"
82+ Just uuid -> return uuid
9283
9384
9485{-
@@ -105,11 +96,3 @@ interpretOps newUUID trans@(DisconnectedTransaction _ context) transGraph instri
10596
10697evalROGraphOp :: SessionId -> Connection -> ROTransactionGraphOperator -> IO (Either RelationalError Relation)
10798evalROGraphOp sessionId conn ShowGraph = transactionGraphAsRelation sessionId conn
108−evalROGraphOp sessionId conn ValidateMerkleHashes = do
109− eVal <- C.validateMerkleHashes sessionId conn
110− case eVal of
111− Left err -> pure (Left err)
112− Right _ -> pure (Right relationTrue)
113−
114−evalConvenienceGraphOp :: SessionId -> Connection -> ConvenienceTransactionGraphOperator -> IO (Either RelationalError ())
115−evalConvenienceGraphOp sessionId conn (AutoMergeToHead strat head') = autoMergeToHead sessionId conn strat head'
TutorialD/Interpreter/Types.hsnew file+49
@@ -0,0 +1,49 @@
1+--parse type and data constructors
2+module TutorialD.Interpreter.Types where
3+import ProjectM36.Base
4+import Text.Parsec.String
5+import Text.Parsec
6+import TutorialD.Interpreter.Base
7+import ProjectM36.DataTypes.Primitive
8+import Control.Monad (liftM)
9+import qualified Data.Text as T
10+
11+-- | Upper case names are type names while lower case names are polymorphic typeconstructor arguments.
12+-- data *Either a b* = Left a | Right b
13+typeConstructorDefP :: Parser TypeConstructorDef
14+typeConstructorDefP = ADTypeConstructorDef <$> liftM T.pack capitalizedIdentifier <*> typeVarNamesP
15+
16+typeVarNamesP :: Parser [TypeVarName]
17+typeVarNamesP = do
18+ vars <- many uncapitalizedIdentifier
19+ pure (map T.pack vars)
20+
21+-- data Either a b = *Left a* | *Right b*
22+dataConstructorDefP :: Parser DataConstructorDef
23+dataConstructorDefP = DataConstructorDef <$> liftM T.pack capitalizedIdentifier <*> many dataConstructorDefArgP
24+
25+-- data *Either a b* = Left *a* | Right *b*
26+dataConstructorDefArgP :: Parser DataConstructorDefArg
27+dataConstructorDefArgP = parens (DataConstructorDefTypeConstructorArg <$> typeConstructorP) <|>
28+ DataConstructorDefTypeConstructorArg <$> typeConstructorP <|>
29+ DataConstructorDefTypeVarNameArg <$> liftM T.pack uncapitalizedIdentifier
30+
31+--built-in, nullary type constructors
32+-- Int, Text, etc.
33+primitiveTypeConstructorP :: Parser TypeConstructor
34+primitiveTypeConstructorP = choice (map (\(PrimitiveTypeConstructorDef name typ, _) -> do
35+ tName <- try $ liftM T.pack (symbol (T.unpack name))
36+ pure $ PrimitiveTypeConstructor tName typ)
37+ primitiveTypeConstructorMapping)
38+
39+-- *Either Int Text*, *Int*
40+typeConstructorP :: Parser TypeConstructor
41+typeConstructorP = primitiveTypeConstructorP <|>
42+ ADTypeConstructor <$> liftM T.pack capitalizedIdentifier <*> many typeConstructorArgP
43+
44+typeConstructorArgP :: Parser TypeConstructorArg
45+typeConstructorArgP = TypeConstructorArg <$> typeConstructorP <|>
46+ TypeConstructorTypeVarArg <$> liftM T.pack uncapitalizedIdentifier
47+
48+
49+
TutorialD/tutd.hsnew file+89
@@ -0,0 +1,89 @@
1+{-# LANGUAGE CPP #-}
2+import TutorialD.Interpreter
3+import ProjectM36.Base
4+import ProjectM36.Client
5+import System.IO
6+import Options.Applicative
7+import System.Exit
8+
9+parseArgs :: Parser InterpreterConfig
10+parseArgs = LocalInterpreterConfig <$> parsePersistenceStrategy <*> parseHeadName <|>
11+ RemoteInterpreterConfig <$> parseNodeId <*> parseDatabaseName <*> parseHeadName
12+
13+parsePersistenceStrategy :: Parser PersistenceStrategy
14+parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>
15+ MinimalPersistence <$> dbdirOpt <|>
16+ pure NoPersistence
17+ where
18+ dbdirOpt = strOption (short 'd' <>
19+ long "database-directory" <>
20+ metavar "DIRECTORY" <>
21+ showDefaultWith show
22+ )
23+ fsyncOpt = switch (short 'f' <>
24+ long "fsync" <>
25+ help "Fsync all new transactions.")
26+
27+parseHeadName :: Parser HeadName
28+parseHeadName = option auto (long "head" <>
29+ help "Start session at head name." <>
30+ value "master"
31+ )
32+
33+parseDatabaseName :: Parser DatabaseName
34+parseDatabaseName = strOption (long "database" <>
35+ help "Remote database name")
36+
37+parseNodeId :: Parser NodeId
38+parseNodeId = createNodeId <$>
39+ strOption (long "host" <>
40+ short 'h' <>
41+ help "Remote host name" <>
42+ value "127.0.0.1") <*>
43+ option auto (long "port" <>
44+ short 'p' <>
45+ help "Remote port" <>
46+ value defaultServerPort)
47+
48+opts :: ParserInfo InterpreterConfig
49+opts = info parseArgs idm
50+
51+connectionInfoForConfig :: InterpreterConfig -> ConnectionInfo
52+connectionInfoForConfig (LocalInterpreterConfig pStrategy _) = InProcessConnectionInfo pStrategy outputNotificationCallback
53+connectionInfoForConfig (RemoteInterpreterConfig remoteNodeId remoteDBName _) = RemoteProcessConnectionInfo remoteDBName remoteNodeId outputNotificationCallback
54+
55+headNameForConfig :: InterpreterConfig -> HeadName
56+headNameForConfig (LocalInterpreterConfig _ headn) = headn
57+headNameForConfig (RemoteInterpreterConfig _ _ headn) = headn
58+
59+errDie :: String -> IO ()
60+errDie err = hPutStrLn stderr err >> exitFailure
61+
62+#ifndef PROJECTM36_VERSION
63+#error PROJECTM36_VERSION is not defined
64+#endif
65+printWelcome :: IO ()
66+printWelcome = do
67+ putStrLn $ "Project:M36 TutorialD Interpreter " ++ PROJECTM36_VERSION
68+ putStrLn "Type \":help\" for more information."
69+ putStrLn "A full tutorial is available at:"
70+ putStrLn "https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown"
71+
72+main :: IO ()
73+main = do
74+ interpreterConfig <- execParser opts
75+ let connInfo = connectionInfoForConfig interpreterConfig
76+ dbconn <- connectProjectM36 connInfo
77+ case dbconn of
78+ Left err -> do
79+ errDie ("Failed to create database connection: " ++ show err)
80+ Right conn -> do
81+ let connHeadName = headNameForConfig interpreterConfig
82+ eSessionId <- createSessionAtHead connHeadName conn
83+ case eSessionId of
84+ Left err -> errDie ("Failed to create database session at \"" ++ show connHeadName ++ "\": " ++ show err)
85+ Right sessionId -> do
86+ printWelcome
87+ _ <- reprLoop interpreterConfig sessionId conn
88+ pure ()
89+
benchmark/Relation.hsnew file+13
@@ -0,0 +1,13 @@
1+import Criterion.Main
2+import ProjectM36.Relation
3+
4+main :: IO ()
5+main = defaultMain [
6+ bgroup "Big Relation" [
7+ bench "100" $ whnf (matrixRelation 10) 100,
8+ bench "1000" $ whnf (matrixRelation 10) 1000,
9+ bench "10000" $ whnf (matrixRelation 10) 10000
10+ ]
11+ ]
12+
13+
src/bin/benchmark/bigrel.hs → benchmark/bigrel.hsrenamed+34−59
@@ -1,41 +1,33 @@
1−{-# LANGUAGE FlexibleInstances, CPP #-}
2−{-# OPTIONS_GHC -fno-warn-orphans #-}
1+{-# LANGUAGE FlexibleInstances #-}
32import ProjectM36.Base
43import ProjectM36.Relation
54import ProjectM36.DateExamples
5+import ProjectM36.DataTypes.Primitive
66import ProjectM36.Error
7−import ProjectM36.StaticOptimizer
87import qualified ProjectM36.Attribute as A
98import qualified Data.Text as T
10−--import ProjectM36.Relation.Show.CSV
9+import ProjectM36.Relation.Show.CSV
1110import ProjectM36.Relation.Show.HTML
11+import TutorialD.Interpreter.DatabaseContextExpr (interpretDatabaseContextExpr)
1212import ProjectM36.RelationalExpression
13−import ProjectM36.TransactionGraph
14−--import qualified Data.HashSet as HS
15−--import qualified Data.ByteString.Lazy.Char8 as BS
16−--import qualified Data.IntMap as IM
17−--import qualified Data.Hashable as Hash
13+import qualified Data.HashSet as HS
14+import qualified Data.ByteString.Lazy.Char8 as BS
15+import qualified Data.IntMap as IM
16+import qualified Data.Hashable as Hash
1817import qualified Data.Vector as V
1918import Options.Applicative
19+import qualified Data.Map as M
2020import qualified Data.Text.IO as TIO
2121import System.IO
22+import Control.Monad.State
2223import Control.DeepSeq
23−import Data.Text hiding (map)
24−import Data.Time.Clock
25−import Data.UUID.V4
26−#if __GLASGOW_HASKELL__ < 804
27−import Data.Monoid
28−#endif
2924
30−
31−{-
3225dumpcsv :: Relation -> IO ()
3326dumpcsv rel = case relationAsCSV rel of
34− Left err -> hPrint stderr err
27+ Left err -> hPutStrLn stderr (show err)
3528 Right bsData -> BS.putStrLn bsData
36−-}
3729
38−data BigrelArgs = BigrelArgs Int Int Text
30+data BigrelArgs = BigrelArgs Int Int String
3931
4032parseAttributeCount :: Parser Int
4133parseAttributeCount = option auto (short 'a' <> long "attribute-count")
@@ -47,7 +39,7 @@ parseTutD :: Parser String
4739parseTutD = strOption (short 'd' <> long "tutoriald")
4840
4941parseArgs :: Parser BigrelArgs
50−parseArgs = BigrelArgs <$> parseAttributeCount <*> parseTupleCount <*> (pack <$> parseTutD)
42+parseArgs = BigrelArgs <$> parseAttributeCount <*> parseTupleCount <*> parseTutD
5143
5244main :: IO ()
5345main = do
@@ -58,75 +50,58 @@ main = do
5850 --intmapMatrixRun
5951
6052matrixRun :: BigrelArgs -> IO ()
61−matrixRun (BigrelArgs attributeCount tupleCount tutd) =
53+matrixRun (BigrelArgs attributeCount tupleCount tutd) = do
6254 case matrixRelation attributeCount tupleCount of
63− Left err -> print err
55+ Left err -> putStrLn (show err)
6456 Right rel -> if tutd == "" then
6557 putStrLn "Done."
6658 else do
67− now <- getCurrentTime
68− tid <- nextRandom
6959 let setx = Assign "x" (ExistingRelation (force rel))
70− graph = bootstrapTransactionGraph now tid dateExamples
71− env = mkDatabaseContextEvalEnv tid graph
72− eNewState = runDatabaseContextEvalMonad dateExamples env (optimizeAndEvalDatabaseContextExpr True setx)
60+ context = execState (evalContextExpr setx) dateExamples
61+ interpreted = interpretDatabaseContextExpr context tutd
7362 --plan = interpretRODatabaseContextOp context $ ":showplan " ++ tutd
7463 --displayOpResult plan
75− case eNewState of
76− Right newState -> do
77− let ctx = dbc_context newState
78− Right x = optimizeAndEvalRelationalExpr env' (RelationVariable "x" ())
79− env' = RelationalExprEnv ctx graph Nothing
80− TIO.putStrLn $ relationAsHTML x
81− Left err -> hPrint stderr err
82−
83−{-
64+ case interpreted of
65+ Right context' -> TIO.putStrLn $ relationAsHTML ((relationVariables context') M.! "x")
66+ Left err -> hPutStrLn stderr (show err)
67+
68+
8469intmapMatrixRun :: IO ()
8570intmapMatrixRun = do
8671 let matrix = intmapMatrixRelation 100 100000
87− print matrix
88−-}
72+ putStrLn (show matrix)
8973
9074--compare IntMap speed and size
9175--this is about 3 times faster (9 minutes) for 10x100000 and uses 800 MB
92−{-
9376intmapMatrixRelation :: Int -> Int -> HS.HashSet (IM.IntMap Atom)
9477intmapMatrixRelation attributeCount tupleCount = HS.fromList $ map mapper [0..tupleCount]
9578 where
96− mapper tupCount = IM.fromList $ map (\c-> (c, IntAtom (fromIntegral tupCount))) [0..attributeCount]
97−-}
98−-- instance Hash.Hashable (IM.IntMap Atom) where
99−-- hashWithSalt salt tupMap = Hash.hashWithSalt salt (show tupMap)
79+ mapper tupCount = IM.fromList $ map (\c-> (c, Atom tupCount)) [0..attributeCount]
80+
81+instance Hash.Hashable (IM.IntMap Atom) where
82+ hashWithSalt salt tupMap = Hash.hashWithSalt salt (show tupMap)
10083
101−{-
10284vectorMatrixRun :: IO ()
10385vectorMatrixRun = do
10486 let matrix = vectorMatrixRelation 100 100000
105− print matrix
106−-}
107−-- 20 s 90 MBs- a clear win- ideal size is 10 * 100000 * 8 bytes = 80 MB! without IntAtom wrapper
108−--with IntAtom wrapper: 1m12s 90 MB
109−{-
110−
87+ putStrLn (show matrix)
11188
11289-- 20 s 90 MBs- a clear win- ideal size is 10 * 100000 * 8 bytes = 80 MB! without IntAtom wrapper
11390--with IntAtom wrapper: 1m12s 90 MB
114−{-
115−
11691vectorMatrixRelation :: Int -> Int -> HS.HashSet (V.Vector Atom)
11792vectorMatrixRelation attributeCount tupleCount = HS.fromList $ map mapper [0..tupleCount]
11893 where
119− mapper tupCount = V.replicate attributeCount (IntAtom (fromIntegral tupCount))
120−-}
94+ mapper tupCount = V.replicate attributeCount (Atom tupCount)
95+
12196instance Hash.Hashable (V.Vector Atom) where
12297 hashWithSalt salt vec = Hash.hashWithSalt salt (show vec)
123−-}
98+
12499-- returns a relation with tupleCount tuples with a set of integer attributes attributesCount long
125100-- this is useful for performance and resource usage testing
126101matrixRelation :: Int -> Int -> Either RelationalError Relation
127102matrixRelation attributeCount tupleCount = do
128− let attrs = A.attributesFromList $ map (\c-> Attribute (T.pack $ "a" ++ show c) IntAtomType) [0 .. attributeCount-1]
129− tuple tupleX = RelationTuple attrs (V.generate attributeCount (\_ -> IntAtom (fromIntegral tupleX)))
130− tuples = map tuple [0 .. tupleCount]
103+ let attrs = A.attributesFromList $ map (\c-> Attribute (T.pack $ "a" ++ show c) intAtomType) [0 .. attributeCount-1]
104+ tuple tupleX = RelationTuple attrs (V.generate attributeCount (\_ -> Atom tupleX))
105+ tuples = map (\c -> tuple c) [0 .. tupleCount]
131106 mkRelationDeferVerify attrs (RelationTupleSet tuples)
132107
cabal.projectdeleted−10
@@ -1,10 +0,0 @@
1−packages: project-m36.cabal
2−
3−package *
4− split-sections: True
5−
6−--high-performance streaming library
7−source-repository-package
8− type: git
9− location: https://github.com/composewell/streamly.git
10− tag: ac3af8749194f1788704dda8667d0b3807075cc2
cbits/darwin_statfs.cdeleted−23
@@ -1,23 +0,0 @@
1−#include <sys/param.h>
2−#include <sys/mount.h>
3−#include <stdio.h>
4−
5−#ifndef _PROJECT_M36_STATFS_
6−#define _PROJECT_M36_STATFS_
7−#ifdef __APPLE__
8−int cDarwinFSJournaled(const char* path)
9−{
10− struct statfs s = {0};
11− int ret = statfs(path, &s);
12− if(ret < 0)
13− {
14− /* error */
15− return ret;
16− }
17− else
18− {
19− return s.f_flags & MNT_JOURNALED;
20− }
21−}
22−#endif
23−#endif
default.nixdeleted−1
@@ -1 +0,0 @@
1−(import ./release.nix { }).project
docker.nixdeleted−18
@@ -1,18 +0,0 @@
1−{ compiler ? "ghc8104"
2−, sources ? import ./nix/sources.nix
3−, pkgs ? import sources.nixpkgs { }
4−}:
5−let
6− release = import ./release.nix { inherit pkgs compiler sources; };
7− static-project-m36 = pkgs.haskell.lib.dontCheck (pkgs.haskell.lib.justStaticExecutables release.project);
8−in
9−pkgs.dockerTools.buildImage {
10− name = "project-m36";
11− tag = "latest";
12− contents = [ static-project-m36 ];
13− # expose default project-m36 and websocket server ports
14− config = {
15− Env = [ "LC_ALL=en_US.UTF-8" ];
16− ExposedPorts = { "6543/tcp" = { }; "8000/tcp" = { }; };
17− };
18−}
docs/15_minute_tutorial.markdown+89−86
@@ -4,39 +4,45 @@ Thank you for evaluating Project:M36, a new relational algebra engine written in
44
55## Prerequisites
66
7−* any Linux, MacOS, or Windows computer with Docker installed
7+* any Linux
8+* GHC 7.10 or later version (Haskell compiler)
9+* cabal (package downloader) installed
810
911## Download and Install
1012
11−Run a pre-built docker image:
12−
13−```docker run -it projectm36/project-m36 tutd```
14−
15−or build it yourself with GHC >= 8.6:
16−
1713```bash
1814git clone https://github.com/agentm/project-m36.git
19−cabal new-run tutd
15+cabal sandbox init
16+cabal install --dependencies-only
17+cabal run tutd
2018```
2119
2220## Some Basic TutorialD
2321
24−When you run the ```tutd``` interpreter, you are interacting with an in-memory database using a dialect of the TutorialD language which is described in numerous books by Chris J. Date. It is a language specifically designed for human interaction with the relational algebra.
22+When you run the ```tutd``` interpreter, you are interacting with an in-memory database using a dialect of the TutorialD language which is described in numerous book by Chris J. Date. It is a language specifically designed for human interaction with the relational algebra.
2523
2624Note that TutorialD is strongly-typed- no type coercions take place automatically. For example, an integer will never be interpreted as a string or vice versa.
2725
2826### Load the Canonical Chris Date Example
2927
3028```
31−TutorialD (master/main): :importexample cjdate
29+TutorialD (master): :importexample date
30+```
31+
32+or
33+
34+```
35+TutorialD (master): :importtud "scripts/DateExamples.tutd"
3236```
3337
34−```:importexample``` (do not skip typing the preceding colon), loads a built-in example schema and executes it to change the state of the database. In this case, the relations "s" (supplier), "p" (product), and "sp" (suppliers-products) are now loaded.
38+```:importtutd``` (do not skip typing the preceding colon), loads a file which contains a script written in the TutorialD dialect used by Project:M36 and executes it to change the state of the database. In this case, the relations "s" (supplier), "p" (product), and "sp" (suppliers-products) are now loaded.
39+
40+```:importexample date``` loads the date example directly without any file I/O, so it is safe to use with the websocket server.
3541
3642### Execute Relational Expressions
3743
3844```
39−TutorialD (master/main): :showexpr s
45+TutorialD (master): :showexpr s
4046┌──────────┬────────┬───────────┬───────────┐
4147│city::Text│s#::Text│sname::Text│status::Int│
4248├──────────┼────────┼───────────┼───────────┤
@@ -57,7 +63,7 @@ You will need to [learn TutorialD](/docs/tutd_tutorial.markdown) to create relat
5763#### Joins
5864
5965```
60−TutorialD (master/main): :showexpr s join sp
66+TutorialD (master): :showexpr s join sp
6167┌──────────┬────────┬────────┬────────┬───────────┬───────────┐
6268│city::Text│p#::Text│qty::Int│s#::Text│sname::Text│status::Int│
6369├──────────┼────────┼────────┼────────┼───────────┼───────────┤
@@ -80,7 +86,7 @@ All joins in TutorialD are similar to "NATURAL JOIN" in SQL.
8086#### Restriction
8187
8288```
83−TutorialD (master/main): :showexpr s where status=20
89+TutorialD (master): :showexpr s where status=20
8490┌──────────┬────────┬───────────┬───────────┐
8591│city::Text│s#::Text│sname::Text│status::Int│
8692├──────────┼────────┼───────────┼───────────┤
@@ -94,7 +100,7 @@ Restrictions are similar to the "WHERE" clause in SQL.
94100#### Projection
95101
96102```
97−TutorialD (master/main): :showexpr p{color,p#,weight}
103+TutorialD (master): :showexpr p{color,p#,weight}
98104┌───────────┬────────┬───────────┐
99105│color::Text│p#::Text│weight::Int│
100106├───────────┼────────┼───────────┤
@@ -112,7 +118,7 @@ Projection is equivalent to "SELECT <columns>" in SQL.
112118#### Attribute Rename
113119
114120```
115−TutorialD (master/main): :showexpr s rename {city as town}
121+TutorialD (master): :showexpr s rename {city as town}
116122┌────────┬───────────┬───────────┬──────────┐
117123│s#::Text│sname::Text│status::Int│town::Text│
118124├────────┼───────────┼───────────┼──────────┤
@@ -133,7 +139,7 @@ The relational algebra includes two fundamental named relations: "true" and "fal
133139"true" is the name of the relation with no attributes and a set of one tuple of no attributes.
134140
135141```
136−TutorialD (master/main): :showexpr true
142+TutorialD (master): :showexpr true
137143┌┐
138144││
139145├┤
@@ -143,7 +149,7 @@ TutorialD (master/main): :showexpr true
143149"false" is the name of the relation with no attributes and an empty tuples set.
144150
145151```
146−TutorialD (master/main): :showexpr false
152+TutorialD (master): :showexpr false
147153┌┐
148154││
149155└┘
@@ -158,8 +164,8 @@ Database context expressions change the state of the database, much like "CREATE
158164#### Create a Relation Variable
159165
160166```
161−TutorialD (master/main): x:=relation{name Text, age Integer}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}
162−TutorialD (master/main): :showexpr x
167+TutorialD (master): x:=relation{name Text, age Int}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}
168+TutorialD (master): :showexpr x
163169┌────────┬──────────┐
164170│age::Int│name::Text│
165171├────────┼──────────┤
@@ -173,25 +179,23 @@ This is similar to SQL's "CREATE TABLE" operator.
173179#### Insert Additional Tuples
174180
175181```
176−TutorialD (master/main): x:=relation{name Text, age Integer}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}
177−TutorialD (master/main): :showexpr x
178−┌────────────┬──────────┐
179−│age::Integer│name::Text│
180−├────────────┼──────────┤
181−│31 │"Mike" │
182−│40 │"Steve" │
183−└────────────┴──────────┘
184−
185−TutorialD (master/main): insert x relation{tuple{name "Bob", age 24}}
186−TutorialD (master/main): :showexpr x
187−┌────────────┬──────────┐
188−│age::Integer│name::Text│
189−├────────────┼──────────┤
190−│31 │"Mike" │
191−│40 │"Steve" │
192−│24 │"Bob" │
193−└────────────┴──────────┘
194−
182+TutorialD (master): x:=relation{name Text, age Int}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}
183+TutorialD (master): :showexpr x
184+┌────────┬──────────┐
185+│age::Int│name::Text│
186+├────────┼──────────┤
187+│40 │"Steve" │
188+│31 │"Mike" │
189+└────────┴──────────┘
190+TutorialD (master): insert x relation{tuple{name "Bob", age 24}}
191+TutorialD (master): :showexpr x
192+┌────────┬──────────┐
193+│age::Int│name::Text│
194+├────────┼──────────┤
195+│40 │"Steve" │
196+│24 │"Bob" │
197+│31 │"Mike" │
198+└────────┴──────────┘
195199```
196200
197201Note that the relational insertion is identical to "x:=x union relation{...}".
@@ -199,52 +203,51 @@ Note that the relational insertion is identical to "x:=x union relation{...}".
199203#### Update Tuples in a Relation Variable
200204
201205```
202−TutorialD (master/main): :showexpr s
203−┌──────────┬────────┬───────────┬───────────────┐
204−│city::Text│s#::Text│sname::Text│status::Integer│
205−├──────────┼────────┼───────────┼───────────────┤
206−│"London" │"S1" │"Smith" │20 │
207−│"Athens" │"S5" │"Adams" │30 │
208−│"Paris" │"S3" │"Blake" │30 │
209−│"London" │"S4" │"Clark" │20 │
210−│"Paris" │"S2" │"Jones" │10 │
211−└──────────┴────────┴───────────┴───────────────┘
212−TutorialD (master/main): update s where city="London" (status:=35)
213−TutorialD (master/main): :showexpr s
214−┌──────────┬────────┬───────────┬───────────────┐
215−│city::Text│s#::Text│sname::Text│status::Integer│
216−├──────────┼────────┼───────────┼───────────────┤
217−│"Athens" │"S5" │"Adams" │30 │
218−│"London" │"S1" │"Smith" │35 │
219−│"London" │"S4" │"Clark" │35 │
220−│"Paris" │"S3" │"Blake" │30 │
221−│"Paris" │"S2" │"Jones" │10 │
222−└──────────┴────────┴───────────┴───────────────┘
223−
206+TutorialD (master): :showexpr s
207+┌──────────┬────────┬───────────┬───────────┐
208+│city::Text│s#::Text│sname::Text│status::Int│
209+├──────────┼────────┼───────────┼───────────┤
210+│"Paris" │"S2" │"Jones" │10 │
211+│"Paris" │"S3" │"Blake" │30 │
212+│"London" │"S1" │"Smith" │20 │
213+│"London" │"S4" │"Clark" │20 │
214+│"Athens" │"S5" │"Adams" │30 │
215+└──────────┴────────┴───────────┴───────────┘
216+TutorialD (master): update s where city="London" (status:=35)
217+TutorialD (master): :showexpr s
218+┌──────────┬────────┬───────────┬───────────┐
219+│city::Text│s#::Text│sname::Text│status::Int│
220+├──────────┼────────┼───────────┼───────────┤
221+│"London" │"S4" │"Clark" │35 │
222+│"London" │"S1" │"Smith" │35 │
223+│"Paris" │"S2" │"Jones" │10 │
224+│"Paris" │"S3" │"Blake" │30 │
225+│"Athens" │"S5" │"Adams" │30 │
226+└──────────┴────────┴───────────┴───────────┘
224227```
225228#### Deleting Tuples from a Relation Variable
226229
227230```
228−TutorialD (master/main): :showexpr s
229−┌──────────┬────────┬───────────┬───────────────┐
230−│city::Text│s#::Text│sname::Text│status::Integer│
231−├──────────┼────────┼───────────┼───────────────┤
232−│"Paris" │"S2" │"Jones" │10 │
233−│"Paris" │"S3" │"Blake" │30 │
234−│"London" │"S1" │"Smith" │20 │
235−│"Athens" │"S5" │"Adams" │30 │
236−│"London" │"S4" │"Clark" │20 │
237−└──────────┴────────┴───────────┴───────────────┘
238−TutorialD (master/main): delete s where sname="Adams"
239−TutorialD (master/main): :showexpr s
240−┌──────────┬────────┬───────────┬───────────────┐
241−│city::Text│s#::Text│sname::Text│status::Integer│
242−├──────────┼────────┼───────────┼───────────────┤
243−│"Paris" │"S2" │"Jones" │10 │
244−│"London" │"S4" │"Clark" │20 │
245−│"Paris" │"S3" │"Blake" │30 │
246−│"London" │"S1" │"Smith" │20 │
247−└──────────┴────────┴───────────┴───────────────┘
231+TutorialD (master): :showexpr s
232+┌──────────┬────────┬───────────┬───────────┐
233+│city::Text│s#::Text│sname::Text│status::Int│
234+├──────────┼────────┼───────────┼───────────┤
235+│"Paris" │"S2" │"Jones" │10 │
236+│"Paris" │"S3" │"Blake" │30 │
237+│"London" │"S1" │"Smith" │20 │
238+│"London" │"S4" │"Clark" │20 │
239+│"Athens" │"S5" │"Adams" │30 │
240+└──────────┴────────┴───────────┴───────────┘
241+TutorialD (master): delete s where sname="Adams"
242+TutorialD (master): :showexpr s
243+┌──────────┬────────┬───────────┬───────────┐
244+│city::Text│s#::Text│sname::Text│status::Int│
245+├──────────┼────────┼───────────┼───────────┤
246+│"Paris" │"S2" │"Jones" │10 │
247+│"Paris" │"S3" │"Blake" │30 │
248+│"London" │"S1" │"Smith" │20 │
249+│"London" │"S4" │"Clark" │20 │
250+└──────────┴────────┴───────────┴───────────┘
248251```
249252
250253### Execute Transaction Graph Expressions
@@ -254,20 +257,20 @@ Unlike typical SQL DBMSs, Project:M36 maintains a graph of transactions, similar
254257#### Committing
255258
256259```
257−TutorialD (master/main): :commit
260+TutorialD (master): :commit
258261```
259262
260263#### Rollback
261264
262265```
263−TutorialD (master/main): :rollback
266+TutorialD (master): :rollback
264267```
265268
266269#### Branching
267270
268271```
269−TutorialD (master/main): :branch experimental
270−TutorialD (experimental): employee:=relation{name Text, salary Integer}
272+TutorialD (master): :branch experimental
273+TutorialD (experimental): employee:=relation{name Text, salary Int}
271274TutorialD (experimental): :commit
272275```
273276
@@ -277,7 +280,7 @@ Note how the prompt changes to reflect the current branch's name.
277280
278281```
279282TutorialD (experimental): :jumphead master
280−TutorialD (master/main): :showexpr employee
283+TutorialD (master): :showexpr employee
281284ERR: RelVarNotDefinedError "employee"
282285```
283286
docs/acid_assessment.markdown+2−2
@@ -41,6 +41,6 @@ However, Project:M36 allows the user to disable fsync()'ing, for example, for th
4141
4242In addition, Project:M36 relies on the user to use Project:M36 databases on ordered, journaled metadata filesystems only. A future improvement could be to detect scenarios under which Project:M36 is not offering guaranteed durability. Write-ahead-logs do not suffer from this requirement.
4343
44−Database directories can be shared across multiple Project:M36 database processes. This operates similarly to SQLite and relies on POSIX advisory locking and Windows file locking to ensure consistency.
44+We feel that these potential pitfalls warrant removing an arbitrary 10% from the compliance scale because there is room for further improvement here. It is, however, possible to use Project:M36 with full durability guarantees.
4545
46−Compliance: 100%
46+Compliance: 90%
docs/atomfunctions.markdowndeleted−75
@@ -1,75 +0,0 @@
1−# Project:M36 Extendable Atom Functions
2−
3−## Introduction
4−
5−While Project:M36 includes a set of basic function which operate on relational values (atoms in Project:M36 parlance), users may find it useful to write functions which operate on these atoms in the database context. For example, if a value represents a temperature in Celsius units, an atom function could be implemented to convert the value to Fahrenheit units.
6−
7−Other DBMSes also include this feature by way of stored functions such as with PL/pgsql, T-SQL, or PL/SQL.
8−
9−Project:M36 allows users to implement strongly-typed and pure atom functions in the Haskell language at runtime. This facility makes use of GHC, the Haskell compiler, as a runtime service. Alternatively, Haskell-based atom functions can be pre-compiled and loaded at runtime.
10−
11−## Atom Function Example
12−
13−In this example, we install an atom function to convert between Fahrenheit and Celsius temperatures where the temperatures are represented as integers of type ```Int```.
14−
15−We write the function giving it the name "celsiusToFahrenheit" with type ```Int -> Int``` which indicates to the compiler that the function take one ```Int``` argument value and returns one ```Int``` value. Finally, the body of the function is implemented in quotes or triple-quotes. Note that the function makes use of the "[ProjectM36.Base](/src/lib/ProjectM36/Base.hs)" module to handle the Atom type. The function must take a list of Atoms as arguments and return an Atom. The standard GHC Prelude is available in this AtomFunctionBody context.
16−
17−```
18−TutorialD (master/main): addatomfunction "celsiusToFahrenheit" Int -> Either AtomFunctionError Int """(\((IntAtom c):_) -> pure $ IntAtom ( (c * 9 `div` 5) + 32)) :: [Atom] -> Either AtomFunctionError Atom"""
19−```
20−
21−Using triple-quotes allows quotes to be used inside the string without backslash escaping, which can become tedious. The sum type using ```Either``` allows the function to return an error, if necessary.
22−
23−## Advanced Atom Function Example
24−
25−Project:M36 also supports runtime-created new data types represented as algebraic data types. Internally, these are represented as ```ConstructedAtom```s, so the atom function script must use appropriate constructors.
26−
27−In the following example, splitting the temperature values into two types make sense because it prevents accidental use of operators between the two domains. For example, a ```CelsiusTemperature``` could never be accidentially added to a ```FahrenheitTemperature``` or otherwise compared without a conversion function in between. Thus, the separation of types increases our confidence in the database results when compared to the raw ```Int``` representation above.
28−
29−```
30−data CelsiusTemperature = CelsiusTemperature Int
31−data FahrenheitTemperature = FahrenheitTemperature Int
32−
33−addatomfunction "celsiusToFahrenheit" CelsiusTemperature -> Either AtomFunctionError FahrenheitTemperature """(\(ConstructedAtom _ _ (IntAtom celsius:_):_) -> pure $ ConstructedAtom "Fahrenheit" (ConstructedAtomType "Fahrenheit" empty) [IntAtom (celsius * (9 `div` 5) + 32)]) :: [Atom] -> Either AtomFunctionError Atom """
34−```
35−
36−First, we define our new types and use these types in the function's type definition. Next, we deconstruct the incoming ```ConstructedAtom``` argument to extract its ```Int``` value. Finally, we perform the calculation and wrap the value in a new Fahrenheit-based ```ConstructedAtom```.
37−
38−Project:M36 also supports polymorphic types when used with atom functions. Here is an implementation of the veritable ```id``` function which merely returns its argument:
39−
40−```
41−addatomfunction "idTest" a -> Either AtomFunctionError a "(\(x:_) -> pure x) :: [Atom] -> Either AtomFunctionError Atom"
42−```
43−
44−## Pre-compiled Atom Functions
45−
46−Compiling atom functions at runtime can incur a performance cost. To mitigate this, atom functions can be compiled by GHC to object files and then loaded into the Project:M36 server. Let's look at an [example](https://github.com/agentm/project-m36/):
47−
48−```haskell
49−module DynamicAtomFunctions where
50−import ProjectM36.Base
51−
52−someAtomFunctions :: [AtomFunction]
53−someAtomFunctions = [AtomFunction{
54− atomFuncName = "constTrue",
55− atomFuncType = [TypeVariableType "a", BoolAtomType],
56− atomFuncBody = AtomFunctionBody Nothing (\(x:_) -> pure (BoolAtom True))}]
57−```
58−
59−Any function inside any module which returns a list of `AtomFunction`s can be used to load more atom functions. First, create the Haskell object file:
60−
61−`cabal exec ghc -- examples/DynamicAtomFunctions.hs -package project-m36`
62−
63−Use cabal or stack to invoke ghc so that the project-m36 installed package will be found.
64−
65−Finally, connect to your Project:M36 database using the `tutd` client and run:
66−
67−`TutorialD (master/main): loadatomfunctions "DynamicAtomFunctions" "someFunctions" "examples/DynamicAtomFunctions.o"`
68−
69−If you see an error such as "unknown symbol", the version of the "project-m36" library installed in your sandbox is different from that with which you linked the object file. Make sure that the same versions are used in linking the server and object file.
70−
71−The atom function is now loaded and ready-to-use. Note, however, that the function must be added every time the project-m36-server starts. This will probably be improved in a future release.
72−
73−## Differences when compared to other DBMSes
74−
75−Project:M36 enforces strongly-typed atom functions. Specifically, atom functions must be pure (free of any side effects) and cannot operate on any variables other than the atoms passed in. This certainly sets stricter limits on what can be accomplished in an atom function when compared to stored functions in other DBMS products. For example, an atom function in Project:M36 would never be able to retrieve stock information from an external website because such a function cannot be pure and thus would be rejected by the atom function compiler. This restriction maintains the mathematical cohesiveness of the database and allows the DBMS to make performance-enhancing inferences it would not otherwise be able to make.
docs/basic_benchmarks.htmldeleted−1230
@@ -1,1230 +0,0 @@
1−<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
2−<html>
3− <head>
4− <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
5− <title>criterion report</title>
6− <script language="javascript" type="text/javascript">
7− /*! jQuery v3.2.1 | (c) JS Foundation and other contributors | jquery.org/license */
8−!function(a,b){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){"use strict";var c=[],d=a.document,e=Object.getPrototypeOf,f=c.slice,g=c.concat,h=c.push,i=c.indexOf,j={},k=j.toString,l=j.hasOwnProperty,m=l.toString,n=m.call(Object),o={};function p(a,b){b=b||d;var c=b.createElement("script");c.text=a,b.head.appendChild(c).parentNode.removeChild(c)}var q="3.2.1",r=function(a,b){return new r.fn.init(a,b)},s=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,t=/^-ms-/,u=/-([a-z])/g,v=function(a,b){return b.toUpperCase()};r.fn=r.prototype={jquery:q,constructor:r,length:0,toArray:function(){return f.call(this)},get:function(a){return null==a?f.call(this):a<0?this[a+this.length]:this[a]},pushStack:function(a){var b=r.merge(this.constructor(),a);return b.prevObject=this,b},each:function(a){return r.each(this,a)},map:function(a){return this.pushStack(r.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(f.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(a<0?b:0);return this.pushStack(c>=0&&c<b?[this[c]]:[])},end:function(){return this.prevObject||this.constructor()},push:h,sort:c.sort,splice:c.splice},r.extend=r.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||r.isFunction(g)||(g={}),h===i&&(g=this,h--);h<i;h++)if(null!=(a=arguments[h]))for(b in a)c=g[b],d=a[b],g!==d&&(j&&d&&(r.isPlainObject(d)||(e=Array.isArray(d)))?(e?(e=!1,f=c&&Array.isArray(c)?c:[]):f=c&&r.isPlainObject(c)?c:{},g[b]=r.extend(j,f,d)):void 0!==d&&(g[b]=d));return g},r.extend({expando:"jQuery"+(q+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===r.type(a)},isWindow:function(a){return null!=a&&a===a.window},isNumeric:function(a){var b=r.type(a);return("number"===b||"string"===b)&&!isNaN(a-parseFloat(a))},isPlainObject:function(a){var b,c;return!(!a||"[object Object]"!==k.call(a))&&(!(b=e(a))||(c=l.call(b,"constructor")&&b.constructor,"function"==typeof c&&m.call(c)===n))},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?j[k.call(a)]||"object":typeof a},globalEval:function(a){p(a)},camelCase:function(a){return a.replace(t,"ms-").replace(u,v)},each:function(a,b){var c,d=0;if(w(a)){for(c=a.length;d<c;d++)if(b.call(a[d],d,a[d])===!1)break}else for(d in a)if(b.call(a[d],d,a[d])===!1)break;return a},trim:function(a){return null==a?"":(a+"").replace(s,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(w(Object(a))?r.merge(c,"string"==typeof a?[a]:a):h.call(c,a)),c},inArray:function(a,b,c){return null==b?-1:i.call(b,a,c)},merge:function(a,b){for(var c=+b.length,d=0,e=a.length;d<c;d++)a[e++]=b[d];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;f<g;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,e,f=0,h=[];if(w(a))for(d=a.length;f<d;f++)e=b(a[f],f,c),null!=e&&h.push(e);else for(f in a)e=b(a[f],f,c),null!=e&&h.push(e);return g.apply([],h)},guid:1,proxy:function(a,b){var c,d,e;if("string"==typeof b&&(c=a[b],b=a,a=c),r.isFunction(a))return d=f.call(arguments,2),e=function(){return a.apply(b||this,d.concat(f.call(arguments)))},e.guid=a.guid=a.guid||r.guid++,e},now:Date.now,support:o}),"function"==typeof Symbol&&(r.fn[Symbol.iterator]=c[Symbol.iterator]),r.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(a,b){j["[object "+b+"]"]=b.toLowerCase()});function w(a){var b=!!a&&"length"in a&&a.length,c=r.type(a);return"function"!==c&&!r.isWindow(a)&&("array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a)}var x=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u="sizzle"+1*new Date,v=a.document,w=0,x=0,y=ha(),z=ha(),A=ha(),B=function(a,b){return a===b&&(l=!0),0},C={}.hasOwnProperty,D=[],E=D.pop,F=D.push,G=D.push,H=D.slice,I=function(a,b){for(var c=0,d=a.length;c<d;c++)if(a[c]===b)return c;return-1},J="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",K="[\\x20\\t\\r\\n\\f]",L="(?:\\\\.|[\\w-]|[^\0-\\xa0])+",M="\\["+K+"*("+L+")(?:"+K+"*([*^$|!~]?=)"+K+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+L+"))|)"+K+"*\\]",N=":("+L+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+M+")*)|.*)\\)|)",O=new RegExp(K+"+","g"),P=new RegExp("^"+K+"+|((?:^|[^\\\\])(?:\\\\.)*)"+K+"+$","g"),Q=new RegExp("^"+K+"*,"+K+"*"),R=new RegExp("^"+K+"*([>+~]|"+K+")"+K+"*"),S=new RegExp("="+K+"*([^\\]'\"]*?)"+K+"*\\]","g"),T=new RegExp(N),U=new RegExp("^"+L+"$"),V={ID:new RegExp("^#("+L+")"),CLASS:new RegExp("^\\.("+L+")"),TAG:new RegExp("^("+L+"|[*])"),ATTR:new RegExp("^"+M),PSEUDO:new RegExp("^"+N),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+K+"*(even|odd|(([+-]|)(\\d*)n|)"+K+"*(?:([+-]|)"+K+"*(\\d+)|))"+K+"*\\)|)","i"),bool:new RegExp("^(?:"+J+")$","i"),needsContext:new RegExp("^"+K+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+K+"*((?:-\\d)?\\d*)"+K+"*\\)|)(?=[^-]|$)","i")},W=/^(?:input|select|textarea|button)$/i,X=/^h\d$/i,Y=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,$=/[+~]/,_=new RegExp("\\\\([\\da-f]{1,6}"+K+"?|("+K+")|.)","ig"),aa=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:d<0?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)},ba=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ca=function(a,b){return b?"\0"===a?"\ufffd":a.slice(0,-1)+"\\"+a.charCodeAt(a.length-1).toString(16)+" ":"\\"+a},da=function(){m()},ea=ta(function(a){return a.disabled===!0&&("form"in a||"label"in a)},{dir:"parentNode",next:"legend"});try{G.apply(D=H.call(v.childNodes),v.childNodes),D[v.childNodes.length].nodeType}catch(fa){G={apply:D.length?function(a,b){F.apply(a,H.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function ga(a,b,d,e){var f,h,j,k,l,o,r,s=b&&b.ownerDocument,w=b?b.nodeType:9;if(d=d||[],"string"!=typeof a||!a||1!==w&&9!==w&&11!==w)return d;if(!e&&((b?b.ownerDocument||b:v)!==n&&m(b),b=b||n,p)){if(11!==w&&(l=Z.exec(a)))if(f=l[1]){if(9===w){if(!(j=b.getElementById(f)))return d;if(j.id===f)return d.push(j),d}else if(s&&(j=s.getElementById(f))&&t(b,j)&&j.id===f)return d.push(j),d}else{if(l[2])return G.apply(d,b.getElementsByTagName(a)),d;if((f=l[3])&&c.getElementsByClassName&&b.getElementsByClassName)return G.apply(d,b.getElementsByClassName(f)),d}if(c.qsa&&!A[a+" "]&&(!q||!q.test(a))){if(1!==w)s=b,r=a;else if("object"!==b.nodeName.toLowerCase()){(k=b.getAttribute("id"))?k=k.replace(ba,ca):b.setAttribute("id",k=u),o=g(a),h=o.length;while(h--)o[h]="#"+k+" "+sa(o[h]);r=o.join(","),s=$.test(a)&&qa(b.parentNode)||b}if(r)try{return G.apply(d,s.querySelectorAll(r)),d}catch(x){}finally{k===u&&b.removeAttribute("id")}}}return i(a.replace(P,"$1"),b,d,e)}function ha(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function ia(a){return a[u]=!0,a}function ja(a){var b=n.createElement("fieldset");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function ka(a,b){var c=a.split("|"),e=c.length;while(e--)d.attrHandle[c[e]]=b}function la(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&a.sourceIndex-b.sourceIndex;if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function ma(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function na(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function oa(a){return function(b){return"form"in b?b.parentNode&&b.disabled===!1?"label"in b?"label"in b.parentNode?b.parentNode.disabled===a:b.disabled===a:b.isDisabled===a||b.isDisabled!==!a&&ea(b)===a:b.disabled===a:"label"in b&&b.disabled===a}}function pa(a){return ia(function(b){return b=+b,ia(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function qa(a){return a&&"undefined"!=typeof a.getElementsByTagName&&a}c=ga.support={},f=ga.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return!!b&&"HTML"!==b.nodeName},m=ga.setDocument=function(a){var b,e,g=a?a.ownerDocument||a:v;return g!==n&&9===g.nodeType&&g.documentElement?(n=g,o=n.documentElement,p=!f(n),v!==n&&(e=n.defaultView)&&e.top!==e&&(e.addEventListener?e.addEventListener("unload",da,!1):e.attachEvent&&e.attachEvent("onunload",da)),c.attributes=ja(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=ja(function(a){return a.appendChild(n.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=Y.test(n.getElementsByClassName),c.getById=ja(function(a){return o.appendChild(a).id=u,!n.getElementsByName||!n.getElementsByName(u).length}),c.getById?(d.filter.ID=function(a){var b=a.replace(_,aa);return function(a){return a.getAttribute("id")===b}},d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c=b.getElementById(a);return c?[c]:[]}}):(d.filter.ID=function(a){var b=a.replace(_,aa);return function(a){var c="undefined"!=typeof a.getAttributeNode&&a.getAttributeNode("id");return c&&c.value===b}},d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c,d,e,f=b.getElementById(a);if(f){if(c=f.getAttributeNode("id"),c&&c.value===a)return[f];e=b.getElementsByName(a),d=0;while(f=e[d++])if(c=f.getAttributeNode("id"),c&&c.value===a)return[f]}return[]}}),d.find.TAG=c.getElementsByTagName?function(a,b){return"undefined"!=typeof b.getElementsByTagName?b.getElementsByTagName(a):c.qsa?b.querySelectorAll(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){if("undefined"!=typeof b.getElementsByClassName&&p)return b.getElementsByClassName(a)},r=[],q=[],(c.qsa=Y.test(n.querySelectorAll))&&(ja(function(a){o.appendChild(a).innerHTML="<a id='"+u+"'></a><select id='"+u+"-\r\\' msallowcapture=''><option selected=''></option></select>",a.querySelectorAll("[msallowcapture^='']").length&&q.push("[*^$]="+K+"*(?:''|\"\")"),a.querySelectorAll("[selected]").length||q.push("\\["+K+"*(?:value|"+J+")"),a.querySelectorAll("[id~="+u+"-]").length||q.push("~="),a.querySelectorAll(":checked").length||q.push(":checked"),a.querySelectorAll("a#"+u+"+*").length||q.push(".#.+[+~]")}),ja(function(a){a.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var b=n.createElement("input");b.setAttribute("type","hidden"),a.appendChild(b).setAttribute("name","D"),a.querySelectorAll("[name=d]").length&&q.push("name"+K+"*[*^$|!~]?="),2!==a.querySelectorAll(":enabled").length&&q.push(":enabled",":disabled"),o.appendChild(a).disabled=!0,2!==a.querySelectorAll(":disabled").length&&q.push(":enabled",":disabled"),a.querySelectorAll("*,:x"),q.push(",.*:")})),(c.matchesSelector=Y.test(s=o.matches||o.webkitMatchesSelector||o.mozMatchesSelector||o.oMatchesSelector||o.msMatchesSelector))&&ja(function(a){c.disconnectedMatch=s.call(a,"*"),s.call(a,"[s!='']:x"),r.push("!=",N)}),q=q.length&&new RegExp(q.join("|")),r=r.length&&new RegExp(r.join("|")),b=Y.test(o.compareDocumentPosition),t=b||Y.test(o.contains)?function(a,b){var c=9===a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a===d||!(!d||1!==d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)while(b=b.parentNode)if(b===a)return!0;return!1},B=b?function(a,b){if(a===b)return l=!0,0;var d=!a.compareDocumentPosition-!b.compareDocumentPosition;return d?d:(d=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):1,1&d||!c.sortDetached&&b.compareDocumentPosition(a)===d?a===n||a.ownerDocument===v&&t(v,a)?-1:b===n||b.ownerDocument===v&&t(v,b)?1:k?I(k,a)-I(k,b):0:4&d?-1:1)}:function(a,b){if(a===b)return l=!0,0;var c,d=0,e=a.parentNode,f=b.parentNode,g=[a],h=[b];if(!e||!f)return a===n?-1:b===n?1:e?-1:f?1:k?I(k,a)-I(k,b):0;if(e===f)return la(a,b);c=a;while(c=c.parentNode)g.unshift(c);c=b;while(c=c.parentNode)h.unshift(c);while(g[d]===h[d])d++;return d?la(g[d],h[d]):g[d]===v?-1:h[d]===v?1:0},n):n},ga.matches=function(a,b){return ga(a,null,null,b)},ga.matchesSelector=function(a,b){if((a.ownerDocument||a)!==n&&m(a),b=b.replace(S,"='$1']"),c.matchesSelector&&p&&!A[b+" "]&&(!r||!r.test(b))&&(!q||!q.test(b)))try{var d=s.call(a,b);if(d||c.disconnectedMatch||a.document&&11!==a.document.nodeType)return d}catch(e){}return ga(b,n,null,[a]).length>0},ga.contains=function(a,b){return(a.ownerDocument||a)!==n&&m(a),t(a,b)},ga.attr=function(a,b){(a.ownerDocument||a)!==n&&m(a);var e=d.attrHandle[b.toLowerCase()],f=e&&C.call(d.attrHandle,b.toLowerCase())?e(a,b,!p):void 0;return void 0!==f?f:c.attributes||!p?a.getAttribute(b):(f=a.getAttributeNode(b))&&f.specified?f.value:null},ga.escape=function(a){return(a+"").replace(ba,ca)},ga.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},ga.uniqueSort=function(a){var b,d=[],e=0,f=0;if(l=!c.detectDuplicates,k=!c.sortStable&&a.slice(0),a.sort(B),l){while(b=a[f++])b===a[f]&&(e=d.push(f));while(e--)a.splice(d[e],1)}return k=null,a},e=ga.getText=function(a){var b,c="",d=0,f=a.nodeType;if(f){if(1===f||9===f||11===f){if("string"==typeof a.textContent)return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=e(a)}else if(3===f||4===f)return a.nodeValue}else while(b=a[d++])c+=e(b);return c},d=ga.selectors={cacheLength:50,createPseudo:ia,match:V,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(_,aa),a[3]=(a[3]||a[4]||a[5]||"").replace(_,aa),"~="===a[2]&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),"nth"===a[1].slice(0,3)?(a[3]||ga.error(a[0]),a[4]=+(a[4]?a[5]+(a[6]||1):2*("even"===a[3]||"odd"===a[3])),a[5]=+(a[7]+a[8]||"odd"===a[3])):a[3]&&ga.error(a[0]),a},PSEUDO:function(a){var b,c=!a[6]&&a[2];return V.CHILD.test(a[0])?null:(a[3]?a[2]=a[4]||a[5]||"":c&&T.test(c)&&(b=g(c,!0))&&(b=c.indexOf(")",c.length-b)-c.length)&&(a[0]=a[0].slice(0,b),a[2]=c.slice(0,b)),a.slice(0,3))}},filter:{TAG:function(a){var b=a.replace(_,aa).toLowerCase();return"*"===a?function(){return!0}:function(a){return a.nodeName&&a.nodeName.toLowerCase()===b}},CLASS:function(a){var b=y[a+" "];return b||(b=new RegExp("(^|"+K+")"+a+"("+K+"|$)"))&&y(a,function(a){return b.test("string"==typeof a.className&&a.className||"undefined"!=typeof a.getAttribute&&a.getAttribute("class")||"")})},ATTR:function(a,b,c){return function(d){var e=ga.attr(d,a);return null==e?"!="===b:!b||(e+="","="===b?e===c:"!="===b?e!==c:"^="===b?c&&0===e.indexOf(c):"*="===b?c&&e.indexOf(c)>-1:"$="===b?c&&e.slice(-c.length)===c:"~="===b?(" "+e.replace(O," ")+" ").indexOf(c)>-1:"|="===b&&(e===c||e.slice(0,c.length+1)===c+"-"))}},CHILD:function(a,b,c,d,e){var f="nth"!==a.slice(0,3),g="last"!==a.slice(-4),h="of-type"===b;return 1===d&&0===e?function(a){return!!a.parentNode}:function(b,c,i){var j,k,l,m,n,o,p=f!==g?"nextSibling":"previousSibling",q=b.parentNode,r=h&&b.nodeName.toLowerCase(),s=!i&&!h,t=!1;if(q){if(f){while(p){m=b;while(m=m[p])if(h?m.nodeName.toLowerCase()===r:1===m.nodeType)return!1;o=p="only"===a&&!o&&"nextSibling"}return!0}if(o=[g?q.firstChild:q.lastChild],g&&s){m=q,l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),j=k[a]||[],n=j[0]===w&&j[1],t=n&&j[2],m=n&&q.childNodes[n];while(m=++n&&m&&m[p]||(t=n=0)||o.pop())if(1===m.nodeType&&++t&&m===b){k[a]=[w,n,t];break}}else if(s&&(m=b,l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),j=k[a]||[],n=j[0]===w&&j[1],t=n),t===!1)while(m=++n&&m&&m[p]||(t=n=0)||o.pop())if((h?m.nodeName.toLowerCase()===r:1===m.nodeType)&&++t&&(s&&(l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),k[a]=[w,t]),m===b))break;return t-=e,t===d||t%d===0&&t/d>=0}}},PSEUDO:function(a,b){var c,e=d.pseudos[a]||d.setFilters[a.toLowerCase()]||ga.error("unsupported pseudo: "+a);return e[u]?e(b):e.length>1?(c=[a,a,"",b],d.setFilters.hasOwnProperty(a.toLowerCase())?ia(function(a,c){var d,f=e(a,b),g=f.length;while(g--)d=I(a,f[g]),a[d]=!(c[d]=f[g])}):function(a){return e(a,0,c)}):e}},pseudos:{not:ia(function(a){var b=[],c=[],d=h(a.replace(P,"$1"));return d[u]?ia(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)(f=g[h])&&(a[h]=!(b[h]=f))}):function(a,e,f){return b[0]=a,d(b,null,f,c),b[0]=null,!c.pop()}}),has:ia(function(a){return function(b){return ga(a,b).length>0}}),contains:ia(function(a){return a=a.replace(_,aa),function(b){return(b.textContent||b.innerText||e(b)).indexOf(a)>-1}}),lang:ia(function(a){return U.test(a||"")||ga.error("unsupported lang: "+a),a=a.replace(_,aa).toLowerCase(),function(b){var c;do if(c=p?b.lang:b.getAttribute("xml:lang")||b.getAttribute("lang"))return c=c.toLowerCase(),c===a||0===c.indexOf(a+"-");while((b=b.parentNode)&&1===b.nodeType);return!1}}),target:function(b){var c=a.location&&a.location.hash;return c&&c.slice(1)===b.id},root:function(a){return a===o},focus:function(a){return a===n.activeElement&&(!n.hasFocus||n.hasFocus())&&!!(a.type||a.href||~a.tabIndex)},enabled:oa(!1),disabled:oa(!0),checked:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&!!a.checked||"option"===b&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},empty:function(a){for(a=a.firstChild;a;a=a.nextSibling)if(a.nodeType<6)return!1;return!0},parent:function(a){return!d.pseudos.empty(a)},header:function(a){return X.test(a.nodeName)},input:function(a){return W.test(a.nodeName)},button:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&"button"===a.type||"button"===b},text:function(a){var b;return"input"===a.nodeName.toLowerCase()&&"text"===a.type&&(null==(b=a.getAttribute("type"))||"text"===b.toLowerCase())},first:pa(function(){return[0]}),last:pa(function(a,b){return[b-1]}),eq:pa(function(a,b,c){return[c<0?c+b:c]}),even:pa(function(a,b){for(var c=0;c<b;c+=2)a.push(c);return a}),odd:pa(function(a,b){for(var c=1;c<b;c+=2)a.push(c);return a}),lt:pa(function(a,b,c){for(var d=c<0?c+b:c;--d>=0;)a.push(d);return a}),gt:pa(function(a,b,c){for(var d=c<0?c+b:c;++d<b;)a.push(d);return a})}},d.pseudos.nth=d.pseudos.eq;for(b in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})d.pseudos[b]=ma(b);for(b in{submit:!0,reset:!0})d.pseudos[b]=na(b);function ra(){}ra.prototype=d.filters=d.pseudos,d.setFilters=new ra,g=ga.tokenize=function(a,b){var c,e,f,g,h,i,j,k=z[a+" "];if(k)return b?0:k.slice(0);h=a,i=[],j=d.preFilter;while(h){c&&!(e=Q.exec(h))||(e&&(h=h.slice(e[0].length)||h),i.push(f=[])),c=!1,(e=R.exec(h))&&(c=e.shift(),f.push({value:c,type:e[0].replace(P," ")}),h=h.slice(c.length));for(g in d.filter)!(e=V[g].exec(h))||j[g]&&!(e=j[g](e))||(c=e.shift(),f.push({value:c,type:g,matches:e}),h=h.slice(c.length));if(!c)break}return b?h.length:h?ga.error(a):z(a,i).slice(0)};function sa(a){for(var b=0,c=a.length,d="";b<c;b++)d+=a[b].value;return d}function ta(a,b,c){var d=b.dir,e=b.next,f=e||d,g=c&&"parentNode"===f,h=x++;return b.first?function(b,c,e){while(b=b[d])if(1===b.nodeType||g)return a(b,c,e);return!1}:function(b,c,i){var j,k,l,m=[w,h];if(i){while(b=b[d])if((1===b.nodeType||g)&&a(b,c,i))return!0}else while(b=b[d])if(1===b.nodeType||g)if(l=b[u]||(b[u]={}),k=l[b.uniqueID]||(l[b.uniqueID]={}),e&&e===b.nodeName.toLowerCase())b=b[d]||b;else{if((j=k[f])&&j[0]===w&&j[1]===h)return m[2]=j[2];if(k[f]=m,m[2]=a(b,c,i))return!0}return!1}}function ua(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function va(a,b,c){for(var d=0,e=b.length;d<e;d++)ga(a,b[d],c);return c}function wa(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;h<i;h++)(f=a[h])&&(c&&!c(f,d,e)||(g.push(f),j&&b.push(h)));return g}function xa(a,b,c,d,e,f){return d&&!d[u]&&(d=xa(d)),e&&!e[u]&&(e=xa(e,f)),ia(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||va(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:wa(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=wa(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?I(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=wa(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):G.apply(g,r)})}function ya(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],h=g||d.relative[" "],i=g?1:0,k=ta(function(a){return a===b},h,!0),l=ta(function(a){return I(b,a)>-1},h,!0),m=[function(a,c,d){var e=!g&&(d||c!==j)||((b=c).nodeType?k(a,c,d):l(a,c,d));return b=null,e}];i<f;i++)if(c=d.relative[a[i].type])m=[ta(ua(m),c)];else{if(c=d.filter[a[i].type].apply(null,a[i].matches),c[u]){for(e=++i;e<f;e++)if(d.relative[a[e].type])break;return xa(i>1&&ua(m),i>1&&sa(a.slice(0,i-1).concat({value:" "===a[i-2].type?"*":""})).replace(P,"$1"),c,i<e&&ya(a.slice(i,e)),e<f&&ya(a=a.slice(e)),e<f&&sa(a))}m.push(c)}return ua(m)}function za(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,h,i,k){var l,o,q,r=0,s="0",t=f&&[],u=[],v=j,x=f||e&&d.find.TAG("*",k),y=w+=null==v?1:Math.random()||.1,z=x.length;for(k&&(j=g===n||g||k);s!==z&&null!=(l=x[s]);s++){if(e&&l){o=0,g||l.ownerDocument===n||(m(l),h=!p);while(q=a[o++])if(q(l,g||n,h)){i.push(l);break}k&&(w=y)}c&&((l=!q&&l)&&r--,f&&t.push(l))}if(r+=s,c&&s!==r){o=0;while(q=b[o++])q(t,u,g,h);if(f){if(r>0)while(s--)t[s]||u[s]||(u[s]=E.call(i));u=wa(u)}G.apply(i,u),k&&!f&&u.length>0&&r+b.length>1&&ga.uniqueSort(i)}return k&&(w=y,j=v),t};return c?ia(f):f}return h=ga.compile=function(a,b){var c,d=[],e=[],f=A[a+" "];if(!f){b||(b=g(a)),c=b.length;while(c--)f=ya(b[c]),f[u]?d.push(f):e.push(f);f=A(a,za(e,d)),f.selector=a}return f},i=ga.select=function(a,b,c,e){var f,i,j,k,l,m="function"==typeof a&&a,n=!e&&g(a=m.selector||a);if(c=c||[],1===n.length){if(i=n[0]=n[0].slice(0),i.length>2&&"ID"===(j=i[0]).type&&9===b.nodeType&&p&&d.relative[i[1].type]){if(b=(d.find.ID(j.matches[0].replace(_,aa),b)||[])[0],!b)return c;m&&(b=b.parentNode),a=a.slice(i.shift().value.length)}f=V.needsContext.test(a)?0:i.length;while(f--){if(j=i[f],d.relative[k=j.type])break;if((l=d.find[k])&&(e=l(j.matches[0].replace(_,aa),$.test(i[0].type)&&qa(b.parentNode)||b))){if(i.splice(f,1),a=e.length&&sa(i),!a)return G.apply(c,e),c;break}}}return(m||h(a,n))(e,b,!p,c,!b||$.test(a)&&qa(b.parentNode)||b),c},c.sortStable=u.split("").sort(B).join("")===u,c.detectDuplicates=!!l,m(),c.sortDetached=ja(function(a){return 1&a.compareDocumentPosition(n.createElement("fieldset"))}),ja(function(a){return a.innerHTML="<a href='#'></a>","#"===a.firstChild.getAttribute("href")})||ka("type|href|height|width",function(a,b,c){if(!c)return a.getAttribute(b,"type"===b.toLowerCase()?1:2)}),c.attributes&&ja(function(a){return a.innerHTML="<input/>",a.firstChild.setAttribute("value",""),""===a.firstChild.getAttribute("value")})||ka("value",function(a,b,c){if(!c&&"input"===a.nodeName.toLowerCase())return a.defaultValue}),ja(function(a){return null==a.getAttribute("disabled")})||ka(J,function(a,b,c){var d;if(!c)return a[b]===!0?b.toLowerCase():(d=a.getAttributeNode(b))&&d.specified?d.value:null}),ga}(a);r.find=x,r.expr=x.selectors,r.expr[":"]=r.expr.pseudos,r.uniqueSort=r.unique=x.uniqueSort,r.text=x.getText,r.isXMLDoc=x.isXML,r.contains=x.contains,r.escapeSelector=x.escape;var y=function(a,b,c){var d=[],e=void 0!==c;while((a=a[b])&&9!==a.nodeType)if(1===a.nodeType){if(e&&r(a).is(c))break;d.push(a)}return d},z=function(a,b){for(var c=[];a;a=a.nextSibling)1===a.nodeType&&a!==b&&c.push(a);return c},A=r.expr.match.needsContext;function B(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()}var C=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i,D=/^.[^:#\[\.,]*$/;function E(a,b,c){return r.isFunction(b)?r.grep(a,function(a,d){return!!b.call(a,d,a)!==c}):b.nodeType?r.grep(a,function(a){return a===b!==c}):"string"!=typeof b?r.grep(a,function(a){return i.call(b,a)>-1!==c}):D.test(b)?r.filter(b,a,c):(b=r.filter(b,a),r.grep(a,function(a){return i.call(b,a)>-1!==c&&1===a.nodeType}))}r.filter=function(a,b,c){var d=b[0];return c&&(a=":not("+a+")"),1===b.length&&1===d.nodeType?r.find.matchesSelector(d,a)?[d]:[]:r.find.matches(a,r.grep(b,function(a){return 1===a.nodeType}))},r.fn.extend({find:function(a){var b,c,d=this.length,e=this;if("string"!=typeof a)return this.pushStack(r(a).filter(function(){for(b=0;b<d;b++)if(r.contains(e[b],this))return!0}));for(c=this.pushStack([]),b=0;b<d;b++)r.find(a,e[b],c);return d>1?r.uniqueSort(c):c},filter:function(a){return this.pushStack(E(this,a||[],!1))},not:function(a){return this.pushStack(E(this,a||[],!0))},is:function(a){return!!E(this,"string"==typeof a&&A.test(a)?r(a):a||[],!1).length}});var F,G=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,H=r.fn.init=function(a,b,c){var e,f;if(!a)return this;if(c=c||F,"string"==typeof a){if(e="<"===a[0]&&">"===a[a.length-1]&&a.length>=3?[null,a,null]:G.exec(a),!e||!e[1]&&b)return!b||b.jquery?(b||c).find(a):this.constructor(b).find(a);if(e[1]){if(b=b instanceof r?b[0]:b,r.merge(this,r.parseHTML(e[1],b&&b.nodeType?b.ownerDocument||b:d,!0)),C.test(e[1])&&r.isPlainObject(b))for(e in b)r.isFunction(this[e])?this[e](b[e]):this.attr(e,b[e]);return this}return f=d.getElementById(e[2]),f&&(this[0]=f,this.length=1),this}return a.nodeType?(this[0]=a,this.length=1,this):r.isFunction(a)?void 0!==c.ready?c.ready(a):a(r):r.makeArray(a,this)};H.prototype=r.fn,F=r(d);var I=/^(?:parents|prev(?:Until|All))/,J={children:!0,contents:!0,next:!0,prev:!0};r.fn.extend({has:function(a){var b=r(a,this),c=b.length;return this.filter(function(){for(var a=0;a<c;a++)if(r.contains(this,b[a]))return!0})},closest:function(a,b){var c,d=0,e=this.length,f=[],g="string"!=typeof a&&r(a);if(!A.test(a))for(;d<e;d++)for(c=this[d];c&&c!==b;c=c.parentNode)if(c.nodeType<11&&(g?g.index(c)>-1:1===c.nodeType&&r.find.matchesSelector(c,a))){f.push(c);break}return this.pushStack(f.length>1?r.uniqueSort(f):f)},index:function(a){return a?"string"==typeof a?i.call(r(a),this[0]):i.call(this,a.jquery?a[0]:a):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(a,b){return this.pushStack(r.uniqueSort(r.merge(this.get(),r(a,b))))},addBack:function(a){return this.add(null==a?this.prevObject:this.prevObject.filter(a))}});function K(a,b){while((a=a[b])&&1!==a.nodeType);return a}r.each({parent:function(a){var b=a.parentNode;return b&&11!==b.nodeType?b:null},parents:function(a){return y(a,"parentNode")},parentsUntil:function(a,b,c){return y(a,"parentNode",c)},next:function(a){return K(a,"nextSibling")},prev:function(a){return K(a,"previousSibling")},nextAll:function(a){return y(a,"nextSibling")},prevAll:function(a){return y(a,"previousSibling")},nextUntil:function(a,b,c){return y(a,"nextSibling",c)},prevUntil:function(a,b,c){return y(a,"previousSibling",c)},siblings:function(a){return z((a.parentNode||{}).firstChild,a)},children:function(a){return z(a.firstChild)},contents:function(a){return B(a,"iframe")?a.contentDocument:(B(a,"template")&&(a=a.content||a),r.merge([],a.childNodes))}},function(a,b){r.fn[a]=function(c,d){var e=r.map(this,b,c);return"Until"!==a.slice(-5)&&(d=c),d&&"string"==typeof d&&(e=r.filter(d,e)),this.length>1&&(J[a]||r.uniqueSort(e),I.test(a)&&e.reverse()),this.pushStack(e)}});var L=/[^\x20\t\r\n\f]+/g;function M(a){var b={};return r.each(a.match(L)||[],function(a,c){b[c]=!0}),b}r.Callbacks=function(a){a="string"==typeof a?M(a):r.extend({},a);var b,c,d,e,f=[],g=[],h=-1,i=function(){for(e=e||a.once,d=b=!0;g.length;h=-1){c=g.shift();while(++h<f.length)f[h].apply(c[0],c[1])===!1&&a.stopOnFalse&&(h=f.length,c=!1)}a.memory||(c=!1),b=!1,e&&(f=c?[]:"")},j={add:function(){return f&&(c&&!b&&(h=f.length-1,g.push(c)),function d(b){r.each(b,function(b,c){r.isFunction(c)?a.unique&&j.has(c)||f.push(c):c&&c.length&&"string"!==r.type(c)&&d(c)})}(arguments),c&&!b&&i()),this},remove:function(){return r.each(arguments,function(a,b){var c;while((c=r.inArray(b,f,c))>-1)f.splice(c,1),c<=h&&h--}),this},has:function(a){return a?r.inArray(a,f)>-1:f.length>0},empty:function(){return f&&(f=[]),this},disable:function(){return e=g=[],f=c="",this},disabled:function(){return!f},lock:function(){return e=g=[],c||b||(f=c=""),this},locked:function(){return!!e},fireWith:function(a,c){return e||(c=c||[],c=[a,c.slice?c.slice():c],g.push(c),b||i()),this},fire:function(){return j.fireWith(this,arguments),this},fired:function(){return!!d}};return j};function N(a){return a}function O(a){throw a}function P(a,b,c,d){var e;try{a&&r.isFunction(e=a.promise)?e.call(a).done(b).fail(c):a&&r.isFunction(e=a.then)?e.call(a,b,c):b.apply(void 0,[a].slice(d))}catch(a){c.apply(void 0,[a])}}r.extend({Deferred:function(b){var c=[["notify","progress",r.Callbacks("memory"),r.Callbacks("memory"),2],["resolve","done",r.Callbacks("once memory"),r.Callbacks("once memory"),0,"resolved"],["reject","fail",r.Callbacks("once memory"),r.Callbacks("once memory"),1,"rejected"]],d="pending",e={state:function(){return d},always:function(){return f.done(arguments).fail(arguments),this},"catch":function(a){return e.then(null,a)},pipe:function(){var a=arguments;return r.Deferred(function(b){r.each(c,function(c,d){var e=r.isFunction(a[d[4]])&&a[d[4]];f[d[1]](function(){var a=e&&e.apply(this,arguments);a&&r.isFunction(a.promise)?a.promise().progress(b.notify).done(b.resolve).fail(b.reject):b[d[0]+"With"](this,e?[a]:arguments)})}),a=null}).promise()},then:function(b,d,e){var f=0;function g(b,c,d,e){return function(){var h=this,i=arguments,j=function(){var a,j;if(!(b<f)){if(a=d.apply(h,i),a===c.promise())throw new TypeError("Thenable self-resolution");j=a&&("object"==typeof a||"function"==typeof a)&&a.then,r.isFunction(j)?e?j.call(a,g(f,c,N,e),g(f,c,O,e)):(f++,j.call(a,g(f,c,N,e),g(f,c,O,e),g(f,c,N,c.notifyWith))):(d!==N&&(h=void 0,i=[a]),(e||c.resolveWith)(h,i))}},k=e?j:function(){try{j()}catch(a){r.Deferred.exceptionHook&&r.Deferred.exceptionHook(a,k.stackTrace),b+1>=f&&(d!==O&&(h=void 0,i=[a]),c.rejectWith(h,i))}};b?k():(r.Deferred.getStackHook&&(k.stackTrace=r.Deferred.getStackHook()),a.setTimeout(k))}}return r.Deferred(function(a){c[0][3].add(g(0,a,r.isFunction(e)?e:N,a.notifyWith)),c[1][3].add(g(0,a,r.isFunction(b)?b:N)),c[2][3].add(g(0,a,r.isFunction(d)?d:O))}).promise()},promise:function(a){return null!=a?r.extend(a,e):e}},f={};return r.each(c,function(a,b){var g=b[2],h=b[5];e[b[1]]=g.add,h&&g.add(function(){d=h},c[3-a][2].disable,c[0][2].lock),g.add(b[3].fire),f[b[0]]=function(){return f[b[0]+"With"](this===f?void 0:this,arguments),this},f[b[0]+"With"]=g.fireWith}),e.promise(f),b&&b.call(f,f),f},when:function(a){var b=arguments.length,c=b,d=Array(c),e=f.call(arguments),g=r.Deferred(),h=function(a){return function(c){d[a]=this,e[a]=arguments.length>1?f.call(arguments):c,--b||g.resolveWith(d,e)}};if(b<=1&&(P(a,g.done(h(c)).resolve,g.reject,!b),"pending"===g.state()||r.isFunction(e[c]&&e[c].then)))return g.then();while(c--)P(e[c],h(c),g.reject);return g.promise()}});var Q=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;r.Deferred.exceptionHook=function(b,c){a.console&&a.console.warn&&b&&Q.test(b.name)&&a.console.warn("jQuery.Deferred exception: "+b.message,b.stack,c)},r.readyException=function(b){a.setTimeout(function(){throw b})};var R=r.Deferred();r.fn.ready=function(a){return R.then(a)["catch"](function(a){r.readyException(a)}),this},r.extend({isReady:!1,readyWait:1,ready:function(a){(a===!0?--r.readyWait:r.isReady)||(r.isReady=!0,a!==!0&&--r.readyWait>0||R.resolveWith(d,[r]))}}),r.ready.then=R.then;function S(){d.removeEventListener("DOMContentLoaded",S),
9−a.removeEventListener("load",S),r.ready()}"complete"===d.readyState||"loading"!==d.readyState&&!d.documentElement.doScroll?a.setTimeout(r.ready):(d.addEventListener("DOMContentLoaded",S),a.addEventListener("load",S));var T=function(a,b,c,d,e,f,g){var h=0,i=a.length,j=null==c;if("object"===r.type(c)){e=!0;for(h in c)T(a,b,h,c[h],!0,f,g)}else if(void 0!==d&&(e=!0,r.isFunction(d)||(g=!0),j&&(g?(b.call(a,d),b=null):(j=b,b=function(a,b,c){return j.call(r(a),c)})),b))for(;h<i;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f},U=function(a){return 1===a.nodeType||9===a.nodeType||!+a.nodeType};function V(){this.expando=r.expando+V.uid++}V.uid=1,V.prototype={cache:function(a){var b=a[this.expando];return b||(b={},U(a)&&(a.nodeType?a[this.expando]=b:Object.defineProperty(a,this.expando,{value:b,configurable:!0}))),b},set:function(a,b,c){var d,e=this.cache(a);if("string"==typeof b)e[r.camelCase(b)]=c;else for(d in b)e[r.camelCase(d)]=b[d];return e},get:function(a,b){return void 0===b?this.cache(a):a[this.expando]&&a[this.expando][r.camelCase(b)]},access:function(a,b,c){return void 0===b||b&&"string"==typeof b&&void 0===c?this.get(a,b):(this.set(a,b,c),void 0!==c?c:b)},remove:function(a,b){var c,d=a[this.expando];if(void 0!==d){if(void 0!==b){Array.isArray(b)?b=b.map(r.camelCase):(b=r.camelCase(b),b=b in d?[b]:b.match(L)||[]),c=b.length;while(c--)delete d[b[c]]}(void 0===b||r.isEmptyObject(d))&&(a.nodeType?a[this.expando]=void 0:delete a[this.expando])}},hasData:function(a){var b=a[this.expando];return void 0!==b&&!r.isEmptyObject(b)}};var W=new V,X=new V,Y=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,Z=/[A-Z]/g;function $(a){return"true"===a||"false"!==a&&("null"===a?null:a===+a+""?+a:Y.test(a)?JSON.parse(a):a)}function _(a,b,c){var d;if(void 0===c&&1===a.nodeType)if(d="data-"+b.replace(Z,"-$&").toLowerCase(),c=a.getAttribute(d),"string"==typeof c){try{c=$(c)}catch(e){}X.set(a,b,c)}else c=void 0;return c}r.extend({hasData:function(a){return X.hasData(a)||W.hasData(a)},data:function(a,b,c){return X.access(a,b,c)},removeData:function(a,b){X.remove(a,b)},_data:function(a,b,c){return W.access(a,b,c)},_removeData:function(a,b){W.remove(a,b)}}),r.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=X.get(f),1===f.nodeType&&!W.get(f,"hasDataAttrs"))){c=g.length;while(c--)g[c]&&(d=g[c].name,0===d.indexOf("data-")&&(d=r.camelCase(d.slice(5)),_(f,d,e[d])));W.set(f,"hasDataAttrs",!0)}return e}return"object"==typeof a?this.each(function(){X.set(this,a)}):T(this,function(b){var c;if(f&&void 0===b){if(c=X.get(f,a),void 0!==c)return c;if(c=_(f,a),void 0!==c)return c}else this.each(function(){X.set(this,a,b)})},null,b,arguments.length>1,null,!0)},removeData:function(a){return this.each(function(){X.remove(this,a)})}}),r.extend({queue:function(a,b,c){var d;if(a)return b=(b||"fx")+"queue",d=W.get(a,b),c&&(!d||Array.isArray(c)?d=W.access(a,b,r.makeArray(c)):d.push(c)),d||[]},dequeue:function(a,b){b=b||"fx";var c=r.queue(a,b),d=c.length,e=c.shift(),f=r._queueHooks(a,b),g=function(){r.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return W.get(a,c)||W.access(a,c,{empty:r.Callbacks("once memory").add(function(){W.remove(a,[b+"queue",c])})})}}),r.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.length<c?r.queue(this[0],a):void 0===b?this:this.each(function(){var c=r.queue(this,a,b);r._queueHooks(this,a),"fx"===a&&"inprogress"!==c[0]&&r.dequeue(this,a)})},dequeue:function(a){return this.each(function(){r.dequeue(this,a)})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,b){var c,d=1,e=r.Deferred(),f=this,g=this.length,h=function(){--d||e.resolveWith(f,[f])};"string"!=typeof a&&(b=a,a=void 0),a=a||"fx";while(g--)c=W.get(f[g],a+"queueHooks"),c&&c.empty&&(d++,c.empty.add(h));return h(),e.promise(b)}});var aa=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,ba=new RegExp("^(?:([+-])=|)("+aa+")([a-z%]*)$","i"),ca=["Top","Right","Bottom","Left"],da=function(a,b){return a=b||a,"none"===a.style.display||""===a.style.display&&r.contains(a.ownerDocument,a)&&"none"===r.css(a,"display")},ea=function(a,b,c,d){var e,f,g={};for(f in b)g[f]=a.style[f],a.style[f]=b[f];e=c.apply(a,d||[]);for(f in b)a.style[f]=g[f];return e};function fa(a,b,c,d){var e,f=1,g=20,h=d?function(){return d.cur()}:function(){return r.css(a,b,"")},i=h(),j=c&&c[3]||(r.cssNumber[b]?"":"px"),k=(r.cssNumber[b]||"px"!==j&&+i)&&ba.exec(r.css(a,b));if(k&&k[3]!==j){j=j||k[3],c=c||[],k=+i||1;do f=f||".5",k/=f,r.style(a,b,k+j);while(f!==(f=h()/i)&&1!==f&&--g)}return c&&(k=+k||+i||0,e=c[1]?k+(c[1]+1)*c[2]:+c[2],d&&(d.unit=j,d.start=k,d.end=e)),e}var ga={};function ha(a){var b,c=a.ownerDocument,d=a.nodeName,e=ga[d];return e?e:(b=c.body.appendChild(c.createElement(d)),e=r.css(b,"display"),b.parentNode.removeChild(b),"none"===e&&(e="block"),ga[d]=e,e)}function ia(a,b){for(var c,d,e=[],f=0,g=a.length;f<g;f++)d=a[f],d.style&&(c=d.style.display,b?("none"===c&&(e[f]=W.get(d,"display")||null,e[f]||(d.style.display="")),""===d.style.display&&da(d)&&(e[f]=ha(d))):"none"!==c&&(e[f]="none",W.set(d,"display",c)));for(f=0;f<g;f++)null!=e[f]&&(a[f].style.display=e[f]);return a}r.fn.extend({show:function(){return ia(this,!0)},hide:function(){return ia(this)},toggle:function(a){return"boolean"==typeof a?a?this.show():this.hide():this.each(function(){da(this)?r(this).show():r(this).hide()})}});var ja=/^(?:checkbox|radio)$/i,ka=/<([a-z][^\/\0>\x20\t\r\n\f]+)/i,la=/^$|\/(?:java|ecma)script/i,ma={option:[1,"<select multiple='multiple'>","</select>"],thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};ma.optgroup=ma.option,ma.tbody=ma.tfoot=ma.colgroup=ma.caption=ma.thead,ma.th=ma.td;function na(a,b){var c;return c="undefined"!=typeof a.getElementsByTagName?a.getElementsByTagName(b||"*"):"undefined"!=typeof a.querySelectorAll?a.querySelectorAll(b||"*"):[],void 0===b||b&&B(a,b)?r.merge([a],c):c}function oa(a,b){for(var c=0,d=a.length;c<d;c++)W.set(a[c],"globalEval",!b||W.get(b[c],"globalEval"))}var pa=/<|&#?\w+;/;function qa(a,b,c,d,e){for(var f,g,h,i,j,k,l=b.createDocumentFragment(),m=[],n=0,o=a.length;n<o;n++)if(f=a[n],f||0===f)if("object"===r.type(f))r.merge(m,f.nodeType?[f]:f);else if(pa.test(f)){g=g||l.appendChild(b.createElement("div")),h=(ka.exec(f)||["",""])[1].toLowerCase(),i=ma[h]||ma._default,g.innerHTML=i[1]+r.htmlPrefilter(f)+i[2],k=i[0];while(k--)g=g.lastChild;r.merge(m,g.childNodes),g=l.firstChild,g.textContent=""}else m.push(b.createTextNode(f));l.textContent="",n=0;while(f=m[n++])if(d&&r.inArray(f,d)>-1)e&&e.push(f);else if(j=r.contains(f.ownerDocument,f),g=na(l.appendChild(f),"script"),j&&oa(g),c){k=0;while(f=g[k++])la.test(f.type||"")&&c.push(f)}return l}!function(){var a=d.createDocumentFragment(),b=a.appendChild(d.createElement("div")),c=d.createElement("input");c.setAttribute("type","radio"),c.setAttribute("checked","checked"),c.setAttribute("name","t"),b.appendChild(c),o.checkClone=b.cloneNode(!0).cloneNode(!0).lastChild.checked,b.innerHTML="<textarea>x</textarea>",o.noCloneChecked=!!b.cloneNode(!0).lastChild.defaultValue}();var ra=d.documentElement,sa=/^key/,ta=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,ua=/^([^.]*)(?:\.(.+)|)/;function va(){return!0}function wa(){return!1}function xa(){try{return d.activeElement}catch(a){}}function ya(a,b,c,d,e,f){var g,h;if("object"==typeof b){"string"!=typeof c&&(d=d||c,c=void 0);for(h in b)ya(a,h,c,d,b[h],f);return a}if(null==d&&null==e?(e=c,d=c=void 0):null==e&&("string"==typeof c?(e=d,d=void 0):(e=d,d=c,c=void 0)),e===!1)e=wa;else if(!e)return a;return 1===f&&(g=e,e=function(a){return r().off(a),g.apply(this,arguments)},e.guid=g.guid||(g.guid=r.guid++)),a.each(function(){r.event.add(this,b,e,d,c)})}r.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,p,q=W.get(a);if(q){c.handler&&(f=c,c=f.handler,e=f.selector),e&&r.find.matchesSelector(ra,e),c.guid||(c.guid=r.guid++),(i=q.events)||(i=q.events={}),(g=q.handle)||(g=q.handle=function(b){return"undefined"!=typeof r&&r.event.triggered!==b.type?r.event.dispatch.apply(a,arguments):void 0}),b=(b||"").match(L)||[""],j=b.length;while(j--)h=ua.exec(b[j])||[],n=p=h[1],o=(h[2]||"").split(".").sort(),n&&(l=r.event.special[n]||{},n=(e?l.delegateType:l.bindType)||n,l=r.event.special[n]||{},k=r.extend({type:n,origType:p,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&r.expr.match.needsContext.test(e),namespace:o.join(".")},f),(m=i[n])||(m=i[n]=[],m.delegateCount=0,l.setup&&l.setup.call(a,d,o,g)!==!1||a.addEventListener&&a.addEventListener(n,g)),l.add&&(l.add.call(a,k),k.handler.guid||(k.handler.guid=c.guid)),e?m.splice(m.delegateCount++,0,k):m.push(k),r.event.global[n]=!0)}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,p,q=W.hasData(a)&&W.get(a);if(q&&(i=q.events)){b=(b||"").match(L)||[""],j=b.length;while(j--)if(h=ua.exec(b[j])||[],n=p=h[1],o=(h[2]||"").split(".").sort(),n){l=r.event.special[n]||{},n=(d?l.delegateType:l.bindType)||n,m=i[n]||[],h=h[2]&&new RegExp("(^|\\.)"+o.join("\\.(?:.*\\.|)")+"(\\.|$)"),g=f=m.length;while(f--)k=m[f],!e&&p!==k.origType||c&&c.guid!==k.guid||h&&!h.test(k.namespace)||d&&d!==k.selector&&("**"!==d||!k.selector)||(m.splice(f,1),k.selector&&m.delegateCount--,l.remove&&l.remove.call(a,k));g&&!m.length&&(l.teardown&&l.teardown.call(a,o,q.handle)!==!1||r.removeEvent(a,n,q.handle),delete i[n])}else for(n in i)r.event.remove(a,n+b[j],c,d,!0);r.isEmptyObject(i)&&W.remove(a,"handle events")}},dispatch:function(a){var b=r.event.fix(a),c,d,e,f,g,h,i=new Array(arguments.length),j=(W.get(this,"events")||{})[b.type]||[],k=r.event.special[b.type]||{};for(i[0]=b,c=1;c<arguments.length;c++)i[c]=arguments[c];if(b.delegateTarget=this,!k.preDispatch||k.preDispatch.call(this,b)!==!1){h=r.event.handlers.call(this,b,j),c=0;while((f=h[c++])&&!b.isPropagationStopped()){b.currentTarget=f.elem,d=0;while((g=f.handlers[d++])&&!b.isImmediatePropagationStopped())b.rnamespace&&!b.rnamespace.test(g.namespace)||(b.handleObj=g,b.data=g.data,e=((r.event.special[g.origType]||{}).handle||g.handler).apply(f.elem,i),void 0!==e&&(b.result=e)===!1&&(b.preventDefault(),b.stopPropagation()))}return k.postDispatch&&k.postDispatch.call(this,b),b.result}},handlers:function(a,b){var c,d,e,f,g,h=[],i=b.delegateCount,j=a.target;if(i&&j.nodeType&&!("click"===a.type&&a.button>=1))for(;j!==this;j=j.parentNode||this)if(1===j.nodeType&&("click"!==a.type||j.disabled!==!0)){for(f=[],g={},c=0;c<i;c++)d=b[c],e=d.selector+" ",void 0===g[e]&&(g[e]=d.needsContext?r(e,this).index(j)>-1:r.find(e,this,null,[j]).length),g[e]&&f.push(d);f.length&&h.push({elem:j,handlers:f})}return j=this,i<b.length&&h.push({elem:j,handlers:b.slice(i)}),h},addProp:function(a,b){Object.defineProperty(r.Event.prototype,a,{enumerable:!0,configurable:!0,get:r.isFunction(b)?function(){if(this.originalEvent)return b(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[a]},set:function(b){Object.defineProperty(this,a,{enumerable:!0,configurable:!0,writable:!0,value:b})}})},fix:function(a){return a[r.expando]?a:new r.Event(a)},special:{load:{noBubble:!0},focus:{trigger:function(){if(this!==xa()&&this.focus)return this.focus(),!1},delegateType:"focusin"},blur:{trigger:function(){if(this===xa()&&this.blur)return this.blur(),!1},delegateType:"focusout"},click:{trigger:function(){if("checkbox"===this.type&&this.click&&B(this,"input"))return this.click(),!1},_default:function(a){return B(a.target,"a")}},beforeunload:{postDispatch:function(a){void 0!==a.result&&a.originalEvent&&(a.originalEvent.returnValue=a.result)}}}},r.removeEvent=function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c)},r.Event=function(a,b){return this instanceof r.Event?(a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||void 0===a.defaultPrevented&&a.returnValue===!1?va:wa,this.target=a.target&&3===a.target.nodeType?a.target.parentNode:a.target,this.currentTarget=a.currentTarget,this.relatedTarget=a.relatedTarget):this.type=a,b&&r.extend(this,b),this.timeStamp=a&&a.timeStamp||r.now(),void(this[r.expando]=!0)):new r.Event(a,b)},r.Event.prototype={constructor:r.Event,isDefaultPrevented:wa,isPropagationStopped:wa,isImmediatePropagationStopped:wa,isSimulated:!1,preventDefault:function(){var a=this.originalEvent;this.isDefaultPrevented=va,a&&!this.isSimulated&&a.preventDefault()},stopPropagation:function(){var a=this.originalEvent;this.isPropagationStopped=va,a&&!this.isSimulated&&a.stopPropagation()},stopImmediatePropagation:function(){var a=this.originalEvent;this.isImmediatePropagationStopped=va,a&&!this.isSimulated&&a.stopImmediatePropagation(),this.stopPropagation()}},r.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(a){var b=a.button;return null==a.which&&sa.test(a.type)?null!=a.charCode?a.charCode:a.keyCode:!a.which&&void 0!==b&&ta.test(a.type)?1&b?1:2&b?3:4&b?2:0:a.which}},r.event.addProp),r.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(a,b){r.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj;return e&&(e===d||r.contains(d,e))||(a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b),c}}}),r.fn.extend({on:function(a,b,c,d){return ya(this,a,b,c,d)},one:function(a,b,c,d){return ya(this,a,b,c,d,1)},off:function(a,b,c){var d,e;if(a&&a.preventDefault&&a.handleObj)return d=a.handleObj,r(a.delegateTarget).off(d.namespace?d.origType+"."+d.namespace:d.origType,d.selector,d.handler),this;if("object"==typeof a){for(e in a)this.off(e,b,a[e]);return this}return b!==!1&&"function"!=typeof b||(c=b,b=void 0),c===!1&&(c=wa),this.each(function(){r.event.remove(this,a,c,b)})}});var za=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,Aa=/<script|<style|<link/i,Ba=/checked\s*(?:[^=]|=\s*.checked.)/i,Ca=/^true\/(.*)/,Da=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function Ea(a,b){return B(a,"table")&&B(11!==b.nodeType?b:b.firstChild,"tr")?r(">tbody",a)[0]||a:a}function Fa(a){return a.type=(null!==a.getAttribute("type"))+"/"+a.type,a}function Ga(a){var b=Ca.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function Ha(a,b){var c,d,e,f,g,h,i,j;if(1===b.nodeType){if(W.hasData(a)&&(f=W.access(a),g=W.set(b,f),j=f.events)){delete g.handle,g.events={};for(e in j)for(c=0,d=j[e].length;c<d;c++)r.event.add(b,e,j[e][c])}X.hasData(a)&&(h=X.access(a),i=r.extend({},h),X.set(b,i))}}function Ia(a,b){var c=b.nodeName.toLowerCase();"input"===c&&ja.test(a.type)?b.checked=a.checked:"input"!==c&&"textarea"!==c||(b.defaultValue=a.defaultValue)}function Ja(a,b,c,d){b=g.apply([],b);var e,f,h,i,j,k,l=0,m=a.length,n=m-1,q=b[0],s=r.isFunction(q);if(s||m>1&&"string"==typeof q&&!o.checkClone&&Ba.test(q))return a.each(function(e){var f=a.eq(e);s&&(b[0]=q.call(this,e,f.html())),Ja(f,b,c,d)});if(m&&(e=qa(b,a[0].ownerDocument,!1,a,d),f=e.firstChild,1===e.childNodes.length&&(e=f),f||d)){for(h=r.map(na(e,"script"),Fa),i=h.length;l<m;l++)j=e,l!==n&&(j=r.clone(j,!0,!0),i&&r.merge(h,na(j,"script"))),c.call(a[l],j,l);if(i)for(k=h[h.length-1].ownerDocument,r.map(h,Ga),l=0;l<i;l++)j=h[l],la.test(j.type||"")&&!W.access(j,"globalEval")&&r.contains(k,j)&&(j.src?r._evalUrl&&r._evalUrl(j.src):p(j.textContent.replace(Da,""),k))}return a}function Ka(a,b,c){for(var d,e=b?r.filter(b,a):a,f=0;null!=(d=e[f]);f++)c||1!==d.nodeType||r.cleanData(na(d)),d.parentNode&&(c&&r.contains(d.ownerDocument,d)&&oa(na(d,"script")),d.parentNode.removeChild(d));return a}r.extend({htmlPrefilter:function(a){return a.replace(za,"<$1></$2>")},clone:function(a,b,c){var d,e,f,g,h=a.cloneNode(!0),i=r.contains(a.ownerDocument,a);if(!(o.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||r.isXMLDoc(a)))for(g=na(h),f=na(a),d=0,e=f.length;d<e;d++)Ia(f[d],g[d]);if(b)if(c)for(f=f||na(a),g=g||na(h),d=0,e=f.length;d<e;d++)Ha(f[d],g[d]);else Ha(a,h);return g=na(h,"script"),g.length>0&&oa(g,!i&&na(a,"script")),h},cleanData:function(a){for(var b,c,d,e=r.event.special,f=0;void 0!==(c=a[f]);f++)if(U(c)){if(b=c[W.expando]){if(b.events)for(d in b.events)e[d]?r.event.remove(c,d):r.removeEvent(c,d,b.handle);c[W.expando]=void 0}c[X.expando]&&(c[X.expando]=void 0)}}}),r.fn.extend({detach:function(a){return Ka(this,a,!0)},remove:function(a){return Ka(this,a)},text:function(a){return T(this,function(a){return void 0===a?r.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=a)})},null,a,arguments.length)},append:function(){return Ja(this,arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=Ea(this,a);b.appendChild(a)}})},prepend:function(){return Ja(this,arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=Ea(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return Ja(this,arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return Ja(this,arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},empty:function(){for(var a,b=0;null!=(a=this[b]);b++)1===a.nodeType&&(r.cleanData(na(a,!1)),a.textContent="");return this},clone:function(a,b){return a=null!=a&&a,b=null==b?a:b,this.map(function(){return r.clone(this,a,b)})},html:function(a){return T(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a&&1===b.nodeType)return b.innerHTML;if("string"==typeof a&&!Aa.test(a)&&!ma[(ka.exec(a)||["",""])[1].toLowerCase()]){a=r.htmlPrefilter(a);try{for(;c<d;c++)b=this[c]||{},1===b.nodeType&&(r.cleanData(na(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=[];return Ja(this,arguments,function(b){var c=this.parentNode;r.inArray(this,a)<0&&(r.cleanData(na(this)),c&&c.replaceChild(b,this))},a)}}),r.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){r.fn[a]=function(a){for(var c,d=[],e=r(a),f=e.length-1,g=0;g<=f;g++)c=g===f?this:this.clone(!0),r(e[g])[b](c),h.apply(d,c.get());return this.pushStack(d)}});var La=/^margin/,Ma=new RegExp("^("+aa+")(?!px)[a-z%]+$","i"),Na=function(b){var c=b.ownerDocument.defaultView;return c&&c.opener||(c=a),c.getComputedStyle(b)};!function(){function b(){if(i){i.style.cssText="box-sizing:border-box;position:relative;display:block;margin:auto;border:1px;padding:1px;top:1%;width:50%",i.innerHTML="",ra.appendChild(h);var b=a.getComputedStyle(i);c="1%"!==b.top,g="2px"===b.marginLeft,e="4px"===b.width,i.style.marginRight="50%",f="4px"===b.marginRight,ra.removeChild(h),i=null}}var c,e,f,g,h=d.createElement("div"),i=d.createElement("div");i.style&&(i.style.backgroundClip="content-box",i.cloneNode(!0).style.backgroundClip="",o.clearCloneStyle="content-box"===i.style.backgroundClip,h.style.cssText="border:0;width:8px;height:0;top:0;left:-9999px;padding:0;margin-top:1px;position:absolute",h.appendChild(i),r.extend(o,{pixelPosition:function(){return b(),c},boxSizingReliable:function(){return b(),e},pixelMarginRight:function(){return b(),f},reliableMarginLeft:function(){return b(),g}}))}();function Oa(a,b,c){var d,e,f,g,h=a.style;return c=c||Na(a),c&&(g=c.getPropertyValue(b)||c[b],""!==g||r.contains(a.ownerDocument,a)||(g=r.style(a,b)),!o.pixelMarginRight()&&Ma.test(g)&&La.test(b)&&(d=h.width,e=h.minWidth,f=h.maxWidth,h.minWidth=h.maxWidth=h.width=g,g=c.width,h.width=d,h.minWidth=e,h.maxWidth=f)),void 0!==g?g+"":g}function Pa(a,b){return{get:function(){return a()?void delete this.get:(this.get=b).apply(this,arguments)}}}var Qa=/^(none|table(?!-c[ea]).+)/,Ra=/^--/,Sa={position:"absolute",visibility:"hidden",display:"block"},Ta={letterSpacing:"0",fontWeight:"400"},Ua=["Webkit","Moz","ms"],Va=d.createElement("div").style;function Wa(a){if(a in Va)return a;var b=a[0].toUpperCase()+a.slice(1),c=Ua.length;while(c--)if(a=Ua[c]+b,a in Va)return a}function Xa(a){var b=r.cssProps[a];return b||(b=r.cssProps[a]=Wa(a)||a),b}function Ya(a,b,c){var d=ba.exec(b);return d?Math.max(0,d[2]-(c||0))+(d[3]||"px"):b}function Za(a,b,c,d,e){var f,g=0;for(f=c===(d?"border":"content")?4:"width"===b?1:0;f<4;f+=2)"margin"===c&&(g+=r.css(a,c+ca[f],!0,e)),d?("content"===c&&(g-=r.css(a,"padding"+ca[f],!0,e)),"margin"!==c&&(g-=r.css(a,"border"+ca[f]+"Width",!0,e))):(g+=r.css(a,"padding"+ca[f],!0,e),"padding"!==c&&(g+=r.css(a,"border"+ca[f]+"Width",!0,e)));return g}function $a(a,b,c){var d,e=Na(a),f=Oa(a,b,e),g="border-box"===r.css(a,"boxSizing",!1,e);return Ma.test(f)?f:(d=g&&(o.boxSizingReliable()||f===a.style[b]),"auto"===f&&(f=a["offset"+b[0].toUpperCase()+b.slice(1)]),f=parseFloat(f)||0,f+Za(a,b,c||(g?"border":"content"),d,e)+"px")}r.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=Oa(a,"opacity");return""===c?"1":c}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":"cssFloat"},style:function(a,b,c,d){if(a&&3!==a.nodeType&&8!==a.nodeType&&a.style){var e,f,g,h=r.camelCase(b),i=Ra.test(b),j=a.style;return i||(b=Xa(h)),g=r.cssHooks[b]||r.cssHooks[h],void 0===c?g&&"get"in g&&void 0!==(e=g.get(a,!1,d))?e:j[b]:(f=typeof c,"string"===f&&(e=ba.exec(c))&&e[1]&&(c=fa(a,b,e),f="number"),null!=c&&c===c&&("number"===f&&(c+=e&&e[3]||(r.cssNumber[h]?"":"px")),o.clearCloneStyle||""!==c||0!==b.indexOf("background")||(j[b]="inherit"),g&&"set"in g&&void 0===(c=g.set(a,c,d))||(i?j.setProperty(b,c):j[b]=c)),void 0)}},css:function(a,b,c,d){var e,f,g,h=r.camelCase(b),i=Ra.test(b);return i||(b=Xa(h)),g=r.cssHooks[b]||r.cssHooks[h],g&&"get"in g&&(e=g.get(a,!0,c)),void 0===e&&(e=Oa(a,b,d)),"normal"===e&&b in Ta&&(e=Ta[b]),""===c||c?(f=parseFloat(e),c===!0||isFinite(f)?f||0:e):e}}),r.each(["height","width"],function(a,b){r.cssHooks[b]={get:function(a,c,d){if(c)return!Qa.test(r.css(a,"display"))||a.getClientRects().length&&a.getBoundingClientRect().width?$a(a,b,d):ea(a,Sa,function(){return $a(a,b,d)})},set:function(a,c,d){var e,f=d&&Na(a),g=d&&Za(a,b,d,"border-box"===r.css(a,"boxSizing",!1,f),f);return g&&(e=ba.exec(c))&&"px"!==(e[3]||"px")&&(a.style[b]=c,c=r.css(a,b)),Ya(a,c,g)}}}),r.cssHooks.marginLeft=Pa(o.reliableMarginLeft,function(a,b){if(b)return(parseFloat(Oa(a,"marginLeft"))||a.getBoundingClientRect().left-ea(a,{marginLeft:0},function(){return a.getBoundingClientRect().left}))+"px"}),r.each({margin:"",padding:"",border:"Width"},function(a,b){r.cssHooks[a+b]={expand:function(c){for(var d=0,e={},f="string"==typeof c?c.split(" "):[c];d<4;d++)e[a+ca[d]+b]=f[d]||f[d-2]||f[0];return e}},La.test(a)||(r.cssHooks[a+b].set=Ya)}),r.fn.extend({css:function(a,b){return T(this,function(a,b,c){var d,e,f={},g=0;if(Array.isArray(b)){for(d=Na(a),e=b.length;g<e;g++)f[b[g]]=r.css(a,b[g],!1,d);return f}return void 0!==c?r.style(a,b,c):r.css(a,b)},a,b,arguments.length>1)}});function _a(a,b,c,d,e){return new _a.prototype.init(a,b,c,d,e)}r.Tween=_a,_a.prototype={constructor:_a,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||r.easing._default,this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(r.cssNumber[c]?"":"px")},cur:function(){var a=_a.propHooks[this.prop];return a&&a.get?a.get(this):_a.propHooks._default.get(this)},run:function(a){var b,c=_a.propHooks[this.prop];return this.options.duration?this.pos=b=r.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):this.pos=b=a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):_a.propHooks._default.set(this),this}},_a.prototype.init.prototype=_a.prototype,_a.propHooks={_default:{get:function(a){var b;return 1!==a.elem.nodeType||null!=a.elem[a.prop]&&null==a.elem.style[a.prop]?a.elem[a.prop]:(b=r.css(a.elem,a.prop,""),b&&"auto"!==b?b:0)},set:function(a){r.fx.step[a.prop]?r.fx.step[a.prop](a):1!==a.elem.nodeType||null==a.elem.style[r.cssProps[a.prop]]&&!r.cssHooks[a.prop]?a.elem[a.prop]=a.now:r.style(a.elem,a.prop,a.now+a.unit)}}},_a.propHooks.scrollTop=_a.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},r.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2},_default:"swing"},r.fx=_a.prototype.init,r.fx.step={};var ab,bb,cb=/^(?:toggle|show|hide)$/,db=/queueHooks$/;function eb(){bb&&(d.hidden===!1&&a.requestAnimationFrame?a.requestAnimationFrame(eb):a.setTimeout(eb,r.fx.interval),r.fx.tick())}function fb(){return a.setTimeout(function(){ab=void 0}),ab=r.now()}function gb(a,b){var c,d=0,e={height:a};for(b=b?1:0;d<4;d+=2-b)c=ca[d],e["margin"+c]=e["padding"+c]=a;return b&&(e.opacity=e.width=a),e}function hb(a,b,c){for(var d,e=(kb.tweeners[b]||[]).concat(kb.tweeners["*"]),f=0,g=e.length;f<g;f++)if(d=e[f].call(c,b,a))return d}function ib(a,b,c){var d,e,f,g,h,i,j,k,l="width"in b||"height"in b,m=this,n={},o=a.style,p=a.nodeType&&da(a),q=W.get(a,"fxshow");c.queue||(g=r._queueHooks(a,"fx"),null==g.unqueued&&(g.unqueued=0,h=g.empty.fire,g.empty.fire=function(){g.unqueued||h()}),g.unqueued++,m.always(function(){m.always(function(){g.unqueued--,r.queue(a,"fx").length||g.empty.fire()})}));for(d in b)if(e=b[d],cb.test(e)){if(delete b[d],f=f||"toggle"===e,e===(p?"hide":"show")){if("show"!==e||!q||void 0===q[d])continue;p=!0}n[d]=q&&q[d]||r.style(a,d)}if(i=!r.isEmptyObject(b),i||!r.isEmptyObject(n)){l&&1===a.nodeType&&(c.overflow=[o.overflow,o.overflowX,o.overflowY],j=q&&q.display,null==j&&(j=W.get(a,"display")),k=r.css(a,"display"),"none"===k&&(j?k=j:(ia([a],!0),j=a.style.display||j,k=r.css(a,"display"),ia([a]))),("inline"===k||"inline-block"===k&&null!=j)&&"none"===r.css(a,"float")&&(i||(m.done(function(){o.display=j}),null==j&&(k=o.display,j="none"===k?"":k)),o.display="inline-block")),c.overflow&&(o.overflow="hidden",m.always(function(){o.overflow=c.overflow[0],o.overflowX=c.overflow[1],o.overflowY=c.overflow[2]})),i=!1;for(d in n)i||(q?"hidden"in q&&(p=q.hidden):q=W.access(a,"fxshow",{display:j}),f&&(q.hidden=!p),p&&ia([a],!0),m.done(function(){p||ia([a]),W.remove(a,"fxshow");for(d in n)r.style(a,d,n[d])})),i=hb(p?q[d]:0,d,m),d in q||(q[d]=i.start,p&&(i.end=i.start,i.start=0))}}function jb(a,b){var c,d,e,f,g;for(c in a)if(d=r.camelCase(c),e=b[d],f=a[c],Array.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=r.cssHooks[d],g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}function kb(a,b,c){var d,e,f=0,g=kb.prefilters.length,h=r.Deferred().always(function(){delete i.elem}),i=function(){if(e)return!1;for(var b=ab||fb(),c=Math.max(0,j.startTime+j.duration-b),d=c/j.duration||0,f=1-d,g=0,i=j.tweens.length;g<i;g++)j.tweens[g].run(f);return h.notifyWith(a,[j,f,c]),f<1&&i?c:(i||h.notifyWith(a,[j,1,0]),h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:r.extend({},b),opts:r.extend(!0,{specialEasing:{},easing:r.easing._default},c),originalProperties:b,originalOptions:c,startTime:ab||fb(),duration:c.duration,tweens:[],createTween:function(b,c){var d=r.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(d),d},stop:function(b){var c=0,d=b?j.tweens.length:0;if(e)return this;for(e=!0;c<d;c++)j.tweens[c].run(1);return b?(h.notifyWith(a,[j,1,0]),h.resolveWith(a,[j,b])):h.rejectWith(a,[j,b]),this}}),k=j.props;for(jb(k,j.opts.specialEasing);f<g;f++)if(d=kb.prefilters[f].call(j,a,k,j.opts))return r.isFunction(d.stop)&&(r._queueHooks(j.elem,j.opts.queue).stop=r.proxy(d.stop,d)),d;return r.map(k,hb,j),r.isFunction(j.opts.start)&&j.opts.start.call(a,j),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always),r.fx.timer(r.extend(i,{elem:a,anim:j,queue:j.opts.queue})),j}r.Animation=r.extend(kb,{tweeners:{"*":[function(a,b){var c=this.createTween(a,b);return fa(c.elem,a,ba.exec(b),c),c}]},tweener:function(a,b){r.isFunction(a)?(b=a,a=["*"]):a=a.match(L);for(var c,d=0,e=a.length;d<e;d++)c=a[d],kb.tweeners[c]=kb.tweeners[c]||[],kb.tweeners[c].unshift(b)},prefilters:[ib],prefilter:function(a,b){b?kb.prefilters.unshift(a):kb.prefilters.push(a)}}),r.speed=function(a,b,c){var d=a&&"object"==typeof a?r.extend({},a):{complete:c||!c&&b||r.isFunction(a)&&a,duration:a,easing:c&&b||b&&!r.isFunction(b)&&b};return r.fx.off?d.duration=0:"number"!=typeof d.duration&&(d.duration in r.fx.speeds?d.duration=r.fx.speeds[d.duration]:d.duration=r.fx.speeds._default),null!=d.queue&&d.queue!==!0||(d.queue="fx"),d.old=d.complete,d.complete=function(){r.isFunction(d.old)&&d.old.call(this),d.queue&&r.dequeue(this,d.queue)},d},r.fn.extend({fadeTo:function(a,b,c,d){return this.filter(da).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=r.isEmptyObject(a),f=r.speed(b,c,d),g=function(){var b=kb(this,r.extend({},a),f);(e||W.get(this,"finish"))&&b.stop(!0)};return g.finish=g,e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,b,c){var d=function(a){var b=a.stop;delete a.stop,b(c)};return"string"!=typeof a&&(c=b,b=a,a=void 0),b&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,e=null!=a&&a+"queueHooks",f=r.timers,g=W.get(this);if(e)g[e]&&g[e].stop&&d(g[e]);else for(e in g)g[e]&&g[e].stop&&db.test(e)&&d(g[e]);for(e=f.length;e--;)f[e].elem!==this||null!=a&&f[e].queue!==a||(f[e].anim.stop(c),b=!1,f.splice(e,1));!b&&c||r.dequeue(this,a)})},finish:function(a){return a!==!1&&(a=a||"fx"),this.each(function(){var b,c=W.get(this),d=c[a+"queue"],e=c[a+"queueHooks"],f=r.timers,g=d?d.length:0;for(c.finish=!0,r.queue(this,a,[]),e&&e.stop&&e.stop.call(this,!0),b=f.length;b--;)f[b].elem===this&&f[b].queue===a&&(f[b].anim.stop(!0),f.splice(b,1));for(b=0;b<g;b++)d[b]&&d[b].finish&&d[b].finish.call(this);delete c.finish})}}),r.each(["toggle","show","hide"],function(a,b){var c=r.fn[b];r.fn[b]=function(a,d,e){return null==a||"boolean"==typeof a?c.apply(this,arguments):this.animate(gb(b,!0),a,d,e)}}),r.each({slideDown:gb("show"),slideUp:gb("hide"),slideToggle:gb("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){r.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),r.timers=[],r.fx.tick=function(){var a,b=0,c=r.timers;for(ab=r.now();b<c.length;b++)a=c[b],a()||c[b]!==a||c.splice(b--,1);c.length||r.fx.stop(),ab=void 0},r.fx.timer=function(a){r.timers.push(a),r.fx.start()},r.fx.interval=13,r.fx.start=function(){bb||(bb=!0,eb())},r.fx.stop=function(){bb=null},r.fx.speeds={slow:600,fast:200,_default:400},r.fn.delay=function(b,c){return b=r.fx?r.fx.speeds[b]||b:b,c=c||"fx",this.queue(c,function(c,d){var e=a.setTimeout(c,b);d.stop=function(){a.clearTimeout(e)}})},function(){var a=d.createElement("input"),b=d.createElement("select"),c=b.appendChild(d.createElement("option"));a.type="checkbox",o.checkOn=""!==a.value,o.optSelected=c.selected,a=d.createElement("input"),a.value="t",a.type="radio",o.radioValue="t"===a.value}();var lb,mb=r.expr.attrHandle;r.fn.extend({attr:function(a,b){return T(this,r.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){r.removeAttr(this,a)})}}),r.extend({attr:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return"undefined"==typeof a.getAttribute?r.prop(a,b,c):(1===f&&r.isXMLDoc(a)||(e=r.attrHooks[b.toLowerCase()]||(r.expr.match.bool.test(b)?lb:void 0)),void 0!==c?null===c?void r.removeAttr(a,b):e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:(a.setAttribute(b,c+""),c):e&&"get"in e&&null!==(d=e.get(a,b))?d:(d=r.find.attr(a,b),
10−null==d?void 0:d))},attrHooks:{type:{set:function(a,b){if(!o.radioValue&&"radio"===b&&B(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}}},removeAttr:function(a,b){var c,d=0,e=b&&b.match(L);if(e&&1===a.nodeType)while(c=e[d++])a.removeAttribute(c)}}),lb={set:function(a,b,c){return b===!1?r.removeAttr(a,c):a.setAttribute(c,c),c}},r.each(r.expr.match.bool.source.match(/\w+/g),function(a,b){var c=mb[b]||r.find.attr;mb[b]=function(a,b,d){var e,f,g=b.toLowerCase();return d||(f=mb[g],mb[g]=e,e=null!=c(a,b,d)?g:null,mb[g]=f),e}});var nb=/^(?:input|select|textarea|button)$/i,ob=/^(?:a|area)$/i;r.fn.extend({prop:function(a,b){return T(this,r.prop,a,b,arguments.length>1)},removeProp:function(a){return this.each(function(){delete this[r.propFix[a]||a]})}}),r.extend({prop:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return 1===f&&r.isXMLDoc(a)||(b=r.propFix[b]||b,e=r.propHooks[b]),void 0!==c?e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:a[b]=c:e&&"get"in e&&null!==(d=e.get(a,b))?d:a[b]},propHooks:{tabIndex:{get:function(a){var b=r.find.attr(a,"tabindex");return b?parseInt(b,10):nb.test(a.nodeName)||ob.test(a.nodeName)&&a.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),o.optSelected||(r.propHooks.selected={get:function(a){var b=a.parentNode;return b&&b.parentNode&&b.parentNode.selectedIndex,null},set:function(a){var b=a.parentNode;b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex)}}),r.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){r.propFix[this.toLowerCase()]=this});function pb(a){var b=a.match(L)||[];return b.join(" ")}function qb(a){return a.getAttribute&&a.getAttribute("class")||""}r.fn.extend({addClass:function(a){var b,c,d,e,f,g,h,i=0;if(r.isFunction(a))return this.each(function(b){r(this).addClass(a.call(this,b,qb(this)))});if("string"==typeof a&&a){b=a.match(L)||[];while(c=this[i++])if(e=qb(c),d=1===c.nodeType&&" "+pb(e)+" "){g=0;while(f=b[g++])d.indexOf(" "+f+" ")<0&&(d+=f+" ");h=pb(d),e!==h&&c.setAttribute("class",h)}}return this},removeClass:function(a){var b,c,d,e,f,g,h,i=0;if(r.isFunction(a))return this.each(function(b){r(this).removeClass(a.call(this,b,qb(this)))});if(!arguments.length)return this.attr("class","");if("string"==typeof a&&a){b=a.match(L)||[];while(c=this[i++])if(e=qb(c),d=1===c.nodeType&&" "+pb(e)+" "){g=0;while(f=b[g++])while(d.indexOf(" "+f+" ")>-1)d=d.replace(" "+f+" "," ");h=pb(d),e!==h&&c.setAttribute("class",h)}}return this},toggleClass:function(a,b){var c=typeof a;return"boolean"==typeof b&&"string"===c?b?this.addClass(a):this.removeClass(a):r.isFunction(a)?this.each(function(c){r(this).toggleClass(a.call(this,c,qb(this),b),b)}):this.each(function(){var b,d,e,f;if("string"===c){d=0,e=r(this),f=a.match(L)||[];while(b=f[d++])e.hasClass(b)?e.removeClass(b):e.addClass(b)}else void 0!==a&&"boolean"!==c||(b=qb(this),b&&W.set(this,"__className__",b),this.setAttribute&&this.setAttribute("class",b||a===!1?"":W.get(this,"__className__")||""))})},hasClass:function(a){var b,c,d=0;b=" "+a+" ";while(c=this[d++])if(1===c.nodeType&&(" "+pb(qb(c))+" ").indexOf(b)>-1)return!0;return!1}});var rb=/\r/g;r.fn.extend({val:function(a){var b,c,d,e=this[0];{if(arguments.length)return d=r.isFunction(a),this.each(function(c){var e;1===this.nodeType&&(e=d?a.call(this,c,r(this).val()):a,null==e?e="":"number"==typeof e?e+="":Array.isArray(e)&&(e=r.map(e,function(a){return null==a?"":a+""})),b=r.valHooks[this.type]||r.valHooks[this.nodeName.toLowerCase()],b&&"set"in b&&void 0!==b.set(this,e,"value")||(this.value=e))});if(e)return b=r.valHooks[e.type]||r.valHooks[e.nodeName.toLowerCase()],b&&"get"in b&&void 0!==(c=b.get(e,"value"))?c:(c=e.value,"string"==typeof c?c.replace(rb,""):null==c?"":c)}}}),r.extend({valHooks:{option:{get:function(a){var b=r.find.attr(a,"value");return null!=b?b:pb(r.text(a))}},select:{get:function(a){var b,c,d,e=a.options,f=a.selectedIndex,g="select-one"===a.type,h=g?null:[],i=g?f+1:e.length;for(d=f<0?i:g?f:0;d<i;d++)if(c=e[d],(c.selected||d===f)&&!c.disabled&&(!c.parentNode.disabled||!B(c.parentNode,"optgroup"))){if(b=r(c).val(),g)return b;h.push(b)}return h},set:function(a,b){var c,d,e=a.options,f=r.makeArray(b),g=e.length;while(g--)d=e[g],(d.selected=r.inArray(r.valHooks.option.get(d),f)>-1)&&(c=!0);return c||(a.selectedIndex=-1),f}}}}),r.each(["radio","checkbox"],function(){r.valHooks[this]={set:function(a,b){if(Array.isArray(b))return a.checked=r.inArray(r(a).val(),b)>-1}},o.checkOn||(r.valHooks[this].get=function(a){return null===a.getAttribute("value")?"on":a.value})});var sb=/^(?:focusinfocus|focusoutblur)$/;r.extend(r.event,{trigger:function(b,c,e,f){var g,h,i,j,k,m,n,o=[e||d],p=l.call(b,"type")?b.type:b,q=l.call(b,"namespace")?b.namespace.split("."):[];if(h=i=e=e||d,3!==e.nodeType&&8!==e.nodeType&&!sb.test(p+r.event.triggered)&&(p.indexOf(".")>-1&&(q=p.split("."),p=q.shift(),q.sort()),k=p.indexOf(":")<0&&"on"+p,b=b[r.expando]?b:new r.Event(p,"object"==typeof b&&b),b.isTrigger=f?2:3,b.namespace=q.join("."),b.rnamespace=b.namespace?new RegExp("(^|\\.)"+q.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=e),c=null==c?[b]:r.makeArray(c,[b]),n=r.event.special[p]||{},f||!n.trigger||n.trigger.apply(e,c)!==!1)){if(!f&&!n.noBubble&&!r.isWindow(e)){for(j=n.delegateType||p,sb.test(j+p)||(h=h.parentNode);h;h=h.parentNode)o.push(h),i=h;i===(e.ownerDocument||d)&&o.push(i.defaultView||i.parentWindow||a)}g=0;while((h=o[g++])&&!b.isPropagationStopped())b.type=g>1?j:n.bindType||p,m=(W.get(h,"events")||{})[b.type]&&W.get(h,"handle"),m&&m.apply(h,c),m=k&&h[k],m&&m.apply&&U(h)&&(b.result=m.apply(h,c),b.result===!1&&b.preventDefault());return b.type=p,f||b.isDefaultPrevented()||n._default&&n._default.apply(o.pop(),c)!==!1||!U(e)||k&&r.isFunction(e[p])&&!r.isWindow(e)&&(i=e[k],i&&(e[k]=null),r.event.triggered=p,e[p](),r.event.triggered=void 0,i&&(e[k]=i)),b.result}},simulate:function(a,b,c){var d=r.extend(new r.Event,c,{type:a,isSimulated:!0});r.event.trigger(d,null,b)}}),r.fn.extend({trigger:function(a,b){return this.each(function(){r.event.trigger(a,b,this)})},triggerHandler:function(a,b){var c=this[0];if(c)return r.event.trigger(a,b,c,!0)}}),r.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(a,b){r.fn[b]=function(a,c){return arguments.length>0?this.on(b,null,a,c):this.trigger(b)}}),r.fn.extend({hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}}),o.focusin="onfocusin"in a,o.focusin||r.each({focus:"focusin",blur:"focusout"},function(a,b){var c=function(a){r.event.simulate(b,a.target,r.event.fix(a))};r.event.special[b]={setup:function(){var d=this.ownerDocument||this,e=W.access(d,b);e||d.addEventListener(a,c,!0),W.access(d,b,(e||0)+1)},teardown:function(){var d=this.ownerDocument||this,e=W.access(d,b)-1;e?W.access(d,b,e):(d.removeEventListener(a,c,!0),W.remove(d,b))}}});var tb=a.location,ub=r.now(),vb=/\?/;r.parseXML=function(b){var c;if(!b||"string"!=typeof b)return null;try{c=(new a.DOMParser).parseFromString(b,"text/xml")}catch(d){c=void 0}return c&&!c.getElementsByTagName("parsererror").length||r.error("Invalid XML: "+b),c};var wb=/\[\]$/,xb=/\r?\n/g,yb=/^(?:submit|button|image|reset|file)$/i,zb=/^(?:input|select|textarea|keygen)/i;function Ab(a,b,c,d){var e;if(Array.isArray(b))r.each(b,function(b,e){c||wb.test(a)?d(a,e):Ab(a+"["+("object"==typeof e&&null!=e?b:"")+"]",e,c,d)});else if(c||"object"!==r.type(b))d(a,b);else for(e in b)Ab(a+"["+e+"]",b[e],c,d)}r.param=function(a,b){var c,d=[],e=function(a,b){var c=r.isFunction(b)?b():b;d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(null==c?"":c)};if(Array.isArray(a)||a.jquery&&!r.isPlainObject(a))r.each(a,function(){e(this.name,this.value)});else for(c in a)Ab(c,a[c],b,e);return d.join("&")},r.fn.extend({serialize:function(){return r.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var a=r.prop(this,"elements");return a?r.makeArray(a):this}).filter(function(){var a=this.type;return this.name&&!r(this).is(":disabled")&&zb.test(this.nodeName)&&!yb.test(a)&&(this.checked||!ja.test(a))}).map(function(a,b){var c=r(this).val();return null==c?null:Array.isArray(c)?r.map(c,function(a){return{name:b.name,value:a.replace(xb,"\r\n")}}):{name:b.name,value:c.replace(xb,"\r\n")}}).get()}});var Bb=/%20/g,Cb=/#.*$/,Db=/([?&])_=[^&]*/,Eb=/^(.*?):[ \t]*([^\r\n]*)$/gm,Fb=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Gb=/^(?:GET|HEAD)$/,Hb=/^\/\//,Ib={},Jb={},Kb="*/".concat("*"),Lb=d.createElement("a");Lb.href=tb.href;function Mb(a){return function(b,c){"string"!=typeof b&&(c=b,b="*");var d,e=0,f=b.toLowerCase().match(L)||[];if(r.isFunction(c))while(d=f[e++])"+"===d[0]?(d=d.slice(1)||"*",(a[d]=a[d]||[]).unshift(c)):(a[d]=a[d]||[]).push(c)}}function Nb(a,b,c,d){var e={},f=a===Jb;function g(h){var i;return e[h]=!0,r.each(a[h]||[],function(a,h){var j=h(b,c,d);return"string"!=typeof j||f||e[j]?f?!(i=j):void 0:(b.dataTypes.unshift(j),g(j),!1)}),i}return g(b.dataTypes[0])||!e["*"]&&g("*")}function Ob(a,b){var c,d,e=r.ajaxSettings.flatOptions||{};for(c in b)void 0!==b[c]&&((e[c]?a:d||(d={}))[c]=b[c]);return d&&r.extend(!0,a,d),a}function Pb(a,b,c){var d,e,f,g,h=a.contents,i=a.dataTypes;while("*"===i[0])i.shift(),void 0===d&&(d=a.mimeType||b.getResponseHeader("Content-Type"));if(d)for(e in h)if(h[e]&&h[e].test(d)){i.unshift(e);break}if(i[0]in c)f=i[0];else{for(e in c){if(!i[0]||a.converters[e+" "+i[0]]){f=e;break}g||(g=e)}f=f||g}if(f)return f!==i[0]&&i.unshift(f),c[f]}function Qb(a,b,c,d){var e,f,g,h,i,j={},k=a.dataTypes.slice();if(k[1])for(g in a.converters)j[g.toLowerCase()]=a.converters[g];f=k.shift();while(f)if(a.responseFields[f]&&(c[a.responseFields[f]]=b),!i&&d&&a.dataFilter&&(b=a.dataFilter(b,a.dataType)),i=f,f=k.shift())if("*"===f)f=i;else if("*"!==i&&i!==f){if(g=j[i+" "+f]||j["* "+f],!g)for(e in j)if(h=e.split(" "),h[1]===f&&(g=j[i+" "+h[0]]||j["* "+h[0]])){g===!0?g=j[e]:j[e]!==!0&&(f=h[0],k.unshift(h[1]));break}if(g!==!0)if(g&&a["throws"])b=g(b);else try{b=g(b)}catch(l){return{state:"parsererror",error:g?l:"No conversion from "+i+" to "+f}}}return{state:"success",data:b}}r.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:tb.href,type:"GET",isLocal:Fb.test(tb.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Kb,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":r.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(a,b){return b?Ob(Ob(a,r.ajaxSettings),b):Ob(r.ajaxSettings,a)},ajaxPrefilter:Mb(Ib),ajaxTransport:Mb(Jb),ajax:function(b,c){"object"==typeof b&&(c=b,b=void 0),c=c||{};var e,f,g,h,i,j,k,l,m,n,o=r.ajaxSetup({},c),p=o.context||o,q=o.context&&(p.nodeType||p.jquery)?r(p):r.event,s=r.Deferred(),t=r.Callbacks("once memory"),u=o.statusCode||{},v={},w={},x="canceled",y={readyState:0,getResponseHeader:function(a){var b;if(k){if(!h){h={};while(b=Eb.exec(g))h[b[1].toLowerCase()]=b[2]}b=h[a.toLowerCase()]}return null==b?null:b},getAllResponseHeaders:function(){return k?g:null},setRequestHeader:function(a,b){return null==k&&(a=w[a.toLowerCase()]=w[a.toLowerCase()]||a,v[a]=b),this},overrideMimeType:function(a){return null==k&&(o.mimeType=a),this},statusCode:function(a){var b;if(a)if(k)y.always(a[y.status]);else for(b in a)u[b]=[u[b],a[b]];return this},abort:function(a){var b=a||x;return e&&e.abort(b),A(0,b),this}};if(s.promise(y),o.url=((b||o.url||tb.href)+"").replace(Hb,tb.protocol+"//"),o.type=c.method||c.type||o.method||o.type,o.dataTypes=(o.dataType||"*").toLowerCase().match(L)||[""],null==o.crossDomain){j=d.createElement("a");try{j.href=o.url,j.href=j.href,o.crossDomain=Lb.protocol+"//"+Lb.host!=j.protocol+"//"+j.host}catch(z){o.crossDomain=!0}}if(o.data&&o.processData&&"string"!=typeof o.data&&(o.data=r.param(o.data,o.traditional)),Nb(Ib,o,c,y),k)return y;l=r.event&&o.global,l&&0===r.active++&&r.event.trigger("ajaxStart"),o.type=o.type.toUpperCase(),o.hasContent=!Gb.test(o.type),f=o.url.replace(Cb,""),o.hasContent?o.data&&o.processData&&0===(o.contentType||"").indexOf("application/x-www-form-urlencoded")&&(o.data=o.data.replace(Bb,"+")):(n=o.url.slice(f.length),o.data&&(f+=(vb.test(f)?"&":"?")+o.data,delete o.data),o.cache===!1&&(f=f.replace(Db,"$1"),n=(vb.test(f)?"&":"?")+"_="+ub++ +n),o.url=f+n),o.ifModified&&(r.lastModified[f]&&y.setRequestHeader("If-Modified-Since",r.lastModified[f]),r.etag[f]&&y.setRequestHeader("If-None-Match",r.etag[f])),(o.data&&o.hasContent&&o.contentType!==!1||c.contentType)&&y.setRequestHeader("Content-Type",o.contentType),y.setRequestHeader("Accept",o.dataTypes[0]&&o.accepts[o.dataTypes[0]]?o.accepts[o.dataTypes[0]]+("*"!==o.dataTypes[0]?", "+Kb+"; q=0.01":""):o.accepts["*"]);for(m in o.headers)y.setRequestHeader(m,o.headers[m]);if(o.beforeSend&&(o.beforeSend.call(p,y,o)===!1||k))return y.abort();if(x="abort",t.add(o.complete),y.done(o.success),y.fail(o.error),e=Nb(Jb,o,c,y)){if(y.readyState=1,l&&q.trigger("ajaxSend",[y,o]),k)return y;o.async&&o.timeout>0&&(i=a.setTimeout(function(){y.abort("timeout")},o.timeout));try{k=!1,e.send(v,A)}catch(z){if(k)throw z;A(-1,z)}}else A(-1,"No Transport");function A(b,c,d,h){var j,m,n,v,w,x=c;k||(k=!0,i&&a.clearTimeout(i),e=void 0,g=h||"",y.readyState=b>0?4:0,j=b>=200&&b<300||304===b,d&&(v=Pb(o,y,d)),v=Qb(o,v,y,j),j?(o.ifModified&&(w=y.getResponseHeader("Last-Modified"),w&&(r.lastModified[f]=w),w=y.getResponseHeader("etag"),w&&(r.etag[f]=w)),204===b||"HEAD"===o.type?x="nocontent":304===b?x="notmodified":(x=v.state,m=v.data,n=v.error,j=!n)):(n=x,!b&&x||(x="error",b<0&&(b=0))),y.status=b,y.statusText=(c||x)+"",j?s.resolveWith(p,[m,x,y]):s.rejectWith(p,[y,x,n]),y.statusCode(u),u=void 0,l&&q.trigger(j?"ajaxSuccess":"ajaxError",[y,o,j?m:n]),t.fireWith(p,[y,x]),l&&(q.trigger("ajaxComplete",[y,o]),--r.active||r.event.trigger("ajaxStop")))}return y},getJSON:function(a,b,c){return r.get(a,b,c,"json")},getScript:function(a,b){return r.get(a,void 0,b,"script")}}),r.each(["get","post"],function(a,b){r[b]=function(a,c,d,e){return r.isFunction(c)&&(e=e||d,d=c,c=void 0),r.ajax(r.extend({url:a,type:b,dataType:e,data:c,success:d},r.isPlainObject(a)&&a))}}),r._evalUrl=function(a){return r.ajax({url:a,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,"throws":!0})},r.fn.extend({wrapAll:function(a){var b;return this[0]&&(r.isFunction(a)&&(a=a.call(this[0])),b=r(a,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstElementChild)a=a.firstElementChild;return a}).append(this)),this},wrapInner:function(a){return r.isFunction(a)?this.each(function(b){r(this).wrapInner(a.call(this,b))}):this.each(function(){var b=r(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=r.isFunction(a);return this.each(function(c){r(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(a){return this.parent(a).not("body").each(function(){r(this).replaceWith(this.childNodes)}),this}}),r.expr.pseudos.hidden=function(a){return!r.expr.pseudos.visible(a)},r.expr.pseudos.visible=function(a){return!!(a.offsetWidth||a.offsetHeight||a.getClientRects().length)},r.ajaxSettings.xhr=function(){try{return new a.XMLHttpRequest}catch(b){}};var Rb={0:200,1223:204},Sb=r.ajaxSettings.xhr();o.cors=!!Sb&&"withCredentials"in Sb,o.ajax=Sb=!!Sb,r.ajaxTransport(function(b){var c,d;if(o.cors||Sb&&!b.crossDomain)return{send:function(e,f){var g,h=b.xhr();if(h.open(b.type,b.url,b.async,b.username,b.password),b.xhrFields)for(g in b.xhrFields)h[g]=b.xhrFields[g];b.mimeType&&h.overrideMimeType&&h.overrideMimeType(b.mimeType),b.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest");for(g in e)h.setRequestHeader(g,e[g]);c=function(a){return function(){c&&(c=d=h.onload=h.onerror=h.onabort=h.onreadystatechange=null,"abort"===a?h.abort():"error"===a?"number"!=typeof h.status?f(0,"error"):f(h.status,h.statusText):f(Rb[h.status]||h.status,h.statusText,"text"!==(h.responseType||"text")||"string"!=typeof h.responseText?{binary:h.response}:{text:h.responseText},h.getAllResponseHeaders()))}},h.onload=c(),d=h.onerror=c("error"),void 0!==h.onabort?h.onabort=d:h.onreadystatechange=function(){4===h.readyState&&a.setTimeout(function(){c&&d()})},c=c("abort");try{h.send(b.hasContent&&b.data||null)}catch(i){if(c)throw i}},abort:function(){c&&c()}}}),r.ajaxPrefilter(function(a){a.crossDomain&&(a.contents.script=!1)}),r.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(a){return r.globalEval(a),a}}}),r.ajaxPrefilter("script",function(a){void 0===a.cache&&(a.cache=!1),a.crossDomain&&(a.type="GET")}),r.ajaxTransport("script",function(a){if(a.crossDomain){var b,c;return{send:function(e,f){b=r("<script>").prop({charset:a.scriptCharset,src:a.url}).on("load error",c=function(a){b.remove(),c=null,a&&f("error"===a.type?404:200,a.type)}),d.head.appendChild(b[0])},abort:function(){c&&c()}}}});var Tb=[],Ub=/(=)\?(?=&|$)|\?\?/;r.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=Tb.pop()||r.expando+"_"+ub++;return this[a]=!0,a}}),r.ajaxPrefilter("json jsonp",function(b,c,d){var e,f,g,h=b.jsonp!==!1&&(Ub.test(b.url)?"url":"string"==typeof b.data&&0===(b.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ub.test(b.data)&&"data");if(h||"jsonp"===b.dataTypes[0])return e=b.jsonpCallback=r.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,h?b[h]=b[h].replace(Ub,"$1"+e):b.jsonp!==!1&&(b.url+=(vb.test(b.url)?"&":"?")+b.jsonp+"="+e),b.converters["script json"]=function(){return g||r.error(e+" was not called"),g[0]},b.dataTypes[0]="json",f=a[e],a[e]=function(){g=arguments},d.always(function(){void 0===f?r(a).removeProp(e):a[e]=f,b[e]&&(b.jsonpCallback=c.jsonpCallback,Tb.push(e)),g&&r.isFunction(f)&&f(g[0]),g=f=void 0}),"script"}),o.createHTMLDocument=function(){var a=d.implementation.createHTMLDocument("").body;return a.innerHTML="<form></form><form></form>",2===a.childNodes.length}(),r.parseHTML=function(a,b,c){if("string"!=typeof a)return[];"boolean"==typeof b&&(c=b,b=!1);var e,f,g;return b||(o.createHTMLDocument?(b=d.implementation.createHTMLDocument(""),e=b.createElement("base"),e.href=d.location.href,b.head.appendChild(e)):b=d),f=C.exec(a),g=!c&&[],f?[b.createElement(f[1])]:(f=qa([a],b,g),g&&g.length&&r(g).remove(),r.merge([],f.childNodes))},r.fn.load=function(a,b,c){var d,e,f,g=this,h=a.indexOf(" ");return h>-1&&(d=pb(a.slice(h)),a=a.slice(0,h)),r.isFunction(b)?(c=b,b=void 0):b&&"object"==typeof b&&(e="POST"),g.length>0&&r.ajax({url:a,type:e||"GET",dataType:"html",data:b}).done(function(a){f=arguments,g.html(d?r("<div>").append(r.parseHTML(a)).find(d):a)}).always(c&&function(a,b){g.each(function(){c.apply(this,f||[a.responseText,b,a])})}),this},r.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(a,b){r.fn[b]=function(a){return this.on(b,a)}}),r.expr.pseudos.animated=function(a){return r.grep(r.timers,function(b){return a===b.elem}).length},r.offset={setOffset:function(a,b,c){var d,e,f,g,h,i,j,k=r.css(a,"position"),l=r(a),m={};"static"===k&&(a.style.position="relative"),h=l.offset(),f=r.css(a,"top"),i=r.css(a,"left"),j=("absolute"===k||"fixed"===k)&&(f+i).indexOf("auto")>-1,j?(d=l.position(),g=d.top,e=d.left):(g=parseFloat(f)||0,e=parseFloat(i)||0),r.isFunction(b)&&(b=b.call(a,c,r.extend({},h))),null!=b.top&&(m.top=b.top-h.top+g),null!=b.left&&(m.left=b.left-h.left+e),"using"in b?b.using.call(a,m):l.css(m)}},r.fn.extend({offset:function(a){if(arguments.length)return void 0===a?this:this.each(function(b){r.offset.setOffset(this,a,b)});var b,c,d,e,f=this[0];if(f)return f.getClientRects().length?(d=f.getBoundingClientRect(),b=f.ownerDocument,c=b.documentElement,e=b.defaultView,{top:d.top+e.pageYOffset-c.clientTop,left:d.left+e.pageXOffset-c.clientLeft}):{top:0,left:0}},position:function(){if(this[0]){var a,b,c=this[0],d={top:0,left:0};return"fixed"===r.css(c,"position")?b=c.getBoundingClientRect():(a=this.offsetParent(),b=this.offset(),B(a[0],"html")||(d=a.offset()),d={top:d.top+r.css(a[0],"borderTopWidth",!0),left:d.left+r.css(a[0],"borderLeftWidth",!0)}),{top:b.top-d.top-r.css(c,"marginTop",!0),left:b.left-d.left-r.css(c,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var a=this.offsetParent;while(a&&"static"===r.css(a,"position"))a=a.offsetParent;return a||ra})}}),r.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,b){var c="pageYOffset"===b;r.fn[a]=function(d){return T(this,function(a,d,e){var f;return r.isWindow(a)?f=a:9===a.nodeType&&(f=a.defaultView),void 0===e?f?f[b]:a[d]:void(f?f.scrollTo(c?f.pageXOffset:e,c?e:f.pageYOffset):a[d]=e)},a,d,arguments.length)}}),r.each(["top","left"],function(a,b){r.cssHooks[b]=Pa(o.pixelPosition,function(a,c){if(c)return c=Oa(a,b),Ma.test(c)?r(a).position()[b]+"px":c})}),r.each({Height:"height",Width:"width"},function(a,b){r.each({padding:"inner"+a,content:b,"":"outer"+a},function(c,d){r.fn[d]=function(e,f){var g=arguments.length&&(c||"boolean"!=typeof e),h=c||(e===!0||f===!0?"margin":"border");return T(this,function(b,c,e){var f;return r.isWindow(b)?0===d.indexOf("outer")?b["inner"+a]:b.document.documentElement["client"+a]:9===b.nodeType?(f=b.documentElement,Math.max(b.body["scroll"+a],f["scroll"+a],b.body["offset"+a],f["offset"+a],f["client"+a])):void 0===e?r.css(b,c,h):r.style(b,c,e,h)},b,g?e:void 0,g)}})}),r.fn.extend({bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return 1===arguments.length?this.off(a,"**"):this.off(b,a||"**",c)}}),r.holdReady=function(a){a?r.readyWait++:r.ready(!0)},r.isArray=Array.isArray,r.parseJSON=JSON.parse,r.nodeName=B,"function"==typeof define&&define.amd&&define("jquery",[],function(){return r});var Vb=a.jQuery,Wb=a.$;return r.noConflict=function(b){return a.$===r&&(a.$=Wb),b&&a.jQuery===r&&(a.jQuery=Vb),r},b||(a.jQuery=a.$=r),r});
11−
12− </script>
13− <script language="javascript" type="text/javascript">
14− /* Javascript plotting library for jQuery, version 0.8.3.
15−
16−Copyright (c) 2007-2014 IOLA and Ole Laursen.
17−Licensed under the MIT license.
18−
19−*/
20−(function($){$.color={};$.color.make=function(r,g,b,a){var o={};o.r=r||0;o.g=g||0;o.b=b||0;o.a=a!=null?a:1;o.add=function(c,d){for(var i=0;i<c.length;++i)o[c.charAt(i)]+=d;return o.normalize()};o.scale=function(c,f){for(var i=0;i<c.length;++i)o[c.charAt(i)]*=f;return o.normalize()};o.toString=function(){if(o.a>=1){return"rgb("+[o.r,o.g,o.b].join(",")+")"}else{return"rgba("+[o.r,o.g,o.b,o.a].join(",")+")"}};o.normalize=function(){function clamp(min,value,max){return value<min?min:value>max?max:value}o.r=clamp(0,parseInt(o.r),255);o.g=clamp(0,parseInt(o.g),255);o.b=clamp(0,parseInt(o.b),255);o.a=clamp(0,o.a,1);return o};o.clone=function(){return $.color.make(o.r,o.b,o.g,o.a)};return o.normalize()};$.color.extract=function(elem,css){var c;do{c=elem.css(css).toLowerCase();if(c!=""&&c!="transparent")break;elem=elem.parent()}while(elem.length&&!$.nodeName(elem.get(0),"body"));if(c=="rgba(0, 0, 0, 0)")c="transparent";return $.color.parse(c)};$.color.parse=function(str){var res,m=$.color.make;if(res=/rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(str))return m(parseInt(res[1],10),parseInt(res[2],10),parseInt(res[3],10));if(res=/rgba\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]+(?:\.[0-9]+)?)\s*\)/.exec(str))return m(parseInt(res[1],10),parseInt(res[2],10),parseInt(res[3],10),parseFloat(res[4]));if(res=/rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(str))return m(parseFloat(res[1])*2.55,parseFloat(res[2])*2.55,parseFloat(res[3])*2.55);if(res=/rgba\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\s*\)/.exec(str))return m(parseFloat(res[1])*2.55,parseFloat(res[2])*2.55,parseFloat(res[3])*2.55,parseFloat(res[4]));if(res=/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(str))return m(parseInt(res[1],16),parseInt(res[2],16),parseInt(res[3],16));if(res=/#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(str))return m(parseInt(res[1]+res[1],16),parseInt(res[2]+res[2],16),parseInt(res[3]+res[3],16));var name=$.trim(str).toLowerCase();if(name=="transparent")return m(255,255,255,0);else{res=lookupColors[name]||[0,0,0];return m(res[0],res[1],res[2])}};var lookupColors={aqua:[0,255,255],azure:[240,255,255],beige:[245,245,220],black:[0,0,0],blue:[0,0,255],brown:[165,42,42],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgrey:[169,169,169],darkgreen:[0,100,0],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkviolet:[148,0,211],fuchsia:[255,0,255],gold:[255,215,0],green:[0,128,0],indigo:[75,0,130],khaki:[240,230,140],lightblue:[173,216,230],lightcyan:[224,255,255],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightyellow:[255,255,224],lime:[0,255,0],magenta:[255,0,255],maroon:[128,0,0],navy:[0,0,128],olive:[128,128,0],orange:[255,165,0],pink:[255,192,203],purple:[128,0,128],violet:[128,0,128],red:[255,0,0],silver:[192,192,192],white:[255,255,255],yellow:[255,255,0]}})(jQuery);(function($){var hasOwnProperty=Object.prototype.hasOwnProperty;if(!$.fn.detach){$.fn.detach=function(){return this.each(function(){if(this.parentNode){this.parentNode.removeChild(this)}})}}function Canvas(cls,container){var element=container.children("."+cls)[0];if(element==null){element=document.createElement("canvas");element.className=cls;$(element).css({direction:"ltr",position:"absolute",left:0,top:0}).appendTo(container);if(!element.getContext){if(window.G_vmlCanvasManager){element=window.G_vmlCanvasManager.initElement(element)}else{throw new Error("Canvas is not available. If you're using IE with a fall-back such as Excanvas, then there's either a mistake in your conditional include, or the page has no DOCTYPE and is rendering in Quirks Mode.")}}}this.element=element;var context=this.context=element.getContext("2d");var devicePixelRatio=window.devicePixelRatio||1,backingStoreRatio=context.webkitBackingStorePixelRatio||context.mozBackingStorePixelRatio||context.msBackingStorePixelRatio||context.oBackingStorePixelRatio||context.backingStorePixelRatio||1;this.pixelRatio=devicePixelRatio/backingStoreRatio;this.resize(container.width(),container.height());this.textContainer=null;this.text={};this._textCache={}}Canvas.prototype.resize=function(width,height){if(width<=0||height<=0){throw new Error("Invalid dimensions for plot, width = "+width+", height = "+height)}var element=this.element,context=this.context,pixelRatio=this.pixelRatio;if(this.width!=width){element.width=width*pixelRatio;element.style.width=width+"px";this.width=width}if(this.height!=height){element.height=height*pixelRatio;element.style.height=height+"px";this.height=height}context.restore();context.save();context.scale(pixelRatio,pixelRatio)};Canvas.prototype.clear=function(){this.context.clearRect(0,0,this.width,this.height)};Canvas.prototype.render=function(){var cache=this._textCache;for(var layerKey in cache){if(hasOwnProperty.call(cache,layerKey)){var layer=this.getTextLayer(layerKey),layerCache=cache[layerKey];layer.hide();for(var styleKey in layerCache){if(hasOwnProperty.call(layerCache,styleKey)){var styleCache=layerCache[styleKey];for(var key in styleCache){if(hasOwnProperty.call(styleCache,key)){var positions=styleCache[key].positions;for(var i=0,position;position=positions[i];i++){if(position.active){if(!position.rendered){layer.append(position.element);position.rendered=true}}else{positions.splice(i--,1);if(position.rendered){position.element.detach()}}}if(positions.length==0){delete styleCache[key]}}}}}layer.show()}}};Canvas.prototype.getTextLayer=function(classes){var layer=this.text[classes];if(layer==null){if(this.textContainer==null){this.textContainer=$("<div class='flot-text'></div>").css({position:"absolute",top:0,left:0,bottom:0,right:0,"font-size":"smaller",color:"#545454"}).insertAfter(this.element)}layer=this.text[classes]=$("<div></div>").addClass(classes).css({position:"absolute",top:0,left:0,bottom:0,right:0}).appendTo(this.textContainer)}return layer};Canvas.prototype.getTextInfo=function(layer,text,font,angle,width){var textStyle,layerCache,styleCache,info;text=""+text;if(typeof font==="object"){textStyle=font.style+" "+font.variant+" "+font.weight+" "+font.size+"px/"+font.lineHeight+"px "+font.family}else{textStyle=font}layerCache=this._textCache[layer];if(layerCache==null){layerCache=this._textCache[layer]={}}styleCache=layerCache[textStyle];if(styleCache==null){styleCache=layerCache[textStyle]={}}info=styleCache[text];if(info==null){var element=$("<div></div>").html(text).css({position:"absolute","max-width":width,top:-9999}).appendTo(this.getTextLayer(layer));if(typeof font==="object"){element.css({font:textStyle,color:font.color})}else if(typeof font==="string"){element.addClass(font)}info=styleCache[text]={width:element.outerWidth(true),height:element.outerHeight(true),element:element,positions:[]};element.detach()}return info};Canvas.prototype.addText=function(layer,x,y,text,font,angle,width,halign,valign){var info=this.getTextInfo(layer,text,font,angle,width),positions=info.positions;if(halign=="center"){x-=info.width/2}else if(halign=="right"){x-=info.width}if(valign=="middle"){y-=info.height/2}else if(valign=="bottom"){y-=info.height}for(var i=0,position;position=positions[i];i++){if(position.x==x&&position.y==y){position.active=true;return}}position={active:true,rendered:false,element:positions.length?info.element.clone():info.element,x:x,y:y};positions.push(position);position.element.css({top:Math.round(y),left:Math.round(x),"text-align":halign})};Canvas.prototype.removeText=function(layer,x,y,text,font,angle){if(text==null){var layerCache=this._textCache[layer];if(layerCache!=null){for(var styleKey in layerCache){if(hasOwnProperty.call(layerCache,styleKey)){var styleCache=layerCache[styleKey];for(var key in styleCache){if(hasOwnProperty.call(styleCache,key)){var positions=styleCache[key].positions;for(var i=0,position;position=positions[i];i++){position.active=false}}}}}}}else{var positions=this.getTextInfo(layer,text,font,angle).positions;for(var i=0,position;position=positions[i];i++){if(position.x==x&&position.y==y){position.active=false}}}};function Plot(placeholder,data_,options_,plugins){var series=[],options={colors:["#edc240","#afd8f8","#cb4b4b","#4da74d","#9440ed"],legend:{show:true,noColumns:1,labelFormatter:null,labelBoxBorderColor:"#ccc",container:null,position:"ne",margin:5,backgroundColor:null,backgroundOpacity:.85,sorted:null},xaxis:{show:null,position:"bottom",mode:null,font:null,color:null,tickColor:null,transform:null,inverseTransform:null,min:null,max:null,autoscaleMargin:null,ticks:null,tickFormatter:null,labelWidth:null,labelHeight:null,reserveSpace:null,tickLength:null,alignTicksWithAxis:null,tickDecimals:null,tickSize:null,minTickSize:null},yaxis:{autoscaleMargin:.02,position:"left"},xaxes:[],yaxes:[],series:{points:{show:false,radius:3,lineWidth:2,fill:true,fillColor:"#ffffff",symbol:"circle"},lines:{lineWidth:2,fill:false,fillColor:null,steps:false},bars:{show:false,lineWidth:2,barWidth:1,fill:true,fillColor:null,align:"left",horizontal:false,zero:true},shadowSize:3,highlightColor:null},grid:{show:true,aboveData:false,color:"#545454",backgroundColor:null,borderColor:null,tickColor:null,margin:0,labelMargin:5,axisMargin:8,borderWidth:2,minBorderMargin:null,markings:null,markingsColor:"#f4f4f4",markingsLineWidth:2,clickable:false,hoverable:false,autoHighlight:true,mouseActiveRadius:10},interaction:{redrawOverlayInterval:1e3/60},hooks:{}},surface=null,overlay=null,eventHolder=null,ctx=null,octx=null,xaxes=[],yaxes=[],plotOffset={left:0,right:0,top:0,bottom:0},plotWidth=0,plotHeight=0,hooks={processOptions:[],processRawData:[],processDatapoints:[],processOffset:[],drawBackground:[],drawSeries:[],draw:[],bindEvents:[],drawOverlay:[],shutdown:[]},plot=this;plot.setData=setData;plot.setupGrid=setupGrid;plot.draw=draw;plot.getPlaceholder=function(){return placeholder};plot.getCanvas=function(){return surface.element};plot.getPlotOffset=function(){return plotOffset};plot.width=function(){return plotWidth};plot.height=function(){return plotHeight};plot.offset=function(){var o=eventHolder.offset();o.left+=plotOffset.left;o.top+=plotOffset.top;return o};plot.getData=function(){return series};plot.getAxes=function(){var res={},i;$.each(xaxes.concat(yaxes),function(_,axis){if(axis)res[axis.direction+(axis.n!=1?axis.n:"")+"axis"]=axis});return res};plot.getXAxes=function(){return xaxes};plot.getYAxes=function(){return yaxes};plot.c2p=canvasToAxisCoords;plot.p2c=axisToCanvasCoords;plot.getOptions=function(){return options};plot.highlight=highlight;plot.unhighlight=unhighlight;plot.triggerRedrawOverlay=triggerRedrawOverlay;plot.pointOffset=function(point){return{left:parseInt(xaxes[axisNumber(point,"x")-1].p2c(+point.x)+plotOffset.left,10),top:parseInt(yaxes[axisNumber(point,"y")-1].p2c(+point.y)+plotOffset.top,10)}};plot.shutdown=shutdown;plot.destroy=function(){shutdown();placeholder.removeData("plot").empty();series=[];options=null;surface=null;overlay=null;eventHolder=null;ctx=null;octx=null;xaxes=[];yaxes=[];hooks=null;highlights=[];plot=null};plot.resize=function(){var width=placeholder.width(),height=placeholder.height();surface.resize(width,height);overlay.resize(width,height)};plot.hooks=hooks;initPlugins(plot);parseOptions(options_);setupCanvases();setData(data_);setupGrid();draw();bindEvents();function executeHooks(hook,args){args=[plot].concat(args);for(var i=0;i<hook.length;++i)hook[i].apply(this,args)}function initPlugins(){var classes={Canvas:Canvas};for(var i=0;i<plugins.length;++i){var p=plugins[i];p.init(plot,classes);if(p.options)$.extend(true,options,p.options)}}function parseOptions(opts){$.extend(true,options,opts);if(opts&&opts.colors){options.colors=opts.colors}if(options.xaxis.color==null)options.xaxis.color=$.color.parse(options.grid.color).scale("a",.22).toString();if(options.yaxis.color==null)options.yaxis.color=$.color.parse(options.grid.color).scale("a",.22).toString();if(options.xaxis.tickColor==null)options.xaxis.tickColor=options.grid.tickColor||options.xaxis.color;if(options.yaxis.tickColor==null)options.yaxis.tickColor=options.grid.tickColor||options.yaxis.color;if(options.grid.borderColor==null)options.grid.borderColor=options.grid.color;if(options.grid.tickColor==null)options.grid.tickColor=$.color.parse(options.grid.color).scale("a",.22).toString();var i,axisOptions,axisCount,fontSize=placeholder.css("font-size"),fontSizeDefault=fontSize?+fontSize.replace("px",""):13,fontDefaults={style:placeholder.css("font-style"),size:Math.round(.8*fontSizeDefault),variant:placeholder.css("font-variant"),weight:placeholder.css("font-weight"),family:placeholder.css("font-family")};axisCount=options.xaxes.length||1;for(i=0;i<axisCount;++i){axisOptions=options.xaxes[i];if(axisOptions&&!axisOptions.tickColor){axisOptions.tickColor=axisOptions.color}axisOptions=$.extend(true,{},options.xaxis,axisOptions);options.xaxes[i]=axisOptions;if(axisOptions.font){axisOptions.font=$.extend({},fontDefaults,axisOptions.font);if(!axisOptions.font.color){axisOptions.font.color=axisOptions.color}if(!axisOptions.font.lineHeight){axisOptions.font.lineHeight=Math.round(axisOptions.font.size*1.15)}}}axisCount=options.yaxes.length||1;for(i=0;i<axisCount;++i){axisOptions=options.yaxes[i];if(axisOptions&&!axisOptions.tickColor){axisOptions.tickColor=axisOptions.color}axisOptions=$.extend(true,{},options.yaxis,axisOptions);options.yaxes[i]=axisOptions;if(axisOptions.font){axisOptions.font=$.extend({},fontDefaults,axisOptions.font);if(!axisOptions.font.color){axisOptions.font.color=axisOptions.color}if(!axisOptions.font.lineHeight){axisOptions.font.lineHeight=Math.round(axisOptions.font.size*1.15)}}}if(options.xaxis.noTicks&&options.xaxis.ticks==null)options.xaxis.ticks=options.xaxis.noTicks;if(options.yaxis.noTicks&&options.yaxis.ticks==null)options.yaxis.ticks=options.yaxis.noTicks;if(options.x2axis){options.xaxes[1]=$.extend(true,{},options.xaxis,options.x2axis);options.xaxes[1].position="top";if(options.x2axis.min==null){options.xaxes[1].min=null}if(options.x2axis.max==null){options.xaxes[1].max=null}}if(options.y2axis){options.yaxes[1]=$.extend(true,{},options.yaxis,options.y2axis);options.yaxes[1].position="right";if(options.y2axis.min==null){options.yaxes[1].min=null}if(options.y2axis.max==null){options.yaxes[1].max=null}}if(options.grid.coloredAreas)options.grid.markings=options.grid.coloredAreas;if(options.grid.coloredAreasColor)options.grid.markingsColor=options.grid.coloredAreasColor;if(options.lines)$.extend(true,options.series.lines,options.lines);if(options.points)$.extend(true,options.series.points,options.points);if(options.bars)$.extend(true,options.series.bars,options.bars);if(options.shadowSize!=null)options.series.shadowSize=options.shadowSize;if(options.highlightColor!=null)options.series.highlightColor=options.highlightColor;for(i=0;i<options.xaxes.length;++i)getOrCreateAxis(xaxes,i+1).options=options.xaxes[i];for(i=0;i<options.yaxes.length;++i)getOrCreateAxis(yaxes,i+1).options=options.yaxes[i];for(var n in hooks)if(options.hooks[n]&&options.hooks[n].length)hooks[n]=hooks[n].concat(options.hooks[n]);executeHooks(hooks.processOptions,[options])}function setData(d){series=parseData(d);fillInSeriesOptions();processData()}function parseData(d){var res=[];for(var i=0;i<d.length;++i){var s=$.extend(true,{},options.series);if(d[i].data!=null){s.data=d[i].data;delete d[i].data;$.extend(true,s,d[i]);d[i].data=s.data}else s.data=d[i];res.push(s)}return res}function axisNumber(obj,coord){var a=obj[coord+"axis"];if(typeof a=="object")a=a.n;if(typeof a!="number")a=1;return a}function allAxes(){return $.grep(xaxes.concat(yaxes),function(a){return a})}function canvasToAxisCoords(pos){var res={},i,axis;for(i=0;i<xaxes.length;++i){axis=xaxes[i];if(axis&&axis.used)res["x"+axis.n]=axis.c2p(pos.left)}for(i=0;i<yaxes.length;++i){axis=yaxes[i];if(axis&&axis.used)res["y"+axis.n]=axis.c2p(pos.top)}if(res.x1!==undefined)res.x=res.x1;if(res.y1!==undefined)res.y=res.y1;return res}function axisToCanvasCoords(pos){var res={},i,axis,key;for(i=0;i<xaxes.length;++i){axis=xaxes[i];if(axis&&axis.used){key="x"+axis.n;if(pos[key]==null&&axis.n==1)key="x";if(pos[key]!=null){res.left=axis.p2c(pos[key]);break}}}for(i=0;i<yaxes.length;++i){axis=yaxes[i];if(axis&&axis.used){key="y"+axis.n;if(pos[key]==null&&axis.n==1)key="y";if(pos[key]!=null){res.top=axis.p2c(pos[key]);break}}}return res}function getOrCreateAxis(axes,number){if(!axes[number-1])axes[number-1]={n:number,direction:axes==xaxes?"x":"y",options:$.extend(true,{},axes==xaxes?options.xaxis:options.yaxis)};return axes[number-1]}function fillInSeriesOptions(){var neededColors=series.length,maxIndex=-1,i;for(i=0;i<series.length;++i){var sc=series[i].color;if(sc!=null){neededColors--;if(typeof sc=="number"&&sc>maxIndex){maxIndex=sc}}}if(neededColors<=maxIndex){neededColors=maxIndex+1}var c,colors=[],colorPool=options.colors,colorPoolSize=colorPool.length,variation=0;for(i=0;i<neededColors;i++){c=$.color.parse(colorPool[i%colorPoolSize]||"#666");if(i%colorPoolSize==0&&i){if(variation>=0){if(variation<.5){variation=-variation-.2}else variation=0}else variation=-variation}colors[i]=c.scale("rgb",1+variation)}var colori=0,s;for(i=0;i<series.length;++i){s=series[i];if(s.color==null){s.color=colors[colori].toString();++colori}else if(typeof s.color=="number")s.color=colors[s.color].toString();if(s.lines.show==null){var v,show=true;for(v in s)if(s[v]&&s[v].show){show=false;break}if(show)s.lines.show=true}if(s.lines.zero==null){s.lines.zero=!!s.lines.fill}s.xaxis=getOrCreateAxis(xaxes,axisNumber(s,"x"));s.yaxis=getOrCreateAxis(yaxes,axisNumber(s,"y"))}}function processData(){var topSentry=Number.POSITIVE_INFINITY,bottomSentry=Number.NEGATIVE_INFINITY,fakeInfinity=Number.MAX_VALUE,i,j,k,m,length,s,points,ps,x,y,axis,val,f,p,data,format;function updateAxis(axis,min,max){if(min<axis.datamin&&min!=-fakeInfinity)axis.datamin=min;if(max>axis.datamax&&max!=fakeInfinity)axis.datamax=max}$.each(allAxes(),function(_,axis){axis.datamin=topSentry;axis.datamax=bottomSentry;axis.used=false});for(i=0;i<series.length;++i){s=series[i];s.datapoints={points:[]};executeHooks(hooks.processRawData,[s,s.data,s.datapoints])}for(i=0;i<series.length;++i){s=series[i];data=s.data;format=s.datapoints.format;if(!format){format=[];format.push({x:true,number:true,required:true});format.push({y:true,number:true,required:true});if(s.bars.show||s.lines.show&&s.lines.fill){var autoscale=!!(s.bars.show&&s.bars.zero||s.lines.show&&s.lines.zero);format.push({y:true,number:true,required:false,defaultValue:0,autoscale:autoscale});if(s.bars.horizontal){delete format[format.length-1].y;format[format.length-1].x=true}}s.datapoints.format=format}if(s.datapoints.pointsize!=null)continue;s.datapoints.pointsize=format.length;ps=s.datapoints.pointsize;points=s.datapoints.points;var insertSteps=s.lines.show&&s.lines.steps;s.xaxis.used=s.yaxis.used=true;for(j=k=0;j<data.length;++j,k+=ps){p=data[j];var nullify=p==null;if(!nullify){for(m=0;m<ps;++m){val=p[m];f=format[m];if(f){if(f.number&&val!=null){val=+val;if(isNaN(val))val=null;else if(val==Infinity)val=fakeInfinity;else if(val==-Infinity)val=-fakeInfinity}if(val==null){if(f.required)nullify=true;if(f.defaultValue!=null)val=f.defaultValue}}points[k+m]=val}}if(nullify){for(m=0;m<ps;++m){val=points[k+m];if(val!=null){f=format[m];if(f.autoscale!==false){if(f.x){updateAxis(s.xaxis,val,val)}if(f.y){updateAxis(s.yaxis,val,val)}}}points[k+m]=null}}else{if(insertSteps&&k>0&&points[k-ps]!=null&&points[k-ps]!=points[k]&&points[k-ps+1]!=points[k+1]){for(m=0;m<ps;++m)points[k+ps+m]=points[k+m];points[k+1]=points[k-ps+1];k+=ps}}}}for(i=0;i<series.length;++i){s=series[i];executeHooks(hooks.processDatapoints,[s,s.datapoints])}for(i=0;i<series.length;++i){s=series[i];points=s.datapoints.points;ps=s.datapoints.pointsize;format=s.datapoints.format;var xmin=topSentry,ymin=topSentry,xmax=bottomSentry,ymax=bottomSentry;for(j=0;j<points.length;j+=ps){if(points[j]==null)continue;for(m=0;m<ps;++m){val=points[j+m];f=format[m];if(!f||f.autoscale===false||val==fakeInfinity||val==-fakeInfinity)continue;if(f.x){if(val<xmin)xmin=val;if(val>xmax)xmax=val}if(f.y){if(val<ymin)ymin=val;if(val>ymax)ymax=val}}}if(s.bars.show){var delta;switch(s.bars.align){case"left":delta=0;break;case"right":delta=-s.bars.barWidth;break;default:delta=-s.bars.barWidth/2}if(s.bars.horizontal){ymin+=delta;ymax+=delta+s.bars.barWidth}else{xmin+=delta;xmax+=delta+s.bars.barWidth}}updateAxis(s.xaxis,xmin,xmax);updateAxis(s.yaxis,ymin,ymax)}$.each(allAxes(),function(_,axis){if(axis.datamin==topSentry)axis.datamin=null;if(axis.datamax==bottomSentry)axis.datamax=null})}function setupCanvases(){placeholder.css("padding",0).children().filter(function(){return!$(this).hasClass("flot-overlay")&&!$(this).hasClass("flot-base")}).remove();if(placeholder.css("position")=="static")placeholder.css("position","relative");surface=new Canvas("flot-base",placeholder);overlay=new Canvas("flot-overlay",placeholder);ctx=surface.context;octx=overlay.context;eventHolder=$(overlay.element).unbind();var existing=placeholder.data("plot");if(existing){existing.shutdown();overlay.clear()}placeholder.data("plot",plot)}function bindEvents(){if(options.grid.hoverable){eventHolder.mousemove(onMouseMove);eventHolder.bind("mouseleave",onMouseLeave)}if(options.grid.clickable)eventHolder.click(onClick);executeHooks(hooks.bindEvents,[eventHolder])}function shutdown(){if(redrawTimeout)clearTimeout(redrawTimeout);eventHolder.unbind("mousemove",onMouseMove);eventHolder.unbind("mouseleave",onMouseLeave);eventHolder.unbind("click",onClick);executeHooks(hooks.shutdown,[eventHolder])}function setTransformationHelpers(axis){function identity(x){return x}var s,m,t=axis.options.transform||identity,it=axis.options.inverseTransform;if(axis.direction=="x"){s=axis.scale=plotWidth/Math.abs(t(axis.max)-t(axis.min));m=Math.min(t(axis.max),t(axis.min))}else{s=axis.scale=plotHeight/Math.abs(t(axis.max)-t(axis.min));s=-s;m=Math.max(t(axis.max),t(axis.min))}if(t==identity)axis.p2c=function(p){return(p-m)*s};else axis.p2c=function(p){return(t(p)-m)*s};if(!it)axis.c2p=function(c){return m+c/s};else axis.c2p=function(c){return it(m+c/s)}}function measureTickLabels(axis){var opts=axis.options,ticks=axis.ticks||[],labelWidth=opts.labelWidth||0,labelHeight=opts.labelHeight||0,maxWidth=labelWidth||(axis.direction=="x"?Math.floor(surface.width/(ticks.length||1)):null),legacyStyles=axis.direction+"Axis "+axis.direction+axis.n+"Axis",layer="flot-"+axis.direction+"-axis flot-"+axis.direction+axis.n+"-axis "+legacyStyles,font=opts.font||"flot-tick-label tickLabel";for(var i=0;i<ticks.length;++i){var t=ticks[i];if(!t.label)continue;var info=surface.getTextInfo(layer,t.label,font,null,maxWidth);labelWidth=Math.max(labelWidth,info.width);labelHeight=Math.max(labelHeight,info.height)}axis.labelWidth=opts.labelWidth||labelWidth;axis.labelHeight=opts.labelHeight||labelHeight}function allocateAxisBoxFirstPhase(axis){var lw=axis.labelWidth,lh=axis.labelHeight,pos=axis.options.position,isXAxis=axis.direction==="x",tickLength=axis.options.tickLength,axisMargin=options.grid.axisMargin,padding=options.grid.labelMargin,innermost=true,outermost=true,first=true,found=false;$.each(isXAxis?xaxes:yaxes,function(i,a){if(a&&(a.show||a.reserveSpace)){if(a===axis){found=true}else if(a.options.position===pos){if(found){outermost=false}else{innermost=false}}if(!found){first=false}}});if(outermost){axisMargin=0}if(tickLength==null){tickLength=first?"full":5}if(!isNaN(+tickLength))padding+=+tickLength;if(isXAxis){lh+=padding;if(pos=="bottom"){plotOffset.bottom+=lh+axisMargin;axis.box={top:surface.height-plotOffset.bottom,height:lh}}else{axis.box={top:plotOffset.top+axisMargin,height:lh};plotOffset.top+=lh+axisMargin}}else{lw+=padding;if(pos=="left"){axis.box={left:plotOffset.left+axisMargin,width:lw};plotOffset.left+=lw+axisMargin}else{plotOffset.right+=lw+axisMargin;axis.box={left:surface.width-plotOffset.right,width:lw}}}axis.position=pos;axis.tickLength=tickLength;axis.box.padding=padding;axis.innermost=innermost}function allocateAxisBoxSecondPhase(axis){if(axis.direction=="x"){axis.box.left=plotOffset.left-axis.labelWidth/2;axis.box.width=surface.width-plotOffset.left-plotOffset.right+axis.labelWidth}else{axis.box.top=plotOffset.top-axis.labelHeight/2;axis.box.height=surface.height-plotOffset.bottom-plotOffset.top+axis.labelHeight}}function adjustLayoutForThingsStickingOut(){var minMargin=options.grid.minBorderMargin,axis,i;if(minMargin==null){minMargin=0;for(i=0;i<series.length;++i)minMargin=Math.max(minMargin,2*(series[i].points.radius+series[i].points.lineWidth/2))}var margins={left:minMargin,right:minMargin,top:minMargin,bottom:minMargin};$.each(allAxes(),function(_,axis){if(axis.reserveSpace&&axis.ticks&&axis.ticks.length){if(axis.direction==="x"){margins.left=Math.max(margins.left,axis.labelWidth/2);margins.right=Math.max(margins.right,axis.labelWidth/2)}else{margins.bottom=Math.max(margins.bottom,axis.labelHeight/2);margins.top=Math.max(margins.top,axis.labelHeight/2)}}});plotOffset.left=Math.ceil(Math.max(margins.left,plotOffset.left));plotOffset.right=Math.ceil(Math.max(margins.right,plotOffset.right));plotOffset.top=Math.ceil(Math.max(margins.top,plotOffset.top));plotOffset.bottom=Math.ceil(Math.max(margins.bottom,plotOffset.bottom))}function setupGrid(){var i,axes=allAxes(),showGrid=options.grid.show;for(var a in plotOffset){var margin=options.grid.margin||0;plotOffset[a]=typeof margin=="number"?margin:margin[a]||0}executeHooks(hooks.processOffset,[plotOffset]);for(var a in plotOffset){if(typeof options.grid.borderWidth=="object"){plotOffset[a]+=showGrid?options.grid.borderWidth[a]:0}else{plotOffset[a]+=showGrid?options.grid.borderWidth:0}}$.each(axes,function(_,axis){var axisOpts=axis.options;axis.show=axisOpts.show==null?axis.used:axisOpts.show;axis.reserveSpace=axisOpts.reserveSpace==null?axis.show:axisOpts.reserveSpace;setRange(axis)});if(showGrid){var allocatedAxes=$.grep(axes,function(axis){return axis.show||axis.reserveSpace});$.each(allocatedAxes,function(_,axis){setupTickGeneration(axis);setTicks(axis);snapRangeToTicks(axis,axis.ticks);measureTickLabels(axis)});for(i=allocatedAxes.length-1;i>=0;--i)allocateAxisBoxFirstPhase(allocatedAxes[i]);adjustLayoutForThingsStickingOut();$.each(allocatedAxes,function(_,axis){allocateAxisBoxSecondPhase(axis)})}plotWidth=surface.width-plotOffset.left-plotOffset.right;plotHeight=surface.height-plotOffset.bottom-plotOffset.top;$.each(axes,function(_,axis){setTransformationHelpers(axis)});if(showGrid){drawAxisLabels()}insertLegend()}function setRange(axis){var opts=axis.options,min=+(opts.min!=null?opts.min:axis.datamin),max=+(opts.max!=null?opts.max:axis.datamax),delta=max-min;if(delta==0){var widen=max==0?1:.01;if(opts.min==null)min-=widen;if(opts.max==null||opts.min!=null)max+=widen}else{var margin=opts.autoscaleMargin;if(margin!=null){if(opts.min==null){min-=delta*margin;if(min<0&&axis.datamin!=null&&axis.datamin>=0)min=0}if(opts.max==null){max+=delta*margin;if(max>0&&axis.datamax!=null&&axis.datamax<=0)max=0}}}axis.min=min;axis.max=max}function setupTickGeneration(axis){var opts=axis.options;var noTicks;if(typeof opts.ticks=="number"&&opts.ticks>0)noTicks=opts.ticks;else noTicks=.3*Math.sqrt(axis.direction=="x"?surface.width:surface.height);var delta=(axis.max-axis.min)/noTicks,dec=-Math.floor(Math.log(delta)/Math.LN10),maxDec=opts.tickDecimals;if(maxDec!=null&&dec>maxDec){dec=maxDec}var magn=Math.pow(10,-dec),norm=delta/magn,size;if(norm<1.5){size=1}else if(norm<3){size=2;if(norm>2.25&&(maxDec==null||dec+1<=maxDec)){size=2.5;++dec}}else if(norm<7.5){size=5}else{size=10}size*=magn;if(opts.minTickSize!=null&&size<opts.minTickSize){size=opts.minTickSize}axis.delta=delta;axis.tickDecimals=Math.max(0,maxDec!=null?maxDec:dec);axis.tickSize=opts.tickSize||size;if(opts.mode=="time"&&!axis.tickGenerator){throw new Error("Time mode requires the flot.time plugin.")}if(!axis.tickGenerator){axis.tickGenerator=function(axis){var ticks=[],start=floorInBase(axis.min,axis.tickSize),i=0,v=Number.NaN,prev;do{prev=v;v=start+i*axis.tickSize;ticks.push(v);++i}while(v<axis.max&&v!=prev);return ticks};axis.tickFormatter=function(value,axis){var factor=axis.tickDecimals?Math.pow(10,axis.tickDecimals):1;var formatted=""+Math.round(value*factor)/factor;if(axis.tickDecimals!=null){var decimal=formatted.indexOf(".");var precision=decimal==-1?0:formatted.length-decimal-1;if(precision<axis.tickDecimals){return(precision?formatted:formatted+".")+(""+factor).substr(1,axis.tickDecimals-precision)}}return formatted}}if($.isFunction(opts.tickFormatter))axis.tickFormatter=function(v,axis){return""+opts.tickFormatter(v,axis)};if(opts.alignTicksWithAxis!=null){var otherAxis=(axis.direction=="x"?xaxes:yaxes)[opts.alignTicksWithAxis-1];if(otherAxis&&otherAxis.used&&otherAxis!=axis){var niceTicks=axis.tickGenerator(axis);if(niceTicks.length>0){if(opts.min==null)axis.min=Math.min(axis.min,niceTicks[0]);if(opts.max==null&&niceTicks.length>1)axis.max=Math.max(axis.max,niceTicks[niceTicks.length-1])}axis.tickGenerator=function(axis){var ticks=[],v,i;for(i=0;i<otherAxis.ticks.length;++i){v=(otherAxis.ticks[i].v-otherAxis.min)/(otherAxis.max-otherAxis.min);v=axis.min+v*(axis.max-axis.min);ticks.push(v)}return ticks};if(!axis.mode&&opts.tickDecimals==null){var extraDec=Math.max(0,-Math.floor(Math.log(axis.delta)/Math.LN10)+1),ts=axis.tickGenerator(axis);if(!(ts.length>1&&/\..*0$/.test((ts[1]-ts[0]).toFixed(extraDec))))axis.tickDecimals=extraDec}}}}function setTicks(axis){var oticks=axis.options.ticks,ticks=[];if(oticks==null||typeof oticks=="number"&&oticks>0)ticks=axis.tickGenerator(axis);else if(oticks){if($.isFunction(oticks))ticks=oticks(axis);else ticks=oticks}var i,v;axis.ticks=[];for(i=0;i<ticks.length;++i){var label=null;var t=ticks[i];if(typeof t=="object"){v=+t[0];if(t.length>1)label=t[1]}else v=+t;if(label==null)label=axis.tickFormatter(v,axis);if(!isNaN(v))axis.ticks.push({v:v,label:label})}}function snapRangeToTicks(axis,ticks){if(axis.options.autoscaleMargin&&ticks.length>0){if(axis.options.min==null)axis.min=Math.min(axis.min,ticks[0].v);if(axis.options.max==null&&ticks.length>1)axis.max=Math.max(axis.max,ticks[ticks.length-1].v)}}function draw(){surface.clear();executeHooks(hooks.drawBackground,[ctx]);var grid=options.grid;if(grid.show&&grid.backgroundColor)drawBackground();if(grid.show&&!grid.aboveData){drawGrid()}for(var i=0;i<series.length;++i){executeHooks(hooks.drawSeries,[ctx,series[i]]);drawSeries(series[i])}executeHooks(hooks.draw,[ctx]);if(grid.show&&grid.aboveData){drawGrid()}surface.render();triggerRedrawOverlay()}function extractRange(ranges,coord){var axis,from,to,key,axes=allAxes();for(var i=0;i<axes.length;++i){axis=axes[i];if(axis.direction==coord){key=coord+axis.n+"axis";if(!ranges[key]&&axis.n==1)key=coord+"axis";if(ranges[key]){from=ranges[key].from;to=ranges[key].to;break}}}if(!ranges[key]){axis=coord=="x"?xaxes[0]:yaxes[0];from=ranges[coord+"1"];to=ranges[coord+"2"]}if(from!=null&&to!=null&&from>to){var tmp=from;from=to;to=tmp}return{from:from,to:to,axis:axis}}function drawBackground(){ctx.save();ctx.translate(plotOffset.left,plotOffset.top);ctx.fillStyle=getColorOrGradient(options.grid.backgroundColor,plotHeight,0,"rgba(255, 255, 255, 0)");ctx.fillRect(0,0,plotWidth,plotHeight);ctx.restore()}function drawGrid(){var i,axes,bw,bc;ctx.save();ctx.translate(plotOffset.left,plotOffset.top);var markings=options.grid.markings;if(markings){if($.isFunction(markings)){axes=plot.getAxes();axes.xmin=axes.xaxis.min;axes.xmax=axes.xaxis.max;axes.ymin=axes.yaxis.min;axes.ymax=axes.yaxis.max;markings=markings(axes)}for(i=0;i<markings.length;++i){var m=markings[i],xrange=extractRange(m,"x"),yrange=extractRange(m,"y");if(xrange.from==null)xrange.from=xrange.axis.min;if(xrange.to==null)xrange.to=xrange.axis.max;
21−if(yrange.from==null)yrange.from=yrange.axis.min;if(yrange.to==null)yrange.to=yrange.axis.max;if(xrange.to<xrange.axis.min||xrange.from>xrange.axis.max||yrange.to<yrange.axis.min||yrange.from>yrange.axis.max)continue;xrange.from=Math.max(xrange.from,xrange.axis.min);xrange.to=Math.min(xrange.to,xrange.axis.max);yrange.from=Math.max(yrange.from,yrange.axis.min);yrange.to=Math.min(yrange.to,yrange.axis.max);var xequal=xrange.from===xrange.to,yequal=yrange.from===yrange.to;if(xequal&&yequal){continue}xrange.from=Math.floor(xrange.axis.p2c(xrange.from));xrange.to=Math.floor(xrange.axis.p2c(xrange.to));yrange.from=Math.floor(yrange.axis.p2c(yrange.from));yrange.to=Math.floor(yrange.axis.p2c(yrange.to));if(xequal||yequal){var lineWidth=m.lineWidth||options.grid.markingsLineWidth,subPixel=lineWidth%2?.5:0;ctx.beginPath();ctx.strokeStyle=m.color||options.grid.markingsColor;ctx.lineWidth=lineWidth;if(xequal){ctx.moveTo(xrange.to+subPixel,yrange.from);ctx.lineTo(xrange.to+subPixel,yrange.to)}else{ctx.moveTo(xrange.from,yrange.to+subPixel);ctx.lineTo(xrange.to,yrange.to+subPixel)}ctx.stroke()}else{ctx.fillStyle=m.color||options.grid.markingsColor;ctx.fillRect(xrange.from,yrange.to,xrange.to-xrange.from,yrange.from-yrange.to)}}}axes=allAxes();bw=options.grid.borderWidth;for(var j=0;j<axes.length;++j){var axis=axes[j],box=axis.box,t=axis.tickLength,x,y,xoff,yoff;if(!axis.show||axis.ticks.length==0)continue;ctx.lineWidth=1;if(axis.direction=="x"){x=0;if(t=="full")y=axis.position=="top"?0:plotHeight;else y=box.top-plotOffset.top+(axis.position=="top"?box.height:0)}else{y=0;if(t=="full")x=axis.position=="left"?0:plotWidth;else x=box.left-plotOffset.left+(axis.position=="left"?box.width:0)}if(!axis.innermost){ctx.strokeStyle=axis.options.color;ctx.beginPath();xoff=yoff=0;if(axis.direction=="x")xoff=plotWidth+1;else yoff=plotHeight+1;if(ctx.lineWidth==1){if(axis.direction=="x"){y=Math.floor(y)+.5}else{x=Math.floor(x)+.5}}ctx.moveTo(x,y);ctx.lineTo(x+xoff,y+yoff);ctx.stroke()}ctx.strokeStyle=axis.options.tickColor;ctx.beginPath();for(i=0;i<axis.ticks.length;++i){var v=axis.ticks[i].v;xoff=yoff=0;if(isNaN(v)||v<axis.min||v>axis.max||t=="full"&&(typeof bw=="object"&&bw[axis.position]>0||bw>0)&&(v==axis.min||v==axis.max))continue;if(axis.direction=="x"){x=axis.p2c(v);yoff=t=="full"?-plotHeight:t;if(axis.position=="top")yoff=-yoff}else{y=axis.p2c(v);xoff=t=="full"?-plotWidth:t;if(axis.position=="left")xoff=-xoff}if(ctx.lineWidth==1){if(axis.direction=="x")x=Math.floor(x)+.5;else y=Math.floor(y)+.5}ctx.moveTo(x,y);ctx.lineTo(x+xoff,y+yoff)}ctx.stroke()}if(bw){bc=options.grid.borderColor;if(typeof bw=="object"||typeof bc=="object"){if(typeof bw!=="object"){bw={top:bw,right:bw,bottom:bw,left:bw}}if(typeof bc!=="object"){bc={top:bc,right:bc,bottom:bc,left:bc}}if(bw.top>0){ctx.strokeStyle=bc.top;ctx.lineWidth=bw.top;ctx.beginPath();ctx.moveTo(0-bw.left,0-bw.top/2);ctx.lineTo(plotWidth,0-bw.top/2);ctx.stroke()}if(bw.right>0){ctx.strokeStyle=bc.right;ctx.lineWidth=bw.right;ctx.beginPath();ctx.moveTo(plotWidth+bw.right/2,0-bw.top);ctx.lineTo(plotWidth+bw.right/2,plotHeight);ctx.stroke()}if(bw.bottom>0){ctx.strokeStyle=bc.bottom;ctx.lineWidth=bw.bottom;ctx.beginPath();ctx.moveTo(plotWidth+bw.right,plotHeight+bw.bottom/2);ctx.lineTo(0,plotHeight+bw.bottom/2);ctx.stroke()}if(bw.left>0){ctx.strokeStyle=bc.left;ctx.lineWidth=bw.left;ctx.beginPath();ctx.moveTo(0-bw.left/2,plotHeight+bw.bottom);ctx.lineTo(0-bw.left/2,0);ctx.stroke()}}else{ctx.lineWidth=bw;ctx.strokeStyle=options.grid.borderColor;ctx.strokeRect(-bw/2,-bw/2,plotWidth+bw,plotHeight+bw)}}ctx.restore()}function drawAxisLabels(){$.each(allAxes(),function(_,axis){var box=axis.box,legacyStyles=axis.direction+"Axis "+axis.direction+axis.n+"Axis",layer="flot-"+axis.direction+"-axis flot-"+axis.direction+axis.n+"-axis "+legacyStyles,font=axis.options.font||"flot-tick-label tickLabel",tick,x,y,halign,valign;surface.removeText(layer);if(!axis.show||axis.ticks.length==0)return;for(var i=0;i<axis.ticks.length;++i){tick=axis.ticks[i];if(!tick.label||tick.v<axis.min||tick.v>axis.max)continue;if(axis.direction=="x"){halign="center";x=plotOffset.left+axis.p2c(tick.v);if(axis.position=="bottom"){y=box.top+box.padding}else{y=box.top+box.height-box.padding;valign="bottom"}}else{valign="middle";y=plotOffset.top+axis.p2c(tick.v);if(axis.position=="left"){x=box.left+box.width-box.padding;halign="right"}else{x=box.left+box.padding}}surface.addText(layer,x,y,tick.label,font,null,null,halign,valign)}})}function drawSeries(series){if(series.lines.show)drawSeriesLines(series);if(series.bars.show)drawSeriesBars(series);if(series.points.show)drawSeriesPoints(series)}function drawSeriesLines(series){function plotLine(datapoints,xoffset,yoffset,axisx,axisy){var points=datapoints.points,ps=datapoints.pointsize,prevx=null,prevy=null;ctx.beginPath();for(var i=ps;i<points.length;i+=ps){var x1=points[i-ps],y1=points[i-ps+1],x2=points[i],y2=points[i+1];if(x1==null||x2==null)continue;if(y1<=y2&&y1<axisy.min){if(y2<axisy.min)continue;x1=(axisy.min-y1)/(y2-y1)*(x2-x1)+x1;y1=axisy.min}else if(y2<=y1&&y2<axisy.min){if(y1<axisy.min)continue;x2=(axisy.min-y1)/(y2-y1)*(x2-x1)+x1;y2=axisy.min}if(y1>=y2&&y1>axisy.max){if(y2>axisy.max)continue;x1=(axisy.max-y1)/(y2-y1)*(x2-x1)+x1;y1=axisy.max}else if(y2>=y1&&y2>axisy.max){if(y1>axisy.max)continue;x2=(axisy.max-y1)/(y2-y1)*(x2-x1)+x1;y2=axisy.max}if(x1<=x2&&x1<axisx.min){if(x2<axisx.min)continue;y1=(axisx.min-x1)/(x2-x1)*(y2-y1)+y1;x1=axisx.min}else if(x2<=x1&&x2<axisx.min){if(x1<axisx.min)continue;y2=(axisx.min-x1)/(x2-x1)*(y2-y1)+y1;x2=axisx.min}if(x1>=x2&&x1>axisx.max){if(x2>axisx.max)continue;y1=(axisx.max-x1)/(x2-x1)*(y2-y1)+y1;x1=axisx.max}else if(x2>=x1&&x2>axisx.max){if(x1>axisx.max)continue;y2=(axisx.max-x1)/(x2-x1)*(y2-y1)+y1;x2=axisx.max}if(x1!=prevx||y1!=prevy)ctx.moveTo(axisx.p2c(x1)+xoffset,axisy.p2c(y1)+yoffset);prevx=x2;prevy=y2;ctx.lineTo(axisx.p2c(x2)+xoffset,axisy.p2c(y2)+yoffset)}ctx.stroke()}function plotLineArea(datapoints,axisx,axisy){var points=datapoints.points,ps=datapoints.pointsize,bottom=Math.min(Math.max(0,axisy.min),axisy.max),i=0,top,areaOpen=false,ypos=1,segmentStart=0,segmentEnd=0;while(true){if(ps>0&&i>points.length+ps)break;i+=ps;var x1=points[i-ps],y1=points[i-ps+ypos],x2=points[i],y2=points[i+ypos];if(areaOpen){if(ps>0&&x1!=null&&x2==null){segmentEnd=i;ps=-ps;ypos=2;continue}if(ps<0&&i==segmentStart+ps){ctx.fill();areaOpen=false;ps=-ps;ypos=1;i=segmentStart=segmentEnd+ps;continue}}if(x1==null||x2==null)continue;if(x1<=x2&&x1<axisx.min){if(x2<axisx.min)continue;y1=(axisx.min-x1)/(x2-x1)*(y2-y1)+y1;x1=axisx.min}else if(x2<=x1&&x2<axisx.min){if(x1<axisx.min)continue;y2=(axisx.min-x1)/(x2-x1)*(y2-y1)+y1;x2=axisx.min}if(x1>=x2&&x1>axisx.max){if(x2>axisx.max)continue;y1=(axisx.max-x1)/(x2-x1)*(y2-y1)+y1;x1=axisx.max}else if(x2>=x1&&x2>axisx.max){if(x1>axisx.max)continue;y2=(axisx.max-x1)/(x2-x1)*(y2-y1)+y1;x2=axisx.max}if(!areaOpen){ctx.beginPath();ctx.moveTo(axisx.p2c(x1),axisy.p2c(bottom));areaOpen=true}if(y1>=axisy.max&&y2>=axisy.max){ctx.lineTo(axisx.p2c(x1),axisy.p2c(axisy.max));ctx.lineTo(axisx.p2c(x2),axisy.p2c(axisy.max));continue}else if(y1<=axisy.min&&y2<=axisy.min){ctx.lineTo(axisx.p2c(x1),axisy.p2c(axisy.min));ctx.lineTo(axisx.p2c(x2),axisy.p2c(axisy.min));continue}var x1old=x1,x2old=x2;if(y1<=y2&&y1<axisy.min&&y2>=axisy.min){x1=(axisy.min-y1)/(y2-y1)*(x2-x1)+x1;y1=axisy.min}else if(y2<=y1&&y2<axisy.min&&y1>=axisy.min){x2=(axisy.min-y1)/(y2-y1)*(x2-x1)+x1;y2=axisy.min}if(y1>=y2&&y1>axisy.max&&y2<=axisy.max){x1=(axisy.max-y1)/(y2-y1)*(x2-x1)+x1;y1=axisy.max}else if(y2>=y1&&y2>axisy.max&&y1<=axisy.max){x2=(axisy.max-y1)/(y2-y1)*(x2-x1)+x1;y2=axisy.max}if(x1!=x1old){ctx.lineTo(axisx.p2c(x1old),axisy.p2c(y1))}ctx.lineTo(axisx.p2c(x1),axisy.p2c(y1));ctx.lineTo(axisx.p2c(x2),axisy.p2c(y2));if(x2!=x2old){ctx.lineTo(axisx.p2c(x2),axisy.p2c(y2));ctx.lineTo(axisx.p2c(x2old),axisy.p2c(y2))}}}ctx.save();ctx.translate(plotOffset.left,plotOffset.top);ctx.lineJoin="round";var lw=series.lines.lineWidth,sw=series.shadowSize;if(lw>0&&sw>0){ctx.lineWidth=sw;ctx.strokeStyle="rgba(0,0,0,0.1)";var angle=Math.PI/18;plotLine(series.datapoints,Math.sin(angle)*(lw/2+sw/2),Math.cos(angle)*(lw/2+sw/2),series.xaxis,series.yaxis);ctx.lineWidth=sw/2;plotLine(series.datapoints,Math.sin(angle)*(lw/2+sw/4),Math.cos(angle)*(lw/2+sw/4),series.xaxis,series.yaxis)}ctx.lineWidth=lw;ctx.strokeStyle=series.color;var fillStyle=getFillStyle(series.lines,series.color,0,plotHeight);if(fillStyle){ctx.fillStyle=fillStyle;plotLineArea(series.datapoints,series.xaxis,series.yaxis)}if(lw>0)plotLine(series.datapoints,0,0,series.xaxis,series.yaxis);ctx.restore()}function drawSeriesPoints(series){function plotPoints(datapoints,radius,fillStyle,offset,shadow,axisx,axisy,symbol){var points=datapoints.points,ps=datapoints.pointsize;for(var i=0;i<points.length;i+=ps){var x=points[i],y=points[i+1];if(x==null||x<axisx.min||x>axisx.max||y<axisy.min||y>axisy.max)continue;ctx.beginPath();x=axisx.p2c(x);y=axisy.p2c(y)+offset;if(symbol=="circle")ctx.arc(x,y,radius,0,shadow?Math.PI:Math.PI*2,false);else symbol(ctx,x,y,radius,shadow);ctx.closePath();if(fillStyle){ctx.fillStyle=fillStyle;ctx.fill()}ctx.stroke()}}ctx.save();ctx.translate(plotOffset.left,plotOffset.top);var lw=series.points.lineWidth,sw=series.shadowSize,radius=series.points.radius,symbol=series.points.symbol;if(lw==0)lw=1e-4;if(lw>0&&sw>0){var w=sw/2;ctx.lineWidth=w;ctx.strokeStyle="rgba(0,0,0,0.1)";plotPoints(series.datapoints,radius,null,w+w/2,true,series.xaxis,series.yaxis,symbol);ctx.strokeStyle="rgba(0,0,0,0.2)";plotPoints(series.datapoints,radius,null,w/2,true,series.xaxis,series.yaxis,symbol)}ctx.lineWidth=lw;ctx.strokeStyle=series.color;plotPoints(series.datapoints,radius,getFillStyle(series.points,series.color),0,false,series.xaxis,series.yaxis,symbol);ctx.restore()}function drawBar(x,y,b,barLeft,barRight,fillStyleCallback,axisx,axisy,c,horizontal,lineWidth){var left,right,bottom,top,drawLeft,drawRight,drawTop,drawBottom,tmp;if(horizontal){drawBottom=drawRight=drawTop=true;drawLeft=false;left=b;right=x;top=y+barLeft;bottom=y+barRight;if(right<left){tmp=right;right=left;left=tmp;drawLeft=true;drawRight=false}}else{drawLeft=drawRight=drawTop=true;drawBottom=false;left=x+barLeft;right=x+barRight;bottom=b;top=y;if(top<bottom){tmp=top;top=bottom;bottom=tmp;drawBottom=true;drawTop=false}}if(right<axisx.min||left>axisx.max||top<axisy.min||bottom>axisy.max)return;if(left<axisx.min){left=axisx.min;drawLeft=false}if(right>axisx.max){right=axisx.max;drawRight=false}if(bottom<axisy.min){bottom=axisy.min;drawBottom=false}if(top>axisy.max){top=axisy.max;drawTop=false}left=axisx.p2c(left);bottom=axisy.p2c(bottom);right=axisx.p2c(right);top=axisy.p2c(top);if(fillStyleCallback){c.fillStyle=fillStyleCallback(bottom,top);c.fillRect(left,top,right-left,bottom-top)}if(lineWidth>0&&(drawLeft||drawRight||drawTop||drawBottom)){c.beginPath();c.moveTo(left,bottom);if(drawLeft)c.lineTo(left,top);else c.moveTo(left,top);if(drawTop)c.lineTo(right,top);else c.moveTo(right,top);if(drawRight)c.lineTo(right,bottom);else c.moveTo(right,bottom);if(drawBottom)c.lineTo(left,bottom);else c.moveTo(left,bottom);c.stroke()}}function drawSeriesBars(series){function plotBars(datapoints,barLeft,barRight,fillStyleCallback,axisx,axisy){var points=datapoints.points,ps=datapoints.pointsize;for(var i=0;i<points.length;i+=ps){if(points[i]==null)continue;drawBar(points[i],points[i+1],points[i+2],barLeft,barRight,fillStyleCallback,axisx,axisy,ctx,series.bars.horizontal,series.bars.lineWidth)}}ctx.save();ctx.translate(plotOffset.left,plotOffset.top);ctx.lineWidth=series.bars.lineWidth;ctx.strokeStyle=series.color;var barLeft;switch(series.bars.align){case"left":barLeft=0;break;case"right":barLeft=-series.bars.barWidth;break;default:barLeft=-series.bars.barWidth/2}var fillStyleCallback=series.bars.fill?function(bottom,top){return getFillStyle(series.bars,series.color,bottom,top)}:null;plotBars(series.datapoints,barLeft,barLeft+series.bars.barWidth,fillStyleCallback,series.xaxis,series.yaxis);ctx.restore()}function getFillStyle(filloptions,seriesColor,bottom,top){var fill=filloptions.fill;if(!fill)return null;if(filloptions.fillColor)return getColorOrGradient(filloptions.fillColor,bottom,top,seriesColor);var c=$.color.parse(seriesColor);c.a=typeof fill=="number"?fill:.4;c.normalize();return c.toString()}function insertLegend(){if(options.legend.container!=null){$(options.legend.container).html("")}else{placeholder.find(".legend").remove()}if(!options.legend.show){return}var fragments=[],entries=[],rowStarted=false,lf=options.legend.labelFormatter,s,label;for(var i=0;i<series.length;++i){s=series[i];if(s.label){label=lf?lf(s.label,s):s.label;if(label){entries.push({label:label,color:s.color})}}}if(options.legend.sorted){if($.isFunction(options.legend.sorted)){entries.sort(options.legend.sorted)}else if(options.legend.sorted=="reverse"){entries.reverse()}else{var ascending=options.legend.sorted!="descending";entries.sort(function(a,b){return a.label==b.label?0:a.label<b.label!=ascending?1:-1})}}for(var i=0;i<entries.length;++i){var entry=entries[i];if(i%options.legend.noColumns==0){if(rowStarted)fragments.push("</tr>");fragments.push("<tr>");rowStarted=true}fragments.push('<td class="legendColorBox"><div style="border:1px solid '+options.legend.labelBoxBorderColor+';padding:1px"><div style="width:4px;height:0;border:5px solid '+entry.color+';overflow:hidden"></div></div></td>'+'<td class="legendLabel">'+entry.label+"</td>")}if(rowStarted)fragments.push("</tr>");if(fragments.length==0)return;var table='<table style="font-size:smaller;color:'+options.grid.color+'">'+fragments.join("")+"</table>";if(options.legend.container!=null)$(options.legend.container).html(table);else{var pos="",p=options.legend.position,m=options.legend.margin;if(m[0]==null)m=[m,m];if(p.charAt(0)=="n")pos+="top:"+(m[1]+plotOffset.top)+"px;";else if(p.charAt(0)=="s")pos+="bottom:"+(m[1]+plotOffset.bottom)+"px;";if(p.charAt(1)=="e")pos+="right:"+(m[0]+plotOffset.right)+"px;";else if(p.charAt(1)=="w")pos+="left:"+(m[0]+plotOffset.left)+"px;";var legend=$('<div class="legend">'+table.replace('style="','style="position:absolute;'+pos+";")+"</div>").appendTo(placeholder);if(options.legend.backgroundOpacity!=0){var c=options.legend.backgroundColor;if(c==null){c=options.grid.backgroundColor;if(c&&typeof c=="string")c=$.color.parse(c);else c=$.color.extract(legend,"background-color");c.a=1;c=c.toString()}var div=legend.children();$('<div style="position:absolute;width:'+div.width()+"px;height:"+div.height()+"px;"+pos+"background-color:"+c+';"> </div>').prependTo(legend).css("opacity",options.legend.backgroundOpacity)}}}var highlights=[],redrawTimeout=null;function findNearbyItem(mouseX,mouseY,seriesFilter){var maxDistance=options.grid.mouseActiveRadius,smallestDistance=maxDistance*maxDistance+1,item=null,foundPoint=false,i,j,ps;for(i=series.length-1;i>=0;--i){if(!seriesFilter(series[i]))continue;var s=series[i],axisx=s.xaxis,axisy=s.yaxis,points=s.datapoints.points,mx=axisx.c2p(mouseX),my=axisy.c2p(mouseY),maxx=maxDistance/axisx.scale,maxy=maxDistance/axisy.scale;ps=s.datapoints.pointsize;if(axisx.options.inverseTransform)maxx=Number.MAX_VALUE;if(axisy.options.inverseTransform)maxy=Number.MAX_VALUE;if(s.lines.show||s.points.show){for(j=0;j<points.length;j+=ps){var x=points[j],y=points[j+1];if(x==null)continue;if(x-mx>maxx||x-mx<-maxx||y-my>maxy||y-my<-maxy)continue;var dx=Math.abs(axisx.p2c(x)-mouseX),dy=Math.abs(axisy.p2c(y)-mouseY),dist=dx*dx+dy*dy;if(dist<smallestDistance){smallestDistance=dist;item=[i,j/ps]}}}if(s.bars.show&&!item){var barLeft,barRight;switch(s.bars.align){case"left":barLeft=0;break;case"right":barLeft=-s.bars.barWidth;break;default:barLeft=-s.bars.barWidth/2}barRight=barLeft+s.bars.barWidth;for(j=0;j<points.length;j+=ps){var x=points[j],y=points[j+1],b=points[j+2];if(x==null)continue;if(series[i].bars.horizontal?mx<=Math.max(b,x)&&mx>=Math.min(b,x)&&my>=y+barLeft&&my<=y+barRight:mx>=x+barLeft&&mx<=x+barRight&&my>=Math.min(b,y)&&my<=Math.max(b,y))item=[i,j/ps]}}}if(item){i=item[0];j=item[1];ps=series[i].datapoints.pointsize;return{datapoint:series[i].datapoints.points.slice(j*ps,(j+1)*ps),dataIndex:j,series:series[i],seriesIndex:i}}return null}function onMouseMove(e){if(options.grid.hoverable)triggerClickHoverEvent("plothover",e,function(s){return s["hoverable"]!=false})}function onMouseLeave(e){if(options.grid.hoverable)triggerClickHoverEvent("plothover",e,function(s){return false})}function onClick(e){triggerClickHoverEvent("plotclick",e,function(s){return s["clickable"]!=false})}function triggerClickHoverEvent(eventname,event,seriesFilter){var offset=eventHolder.offset(),canvasX=event.pageX-offset.left-plotOffset.left,canvasY=event.pageY-offset.top-plotOffset.top,pos=canvasToAxisCoords({left:canvasX,top:canvasY});pos.pageX=event.pageX;pos.pageY=event.pageY;var item=findNearbyItem(canvasX,canvasY,seriesFilter);if(item){item.pageX=parseInt(item.series.xaxis.p2c(item.datapoint[0])+offset.left+plotOffset.left,10);item.pageY=parseInt(item.series.yaxis.p2c(item.datapoint[1])+offset.top+plotOffset.top,10)}if(options.grid.autoHighlight){for(var i=0;i<highlights.length;++i){var h=highlights[i];if(h.auto==eventname&&!(item&&h.series==item.series&&h.point[0]==item.datapoint[0]&&h.point[1]==item.datapoint[1]))unhighlight(h.series,h.point)}if(item)highlight(item.series,item.datapoint,eventname)}placeholder.trigger(eventname,[pos,item])}function triggerRedrawOverlay(){var t=options.interaction.redrawOverlayInterval;if(t==-1){drawOverlay();return}if(!redrawTimeout)redrawTimeout=setTimeout(drawOverlay,t)}function drawOverlay(){redrawTimeout=null;octx.save();overlay.clear();octx.translate(plotOffset.left,plotOffset.top);var i,hi;for(i=0;i<highlights.length;++i){hi=highlights[i];if(hi.series.bars.show)drawBarHighlight(hi.series,hi.point);else drawPointHighlight(hi.series,hi.point)}octx.restore();executeHooks(hooks.drawOverlay,[octx])}function highlight(s,point,auto){if(typeof s=="number")s=series[s];if(typeof point=="number"){var ps=s.datapoints.pointsize;point=s.datapoints.points.slice(ps*point,ps*(point+1))}var i=indexOfHighlight(s,point);if(i==-1){highlights.push({series:s,point:point,auto:auto});triggerRedrawOverlay()}else if(!auto)highlights[i].auto=false}function unhighlight(s,point){if(s==null&&point==null){highlights=[];triggerRedrawOverlay();return}if(typeof s=="number")s=series[s];if(typeof point=="number"){var ps=s.datapoints.pointsize;point=s.datapoints.points.slice(ps*point,ps*(point+1))}var i=indexOfHighlight(s,point);if(i!=-1){highlights.splice(i,1);triggerRedrawOverlay()}}function indexOfHighlight(s,p){for(var i=0;i<highlights.length;++i){var h=highlights[i];if(h.series==s&&h.point[0]==p[0]&&h.point[1]==p[1])return i}return-1}function drawPointHighlight(series,point){var x=point[0],y=point[1],axisx=series.xaxis,axisy=series.yaxis,highlightColor=typeof series.highlightColor==="string"?series.highlightColor:$.color.parse(series.color).scale("a",.5).toString();if(x<axisx.min||x>axisx.max||y<axisy.min||y>axisy.max)return;var pointRadius=series.points.radius+series.points.lineWidth/2;octx.lineWidth=pointRadius;octx.strokeStyle=highlightColor;var radius=1.5*pointRadius;x=axisx.p2c(x);y=axisy.p2c(y);octx.beginPath();if(series.points.symbol=="circle")octx.arc(x,y,radius,0,2*Math.PI,false);else series.points.symbol(octx,x,y,radius,false);octx.closePath();octx.stroke()}function drawBarHighlight(series,point){var highlightColor=typeof series.highlightColor==="string"?series.highlightColor:$.color.parse(series.color).scale("a",.5).toString(),fillStyle=highlightColor,barLeft;switch(series.bars.align){case"left":barLeft=0;break;case"right":barLeft=-series.bars.barWidth;break;default:barLeft=-series.bars.barWidth/2}octx.lineWidth=series.bars.lineWidth;octx.strokeStyle=highlightColor;drawBar(point[0],point[1],point[2]||0,barLeft,barLeft+series.bars.barWidth,function(){return fillStyle},series.xaxis,series.yaxis,octx,series.bars.horizontal,series.bars.lineWidth)}function getColorOrGradient(spec,bottom,top,defaultColor){if(typeof spec=="string")return spec;else{var gradient=ctx.createLinearGradient(0,top,0,bottom);for(var i=0,l=spec.colors.length;i<l;++i){var c=spec.colors[i];if(typeof c!="string"){var co=$.color.parse(defaultColor);if(c.brightness!=null)co=co.scale("rgb",c.brightness);if(c.opacity!=null)co.a*=c.opacity;c=co.toString()}gradient.addColorStop(i/(l-1),c)}return gradient}}}$.plot=function(placeholder,data,options){var plot=new Plot($(placeholder),data,options,$.plot.plugins);return plot};$.plot.version="0.8.3";$.plot.plugins=[];$.fn.plot=function(data,options){return this.each(function(){$.plot(this,data,options)})};function floorInBase(n,base){return base*Math.floor(n/base)}})(jQuery);
22− </script>
23− <script language="javascript" type="text/javascript">
24− /* Javascript plotting library for jQuery, version 0.8.3.
25−
26−Copyright (c) 2007-2014 IOLA and Ole Laursen.
27−Licensed under the MIT license.
28−
29−*/
30−(function($){var options={series:{points:{errorbars:null,xerr:{err:"x",show:null,asymmetric:null,upperCap:null,lowerCap:null,color:null,radius:null},yerr:{err:"y",show:null,asymmetric:null,upperCap:null,lowerCap:null,color:null,radius:null}}}};function processRawData(plot,series,data,datapoints){if(!series.points.errorbars)return;var format=[{x:true,number:true,required:true},{y:true,number:true,required:true}];var errors=series.points.errorbars;if(errors=="x"||errors=="xy"){if(series.points.xerr.asymmetric){format.push({x:true,number:true,required:true});format.push({x:true,number:true,required:true})}else format.push({x:true,number:true,required:true})}if(errors=="y"||errors=="xy"){if(series.points.yerr.asymmetric){format.push({y:true,number:true,required:true});format.push({y:true,number:true,required:true})}else format.push({y:true,number:true,required:true})}datapoints.format=format}function parseErrors(series,i){var points=series.datapoints.points;var exl=null,exu=null,eyl=null,eyu=null;var xerr=series.points.xerr,yerr=series.points.yerr;var eb=series.points.errorbars;if(eb=="x"||eb=="xy"){if(xerr.asymmetric){exl=points[i+2];exu=points[i+3];if(eb=="xy")if(yerr.asymmetric){eyl=points[i+4];eyu=points[i+5]}else eyl=points[i+4]}else{exl=points[i+2];if(eb=="xy")if(yerr.asymmetric){eyl=points[i+3];eyu=points[i+4]}else eyl=points[i+3]}}else if(eb=="y")if(yerr.asymmetric){eyl=points[i+2];eyu=points[i+3]}else eyl=points[i+2];if(exu==null)exu=exl;if(eyu==null)eyu=eyl;var errRanges=[exl,exu,eyl,eyu];if(!xerr.show){errRanges[0]=null;errRanges[1]=null}if(!yerr.show){errRanges[2]=null;errRanges[3]=null}return errRanges}function drawSeriesErrors(plot,ctx,s){var points=s.datapoints.points,ps=s.datapoints.pointsize,ax=[s.xaxis,s.yaxis],radius=s.points.radius,err=[s.points.xerr,s.points.yerr];var invertX=false;if(ax[0].p2c(ax[0].max)<ax[0].p2c(ax[0].min)){invertX=true;var tmp=err[0].lowerCap;err[0].lowerCap=err[0].upperCap;err[0].upperCap=tmp}var invertY=false;if(ax[1].p2c(ax[1].min)<ax[1].p2c(ax[1].max)){invertY=true;var tmp=err[1].lowerCap;err[1].lowerCap=err[1].upperCap;err[1].upperCap=tmp}for(var i=0;i<s.datapoints.points.length;i+=ps){var errRanges=parseErrors(s,i);for(var e=0;e<err.length;e++){var minmax=[ax[e].min,ax[e].max];if(errRanges[e*err.length]){var x=points[i],y=points[i+1];var upper=[x,y][e]+errRanges[e*err.length+1],lower=[x,y][e]-errRanges[e*err.length];if(err[e].err=="x")if(y>ax[1].max||y<ax[1].min||upper<ax[0].min||lower>ax[0].max)continue;if(err[e].err=="y")if(x>ax[0].max||x<ax[0].min||upper<ax[1].min||lower>ax[1].max)continue;var drawUpper=true,drawLower=true;if(upper>minmax[1]){drawUpper=false;upper=minmax[1]}if(lower<minmax[0]){drawLower=false;lower=minmax[0]}if(err[e].err=="x"&&invertX||err[e].err=="y"&&invertY){var tmp=lower;lower=upper;upper=tmp;tmp=drawLower;drawLower=drawUpper;drawUpper=tmp;tmp=minmax[0];minmax[0]=minmax[1];minmax[1]=tmp}x=ax[0].p2c(x),y=ax[1].p2c(y),upper=ax[e].p2c(upper);lower=ax[e].p2c(lower);minmax[0]=ax[e].p2c(minmax[0]);minmax[1]=ax[e].p2c(minmax[1]);var lw=err[e].lineWidth?err[e].lineWidth:s.points.lineWidth,sw=s.points.shadowSize!=null?s.points.shadowSize:s.shadowSize;if(lw>0&&sw>0){var w=sw/2;ctx.lineWidth=w;ctx.strokeStyle="rgba(0,0,0,0.1)";drawError(ctx,err[e],x,y,upper,lower,drawUpper,drawLower,radius,w+w/2,minmax);ctx.strokeStyle="rgba(0,0,0,0.2)";drawError(ctx,err[e],x,y,upper,lower,drawUpper,drawLower,radius,w/2,minmax)}ctx.strokeStyle=err[e].color?err[e].color:s.color;ctx.lineWidth=lw;drawError(ctx,err[e],x,y,upper,lower,drawUpper,drawLower,radius,0,minmax)}}}}function drawError(ctx,err,x,y,upper,lower,drawUpper,drawLower,radius,offset,minmax){y+=offset;upper+=offset;lower+=offset;if(err.err=="x"){if(upper>x+radius)drawPath(ctx,[[upper,y],[Math.max(x+radius,minmax[0]),y]]);else drawUpper=false;if(lower<x-radius)drawPath(ctx,[[Math.min(x-radius,minmax[1]),y],[lower,y]]);else drawLower=false}else{if(upper<y-radius)drawPath(ctx,[[x,upper],[x,Math.min(y-radius,minmax[0])]]);else drawUpper=false;if(lower>y+radius)drawPath(ctx,[[x,Math.max(y+radius,minmax[1])],[x,lower]]);else drawLower=false}radius=err.radius!=null?err.radius:radius;if(drawUpper){if(err.upperCap=="-"){if(err.err=="x")drawPath(ctx,[[upper,y-radius],[upper,y+radius]]);else drawPath(ctx,[[x-radius,upper],[x+radius,upper]])}else if($.isFunction(err.upperCap)){if(err.err=="x")err.upperCap(ctx,upper,y,radius);else err.upperCap(ctx,x,upper,radius)}}if(drawLower){if(err.lowerCap=="-"){if(err.err=="x")drawPath(ctx,[[lower,y-radius],[lower,y+radius]]);else drawPath(ctx,[[x-radius,lower],[x+radius,lower]])}else if($.isFunction(err.lowerCap)){if(err.err=="x")err.lowerCap(ctx,lower,y,radius);else err.lowerCap(ctx,x,lower,radius)}}}function drawPath(ctx,pts){ctx.beginPath();ctx.moveTo(pts[0][0],pts[0][1]);for(var p=1;p<pts.length;p++)ctx.lineTo(pts[p][0],pts[p][1]);ctx.stroke()}function draw(plot,ctx){var plotOffset=plot.getPlotOffset();ctx.save();ctx.translate(plotOffset.left,plotOffset.top);$.each(plot.getData(),function(i,s){if(s.points.errorbars&&(s.points.xerr.show||s.points.yerr.show))drawSeriesErrors(plot,ctx,s)});ctx.restore()}function init(plot){plot.hooks.processRawData.push(processRawData);plot.hooks.draw.push(draw)}$.plot.plugins.push({init:init,options:options,name:"errorbars",version:"1.0"})})(jQuery);
31− </script>
32− <script language="javascript" type="text/javascript">
33− /* Javascript plotting library for jQuery, version 0.8.3.
34−
35−Copyright (c) 2007-2014 IOLA and Ole Laursen.
36−Licensed under the MIT license.
37−
38−*/
39−(function(a){function e(h){var k,j=this,l=h.data||{};if(l.elem)j=h.dragTarget=l.elem,h.dragProxy=d.proxy||j,h.cursorOffsetX=l.pageX-l.left,h.cursorOffsetY=l.pageY-l.top,h.offsetX=h.pageX-h.cursorOffsetX,h.offsetY=h.pageY-h.cursorOffsetY;else if(d.dragging||l.which>0&&h.which!=l.which||a(h.target).is(l.not))return;switch(h.type){case"mousedown":return a.extend(l,a(j).offset(),{elem:j,target:h.target,pageX:h.pageX,pageY:h.pageY}),b.add(document,"mousemove mouseup",e,l),i(j,!1),d.dragging=null,!1;case!d.dragging&&"mousemove":if(g(h.pageX-l.pageX)+g(h.pageY-l.pageY)<l.distance)break;h.target=l.target,k=f(h,"dragstart",j),k!==!1&&(d.dragging=j,d.proxy=h.dragProxy=a(k||j)[0]);case"mousemove":if(d.dragging){if(k=f(h,"drag",j),c.drop&&(c.drop.allowed=k!==!1,c.drop.handler(h)),k!==!1)break;h.type="mouseup"}case"mouseup":b.remove(document,"mousemove mouseup",e),d.dragging&&(c.drop&&c.drop.handler(h),f(h,"dragend",j)),i(j,!0),d.dragging=d.proxy=l.elem=!1}return!0}function f(b,c,d){b.type=c;var e=a.event.dispatch.call(d,b);return e===!1?!1:e||b.result}function g(a){return Math.pow(a,2)}function h(){return d.dragging===!1}function i(a,b){a&&(a.unselectable=b?"off":"on",a.onselectstart=function(){return b},a.style&&(a.style.MozUserSelect=b?"":"none"))}a.fn.drag=function(a,b,c){return b&&this.bind("dragstart",a),c&&this.bind("dragend",c),a?this.bind("drag",b?b:a):this.trigger("drag")};var b=a.event,c=b.special,d=c.drag={not:":input",distance:0,which:1,dragging:!1,setup:function(c){c=a.extend({distance:d.distance,which:d.which,not:d.not},c||{}),c.distance=g(c.distance),b.add(this,"mousedown",e,c),this.attachEvent&&this.attachEvent("ondragstart",h)},teardown:function(){b.remove(this,"mousedown",e),this===d.dragging&&(d.dragging=d.proxy=!1),i(this,!0),this.detachEvent&&this.detachEvent("ondragstart",h)}};c.dragstart=c.dragend={setup:function(){},teardown:function(){}}})(jQuery);(function(d){function e(a){var b=a||window.event,c=[].slice.call(arguments,1),f=0,e=0,g=0,a=d.event.fix(b);a.type="mousewheel";b.wheelDelta&&(f=b.wheelDelta/120);b.detail&&(f=-b.detail/3);g=f;void 0!==b.axis&&b.axis===b.HORIZONTAL_AXIS&&(g=0,e=-1*f);void 0!==b.wheelDeltaY&&(g=b.wheelDeltaY/120);void 0!==b.wheelDeltaX&&(e=-1*b.wheelDeltaX/120);c.unshift(a,f,e,g);return(d.event.dispatch||d.event.handle).apply(this,c)}var c=["DOMMouseScroll","mousewheel"];if(d.event.fixHooks)for(var h=c.length;h;)d.event.fixHooks[c[--h]]=d.event.mouseHooks;d.event.special.mousewheel={setup:function(){if(this.addEventListener)for(var a=c.length;a;)this.addEventListener(c[--a],e,!1);else this.onmousewheel=e},teardown:function(){if(this.removeEventListener)for(var a=c.length;a;)this.removeEventListener(c[--a],e,!1);else this.onmousewheel=null}};d.fn.extend({mousewheel:function(a){return a?this.bind("mousewheel",a):this.trigger("mousewheel")},unmousewheel:function(a){return this.unbind("mousewheel",a)}})})(jQuery);(function($){var options={xaxis:{zoomRange:null,panRange:null},zoom:{interactive:false,trigger:"dblclick",amount:1.5},pan:{interactive:false,cursor:"move",frameRate:20}};function init(plot){function onZoomClick(e,zoomOut){var c=plot.offset();c.left=e.pageX-c.left;c.top=e.pageY-c.top;if(zoomOut)plot.zoomOut({center:c});else plot.zoom({center:c})}function onMouseWheel(e,delta){e.preventDefault();onZoomClick(e,delta<0);return false}var prevCursor="default",prevPageX=0,prevPageY=0,panTimeout=null;function onDragStart(e){if(e.which!=1)return false;var c=plot.getPlaceholder().css("cursor");if(c)prevCursor=c;plot.getPlaceholder().css("cursor",plot.getOptions().pan.cursor);prevPageX=e.pageX;prevPageY=e.pageY}function onDrag(e){var frameRate=plot.getOptions().pan.frameRate;if(panTimeout||!frameRate)return;panTimeout=setTimeout(function(){plot.pan({left:prevPageX-e.pageX,top:prevPageY-e.pageY});prevPageX=e.pageX;prevPageY=e.pageY;panTimeout=null},1/frameRate*1e3)}function onDragEnd(e){if(panTimeout){clearTimeout(panTimeout);panTimeout=null}plot.getPlaceholder().css("cursor",prevCursor);plot.pan({left:prevPageX-e.pageX,top:prevPageY-e.pageY})}function bindEvents(plot,eventHolder){var o=plot.getOptions();if(o.zoom.interactive){eventHolder[o.zoom.trigger](onZoomClick);eventHolder.mousewheel(onMouseWheel)}if(o.pan.interactive){eventHolder.bind("dragstart",{distance:10},onDragStart);eventHolder.bind("drag",onDrag);eventHolder.bind("dragend",onDragEnd)}}plot.zoomOut=function(args){if(!args)args={};if(!args.amount)args.amount=plot.getOptions().zoom.amount;args.amount=1/args.amount;plot.zoom(args)};plot.zoom=function(args){if(!args)args={};var c=args.center,amount=args.amount||plot.getOptions().zoom.amount,w=plot.width(),h=plot.height();if(!c)c={left:w/2,top:h/2};var xf=c.left/w,yf=c.top/h,minmax={x:{min:c.left-xf*w/amount,max:c.left+(1-xf)*w/amount},y:{min:c.top-yf*h/amount,max:c.top+(1-yf)*h/amount}};$.each(plot.getAxes(),function(_,axis){var opts=axis.options,min=minmax[axis.direction].min,max=minmax[axis.direction].max,zr=opts.zoomRange,pr=opts.panRange;if(zr===false)return;min=axis.c2p(min);max=axis.c2p(max);if(min>max){var tmp=min;min=max;max=tmp}if(pr){if(pr[0]!=null&&min<pr[0]){min=pr[0]}if(pr[1]!=null&&max>pr[1]){max=pr[1]}}var range=max-min;if(zr&&(zr[0]!=null&&range<zr[0]&&amount>1||zr[1]!=null&&range>zr[1]&&amount<1))return;opts.min=min;opts.max=max});plot.setupGrid();plot.draw();if(!args.preventEvent)plot.getPlaceholder().trigger("plotzoom",[plot,args])};plot.pan=function(args){var delta={x:+args.left,y:+args.top};if(isNaN(delta.x))delta.x=0;if(isNaN(delta.y))delta.y=0;$.each(plot.getAxes(),function(_,axis){var opts=axis.options,min,max,d=delta[axis.direction];min=axis.c2p(axis.p2c(axis.min)+d),max=axis.c2p(axis.p2c(axis.max)+d);var pr=opts.panRange;if(pr===false)return;if(pr){if(pr[0]!=null&&pr[0]>min){d=pr[0]-min;min+=d;max+=d}if(pr[1]!=null&&pr[1]<max){d=pr[1]-max;min+=d;max+=d}}opts.min=min;opts.max=max});plot.setupGrid();plot.draw();if(!args.preventEvent)plot.getPlaceholder().trigger("plotpan",[plot,args])};function shutdown(plot,eventHolder){eventHolder.unbind(plot.getOptions().zoom.trigger,onZoomClick);eventHolder.unbind("mousewheel",onMouseWheel);eventHolder.unbind("dragstart",onDragStart);eventHolder.unbind("drag",onDrag);eventHolder.unbind("dragend",onDragEnd);if(panTimeout)clearTimeout(panTimeout)}plot.hooks.bindEvents.push(bindEvents);plot.hooks.shutdown.push(shutdown)}$.plot.plugins.push({init:init,options:options,name:"navigate",version:"1.3"})})(jQuery);
40− </script>
41− <script language="javascript" type="text/javascript">
42− (function ($) {
43− $.zip = function(a,b) {
44− var x = Math.min(a.length,b.length);
45− var c = new Array(x);
46− for (var i = 0; i < x; i++)
47− c[i] = [a[i],b[i]];
48− return c;
49− };
50−
51− $.mean = function(ary) {
52− var m = 0, i = 0;
53−
54− while (i < ary.length) {
55− var j = i++;
56− m += (ary[j] - m) / i;
57− }
58−
59− return m;
60− };
61−
62− $.timeUnits = function(secs) {
63− if (secs < 0) return $.timeUnits(-secs);
64− else if (secs >= 1e9) return [1e-9, "Gs"];
65− else if (secs >= 1e6) return [1e-6, "Ms"];
66− else if (secs >= 1) return [1, "s"];
67− else if (secs >= 1e-3) return [1e3, "ms"];
68− else if (secs >= 1e-6) return [1e6, "\u03bcs"];
69− else if (secs >= 1e-9) return [1e9, "ns"];
70− else if (secs >= 1e-12) return [1e12, "ps"];
71− return [1, "s"];
72− };
73−
74− $.scaleTimes = function(ary) {
75− var s = $.timeUnits($.mean(ary));
76− return [$.scaleBy(s[0], ary), s[0]];
77− };
78−
79− $.prepareTime = function(secs) {
80− var units = $.timeUnits(secs);
81− var scaled = secs * units[0];
82− var s = scaled.toPrecision(3);
83− var t = scaled.toString();
84− return [t.length < s.length ? t : s, units[1]];
85− };
86−
87− $.scaleBy = function(x, ary) {
88− var nary = new Array(ary.length);
89− for (var i = 0; i < ary.length; i++)
90− nary[i] = ary[i] * x;
91− return nary;
92− };
93−
94− $.renderTime = function(secs) {
95− var x = $.prepareTime(secs);
96− return x[0] + ' ' + x[1];
97− };
98−
99− $.unitFormatter = function(scale) {
100− var labelname;
101− return function(secs,axis) {
102− var x = $.prepareTime(secs / scale);
103− if (labelname === x[1])
104− return x[0];
105− else {
106− labelname = x[1];
107− return x[0] + ' ' + x[1];
108− }
109− };
110− };
111−
112− $.addTooltip = function(name, renderText) {
113− function showTooltip(x, y, contents) {
114− $('<div id="tooltip">' + contents + '</div>').css( {
115− position: 'absolute',
116− display: 'none',
117− top: y + 5,
118− left: x + 5,
119− border: '1px solid #fdd',
120− padding: '2px',
121− 'background-color': '#fee',
122− opacity: 0.80
123− }).appendTo("body").fadeIn(200);
124− };
125− var pp = null;
126− $(name).bind("plothover", function (event, pos, item) {
127− $("#x").text(pos.x.toFixed(2));
128− $("#y").text(pos.y.toFixed(2));
129−
130− if (item) {
131− if (pp != item.dataIndex) {
132− pp = item.dataIndex;
133−
134− $("#tooltip").remove();
135− var x = item.datapoint[0],
136− y = item.datapoint[1];
137−
138− showTooltip(item.pageX, item.pageY, renderText(x,y));
139− }
140− }
141− else {
142− $("#tooltip").remove();
143− pp = null;
144− }
145− });
146− };
147−})(jQuery);
148−
149− </script>
150− <style type="text/css">
151− html, body {
152− height: 100%;
153− margin: 0;
154−}
155−
156−#wrap {
157− min-height: 100%;
158−}
159−
160−#main {
161− overflow: auto;
162− padding-bottom: 180px; /* must be same height as the footer */
163−}
164−
165−#footer {
166− position: relative;
167− margin-top: -180px; /* negative value of footer height */
168− height: 180px;
169− clear: both;
170− background: #888;
171− margin: 40px 0 0;
172− color: white;
173− font-size: larger;
174− font-weight: 300;
175−}
176−
177−body:before {
178− /* Opera fix */
179− content: "";
180− height: 100%;
181− float: left;
182− width: 0;
183− margin-top: -32767px;
184−}
185−
186−body {
187− font: 14px Helvetica Neue;
188− text-rendering: optimizeLegibility;
189− margin-top: 1em;
190−}
191−
192−a:link {
193− color: steelblue;
194− text-decoration: none;
195−}
196−
197−a:visited {
198− color: #4a743b;
199− text-decoration: none;
200−}
201−
202−#footer a {
203− color: white;
204− text-decoration: underline;
205−}
206−
207−.hover {
208− color: steelblue;
209− text-decoration: none;
210−}
211−
212−.body {
213− width: 960px;
214− margin: auto;
215−}
216−
217−.footfirst {
218− position: relative;
219− top: 30px;
220−}
221−
222−th {
223− font-weight: 500;
224− opacity: 0.8;
225−}
226−
227−th.cibound {
228− opacity: 0.4;
229−}
230−
231−.confinterval {
232− opacity: 0.5;
233−}
234−
235−h1 {
236− font-size: 36px;
237− font-weight: 300;
238− margin-bottom: .3em;
239−}
240−
241−h2 {
242− font-size: 30px;
243− font-weight: 300;
244− margin-bottom: .3em;
245−}
246−
247−.meanlegend {
248− color: #404040;
249− background-color: #ffffff;
250− opacity: 0.6;
251− font-size: smaller;
252−}
253−
254− </style>
255− <!--[if !IE 7]>
256− <style type="text/css">
257− #wrap {display:table;height:100%}
258− </style>
259− <![endif]-->
260− </head>
261− <body>
262− <div id="wrap">
263− <div id="main" class="body">
264− <h1>criterion performance measurements</h1>
265−
266−<h2>overview</h2>
267−
268−<p><a href="#grokularation">want to understand this report?</a></p>
269−
270−<p>Environment: AMD Opteron 6168 on Ubuntu 12.04 with GHC 8.0.2</p>
271−
272−<div id="overview" class="ovchart" style="width:900px;height:100px;"></div>
273−
274−<h2><a name="b0">create/relation 10x100</a></h2>
275− <table width="100%">
276− <tbody>
277− <tr>
278− <td><div id="kde0" class="kdechart"
279− style="width:450px;height:278px;"></div></td>
280− <td><div id="time0" class="timechart"
281− style="width:450px;height:278px;"></div></td>
282−<!--
283− <td><div id="cycle0" class="cyclechart"
284− style="width:300px;height:278px;"></div></td>
285−-->
286− </tr>
287− </tbody>
288− </table>
289−
290− <table>
291− <thead class="analysis">
292− <th></th>
293− <th class="cibound"
294− title="0.95 confidence level">lower bound</th>
295− <th>estimate</th>
296− <th class="cibound"
297− title="0.95 confidence level">upper bound</th>
298− </thead>
299− <tbody>
300− <tr>
301− <td>OLS regression</td>
302− <td><span class="confinterval olstimelb0">xxx</span></td>
303− <td><span class="olstimept0">xxx</span></td>
304− <td><span class="confinterval olstimeub0">xxx</span></td>
305− </tr>
306− <tr>
307− <td>R&#xb2; goodness-of-fit</td>
308− <td><span class="confinterval olsr2lb0">xxx</span></td>
309− <td><span class="olsr2pt0">xxx</span></td>
310− <td><span class="confinterval olsr2ub0">xxx</span></td>
311− </tr>
312− <tr>
313− <td>Mean execution time</td>
314− <td><span class="confinterval citime">5.891481267739451e-4</span></td>
315− <td><span class="time">5.906283388143756e-4</span></td>
316− <td><span class="confinterval citime">5.919056866982677e-4</span></td>
317− </tr>
318− <tr>
319− <td>Standard deviation</td>
320− <td><span class="confinterval citime">3.7867077713250133e-6</span></td>
321− <td><span class="time">4.502571301832575e-6</span></td>
322− <td><span class="confinterval citime">5.8062391798041006e-6</span></td>
323− </tr>
324− </tbody>
325− </table>
326−
327− <span class="outliers">
328− <p>Outlying measurements have slight
329− (<span class="percent">1.2343749999999981e-2</span>%)
330− effect on estimated standard deviation.</p>
331− </span>
332−<h2><a name="b1">create/relation 10x1000</a></h2>
333− <table width="100%">
334− <tbody>
335− <tr>
336− <td><div id="kde1" class="kdechart"
337− style="width:450px;height:278px;"></div></td>
338− <td><div id="time1" class="timechart"
339− style="width:450px;height:278px;"></div></td>
340−<!--
341− <td><div id="cycle1" class="cyclechart"
342− style="width:300px;height:278px;"></div></td>
343−-->
344− </tr>
345− </tbody>
346− </table>
347−
348− <table>
349− <thead class="analysis">
350− <th></th>
351− <th class="cibound"
352− title="0.95 confidence level">lower bound</th>
353− <th>estimate</th>
354− <th class="cibound"
355− title="0.95 confidence level">upper bound</th>
356− </thead>
357− <tbody>
358− <tr>
359− <td>OLS regression</td>
360− <td><span class="confinterval olstimelb1">xxx</span></td>
361− <td><span class="olstimept1">xxx</span></td>
362− <td><span class="confinterval olstimeub1">xxx</span></td>
363− </tr>
364− <tr>
365− <td>R&#xb2; goodness-of-fit</td>
366− <td><span class="confinterval olsr2lb1">xxx</span></td>
367− <td><span class="olsr2pt1">xxx</span></td>
368− <td><span class="confinterval olsr2ub1">xxx</span></td>
369− </tr>
370− <tr>
371− <td>Mean execution time</td>
372− <td><span class="confinterval citime">5.760191573102873e-3</span></td>
373− <td><span class="time">5.770838309782314e-3</span></td>
374− <td><span class="confinterval citime">5.779948952798578e-3</span></td>
375− </tr>
376− <tr>
377− <td>Standard deviation</td>
378− <td><span class="confinterval citime">2.2935863601065537e-5</span></td>
379− <td><span class="time">2.8815215559732134e-5</span></td>
380− <td><span class="confinterval citime">3.914144050420156e-5</span></td>
381− </tr>
382− </tbody>
383− </table>
384−
385− <span class="outliers">
386− <p>Outlying measurements have slight
387− (<span class="percent">2.5623268698060614e-2</span>%)
388− effect on estimated standard deviation.</p>
389− </span>
390−<h2><a name="b2">create/relation 10x10000</a></h2>
391− <table width="100%">
392− <tbody>
393− <tr>
394− <td><div id="kde2" class="kdechart"
395− style="width:450px;height:278px;"></div></td>
396− <td><div id="time2" class="timechart"
397− style="width:450px;height:278px;"></div></td>
398−<!--
399− <td><div id="cycle2" class="cyclechart"
400− style="width:300px;height:278px;"></div></td>
401−-->
402− </tr>
403− </tbody>
404− </table>
405−
406− <table>
407− <thead class="analysis">
408− <th></th>
409− <th class="cibound"
410− title="0.95 confidence level">lower bound</th>
411− <th>estimate</th>
412− <th class="cibound"
413− title="0.95 confidence level">upper bound</th>
414− </thead>
415− <tbody>
416− <tr>
417− <td>OLS regression</td>
418− <td><span class="confinterval olstimelb2">xxx</span></td>
419− <td><span class="olstimept2">xxx</span></td>
420− <td><span class="confinterval olstimeub2">xxx</span></td>
421− </tr>
422− <tr>
423− <td>R&#xb2; goodness-of-fit</td>
424− <td><span class="confinterval olsr2lb2">xxx</span></td>
425− <td><span class="olsr2pt2">xxx</span></td>
426− <td><span class="confinterval olsr2ub2">xxx</span></td>
427− </tr>
428− <tr>
429− <td>Mean execution time</td>
430− <td><span class="confinterval citime">5.772489494946795e-2</span></td>
431− <td><span class="time">5.784195729887314e-2</span></td>
432− <td><span class="confinterval citime">5.792298187695035e-2</span></td>
433− </tr>
434− <tr>
435− <td>Standard deviation</td>
436− <td><span class="confinterval citime">1.0422507194091924e-4</span></td>
437− <td><span class="time">1.7121491767487851e-4</span></td>
438− <td><span class="confinterval citime">2.73724491538287e-4</span></td>
439− </tr>
440− </tbody>
441− </table>
442−
443− <span class="outliers">
444− <p>Outlying measurements have slight
445− (<span class="percent">7.638888888888888e-2</span>%)
446− effect on estimated standard deviation.</p>
447− </span>
448−<h2><a name="b3">restrict/restrict relation 10x10000 to 10x1</a></h2>
449− <table width="100%">
450− <tbody>
451− <tr>
452− <td><div id="kde3" class="kdechart"
453− style="width:450px;height:278px;"></div></td>
454− <td><div id="time3" class="timechart"
455− style="width:450px;height:278px;"></div></td>
456−<!--
457− <td><div id="cycle3" class="cyclechart"
458− style="width:300px;height:278px;"></div></td>
459−-->
460− </tr>
461− </tbody>
462− </table>
463−
464− <table>
465− <thead class="analysis">
466− <th></th>
467− <th class="cibound"
468− title="0.95 confidence level">lower bound</th>
469− <th>estimate</th>
470− <th class="cibound"
471− title="0.95 confidence level">upper bound</th>
472− </thead>
473− <tbody>
474− <tr>
475− <td>OLS regression</td>
476− <td><span class="confinterval olstimelb3">xxx</span></td>
477− <td><span class="olstimept3">xxx</span></td>
478− <td><span class="confinterval olstimeub3">xxx</span></td>
479− </tr>
480− <tr>
481− <td>R&#xb2; goodness-of-fit</td>
482− <td><span class="confinterval olsr2lb3">xxx</span></td>
483− <td><span class="olsr2pt3">xxx</span></td>
484− <td><span class="confinterval olsr2ub3">xxx</span></td>
485− </tr>
486− <tr>
487− <td>Mean execution time</td>
488− <td><span class="confinterval citime">1.4337830338577313e-2</span></td>
489− <td><span class="time">1.448797309139284e-2</span></td>
490− <td><span class="confinterval citime">1.4763601823824296e-2</span></td>
491− </tr>
492− <tr>
493− <td>Standard deviation</td>
494− <td><span class="confinterval citime">2.772536754203617e-4</span></td>
495− <td><span class="time">4.774249175945004e-4</span></td>
496− <td><span class="confinterval citime">8.291091461013828e-4</span></td>
497− </tr>
498− </tbody>
499− </table>
500−
501− <span class="outliers">
502− <p>Outlying measurements have moderate
503− (<span class="percent">0.11563227985262721</span>%)
504− effect on estimated standard deviation.</p>
505− </span>
506−<h2><a name="b4">restrict/restrict relation 10x10000 to 10x5000</a></h2>
507− <table width="100%">
508− <tbody>
509− <tr>
510− <td><div id="kde4" class="kdechart"
511− style="width:450px;height:278px;"></div></td>
512− <td><div id="time4" class="timechart"
513− style="width:450px;height:278px;"></div></td>
514−<!--
515− <td><div id="cycle4" class="cyclechart"
516− style="width:300px;height:278px;"></div></td>
517−-->
518− </tr>
519− </tbody>
520− </table>
521−
522− <table>
523− <thead class="analysis">
524− <th></th>
525− <th class="cibound"
526− title="0.95 confidence level">lower bound</th>
527− <th>estimate</th>
528− <th class="cibound"
529− title="0.95 confidence level">upper bound</th>
530− </thead>
531− <tbody>
532− <tr>
533− <td>OLS regression</td>
534− <td><span class="confinterval olstimelb4">xxx</span></td>
535− <td><span class="olstimept4">xxx</span></td>
536− <td><span class="confinterval olstimeub4">xxx</span></td>
537− </tr>
538− <tr>
539− <td>R&#xb2; goodness-of-fit</td>
540− <td><span class="confinterval olsr2lb4">xxx</span></td>
541− <td><span class="olsr2pt4">xxx</span></td>
542− <td><span class="confinterval olsr2ub4">xxx</span></td>
543− </tr>
544− <tr>
545− <td>Mean execution time</td>
546− <td><span class="confinterval citime">8.322941573263729e-2</span></td>
547− <td><span class="time">8.447258684075218e-2</span></td>
548− <td><span class="confinterval citime">8.511386931168204e-2</span></td>
549− </tr>
550− <tr>
551− <td>Standard deviation</td>
552− <td><span class="confinterval citime">6.118316959029327e-4</span></td>
553− <td><span class="time">1.4013810341920257e-3</span></td>
554− <td><span class="confinterval citime">2.3016514403696887e-3</span></td>
555− </tr>
556− </tbody>
557− </table>
558−
559− <span class="outliers">
560− <p>Outlying measurements have slight
561− (<span class="percent">9.0e-2</span>%)
562− effect on estimated standard deviation.</p>
563− </span>
564−<h2><a name="b5">project/project 10x1000 to 1x1000</a></h2>
565− <table width="100%">
566− <tbody>
567− <tr>
568− <td><div id="kde5" class="kdechart"
569− style="width:450px;height:278px;"></div></td>
570− <td><div id="time5" class="timechart"
571− style="width:450px;height:278px;"></div></td>
572−<!--
573− <td><div id="cycle5" class="cyclechart"
574− style="width:300px;height:278px;"></div></td>
575−-->
576− </tr>
577− </tbody>
578− </table>
579−
580− <table>
581− <thead class="analysis">
582− <th></th>
583− <th class="cibound"
584− title="0.95 confidence level">lower bound</th>
585− <th>estimate</th>
586− <th class="cibound"
587− title="0.95 confidence level">upper bound</th>
588− </thead>
589− <tbody>
590− <tr>
591− <td>OLS regression</td>
592− <td><span class="confinterval olstimelb5">xxx</span></td>
593− <td><span class="olstimept5">xxx</span></td>
594− <td><span class="confinterval olstimeub5">xxx</span></td>
595− </tr>
596− <tr>
597− <td>R&#xb2; goodness-of-fit</td>
598− <td><span class="confinterval olsr2lb5">xxx</span></td>
599− <td><span class="olsr2pt5">xxx</span></td>
600− <td><span class="confinterval olsr2ub5">xxx</span></td>
601− </tr>
602− <tr>
603− <td>Mean execution time</td>
604− <td><span class="confinterval citime">1.2211661066456561e-2</span></td>
605− <td><span class="time">1.243577405705988e-2</span></td>
606− <td><span class="confinterval citime">1.2583044006972743e-2</span></td>
607− </tr>
608− <tr>
609− <td>Standard deviation</td>
610− <td><span class="confinterval citime">3.0211460384957275e-4</span></td>
611− <td><span class="time">4.600204612133745e-4</span></td>
612− <td><span class="confinterval citime">5.956804020691042e-4</span></td>
613− </tr>
614− </tbody>
615− </table>
616−
617− <span class="outliers">
618− <p>Outlying measurements have moderate
619− (<span class="percent">0.14345146934193906</span>%)
620− effect on estimated standard deviation.</p>
621− </span>
622−<h2><a name="b6">project/project 10x1000 to 5x1000</a></h2>
623− <table width="100%">
624− <tbody>
625− <tr>
626− <td><div id="kde6" class="kdechart"
627− style="width:450px;height:278px;"></div></td>
628− <td><div id="time6" class="timechart"
629− style="width:450px;height:278px;"></div></td>
630−<!--
631− <td><div id="cycle6" class="cyclechart"
632− style="width:300px;height:278px;"></div></td>
633−-->
634− </tr>
635− </tbody>
636− </table>
637−
638− <table>
639− <thead class="analysis">
640− <th></th>
641− <th class="cibound"
642− title="0.95 confidence level">lower bound</th>
643− <th>estimate</th>
644− <th class="cibound"
645− title="0.95 confidence level">upper bound</th>
646− </thead>
647− <tbody>
648− <tr>
649− <td>OLS regression</td>
650− <td><span class="confinterval olstimelb6">xxx</span></td>
651− <td><span class="olstimept6">xxx</span></td>
652− <td><span class="confinterval olstimeub6">xxx</span></td>
653− </tr>
654− <tr>
655− <td>R&#xb2; goodness-of-fit</td>
656− <td><span class="confinterval olsr2lb6">xxx</span></td>
657− <td><span class="olsr2pt6">xxx</span></td>
658− <td><span class="confinterval olsr2ub6">xxx</span></td>
659− </tr>
660− <tr>
661− <td>Mean execution time</td>
662− <td><span class="confinterval citime">1.5271674270594341e-2</span></td>
663− <td><span class="time">1.547382196820991e-2</span></td>
664− <td><span class="confinterval citime">1.5622307025724294e-2</span></td>
665− </tr>
666− <tr>
667− <td>Standard deviation</td>
668− <td><span class="confinterval citime">2.873217405621163e-4</span></td>
669− <td><span class="time">3.978143402171812e-4</span></td>
670− <td><span class="confinterval citime">5.247713511789067e-4</span></td>
671− </tr>
672− </tbody>
673− </table>
674−
675− <span class="outliers">
676− <p>Outlying measurements have slight
677− (<span class="percent">4.1587901701323225e-2</span>%)
678− effect on estimated standard deviation.</p>
679− </span>
680−<h2><a name="b7">union/union identical 10x1000</a></h2>
681− <table width="100%">
682− <tbody>
683− <tr>
684− <td><div id="kde7" class="kdechart"
685− style="width:450px;height:278px;"></div></td>
686− <td><div id="time7" class="timechart"
687− style="width:450px;height:278px;"></div></td>
688−<!--
689− <td><div id="cycle7" class="cyclechart"
690− style="width:300px;height:278px;"></div></td>
691−-->
692− </tr>
693− </tbody>
694− </table>
695−
696− <table>
697− <thead class="analysis">
698− <th></th>
699− <th class="cibound"
700− title="0.95 confidence level">lower bound</th>
701− <th>estimate</th>
702− <th class="cibound"
703− title="0.95 confidence level">upper bound</th>
704− </thead>
705− <tbody>
706− <tr>
707− <td>OLS regression</td>
708− <td><span class="confinterval olstimelb7">xxx</span></td>
709− <td><span class="olstimept7">xxx</span></td>
710− <td><span class="confinterval olstimeub7">xxx</span></td>
711− </tr>
712− <tr>
713− <td>R&#xb2; goodness-of-fit</td>
714− <td><span class="confinterval olsr2lb7">xxx</span></td>
715− <td><span class="olsr2pt7">xxx</span></td>
716− <td><span class="confinterval olsr2ub7">xxx</span></td>
717− </tr>
718− <tr>
719− <td>Mean execution time</td>
720− <td><span class="confinterval citime">4.908323998442862e-2</span></td>
721− <td><span class="time">4.923173514046889e-2</span></td>
722− <td><span class="confinterval citime">4.94547578201357e-2</span></td>
723− </tr>
724− <tr>
725− <td>Standard deviation</td>
726− <td><span class="confinterval citime">2.09615306506087e-4</span></td>
727− <td><span class="time">3.275115670368287e-4</span></td>
728− <td><span class="confinterval citime">4.977889379852797e-4</span></td>
729− </tr>
730− </tbody>
731− </table>
732−
733− <span class="outliers">
734− <p>Outlying measurements have slight
735− (<span class="percent">7.100591715976319e-2</span>%)
736− effect on estimated standard deviation.</p>
737− </span>
738−<h2><a name="b8">union/union identical 10x10000</a></h2>
739− <table width="100%">
740− <tbody>
741− <tr>
742− <td><div id="kde8" class="kdechart"
743− style="width:450px;height:278px;"></div></td>
744− <td><div id="time8" class="timechart"
745− style="width:450px;height:278px;"></div></td>
746−<!--
747− <td><div id="cycle8" class="cyclechart"
748− style="width:300px;height:278px;"></div></td>
749−-->
750− </tr>
751− </tbody>
752− </table>
753−
754− <table>
755− <thead class="analysis">
756− <th></th>
757− <th class="cibound"
758− title="0.95 confidence level">lower bound</th>
759− <th>estimate</th>
760− <th class="cibound"
761− title="0.95 confidence level">upper bound</th>
762− </thead>
763− <tbody>
764− <tr>
765− <td>OLS regression</td>
766− <td><span class="confinterval olstimelb8">xxx</span></td>
767− <td><span class="olstimept8">xxx</span></td>
768− <td><span class="confinterval olstimeub8">xxx</span></td>
769− </tr>
770− <tr>
771− <td>R&#xb2; goodness-of-fit</td>
772− <td><span class="confinterval olsr2lb8">xxx</span></td>
773− <td><span class="olsr2pt8">xxx</span></td>
774− <td><span class="confinterval olsr2ub8">xxx</span></td>
775− </tr>
776− <tr>
777− <td>Mean execution time</td>
778− <td><span class="confinterval citime">0.5144192261126985</span></td>
779− <td><span class="time">0.5157808375258943</span></td>
780− <td><span class="confinterval citime">0.5164000385072457</span></td>
781− </tr>
782− <tr>
783− <td>Standard deviation</td>
784− <td><span class="confinterval citime">0</span></td>
785− <td><span class="time">1.1935851498586624e-3</span></td>
786− <td><span class="confinterval citime">1.285892588023751e-3</span></td>
787− </tr>
788− </tbody>
789− </table>
790−
791− <span class="outliers">
792− <p>Outlying measurements have moderate
793− (<span class="percent">0.18749999999999997</span>%)
794− effect on estimated standard deviation.</p>
795− </span>
796−<h2><a name="b9">join/join identical 10x100</a></h2>
797− <table width="100%">
798− <tbody>
799− <tr>
800− <td><div id="kde9" class="kdechart"
801− style="width:450px;height:278px;"></div></td>
802− <td><div id="time9" class="timechart"
803− style="width:450px;height:278px;"></div></td>
804−<!--
805− <td><div id="cycle9" class="cyclechart"
806− style="width:300px;height:278px;"></div></td>
807−-->
808− </tr>
809− </tbody>
810− </table>
811−
812− <table>
813− <thead class="analysis">
814− <th></th>
815− <th class="cibound"
816− title="0.95 confidence level">lower bound</th>
817− <th>estimate</th>
818− <th class="cibound"
819− title="0.95 confidence level">upper bound</th>
820− </thead>
821− <tbody>
822− <tr>
823− <td>OLS regression</td>
824− <td><span class="confinterval olstimelb9">xxx</span></td>
825− <td><span class="olstimept9">xxx</span></td>
826− <td><span class="confinterval olstimeub9">xxx</span></td>
827− </tr>
828− <tr>
829− <td>R&#xb2; goodness-of-fit</td>
830− <td><span class="confinterval olsr2lb9">xxx</span></td>
831− <td><span class="olsr2pt9">xxx</span></td>
832− <td><span class="confinterval olsr2ub9">xxx</span></td>
833− </tr>
834− <tr>
835− <td>Mean execution time</td>
836− <td><span class="confinterval citime">0.3355841931137941</span></td>
837− <td><span class="time">0.3374978199984254</span></td>
838− <td><span class="confinterval citime">0.3385756312293291</span></td>
839− </tr>
840− <tr>
841− <td>Standard deviation</td>
842− <td><span class="confinterval citime">0</span></td>
843− <td><span class="time">1.6965376723717264e-3</span></td>
844− <td><span class="confinterval citime">1.8668238128934738e-3</span></td>
845− </tr>
846− </tbody>
847− </table>
848−
849− <span class="outliers">
850− <p>Outlying measurements have moderate
851− (<span class="percent">0.1875</span>%)
852− effect on estimated standard deviation.</p>
853− </span>
854−<h2><a name="b10">group/group 10x100</a></h2>
855− <table width="100%">
856− <tbody>
857− <tr>
858− <td><div id="kde10" class="kdechart"
859− style="width:450px;height:278px;"></div></td>
860− <td><div id="time10" class="timechart"
861− style="width:450px;height:278px;"></div></td>
862−<!--
863− <td><div id="cycle10" class="cyclechart"
864− style="width:300px;height:278px;"></div></td>
865−-->
866− </tr>
867− </tbody>
868− </table>
869−
870− <table>
871− <thead class="analysis">
872− <th></th>
873− <th class="cibound"
874− title="0.95 confidence level">lower bound</th>
875− <th>estimate</th>
876− <th class="cibound"
877− title="0.95 confidence level">upper bound</th>
878− </thead>
879− <tbody>
880− <tr>
881− <td>OLS regression</td>
882− <td><span class="confinterval olstimelb10">xxx</span></td>
883− <td><span class="olstimept10">xxx</span></td>
884− <td><span class="confinterval olstimeub10">xxx</span></td>
885− </tr>
886− <tr>
887− <td>R&#xb2; goodness-of-fit</td>
888− <td><span class="confinterval olsr2lb10">xxx</span></td>
889− <td><span class="olsr2pt10">xxx</span></td>
890− <td><span class="confinterval olsr2ub10">xxx</span></td>
891− </tr>
892− <tr>
893− <td>Mean execution time</td>
894− <td><span class="confinterval citime">4.666001885635249e-2</span></td>
895− <td><span class="time">4.70336206675725e-2</span></td>
896− <td><span class="confinterval citime">4.7476184359486216e-2</span></td>
897− </tr>
898− <tr>
899− <td>Standard deviation</td>
900− <td><span class="confinterval citime">5.178696454087703e-4</span></td>
901− <td><span class="time">7.389605929837668e-4</span></td>
902− <td><span class="confinterval citime">1.1404867684675546e-3</span></td>
903− </tr>
904− </tbody>
905− </table>
906−
907− <span class="outliers">
908− <p>Outlying measurements have slight
909− (<span class="percent">7.100591715976322e-2</span>%)
910− effect on estimated standard deviation.</p>
911− </span>
912−<h2><a name="b11">write/write 10x1000</a></h2>
913− <table width="100%">
914− <tbody>
915− <tr>
916− <td><div id="kde11" class="kdechart"
917− style="width:450px;height:278px;"></div></td>
918− <td><div id="time11" class="timechart"
919− style="width:450px;height:278px;"></div></td>
920−<!--
921− <td><div id="cycle11" class="cyclechart"
922− style="width:300px;height:278px;"></div></td>
923−-->
924− </tr>
925− </tbody>
926− </table>
927−
928− <table>
929− <thead class="analysis">
930− <th></th>
931− <th class="cibound"
932− title="0.95 confidence level">lower bound</th>
933− <th>estimate</th>
934− <th class="cibound"
935− title="0.95 confidence level">upper bound</th>
936− </thead>
937− <tbody>
938− <tr>
939− <td>OLS regression</td>
940− <td><span class="confinterval olstimelb11">xxx</span></td>
941− <td><span class="olstimept11">xxx</span></td>
942− <td><span class="confinterval olstimeub11">xxx</span></td>
943− </tr>
944− <tr>
945− <td>R&#xb2; goodness-of-fit</td>
946− <td><span class="confinterval olsr2lb11">xxx</span></td>
947− <td><span class="olsr2pt11">xxx</span></td>
948− <td><span class="confinterval olsr2ub11">xxx</span></td>
949− </tr>
950− <tr>
951− <td>Mean execution time</td>
952− <td><span class="confinterval citime">1.5472953190097016e-3</span></td>
953− <td><span class="time">1.5673276303702817e-3</span></td>
954− <td><span class="confinterval citime">1.5890440248897237e-3</span></td>
955− </tr>
956− <tr>
957− <td>Standard deviation</td>
958− <td><span class="confinterval citime">6.110376965683773e-5</span></td>
959− <td><span class="time">6.970009193368111e-5</span></td>
960− <td><span class="confinterval citime">7.954403273020534e-5</span></td>
961− </tr>
962− </tbody>
963− </table>
964−
965− <span class="outliers">
966− <p>Outlying measurements have moderate
967− (<span class="percent">0.30346203307926556</span>%)
968− effect on estimated standard deviation.</p>
969− </span>
970−
971− <h2><a name="grokularation">understanding this report</a></h2>
972−
973− <p>In this report, each function benchmarked by criterion is assigned
974− a section of its own. The charts in each section are active; if
975− you hover your mouse over data points and annotations, you will see
976− more details.</p>
977−
978− <ul>
979− <li>The chart on the left is a
980− <a href="http://en.wikipedia.org/wiki/Kernel_density_estimation">kernel
981− density estimate</a> (also known as a KDE) of time
982− measurements. This graphs the probability of any given time
983− measurement occurring. A spike indicates that a measurement of a
984− particular time occurred; its height indicates how often that
985− measurement was repeated.</li>
986−
987− <li>The chart on the right is the raw data from which the kernel
988− density estimate is built. The <i>x</i> axis indicates the
989− number of loop iterations, while the <i>y</i> axis shows measured
990− execution time for the given number of loop iterations. The
991− line behind the values is the linear regression prediction of
992− execution time for a given number of iterations. Ideally, all
993− measurements will be on (or very near) this line.</li>
994− </ul>
995−
996− <p>Under the charts is a small table.
997− The first two rows are the results of a linear regression run
998− on the measurements displayed in the right-hand chart.</p>
999−
1000− <ul>
1001− <li><i>OLS regression</i> indicates the
1002− time estimated for a single loop iteration using an ordinary
1003− least-squares regression model. This number is more accurate
1004− than the <i>mean</i> estimate below it, as it more effectively
1005− eliminates measurement overhead and other constant factors.</li>
1006− <li><i>R&#xb2; goodness-of-fit</i> is a measure of how
1007− accurately the linear regression model fits the observed
1008− measurements. If the measurements are not too noisy, R&#xb2;
1009− should lie between 0.99 and 1, indicating an excellent fit. If
1010− the number is below 0.99, something is confounding the accuracy
1011− of the linear model.</li>
1012− <li><i>Mean execution time</i> and <i>standard deviation</i> are
1013− statistics calculated from execution time
1014− divided by number of iterations.</li>
1015− </ul>
1016−
1017− <p>We use a statistical technique called
1018− the <a href="http://en.wikipedia.org/wiki/Bootstrapping_(statistics)">bootstrap</a>
1019− to provide confidence intervals on our estimates. The
1020− bootstrap-derived upper and lower bounds on estimates let you see
1021− how accurate we believe those estimates to be. (Hover the mouse
1022− over the table headers to see the confidence levels.)</p>
1023−
1024− <p>A noisy benchmarking environment can cause some or many
1025− measurements to fall far from the mean. These outlying
1026− measurements can have a significant inflationary effect on the
1027− estimate of the standard deviation. We calculate and display an
1028− estimate of the extent to which the standard deviation has been
1029− inflated by outliers.</p>
1030−
1031−<script type="text/javascript">
1032−$(function () {
1033− function mangulate(rpt) {
1034− var measured = function(key) {
1035− var idx = rpt.reportKeys.indexOf(key);
1036− return rpt.reportMeasured.map(function(r) { return r[idx]; });
1037− };
1038− var lowerBound = function(est) {
1039− return est.estPoint - est.estError.confIntLDX;
1040− };
1041− var upperBound = function(est) {
1042− return est.estPoint + est.estError.confIntUDX;
1043− };
1044− var number = rpt.reportNumber;
1045− var name = rpt.reportName;
1046− var mean = rpt.reportAnalysis.anMean.estPoint;
1047− var iters = measured("iters");
1048− var times = measured("time");
1049− var kdetimes = rpt.reportKDEs[0].kdeValues;
1050− var kdepdf = rpt.reportKDEs[0].kdePDF;
1051−
1052− var meanSecs = mean;
1053− var units = $.timeUnits(mean);
1054− var rgrs = rpt.reportAnalysis.anRegress[0];
1055− var scale = units[0];
1056− var olsTime = rgrs.regCoeffs.iters;
1057− $(".olstimept" + number).text(function() {
1058− return $.renderTime(olsTime.estPoint);
1059− });
1060− $(".olstimelb" + number).text(function() {
1061− return $.renderTime(lowerBound(olsTime));
1062− });
1063− $(".olstimeub" + number).text(function() {
1064− return $.renderTime(upperBound(olsTime));
1065− });
1066− $(".olsr2pt" + number).text(function() {
1067− return rgrs.regRSquare.estPoint.toFixed(3);
1068− });
1069− $(".olsr2lb" + number).text(function() {
1070− return lowerBound(rgrs.regRSquare).toFixed(3);
1071− });
1072− $(".olsr2ub" + number).text(function() {
1073− return upperBound(rgrs.regRSquare).toFixed(3);
1074− });
1075− mean *= scale;
1076− kdetimes = $.scaleBy(scale, kdetimes);
1077− var kq = $("#kde" + number);
1078− var k = $.plot(kq,
1079− [{ label: name + " time densities",
1080− data: $.zip(kdetimes, kdepdf),
1081− }],
1082− { xaxis: { tickFormatter: $.unitFormatter(scale) },
1083− yaxis: { ticks: false },
1084− grid: { borderColor: "#777",
1085− hoverable: true, markings: [ { color: '#6fd3fb',
1086− lineWidth: 1.5, xaxis: { from: mean, to: mean } } ] },
1087− });
1088− var o = k.pointOffset({ x: mean, y: 0});
1089− kq.append('<div class="meanlegend" title="' + $.renderTime(meanSecs) +
1090− '" style="position:absolute;left:' + (o.left + 4) +
1091− 'px;bottom:139px;">mean</div>');
1092− $.addTooltip("#kde" + number,
1093− function(secs) { return $.renderTime(secs / scale); });
1094− var timepairs = new Array(times.length);
1095− var lastiter = iters[iters.length-1];
1096− var olspairs = [[0,0], [lastiter, lastiter * scale * olsTime.estPoint]];
1097− for (var i = 0; i < times.length; i++)
1098− timepairs[i] = [iters[i],times[i]*scale];
1099− iterFormatter = function() {
1100− var denom = 0;
1101− return function(iters) {
1102− if (iters == 0)
1103− return '';
1104− if (denom > 0)
1105− return (iters / denom).toFixed();
1106− var power;
1107− if (iters >= 1e9) {
1108− denom = '1e9'; power = '&#x2079;';
1109− }
1110− if (iters >= 1e6) {
1111− denom = '1e6'; power = '&#x2076;';
1112− }
1113− else if (iters >= 1e3) {
1114− denom = '1e3'; power = '&#xb3;';
1115− }
1116− else denom = 1;
1117− if (denom > 1) {
1118− iters = (iters / denom).toFixed();
1119− iters += '&times;10' + power + ' iters';
1120− } else {
1121− iters += ' iters';
1122− }
1123− return iters;
1124− };
1125− };
1126− $.plot($("#time" + number),
1127− [{ label: "regression", data: olspairs,
1128− lines: { show: true } },
1129− { label: name + " times", data: timepairs,
1130− points: { show: true } }],
1131− { grid: { borderColor: "#777", hoverable: true },
1132− xaxis: { tickFormatter: iterFormatter() },
1133− yaxis: { tickFormatter: $.unitFormatter(scale) } });
1134− $.addTooltip("#time" + number,
1135− function(iters,secs) {
1136− return ($.renderTime(secs / scale) + ' / ' +
1137− iters.toLocaleString() + ' iters');
1138− });
1139− if (0) {
1140− var cyclepairs = new Array(cycles.length);
1141− for (var i = 0; i < cycles.length; i++)
1142− cyclepairs[i] = [cycles[i],i];
1143− $.plot($("#cycle" + number),
1144− [{ label: name + " cycles",
1145− data: cyclepairs }],
1146− { points: { show: true },
1147− grid: { borderColor: "#777", hoverable: true },
1148− xaxis: { tickFormatter:
1149− function(cycles,axis) { return cycles + ' cycles'; }},
1150− yaxis: { ticks: false },
1151− });
1152− $.addTooltip("#cycles" + number, function(x,y) { return x + ' cycles'; });
1153− }
1154− };
1155− var reports = [{"reportAnalysis":{"anMean":{"estError":{"confIntLDX":1.480212040430454e-6,"confIntUDX":1.2773478838920983e-6,"confIntCL":5.0e-2},"estPoint":5.906283388143756e-4},"anRegress":[{"regRSquare":{"estError":{"confIntLDX":3.555021666379332e-6,"confIntUDX":3.2835390818553023e-6,"confIntCL":5.0e-2},"estPoint":0.999994210390811},"regResponder":"time","regCoeffs":{"y":{"estError":{"confIntLDX":3.992840580325896e-5,"confIntUDX":3.5096033885701615e-5,"confIntCL":5.0e-2},"estPoint":4.5018032731655834e-5},"iters":{"estError":{"confIntLDX":4.916701435576497e-7,"confIntUDX":6.481819002255793e-7,"confIntCL":5.0e-2},"estPoint":5.990242120138069e-4}}}],"anStdDev":{"estError":{"confIntLDX":7.158635305075615e-7,"confIntUDX":1.3036678779715258e-6,"confIntCL":5.0e-2},"estPoint":4.502571301832575e-6},"anOutlierVar":{"ovFraction":1.2343749999999981e-2,"ovDesc":"slight","ovEffect":"Slight"},"anOverhead":2.1820495514718956e-3},"reportKDEs":[{"kdeValues":[5.767309127295322e-4,5.769143047848586e-4,5.770976968401851e-4,5.772810888955115e-4,5.77464480950838e-4,5.776478730061645e-4,5.77831265061491e-4,5.780146571168174e-4,5.781980491721439e-4,5.783814412274703e-4,5.785648332827969e-4,5.787482253381233e-4,5.789316173934497e-4,5.791150094487762e-4,5.792984015041027e-4,5.794817935594292e-4,5.796651856147556e-4,5.798485776700821e-4,5.800319697254085e-4,5.802153617807351e-4,5.803987538360615e-4,5.80582145891388e-4,5.807655379467144e-4,5.80948930002041e-4,5.811323220573674e-4,5.813157141126938e-4,5.814991061680203e-4,5.816824982233467e-4,5.818658902786733e-4,5.820492823339997e-4,5.822326743893262e-4,5.824160664446526e-4,5.825994584999791e-4,5.827828505553056e-4,5.829662426106321e-4,5.831496346659585e-4,5.833330267212849e-4,5.835164187766114e-4,5.836998108319379e-4,5.838832028872644e-4,5.840665949425908e-4,5.842499869979173e-4,5.844333790532437e-4,5.846167711085703e-4,5.848001631638967e-4,5.849835552192232e-4,5.851669472745496e-4,5.85350339329876e-4,5.855337313852026e-4,5.85717123440529e-4,5.859005154958555e-4,5.860839075511819e-4,5.862672996065085e-4,5.864506916618349e-4,5.866340837171614e-4,5.868174757724878e-4,5.870008678278143e-4,5.871842598831408e-4,5.873676519384673e-4,5.875510439937937e-4,5.877344360491201e-4,5.879178281044466e-4,5.881012201597731e-4,5.882846122150996e-4,5.88468004270426e-4,5.886513963257525e-4,5.88834788381079e-4,5.890181804364055e-4,5.892015724917319e-4,5.893849645470584e-4,5.895683566023848e-4,5.897517486577112e-4,5.899351407130378e-4,5.901185327683642e-4,5.903019248236907e-4,5.904853168790171e-4,5.906687089343437e-4,5.908521009896701e-4,5.910354930449966e-4,5.91218885100323e-4,5.914022771556495e-4,5.91585669210976e-4,5.917690612663024e-4,5.919524533216289e-4,5.921358453769553e-4,5.923192374322818e-4,5.925026294876083e-4,5.926860215429348e-4,5.928694135982612e-4,5.930528056535877e-4,5.932361977089142e-4,5.934195897642407e-4,5.936029818195671e-4,5.937863738748935e-4,5.9396976593022e-4,5.941531579855465e-4,5.94336550040873e-4,5.945199420961994e-4,5.947033341515259e-4,5.948867262068523e-4,5.950701182621789e-4,5.952535103175053e-4,5.954369023728318e-4,5.956202944281582e-4,5.958036864834846e-4,5.959870785388112e-4,5.961704705941376e-4,5.963538626494641e-4,5.965372547047905e-4,5.96720646760117e-4,5.969040388154435e-4,5.9708743087077e-4,5.972708229260964e-4,5.974542149814229e-4,5.976376070367494e-4,5.978209990920759e-4,5.980043911474023e-4,5.981877832027287e-4,5.983711752580552e-4,5.985545673133817e-4,5.987379593687082e-4,5.989213514240346e-4,5.991047434793611e-4,5.992881355346875e-4,5.994715275900141e-4,5.996549196453405e-4,5.99838311700667e-4,6.000217037559934e-4],"kdeType":"time","kdePDF":[7439.606200664009,7463.860772581996,7512.519471367643,7585.879034733249,7684.378650480464,7808.59288896541,7959.222344451404,8137.082052941013,8343.087784506373,8578.240345240563,8843.608066987465,9140.307710396293,9469.484056270247,9832.288508711508,10229.85707790064,10663.288147018666,11133.620453497775,11641.811726519703,12188.718418185661,12775.076943623719,13401.48680508669,14068.395917549335,14776.088380313859,15524.674853637032,16314.085605322467,17144.066194245657,18014.17566107358,18923.787006368777,19872.089658085122,20858.093568968376,21880.63454363045,22938.38037810305,24029.837403295212,25153.35705838,26307.1421796571,27489.252772337637,28697.611133056118,29930.00630457071,31184.097964923378,32457.419974418754,33747.38391792052,35051.283079886554,36366.2973683962,37689.499755989564,39017.864824376906,40348.27998326451,41677.55987863412,43002.46441251096,44319.720666231085,45626.048855992674,46918.19225848234,48192.9508326456,49447.218039767664,50678.02013753379,51882.55700504304,53058.24335548316,54202.74902189472,55314.036869023075,56390.396799555885,57430.47429337121,58433.29194928923,59398.26259347494,60325.19267798467,61214.27491525301,62066.069375311075,62881.472605315255,63661.67470632853,64408.10470879936,65122.36501266323,65806.15608584625,66461.19303076026,67089.1160163213,67691.39691757591,68269.24479142003,68823.51303185195,69354.61118031963,69862.42440713938,70346.24362265936,70804.70901910632,71235.76958662862,71636.66079434061,72003.90218716432,72333.31613345034,72620.06838137904,72858.73046143548,73043.3633274288,73167.62098077408,73224.87219401666,73208.33786178584,73111.2409815332,72926.96582184076,72649.22248949985,72272.2128714332,71790.79381341882,71200.63340969513,70498.35641645365,69681.67506379938,68749.50191620484,67702.04190771938,66540.86123835878,65268.93144221416,63890.64760364616,62411.82038186993,60839.642182361524,59182.628462524866,57450.535757302285,55654.25853871905,53805.707465851454,51917.67192636734,50003.67000988945,48077.78918372171,46154.520964229625,44248.59279791539,42374.80019444325,40547.841902338376,38782.160602275166,37091.79123010303,35490.21865040699,33990.24599998552,32603.874627041063,31342.19618255019,30215.2970895606,29232.17533570354,28400.669312593527,27727.39826820856,27217.713846527327,26875.662160911106,26703.955878966048]}],"reportKeys":["time","cpuTime","cycles","iters","allocated","numGcs","bytesCopied","mutatorWallSeconds","mutatorCpuSeconds","gcWallSeconds","gcCpuSeconds"],"reportNumber":0,"reportName":"create/relation 10x100","reportOutliers":{"highSevere":0,"highMild":0,"lowMild":0,"samplesSeen":42,"lowSevere":0},"reportMeasured":[[6.813240033807233e-4,6.795370000000009e-4,1291970,1,null,null,null,null,null,null,null],[1.2316010033828206e-3,1.2288760000000003e-3,2337568,2,null,null,null,null,null,null,null],[1.8350910031585954e-3,1.8311770000000033e-3,3484055,3,null,null,null,null,null,null,null],[2.427155995974317e-3,2.4221040000000013e-3,4608527,4,null,null,null,null,null,null,null],[3.0626340012531728e-3,3.052128000000001e-3,5816367,5,null,null,null,null,null,null,null],[3.638373003923334e-3,3.6385010000000023e-3,6911175,6,null,null,null,null,null,null,null],[4.216387998894788e-3,4.203885999999997e-3,8007897,7,null,null,null,null,null,null,null],[4.8334379971493036e-3,4.838462000000002e-3,9181602,8,null,null,null,null,null,null,null],[5.428168005892076e-3,5.415576000000005e-3,10312089,9,null,null,null,null,null,null,null],[6.012180994730443e-3,6.00813e-3,11421128,10,null,null,null,null,null,null,null],[6.5902550049941055e-3,6.592010999999995e-3,12518912,11,null,null,null,null,null,null,null],[7.23675199697027e-3,7.229662999999997e-3,13747464,12,null,null,null,null,null,null,null],[7.84011700307019e-3,7.831859999999996e-3,14893518,13,null,null,null,null,null,null,null],[8.434026000031736e-3,8.425254999999993e-3,16022852,14,null,null,null,null,null,null,null],[9.01525300287176e-3,9.005011000000007e-3,17125378,15,null,null,null,null,null,null,null],[9.62481100577861e-3,9.613589000000006e-3,18284524,16,null,null,null,null,null,null,null],[1.0174692004511598e-2,1.0159233000000017e-2,19330158,17,null,null,null,null,null,null,null],[1.0838796995813027e-2,1.0825276000000023e-2,20590579,18,null,null,null,null,null,null,null],[1.1404266006138641e-2,1.1396694000000013e-2,21666369,19,null,null,null,null,null,null,null],[1.2019466004858259e-2,1.200773400000002e-2,22835526,20,null,null,null,null,null,null,null],[1.2612122001883108e-2,1.2602988999999981e-2,23960806,21,null,null,null,null,null,null,null],[1.3185921001422685e-2,1.3175439999999983e-2,25039019,22,null,null,null,null,null,null,null],[1.380999500543112e-2,1.3800904000000003e-2,26235900,23,null,null,null,null,null,null,null],[1.5010613002232276e-2,1.5004187000000002e-2,28517754,25,null,null,null,null,null,null,null],[1.5596878998621833e-2,1.5588999999999964e-2,29631118,26,null,null,null,null,null,null,null],[1.619237400154816e-2,1.6183787000000005e-2,30763246,27,null,null,null,null,null,null,null],[1.6726298003050033e-2,1.6716809e-2,31778366,28,null,null,null,null,null,null,null],[1.7975681999814697e-2,1.7950438999999985e-2,34152290,30,null,null,null,null,null,null,null],[1.8578729999717325e-2,1.856606700000002e-2,35298278,31,null,null,null,null,null,null,null],[1.9729389998246916e-2,1.972127800000001e-2,37482481,33,null,null,null,null,null,null,null],[2.0979664994229097e-2,2.0962800000000004e-2,39859087,35,null,null,null,null,null,null,null],[2.1577223000349477e-2,2.1558966000000013e-2,40993942,36,null,null,null,null,null,null,null],[2.283525199891301e-2,2.282013599999999e-2,43384199,38,null,null,null,null,null,null,null],[2.397813599964138e-2,2.3962815000000026e-2,45555911,40,null,null,null,null,null,null,null],[2.510333999816794e-2,2.5077219999999956e-2,47676154,42,null,null,null,null,null,null,null],[2.6329069005441852e-2,2.6309212000000026e-2,50021602,44,null,null,null,null,null,null,null],[2.815628200187348e-2,2.8133567000000026e-2,53494575,47,null,null,null,null,null,null,null],[2.939282599982107e-2,2.937685499999998e-2,55844069,49,null,null,null,null,null,null,null],[3.1181958998786286e-2,3.1156967000000035e-2,59243868,52,null,null,null,null,null,null,null],[3.252649400383234e-2,3.249802700000004e-2,61797251,54,null,null,null,null,null,null,null],[3.4448503000021446e-2,3.442938200000001e-2,65450278,57,null,null,null,null,null,null,null],[3.607152900076471e-2,3.6039925000000084e-2,68534608,60,null,null,null,null,null,null,null],[3.795692800485995e-2,3.7922617999999964e-2,72115683,63,null,null,null,null,null,null,null],[3.981165000004694e-2,3.978681899999992e-2,75640494,66,null,null,null,null,null,null,null],[4.13812839979073e-2,4.134547600000005e-2,78620459,69,null,null,null,null,null,null,null],[4.381340800318867e-2,4.3773587e-2,83243475,73,null,null,null,null,null,null,null],[4.59521769953426e-2,4.591688100000002e-2,87305971,76,null,null,null,null,null,null,null],[4.8131951996765565e-2,4.807948400000006e-2,91447845,80,null,null,null,null,null,null,null],[5.042989100184059e-2,5.0378136000000184e-2,95814508,84,null,null,null,null,null,null,null],[5.349220000061905e-2,5.3437803000000006e-2,101632803,89,null,null,null,null,null,null,null],[5.570261099637719e-2,5.566170800000014e-2,105832608,93,null,null,null,null,null,null,null],[5.8637883004848845e-2,5.8586950000000027e-2,111410682,98,null,null,null,null,null,null,null],[6.1715287003607955e-2,6.1675520000000095e-2,117257562,103,null,null,null,null,null,null,null],[6.46549410012085e-2,6.460622500000013e-2,122841390,108,null,null,null,null,null,null,null],[6.766005199460778e-2,6.762474500000004e-2,128551690,113,null,null,null,null,null,null,null],[7.115251399955014e-2,7.110800200000011e-2,135187173,119,null,null,null,null,null,null,null],[7.494805199530674e-2,7.490005500000008e-2,142399851,125,null,null,null,null,null,null,null],[7.836887799930992e-2,7.830414600000002e-2,148897308,131,null,null,null,null,null,null,null],[8.264995200443082e-2,8.25901229999999e-2,157032133,138,null,null,null,null,null,null,null],[8.62455440001213e-2,8.619491499999987e-2,163865596,144,null,null,null,null,null,null,null],[9.091036900645122e-2,9.084664899999995e-2,172727386,152,null,null,null,null,null,null,null],[9.528734099876601e-2,9.521602299999987e-2,181043100,159,null,null,null,null,null,null,null],[0.10003491100360407,9.9945022e-2,190062923,167,null,null,null,null,null,null,null],[0.10540352200041525,0.1053145390000001,200264351,176,null,null,null,null,null,null,null],[0.1109114220016636,0.11082174499999997,210729214,185,null,null,null,null,null,null,null],[0.11628856800234644,0.11619333099999984,220946401,194,null,null,null,null,null,null,null],[0.12236196899903007,0.12219322300000002,232485189,204,null,null,null,null,null,null,null],[0.1280951240041759,0.12801656100000036,243377425,214,null,null,null,null,null,null,null],[0.13404688699665712,0.13395500699999996,254686351,224,null,null,null,null,null,null,null],[0.14159004599787295,0.14147092299999997,269018879,236,null,null,null,null,null,null,null],[0.14789382999879308,0.14779020099999984,280995516,247,null,null,null,null,null,null,null],[0.15566811999451602,0.1555507089999999,295767514,260,null,null,null,null,null,null,null],[0.16341256899613654,0.1632890299999996,310480881,273,null,null,null,null,null,null,null],[0.17193876200326486,0.17182209000000004,326682249,287,null,null,null,null,null,null,null],[0.18065470200235723,0.18048433699999977,343241359,301,null,null,null,null,null,null,null],[0.19008455899893306,0.18990984600000038,361158953,316,null,null,null,null,null,null,null],[0.19925997099926462,0.19908731799999924,378591096,332,null,null,null,null,null,null,null],[0.20827979499881621,0.2080981780000002,395729002,348,null,null,null,null,null,null,null],[0.21893202800129075,0.21876482700000022,415967666,366,null,null,null,null,null,null,null],[0.22986117999971611,0.2297205800000004,436734977,384,null,null,null,null,null,null,null]]},{"reportAnalysis":{"anMean":{"estError":{"confIntLDX":1.064673667944098e-5,"confIntUDX":9.11064301626404e-6,"confIntCL":5.0e-2},"estPoint":5.770838309782314e-3},"anRegress":[{"regRSquare":{"estError":{"confIntLDX":5.15058316596928e-6,"confIntUDX":3.7708817312021026e-6,"confIntCL":5.0e-2},"estPoint":0.9999926782872085},"regResponder":"time","regCoeffs":{"y":{"estError":{"confIntLDX":1.2175205858588846e-4,"confIntUDX":1.1025796245932467e-4,"confIntCL":5.0e-2},"estPoint":1.2610346963985624e-4},"iters":{"estError":{"confIntLDX":5.124258960720503e-6,"confIntUDX":5.297958354179462e-6,"confIntCL":5.0e-2},"estPoint":5.823855877516418e-3}}}],"anStdDev":{"estError":{"confIntLDX":5.879351958666597e-6,"confIntUDX":1.0326224944469426e-5,"confIntCL":5.0e-2},"estPoint":2.8815215559732134e-5},"anOutlierVar":{"ovFraction":2.5623268698060614e-2,"ovDesc":"slight","ovEffect":"Slight"},"anOverhead":2.1820495514718956e-3},"reportKDEs":[{"kdeValues":[5.671752972753566e-3,5.672973797666535e-3,5.674194622579503e-3,5.675415447492472e-3,5.676636272405441e-3,5.67785709731841e-3,5.679077922231379e-3,5.6802987471443476e-3,5.681519572057317e-3,5.682740396970285e-3,5.683961221883254e-3,5.685182046796224e-3,5.686402871709192e-3,5.687623696622161e-3,5.6888445215351295e-3,5.690065346448099e-3,5.691286171361068e-3,5.692506996274036e-3,5.6937278211870055e-3,5.694948646099974e-3,5.696169471012943e-3,5.697390295925912e-3,5.698611120838881e-3,5.69983194575185e-3,5.701052770664818e-3,5.7022735955777875e-3,5.703494420490757e-3,5.704715245403725e-3,5.705936070316694e-3,5.707156895229663e-3,5.708377720142632e-3,5.709598545055601e-3,5.7108193699685695e-3,5.712040194881539e-3,5.713261019794507e-3,5.714481844707476e-3,5.7157026696204455e-3,5.716923494533414e-3,5.718144319446383e-3,5.719365144359351e-3,5.720585969272321e-3,5.72180679418529e-3,5.723027619098258e-3,5.7242484440112274e-3,5.725469268924196e-3,5.726690093837165e-3,5.727910918750134e-3,5.729131743663103e-3,5.730352568576072e-3,5.73157339348904e-3,5.732794218402009e-3,5.734015043314979e-3,5.735235868227947e-3,5.736456693140916e-3,5.737677518053885e-3,5.738898342966854e-3,5.740119167879823e-3,5.741339992792791e-3,5.742560817705761e-3,5.743781642618729e-3,5.745002467531698e-3,5.746223292444667e-3,5.747444117357636e-3,5.748664942270605e-3,5.749885767183573e-3,5.7511065920965426e-3,5.752327417009512e-3,5.75354824192248e-3,5.754769066835449e-3,5.755989891748418e-3,5.757210716661387e-3,5.758431541574355e-3,5.7596523664873245e-3,5.760873191400294e-3,5.762094016313262e-3,5.763314841226231e-3,5.7645356661392e-3,5.765756491052169e-3,5.766977315965138e-3,5.7681981408781065e-3,5.769418965791076e-3,5.770639790704044e-3,5.771860615617013e-3,5.7730814405299825e-3,5.774302265442951e-3,5.77552309035592e-3,5.7767439152688884e-3,5.777964740181858e-3,5.779185565094827e-3,5.780406390007795e-3,5.7816272149207645e-3,5.782848039833733e-3,5.784068864746702e-3,5.785289689659671e-3,5.78651051457264e-3,5.787731339485609e-3,5.788952164398577e-3,5.790172989311546e-3,5.791393814224516e-3,5.792614639137484e-3,5.793835464050453e-3,5.795056288963422e-3,5.796277113876391e-3,5.79749793878936e-3,5.798718763702328e-3,5.799939588615298e-3,5.801160413528266e-3,5.802381238441235e-3,5.803602063354204e-3,5.804822888267173e-3,5.806043713180142e-3,5.80726453809311e-3,5.80848536300608e-3,5.809706187919049e-3,5.810927012832017e-3,5.812147837744986e-3,5.813368662657955e-3,5.814589487570924e-3,5.815810312483893e-3,5.8170311373968615e-3,5.818251962309831e-3,5.819472787222799e-3,5.820693612135768e-3,5.8219144370487376e-3,5.823135261961706e-3,5.824356086874675e-3,5.8255769117876435e-3,5.826797736700613e-3],"kdeType":"time","kdePDF":[1019.5373084237668,1019.7637421621965,1020.2533075587864,1021.0792144186191,1022.3508072300559,1024.2129867878552,1026.8454162718053,1030.4614937957865,1035.3070707871354,1041.6588940448357,1049.8227491047244,1060.1312837170783,1072.941492877457,1088.6318509576324,1107.5990820219793,1130.2545662959658,1157.0203888375997,1188.325045561594,1224.5988316461085,1266.268947740355,1313.7543699811238,1367.4605402846023,1427.7739433567695,1495.0566460032612,1569.6408822636686,1651.8237743055083,1741.8622835752412,1839.9684891405898,1946.3052902416885,2060.9826276280264,2184.0543131922036,2315.515549693471,2455.3012120490203,2603.284948897687,2759.2791481342897,2923.0357931793324,3094.248218274285,3272.553751529788,3457.537214316371,3648.7352254287057,3845.6412388599433,4047.7112255820925,4254.369893024689,4465.017321523728,4679.035885376282,4895.797317705572,5114.669773457488,5335.024743740762,5556.2436775111355,5777.72417327335,5998.885613905776,6219.1741316372745,6438.066807253191,6655.07502728686,6869.746944694798,7081.6690116630525,7290.466577058243,7495.80356489116,7697.381273290746,7894.936355194286,8088.238061616294,8277.084845397681,8461.30043730499,8640.729516891945,8815.233107438498,8984.683827447849,9148.961130658738,9307.94666247959,9461.519853464551,9609.553860308291,9751.911952311124,9888.444426880076,10018.986121954547,10143.354576845091,10261.348876416434,10372.749197347559,10477.317059833256,10574.796273936703,10664.914557169564,10747.385788965996,10821.912858643147,10888.191056211128,10945.911949936743,10994.767690718814,11034.455680884012,11064.683543693101,11085.17432937169,11095.671893546707,11095.946384299015,11085.799774378575,11065.071375267627,11033.643269570874,10991.445597583166,10938.46163282784,10874.732579941767,10800.36202664313,10715.51997985466,10620.446414617943,10515.454263509158,10400.93177415873,10277.34416349412,10145.234499758115,10005.22374746179,9858.009916420577,9704.366264036635,9545.13851010128,9381.241035581452,9213.652051023826,9043.407736167,8871.595369822204,8699.345487711116,8527.823125314791,8358.218222412313,8191.735285356814,8029.582421708993,7872.959879083788,7723.0482354335945,7580.996400997628,7447.909602344188,7324.837525942117,7212.76280221673,7112.590010864868,7025.135384208468,6951.117377548318,6891.148263932293,6845.726895675284,6815.232756655521,6799.921408252735]}],"reportKeys":["time","cpuTime","cycles","iters","allocated","numGcs","bytesCopied","mutatorWallSeconds","mutatorCpuSeconds","gcWallSeconds","gcCpuSeconds"],"reportNumber":1,"reportName":"create/relation 10x1000","reportOutliers":{"highSevere":0,"highMild":0,"lowMild":1,"samplesSeen":33,"lowSevere":0},"reportMeasured":[[5.887054001505021e-3,5.879581999999495e-3,11182234,1,null,null,null,null,null,null,null],[1.1682764001307078e-2,1.1675040000000081e-2,22194893,2,null,null,null,null,null,null,null],[1.7509942001197487e-2,1.74909379999999e-2,33265063,3,null,null,null,null,null,null,null],[2.3410166999383364e-2,2.3395288999999764e-2,44477630,4,null,null,null,null,null,null,null],[2.9472086003806908e-2,2.9430035999999937e-2,55992906,5,null,null,null,null,null,null,null],[3.5199064994230866e-2,3.516572100000026e-2,66874109,6,null,null,null,null,null,null,null],[4.122917899803724e-2,4.1192778000000096e-2,78332155,7,null,null,null,null,null,null,null],[4.701189199840883e-2,4.6936478000000115e-2,89320165,8,null,null,null,null,null,null,null],[5.271683200408006e-2,5.2686497999999915e-2,100160078,9,null,null,null,null,null,null,null],[5.865615299990168e-2,5.859188300000007e-2,111442987,10,null,null,null,null,null,null,null],[6.451627500064205e-2,6.446151800000077e-2,122578882,11,null,null,null,null,null,null,null],[6.994964399927994e-2,6.990481299999995e-2,132901645,12,null,null,null,null,null,null,null],[7.564991200342774e-2,7.560714800000046e-2,143731876,13,null,null,null,null,null,null,null],[8.150492400454823e-2,8.145551299999987e-2,154856276,14,null,null,null,null,null,null,null],[8.717107799748192e-2,8.711902599999988e-2,165622826,15,null,null,null,null,null,null,null],[9.312852899893187e-2,9.307294599999949e-2,176940830,16,null,null,null,null,null,null,null],[9.896839800057933e-2,9.890558900000013e-2,188037060,17,null,null,null,null,null,null,null],[0.10488027700193925,0.10481192300000064,199268869,18,null,null,null,null,null,null,null],[0.11073017199669266,0.11065237000000039,210383777,19,null,null,null,null,null,null,null],[0.1164985559953493,0.11641449700000006,221345187,20,null,null,null,null,null,null,null],[0.12229861300147604,0.12221939399999915,232363084,21,null,null,null,null,null,null,null],[0.12807984399842098,0.12799171500000028,243349421,22,null,null,null,null,null,null,null],[0.13390199199784547,0.1338048280000006,254410896,23,null,null,null,null,null,null,null],[0.14545249000366312,0.1453479619999989,276355041,25,null,null,null,null,null,null,null],[0.15155094099463895,0.15144441099999995,287943394,26,null,null,null,null,null,null,null],[0.15711575300520053,0.1570216500000008,298516821,27,null,null,null,null,null,null,null],[0.1631851429992821,0.16307090699999982,310048392,28,null,null,null,null,null,null,null],[0.1747862139964127,0.1746803400000001,332090436,30,null,null,null,null,null,null,null],[0.18045503400207963,0.1803195800000008,342861401,31,null,null,null,null,null,null,null],[0.19231173899606802,0.1921958280000009,365388724,33,null,null,null,null,null,null,null],[0.2039038500006427,0.20378220699999972,387412480,35,null,null,null,null,null,null,null],[0.21039060900511686,0.21022488999999922,399739724,36,null,null,null,null,null,null,null],[0.22193210600380553,0.22176617799999931,421666776,38,null,null,null,null,null,null,null],[0.2330857230044785,0.23292181699999936,442860210,40,null,null,null,null,null,null,null],[0.24479770500329323,0.24462668700000023,465112860,42,null,null,null,null,null,null,null],[0.25617124199925456,0.25600337800000084,486722943,44,null,null,null,null,null,null,null],[0.27382572499482194,0.2736053199999997,520266634,47,null,null,null,null,null,null,null],[0.28562600299483165,0.28540836500000033,542685866,49,null,null,null,null,null,null,null]]},{"reportAnalysis":{"anMean":{"estError":{"confIntLDX":1.1706234940519339e-4,"confIntUDX":8.102457807721009e-5,"confIntCL":5.0e-2},"estPoint":5.784195729887314e-2},"anRegress":[{"regRSquare":{"estError":{"confIntLDX":1.0044644099260758e-5,"confIntUDX":5.5926182669363556e-6,"confIntCL":5.0e-2},"estPoint":0.9999927443132401},"regResponder":"time","regCoeffs":{"y":{"estError":{"confIntLDX":4.549259207879345e-4,"confIntUDX":5.647312782263292e-4,"confIntCL":5.0e-2},"estPoint":-1.3937853123716963e-4},"iters":{"estError":{"confIntLDX":1.1138027169087239e-4,"confIntUDX":8.933946864835007e-5,"confIntCL":5.0e-2},"estPoint":5.807704609456791e-2}}}],"anStdDev":{"estError":{"confIntLDX":6.698984573395927e-5,"confIntUDX":1.0250957386340848e-4,"confIntCL":5.0e-2},"estPoint":1.7121491767487851e-4},"anOutlierVar":{"ovFraction":7.638888888888888e-2,"ovDesc":"slight","ovEffect":"Slight"},"anOverhead":2.1820495514718956e-3},"reportKDEs":[{"kdeValues":[5.741071695578914e-2,5.741628100214218e-2,5.742184504849522e-2,5.742740909484826e-2,5.74329731412013e-2,5.743853718755434e-2,5.744410123390738e-2,5.7449665280260416e-2,5.7455229326613455e-2,5.7460793372966494e-2,5.746635741931953e-2,5.747192146567257e-2,5.747748551202561e-2,5.748304955837865e-2,5.748861360473169e-2,5.749417765108473e-2,5.749974169743777e-2,5.7505305743790806e-2,5.7510869790143845e-2,5.7516433836496884e-2,5.752199788284992e-2,5.752756192920296e-2,5.7533125975556e-2,5.753869002190904e-2,5.754425406826208e-2,5.754981811461512e-2,5.755538216096816e-2,5.75609462073212e-2,5.7566510253674236e-2,5.7572074300027275e-2,5.7577638346380314e-2,5.758320239273335e-2,5.758876643908639e-2,5.759433048543943e-2,5.759989453179247e-2,5.760545857814551e-2,5.761102262449855e-2,5.761658667085159e-2,5.7622150717204626e-2,5.7627714763557665e-2,5.7633278809910704e-2,5.763884285626374e-2,5.764440690261678e-2,5.764997094896982e-2,5.765553499532286e-2,5.76610990416759e-2,5.766666308802894e-2,5.767222713438198e-2,5.7677791180735016e-2,5.7683355227088055e-2,5.7688919273441094e-2,5.769448331979413e-2,5.770004736614717e-2,5.770561141250021e-2,5.771117545885325e-2,5.771673950520629e-2,5.772230355155933e-2,5.772786759791237e-2,5.773343164426541e-2,5.7738995690618446e-2,5.7744559736971485e-2,5.7750123783324524e-2,5.775568782967756e-2,5.77612518760306e-2,5.776681592238364e-2,5.777237996873668e-2,5.777794401508972e-2,5.778350806144276e-2,5.77890721077958e-2,5.7794636154148836e-2,5.7800200200501875e-2,5.7805764246854914e-2,5.781132829320795e-2,5.781689233956099e-2,5.782245638591403e-2,5.782802043226707e-2,5.783358447862011e-2,5.783914852497315e-2,5.784471257132619e-2,5.7850276617679226e-2,5.7855840664032265e-2,5.7861404710385304e-2,5.786696875673834e-2,5.787253280309138e-2,5.787809684944442e-2,5.788366089579746e-2,5.78892249421505e-2,5.789478898850354e-2,5.790035303485658e-2,5.790591708120962e-2,5.7911481127562656e-2,5.7917045173915695e-2,5.7922609220268734e-2,5.792817326662177e-2,5.793373731297481e-2,5.793930135932785e-2,5.794486540568089e-2,5.795042945203393e-2,5.795599349838697e-2,5.796155754474001e-2,5.7967121591093046e-2,5.7972685637446085e-2,5.7978249683799124e-2,5.798381373015216e-2,5.79893777765052e-2,5.799494182285824e-2,5.800050586921128e-2,5.800606991556432e-2,5.801163396191736e-2,5.80171980082704e-2,5.8022762054623436e-2,5.8028326100976475e-2,5.8033890147329514e-2,5.803945419368255e-2,5.804501824003559e-2,5.805058228638863e-2,5.805614633274167e-2,5.806171037909471e-2,5.806727442544775e-2,5.807283847180079e-2,5.807840251815383e-2,5.8083966564506866e-2,5.8089530610859905e-2,5.8095094657212944e-2,5.810065870356598e-2,5.810622274991902e-2,5.811178679627206e-2,5.81173508426251e-2],"kdeType":"time","kdePDF":[864.337780567609,864.7149663440533,865.4691143773614,866.5997771575265,868.1062822472436,869.9877308886195,872.2429961678006,874.8707207565141,877.869314254025,881.23695015743,884.9715624924057,889.0708421405709,893.5322329034202,898.3529273463608,903.5298624696674,909.0597152562005,914.9388981484232,921.1635545096367,927.729554126396,934.632488810753,941.8676681622743,949.4301155507385,957.3145643809444,965.5154547012332,974.0269302170491,982.8428357702603,991.9567153438611,1001.3618106502569,1011.0510603594689,1021.0171000213678,1031.252262733412,1041.7485806023867,1052.4977870452958,1063.491319970846,1074.7203258789777,1086.1756649115468,1097.8479168826773,1109.7273883124024,1121.8041204821538,1134.0678985252673,1146.5082615602405,1159.1145138687505,1171.8757371147092,1184.7808035946825,1197.8183905041446,1210.97699519794,1224.2449514174898,1237.6104464512014,1251.0615391888011,1264.5861790244194,1278.17222555776,1291.8074690370927,1305.4796514826935,1319.176488424201,1332.8856911807407,1346.594989608087,1360.2921552331238,1373.9650246919678,1387.6015233848482,1401.189689257703,1414.7176966180257,1428.173879890213,1441.5467572141677,1454.8250537895403,1467.9977248674795,1481.0539782913854,1493.9832964886293,1506.7754578158913,1519.4205571622201,1531.909025715667,1544.2316498018174,1556.3795887053034,1568.34439138886,1580.1180120282238,1591.6928242856093,1603.0616342491494,1614.2176919710232,1625.1547015424637,1635.8668296499902,1646.3487125634085,1656.5954615129635,1666.6026664198482,1676.3663979516655,1685.8832078817686,1695.15012773918,1704.1646657434887,1712.9248020271448,1721.428982155464,1729.6761089627587,1737.6655327309381,1745.397039744956,1752.87083926725,1760.0875489811233,1767.0481789604837,1773.7541142307196,1780.2070959925284,1786.4092015872814,1792.3628232889182,1798.0706460134295,1803.5356240426133,1808.7609568640078,1813.7500642336247,1818.5065605723607,1823.034228810673,1827.3369937992732,1831.418895406227,1835.2840614228421,1838.9366804022002,1842.3809745549881,1845.6211728275348,1848.661484286526,1851.506071933908,1854.1590270738127,1856.6243443511423,1858.9058975785972,1861.0074164655264,1862.9324643579657,1864.684417094723,1866.2664430792536,1867.6814846615316,1868.9322409180254,1870.0211519114143,1870.9503845047345,1871.7218197973543,1872.337042242516,1872.7973304982488,1873.1036500552098,1873.2566476765892]}],"reportKeys":["time","cpuTime","cycles","iters","allocated","numGcs","bytesCopied","mutatorWallSeconds","mutatorCpuSeconds","gcWallSeconds","gcCpuSeconds"],"reportNumber":2,"reportName":"create/relation 10x10000","reportOutliers":{"highSevere":0,"highMild":0,"lowMild":1,"samplesSeen":11,"lowSevere":0},"reportMeasured":[[5.802666299859993e-2,5.799217000000034e-2,110247192,1,null,null,null,null,null,null,null],[0.11603023100178689,0.11595200700000063,220455093,2,null,null,null,null,null,null,null],[0.1739662089967169,0.1738531520000013,330532285,3,null,null,null,null,null,null,null],[0.23227401099575218,0.2321224449999999,441317043,4,null,null,null,null,null,null,null],[0.2908108289993834,0.2905827829999996,552537826,5,null,null,null,null,null,null,null],[0.34785422600543825,0.34761730600000007,660920579,6,null,null,null,null,null,null,null],[0.40712012400035746,0.40688040700000094,773525905,7,null,null,null,null,null,null,null],[0.4638553500044509,0.46359462299999876,881324905,8,null,null,null,null,null,null,null],[0.5220888359981473,0.5217654560000007,991965021,9,null,null,null,null,null,null,null],[0.5797449680030695,0.5794075549999995,1101513012,10,null,null,null,null,null,null,null],[0.638773004997347,0.6383390959999993,1213664465,11,null,null,null,null,null,null,null],[0.6977926010004012,0.6972165320000006,1325803613,12,null,null,null,null,null,null,null]]},{"reportAnalysis":{"anMean":{"estError":{"confIntLDX":1.501427528155276e-4,"confIntUDX":2.7562873243145575e-4,"confIntCL":5.0e-2},"estPoint":1.448797309139284e-2},"anRegress":[{"regRSquare":{"estError":{"confIntLDX":7.047959918693447e-4,"confIntUDX":5.488466394070191e-4,"confIntCL":5.0e-2},"estPoint":0.9988610048876899},"regResponder":"time","regCoeffs":{"y":{"estError":{"confIntLDX":2.8646289933435686e-3,"confIntUDX":3.244918023182094e-3,"confIntCL":5.0e-2},"estPoint":5.033271389983918e-4},"iters":{"estError":{"confIntLDX":2.0722653404042432e-4,"confIntUDX":2.1460011194947975e-4,"confIntCL":5.0e-2},"estPoint":1.4458875553677806e-2}}}],"anStdDev":{"estError":{"confIntLDX":2.0017124217413867e-4,"confIntUDX":3.516842285068824e-4,"confIntCL":5.0e-2},"estPoint":4.774249175945004e-4},"anOutlierVar":{"ovFraction":0.11563227985262721,"ovDesc":"moderate","ovEffect":"Moderate"},"anOverhead":2.1820495514718956e-3},"reportKDEs":[{"kdeValues":[1.3629004076506593e-2,1.3650202404333968e-2,1.367140073216134e-2,1.3692599059988715e-2,1.3713797387816088e-2,1.3734995715643463e-2,1.3756194043470836e-2,1.377739237129821e-2,1.3798590699125585e-2,1.3819789026952958e-2,1.3840987354780333e-2,1.3862185682607706e-2,1.388338401043508e-2,1.3904582338262453e-2,1.3925780666089828e-2,1.39469789939172e-2,1.3968177321744575e-2,1.398937564957195e-2,1.4010573977399323e-2,1.4031772305226698e-2,1.405297063305407e-2,1.4074168960881445e-2,1.4095367288708818e-2,1.4116565616536193e-2,1.4137763944363568e-2,1.415896227219094e-2,1.4180160600018315e-2,1.4201358927845688e-2,1.4222557255673063e-2,1.4243755583500436e-2,1.426495391132781e-2,1.4286152239155185e-2,1.4307350566982558e-2,1.4328548894809933e-2,1.4349747222637306e-2,1.437094555046468e-2,1.4392143878292053e-2,1.4413342206119428e-2,1.4434540533946803e-2,1.4455738861774176e-2,1.447693718960155e-2,1.4498135517428923e-2,1.4519333845256298e-2,1.454053217308367e-2,1.4561730500911045e-2,1.458292882873842e-2,1.4604127156565793e-2,1.4625325484393168e-2,1.464652381222054e-2,1.4667722140047915e-2,1.4688920467875288e-2,1.4710118795702663e-2,1.4731317123530038e-2,1.475251545135741e-2,1.4773713779184785e-2,1.4794912107012158e-2,1.4816110434839533e-2,1.4837308762666906e-2,1.485850709049428e-2,1.4879705418321653e-2,1.4900903746149028e-2,1.4922102073976401e-2,1.4943300401803776e-2,1.496449872963115e-2,1.4985697057458523e-2,1.5006895385285898e-2,1.5028093713113271e-2,1.5049292040940646e-2,1.5070490368768018e-2,1.5091688696595393e-2,1.5112887024422768e-2,1.513408535225014e-2,1.5155283680077515e-2,1.5176482007904888e-2,1.5197680335732263e-2,1.5218878663559636e-2,1.524007699138701e-2,1.5261275319214385e-2,1.5282473647041758e-2,1.5303671974869133e-2,1.5324870302696506e-2,1.534606863052388e-2,1.5367266958351253e-2,1.5388465286178628e-2,1.5409663614006003e-2,1.5430861941833376e-2,1.545206026966075e-2,1.5473258597488123e-2,1.5494456925315498e-2,1.5515655253142871e-2,1.5536853580970246e-2,1.555805190879762e-2,1.5579250236624993e-2,1.5600448564452368e-2,1.562164689227974e-2,1.5642845220107116e-2,1.566404354793449e-2,1.568524187576186e-2,1.5706440203589238e-2,1.572763853141661e-2,1.5748836859243984e-2,1.577003518707136e-2,1.5791233514898733e-2,1.5812431842726106e-2,1.5833630170553482e-2,1.5854828498380855e-2,1.5876026826208228e-2,1.58972251540356e-2,1.5918423481862978e-2,1.593962180969035e-2,1.5960820137517723e-2,1.5982018465345096e-2,1.6003216793172473e-2,1.6024415120999846e-2,1.604561344882722e-2,1.6066811776654595e-2,1.6088010104481968e-2,1.610920843230934e-2,1.6130406760136714e-2,1.615160508796409e-2,1.6172803415791463e-2,1.6194001743618836e-2,1.621520007144621e-2,1.6236398399273586e-2,1.625759672710096e-2,1.627879505492833e-2,1.6299993382755708e-2,1.632119171058308e-2],"kdeType":"time","kdePDF":[236.1468506342645,238.42315975933295,242.96912858425986,249.77198675890781,258.8138142621554,270.07279242351245,283.52451076567814,299.1430674014351,316.90168943873925,336.77261765772505,358.72604613157625,382.72797946098194,408.7369625833353,436.69974353713724,466.5460396403535,498.1826831747923,531.4875148321455,566.3034636291537,602.4332939206391,639.6355086652782,677.6218707076326,716.0569405724475,754.5599327746658,792.7090680628882,830.0484536556194,866.0973664698996,900.3616558446292,932.3468331312696,961.5722863992992,987.5859591179271,1009.978770149166,1028.3980345754383,1042.5591738408243,1052.255079284244,1057.3626119132182,1057.8458764597917,1053.7560896840748,1045.228059505023,1032.4734892826261,1015.7715063844435,995.4569725890917,971.9072541984668,945.5282030112918,916.7401202180627,885.9644426127243,853.6118073895211,820.0720254013871,785.7063337796247,750.8421204799047,715.7701302205685,680.7439880684003,645.9817270145621,611.6688902672513,577.9627053380816,544.9967990765202,512.8859402702265,481.73035503504656,451.6192523818604,422.6333129877053,394.8460217808541,368.32385260089035,343.1254297925042,319.29988770945994,296.88471774821517,275.9034295927156,256.36335778327094,238.25391840349252,221.5455680459126,206.18964467993428,192.11918528566417,179.25072631553067,167.48700813895317,156.72043063320865,146.83704957553374,137.7208662156558,129.2581471128136,121.34151775755043,113.87359959872839,106.77000229107666,99.96153662365278,93.39557344526342,87.03653463389456,80.86555879591435,74.87943272728975,69.08891658802744,63.516614347273304,58.19455077189301,53.161612727553226,48.46099759342363,44.13778775416025,40.236740558202534,36.80035116808556,33.86721462261318,31.4706860431445,29.637816491489335,28.388527993554806,27.734985289792334,27.681123706087906,28.222301108778947,29.345055507877436,31.02696632313282,33.23663419562585,35.93380906597205,39.069706823689295,42.58755937487617,46.42344031070433,50.507398070112885,54.76491097350307,59.118654965810116,63.49054728078228,67.80400003385625,71.9862898417851,75.97092592957311,79.6998826143421,83.12555488150204,86.21229959990345,88.93744044624657,91.29164146592449,93.278590954289,94.91398156497118,96.22382098041126,97.24215629121531,98.00834036880944,98.56400605518164,98.94994050786177,99.20306493132794,99.35372269439145,99.42346123269024]}],"reportKeys":["time","cpuTime","cycles","iters","allocated","numGcs","bytesCopied","mutatorWallSeconds","mutatorCpuSeconds","gcWallSeconds","gcCpuSeconds"],"reportNumber":3,"reportName":"restrict/restrict relation 10x10000 to 10x1","reportOutliers":{"highSevere":1,"highMild":0,"lowMild":0,"samplesSeen":22,"lowSevere":0},"reportMeasured":[[1.254821499605896e-2,1.253168299999885e-2,23833172,1,null,null,null,null,null,null,null],[2.469259400095325e-2,2.4657473000001318e-2,46908325,2,null,null,null,null,null,null,null],[4.938155299896607e-2,4.931847499999975e-2,93819295,3,null,null,null,null,null,null,null],[5.7797679997747764e-2,5.77268619999991e-2,109805686,4,null,null,null,null,null,null,null],[7.035779000580078e-2,7.0287411999999e-2,133671460,5,null,null,null,null,null,null,null],[9.253486299712677e-2,9.243146399999702e-2,175809034,6,null,null,null,null,null,null,null],[0.10170249599468661,0.10158981499999697,193225303,7,null,null,null,null,null,null,null],[0.11512309200043092,0.11497926600000241,218724826,8,null,null,null,null,null,null,null],[0.12616992999392096,0.1260058870000016,239715692,9,null,null,null,null,null,null,null],[0.14971562999562593,0.14953576899999987,284452564,10,null,null,null,null,null,null,null],[0.1593516780048958,0.15915635500000036,302758476,11,null,null,null,null,null,null,null],[0.16994197700114455,0.16973221199999955,322882229,12,null,null,null,null,null,null,null],[0.19297148700570688,0.19272797600000047,366638785,13,null,null,null,null,null,null,null],[0.20395877199916868,0.20370798700000137,387512061,14,null,null,null,null,null,null,null],[0.21702719799941406,0.21678522699999903,412342135,15,null,null,null,null,null,null,null],[0.2289532409995445,0.22868242799999905,435003398,16,null,null,null,null,null,null,null],[0.25124789999972563,0.2509605150000027,477365114,17,null,null,null,null,null,null,null],[0.2602841040061321,0.25986185000000006,494530761,18,null,null,null,null,null,null,null],[0.27312203800102,0.2727749569999993,518923833,19,null,null,null,null,null,null,null],[0.2951591550008743,0.29479497700000223,560790800,20,null,null,null,null,null,null,null],[0.30637529699743027,0.3059842109999984,582103272,21,null,null,null,null,null,null,null],[0.3175946830015164,0.31720702700000203,603421740,22,null,null,null,null,null,null,null],[0.3274035539943725,0.32700220600000307,622057602,23,null,null,null,null,null,null,null],[0.36078646600071806,0.36023960700000046,685484566,25,null,null,null,null,null,null,null]]},{"reportAnalysis":{"anMean":{"estError":{"confIntLDX":1.2431711081148933e-3,"confIntUDX":6.412824709298576e-4,"confIntCL":5.0e-2},"estPoint":8.447258684075218e-2},"anRegress":[{"regRSquare":{"estError":{"confIntLDX":3.1814620502657043e-4,"confIntUDX":1.8060952075904524e-4,"confIntCL":5.0e-2},"estPoint":0.9997530519626538},"regResponder":"time","regCoeffs":{"y":{"estError":{"confIntLDX":5.320556288099867e-3,"confIntUDX":6.507065883152455e-3,"confIntCL":5.0e-2},"estPoint":-1.3701538662041516e-3},"iters":{"estError":{"confIntLDX":9.266209026589783e-4,"confIntUDX":1.1153229224582645e-3,"confIntCL":5.0e-2},"estPoint":8.504563215758416e-2}}}],"anStdDev":{"estError":{"confIntLDX":7.89549338289093e-4,"confIntUDX":9.00270406177663e-4,"confIntCL":5.0e-2},"estPoint":1.4013810341920257e-3},"anOutlierVar":{"ovFraction":9.0e-2,"ovDesc":"slight","ovEffect":"Slight"},"anOverhead":2.1820495514718956e-3},"reportKDEs":[{"kdeValues":[8.070310981625707e-2,8.075036357653102e-2,8.079761733680496e-2,8.084487109707891e-2,8.089212485735285e-2,8.09393786176268e-2,8.098663237790076e-2,8.10338861381747e-2,8.108113989844865e-2,8.112839365872258e-2,8.117564741899654e-2,8.122290117927049e-2,8.127015493954443e-2,8.131740869981838e-2,8.136466246009232e-2,8.141191622036627e-2,8.145916998064022e-2,8.150642374091416e-2,8.155367750118811e-2,8.160093126146205e-2,8.1648185021736e-2,8.169543878200995e-2,8.174269254228389e-2,8.178994630255784e-2,8.183720006283178e-2,8.188445382310573e-2,8.193170758337968e-2,8.197896134365362e-2,8.202621510392757e-2,8.207346886420151e-2,8.212072262447546e-2,8.216797638474942e-2,8.221523014502335e-2,8.22624839052973e-2,8.230973766557124e-2,8.23569914258452e-2,8.240424518611915e-2,8.245149894639309e-2,8.249875270666704e-2,8.254600646694098e-2,8.259326022721493e-2,8.264051398748888e-2,8.268776774776282e-2,8.273502150803677e-2,8.278227526831071e-2,8.282952902858466e-2,8.287678278885861e-2,8.292403654913255e-2,8.29712903094065e-2,8.301854406968044e-2,8.30657978299544e-2,8.311305159022835e-2,8.316030535050228e-2,8.320755911077624e-2,8.325481287105017e-2,8.330206663132413e-2,8.334932039159808e-2,8.339657415187202e-2,8.344382791214597e-2,8.34910816724199e-2,8.353833543269386e-2,8.358558919296781e-2,8.363284295324175e-2,8.36800967135157e-2,8.372735047378964e-2,8.377460423406359e-2,8.382185799433753e-2,8.386911175461148e-2,8.391636551488543e-2,8.396361927515937e-2,8.401087303543332e-2,8.405812679570726e-2,8.410538055598121e-2,8.415263431625516e-2,8.41998880765291e-2,8.424714183680306e-2,8.4294395597077e-2,8.434164935735095e-2,8.43889031176249e-2,8.443615687789884e-2,8.448341063817279e-2,8.453066439844673e-2,8.457791815872068e-2,8.462517191899463e-2,8.467242567926857e-2,8.471967943954252e-2,8.476693319981646e-2,8.481418696009041e-2,8.486144072036436e-2,8.49086944806383e-2,8.495594824091225e-2,8.500320200118619e-2,8.505045576146014e-2,8.50977095217341e-2,8.514496328200803e-2,8.519221704228198e-2,8.523947080255592e-2,8.528672456282987e-2,8.533397832310383e-2,8.538123208337776e-2,8.542848584365172e-2,8.547573960392565e-2,8.55229933641996e-2,8.557024712447356e-2,8.56175008847475e-2,8.566475464502145e-2,8.571200840529539e-2,8.575926216556934e-2,8.580651592584329e-2,8.585376968611723e-2,8.590102344639118e-2,8.594827720666512e-2,8.599553096693907e-2,8.604278472721302e-2,8.609003848748696e-2,8.613729224776091e-2,8.618454600803485e-2,8.62317997683088e-2,8.627905352858276e-2,8.63263072888567e-2,8.637356104913065e-2,8.642081480940458e-2,8.646806856967854e-2,8.651532232995249e-2,8.656257609022643e-2,8.660982985050038e-2,8.665708361077432e-2,8.670433737104827e-2],"kdeType":"time","kdePDF":[92.3086773908225,92.357761886428,92.45590651832431,92.60306248601609,92.79915638482603,93.04408996321756,93.33773980261624,93.67995692261259,94.07056631511186,94.50936641166705,94.99612848886476,95.53059601724885,96.11248395983819,96.7414780268368,97.4172338936303,98.13937638961931,98.90749866584518,99.72116134972482,100.57989169551458,101.4831827393787,102.430492468132,103.42124301086862,104.4548198627676,105.53057115039063,106.64780694774748,107.8057986523098,109.00377842999379,110.2409387379196,111.51643193347834,112.82936997790614,114.17882424217945,115.5638254226023,116.98336357296606,118.43638825961767,119.92180884518928,121.43849490610339,122.98527678830536,124.5609463049578,126.16425757910008,127.79392803349742,129.4486395291201,131.1270396528686,132.82774315434182,134.54933353059192,136.2903647569761,138.0493631613498,139.82482943801733,141.61524079699913,143.41905324336705,145.23470398057296,147.06061393092673,148.89519036560333,150.7368296358464,152.58391999632633,154.43484451097473,156.28798403098938,158.14172023415975,159.99443871413416,161.84453210781078,163.6904032486151,165.5304683331085,167.3631600880728,169.1869309250239,171.00025606894118,172.80163664793898,174.58960273057647,176.36271629758048,178.1195741348641,179.85881063494068,181.5791004940798,183.2791612929059,184.95775594852157,186.61369502672306,188.24583890338815,189.85309976472294,191.4344434366877,192.98889103464302,194.51552042499648,196.01346749145253,197.48192719930077,198.9201544520853,200.32746473590544,201.7032345475745,203.0469016038301,204.357964829811,205.63598412602408,206.88057991407305,208.09143246244727,209.2682809947231,210.41092258355513,211.51921083487218,212.5930543676943,213.63241509598726,214.63730631992814,215.60779063489645,216.5439776673988,217.44602164799662,218.3141188321171,219.14850478039233,219.9494515108795,220.71726453617,221.45227979898345,222.15486052037198,222.8253939751184,223.46428820930262,224.0719687153282,224.64887507994445,225.19545762097002,225.71217402851266,226.19948602649902,226.6578560702619,227.08774409579618,227.489604336074,227.86388221952174,228.21101136538908,228.53141069030488,228.8254816397991,229.09360555799407,229.3361412080195,229.55342245500205,229.74575612270667,229.9134200340936,230.0566612451716,230.1756944806159,230.27070077864968,230.34182635169338,230.38918166824777,230.4128407604204]}],"reportKeys":["time","cpuTime","cycles","iters","allocated","numGcs","bytesCopied","mutatorWallSeconds","mutatorCpuSeconds","gcWallSeconds","gcCpuSeconds"],"reportNumber":4,"reportName":"restrict/restrict relation 10x10000 to 10x5000","reportOutliers":{"highSevere":0,"highMild":0,"lowMild":0,"samplesSeen":9,"lowSevere":1},"reportMeasured":[[8.242733500082977e-2,8.23534549999998e-2,156602833,1,null,null,null,null,null,null,null],[0.16349744900071528,0.16337303199999909,310634560,2,null,null,null,null,null,null,null],[0.259703730000183,0.2595030559999998,493428789,3,null,null,null,null,null,null,null],[0.34040561800065916,0.340130073000001,646761164,4,null,null,null,null,null,null,null],[0.4212543219982763,0.4209288019999988,800374404,5,null,null,null,null,null,null,null],[0.5070945240004221,0.5067263110000013,963471707,6,null,null,null,null,null,null,null],[0.5995631650002906,0.599115004999998,1139160942,7,null,null,null,null,null,null,null],[0.6832402630025172,0.6827478420000013,1298146922,8,null,null,null,null,null,null,null],[0.7608672300048056,0.7602914290000022,1445639167,9,null,null,null,null,null,null,null],[0.8457545939963893,0.8451073460000025,1606924694,10,null,null,null,null,null,null,null]]},{"reportAnalysis":{"anMean":{"estError":{"confIntLDX":2.241129906033184e-4,"confIntUDX":1.4726994991286387e-4,"confIntCL":5.0e-2},"estPoint":1.243577405705988e-2},"anRegress":[{"regRSquare":{"estError":{"confIntLDX":4.874527268268203e-4,"confIntUDX":3.9628034480598817e-4,"confIntCL":5.0e-2},"estPoint":0.999248061855069},"regResponder":"time","regCoeffs":{"y":{"estError":{"confIntLDX":2.138261771143397e-3,"confIntUDX":1.7479280365314538e-3,"confIntCL":5.0e-2},"estPoint":-4.138930822500715e-3},"iters":{"estError":{"confIntLDX":1.521867184636535e-4,"confIntUDX":1.4879101356986973e-4,"confIntCL":5.0e-2},"estPoint":1.2976132037824937e-2}}}],"anStdDev":{"estError":{"confIntLDX":1.5790585736380177e-4,"confIntUDX":1.3565994085572964e-4,"confIntCL":5.0e-2},"estPoint":4.600204612133745e-4},"anOutlierVar":{"ovFraction":0.14345146934193906,"ovDesc":"moderate","ovEffect":"Moderate"},"anOverhead":2.1820495514718956e-3},"reportKDEs":[{"kdeValues":[1.1216415464752303e-2,1.1231742709670032e-2,1.1247069954587761e-2,1.1262397199505492e-2,1.1277724444423222e-2,1.129305168934095e-2,1.130837893425868e-2,1.132370617917641e-2,1.1339033424094138e-2,1.135436066901187e-2,1.1369687913929599e-2,1.1385015158847328e-2,1.1400342403765057e-2,1.1415669648682786e-2,1.1430996893600515e-2,1.1446324138518246e-2,1.1461651383435975e-2,1.1476978628353705e-2,1.1492305873271434e-2,1.1507633118189163e-2,1.1522960363106892e-2,1.1538287608024623e-2,1.1553614852942352e-2,1.1568942097860082e-2,1.158426934277781e-2,1.159959658769554e-2,1.1614923832613271e-2,1.1630251077531e-2,1.164557832244873e-2,1.1660905567366459e-2,1.1676232812284188e-2,1.1691560057201917e-2,1.1706887302119648e-2,1.1722214547037377e-2,1.1737541791955106e-2,1.1752869036872836e-2,1.1768196281790565e-2,1.1783523526708294e-2,1.1798850771626025e-2,1.1814178016543754e-2,1.1829505261461483e-2,1.1844832506379212e-2,1.1860159751296942e-2,1.187548699621467e-2,1.1890814241132402e-2,1.1906141486050131e-2,1.192146873096786e-2,1.193679597588559e-2,1.1952123220803319e-2,1.196745046572105e-2,1.1982777710638779e-2,1.1998104955556508e-2,1.2013432200474237e-2,1.2028759445391966e-2,1.2044086690309696e-2,1.2059413935227426e-2,1.2074741180145156e-2,1.2090068425062885e-2,1.2105395669980614e-2,1.2120722914898343e-2,1.2136050159816072e-2,1.2151377404733803e-2,1.2166704649651533e-2,1.2182031894569262e-2,1.2197359139486991e-2,1.221268638440472e-2,1.2228013629322451e-2,1.224334087424018e-2,1.225866811915791e-2,1.2273995364075639e-2,1.2289322608993368e-2,1.2304649853911097e-2,1.2319977098828826e-2,1.2335304343746557e-2,1.2350631588664287e-2,1.2365958833582016e-2,1.2381286078499745e-2,1.2396613323417474e-2,1.2411940568335205e-2,1.2427267813252934e-2,1.2442595058170663e-2,1.2457922303088393e-2,1.2473249548006122e-2,1.2488576792923851e-2,1.2503904037841582e-2,1.2519231282759311e-2,1.253455852767704e-2,1.254988577259477e-2,1.2565213017512499e-2,1.2580540262430228e-2,1.2595867507347959e-2,1.2611194752265688e-2,1.2626521997183417e-2,1.2641849242101147e-2,1.2657176487018876e-2,1.2672503731936607e-2,1.2687830976854336e-2,1.2703158221772065e-2,1.2718485466689794e-2,1.2733812711607524e-2,1.2749139956525253e-2,1.2764467201442982e-2,1.2779794446360713e-2,1.2795121691278442e-2,1.2810448936196171e-2,1.28257761811139e-2,1.284110342603163e-2,1.285643067094936e-2,1.287175791586709e-2,1.2887085160784819e-2,1.2902412405702548e-2,1.2917739650620277e-2,1.2933066895538008e-2,1.2948394140455738e-2,1.2963721385373467e-2,1.2979048630291196e-2,1.2994375875208925e-2,1.3009703120126654e-2,1.3025030365044384e-2,1.3040357609962114e-2,1.3055684854879844e-2,1.3071012099797573e-2,1.3086339344715302e-2,1.3101666589633031e-2,1.3116993834550762e-2,1.3132321079468491e-2,1.314764832438622e-2,1.316297556930395e-2],"kdeType":"time","kdePDF":[226.39213579040626,227.74737208286672,230.4240209777485,234.35520446525166,239.44251189763614,245.55824020542485,252.54830281977044,260.23574239210177,268.42476856524763,276.90522970074903,285.4574168248726,293.857089327339,301.88060533640714,309.3100354147814,315.9381364991158,321.5730640786122,326.04270470946744,329.1985183000614,330.91879032668004,331.11120830482804,329.7146943643358,326.70044640392877,322.07216358193614,315.8654571759498,308.1464742561771,299.0097881330211,288.5756350012319,276.9865993921043,264.4038707584309,251.00320864962754,236.9707635617167,222.4989039966407,207.78219717561993,193.01368120718084,178.38155065714358,164.06635609851597,150.23879233903116,137.05812089351653,124.67124133043687,113.21239491946292,102.80345409486672,93.55472411010112,85.56616022287774,78.92888592916546,73.72688599788663,70.03874287314144,67.93928660130277,67.50103665813326,68.79532841542114,71.89303670435095,76.86483293611263,83.78093923284351,92.71037154239649,103.71969220152411,116.87131930550787,132.22146404469964,149.8177865562957,169.69687474606908,191.8816582336357,216.3788707422337,243.17666901250362,272.2425052447056,303.52133417118614,336.9342164993303,372.37735927907704,409.721612502002,448.8124216740795,489.4702197772223,531.4912301625712,574.6486452440753,618.6941445652857,663.3597194720666,708.3597792379582,753.3935235600917,798.1475770274628,842.2988904557856,885.5179199440715,927.4720954846134,967.8295857961837,1006.2633542572273,1042.4554826658525,1076.1017161094705,1106.9161552836308,1134.6359945388488,1159.0261775156848,1179.8838203249143,1197.0422375434712,1210.374401077014,1219.7956677387433,1225.2656288821559,1226.7889642908985,1224.4152214676953,1218.237488266476,1208.3899785330054,1195.044603621632,1178.4066536929734,1158.709758016505,1136.2103299323414,1111.181727129456,1083.9083697562796,1054.6800568134404,1023.7867054776729,991.5137095872026,958.1380744126301,923.9254376202575,889.1280340279541,853.9836076027433,818.715221407658,783.5318679329476,748.629741137533,714.1939997715211,680.4008307382902,647.4196123111446,615.4149801841269,584.5486141706749,554.9805887901812,526.8701653502904,500.3759443079053,475.65534216819646,452.86340421171957,432.151010083949,413.6625709617908,397.53335207497497,383.88658063512054,372.8305150623065,364.4556557868969,358.8322705486918,356.00838847365]}],"reportKeys":["time","cpuTime","cycles","iters","allocated","numGcs","bytesCopied","mutatorWallSeconds","mutatorCpuSeconds","gcWallSeconds","gcCpuSeconds"],"reportNumber":5,"reportName":"project/project 10x1000 to 1x1000","reportOutliers":{"highSevere":0,"highMild":0,"lowMild":4,"samplesSeen":24,"lowSevere":0},"reportMeasured":[[1.1805506001110189e-2,1.1793334000000044e-2,22422097,1,null,null,null,null,null,null,null],[2.3688543995376676e-2,2.3665619999999166e-2,44998973,2,null,null,null,null,null,null,null],[3.559850100282347e-2,3.5557807e-2,67629392,3,null,null,null,null,null,null,null],[4.660554000292905e-2,4.656808600000062e-2,88522841,4,null,null,null,null,null,null,null],[5.880757200066e-2,5.875392799999801e-2,111725134,5,null,null,null,null,null,null,null],[7.08814989993698e-2,7.08285650000029e-2,134666505,6,null,null,null,null,null,null,null],[8.951854199403897e-2,8.944563700000074e-2,170086558,7,null,null,null,null,null,null,null],[0.10135353299847338,0.10126066199999784,192564595,8,null,null,null,null,null,null,null],[0.11417685800552135,0.1140760279999995,216925949,9,null,null,null,null,null,null,null],[0.1255695689978893,0.1254597309999994,238572908,10,null,null,null,null,null,null,null],[0.13713935700070579,0.13703011200000148,260557082,11,null,null,null,null,null,null,null],[0.14897361699695466,0.1488434130000016,283042615,12,null,null,null,null,null,null,null],[0.16108048299793154,0.16094834200000108,306044257,13,null,null,null,null,null,null,null],[0.1797490840035607,0.17961487999999903,341513638,14,null,null,null,null,null,null,null],[0.19128122000256553,0.19112937800000296,363427079,15,null,null,null,null,null,null,null],[0.2028727059951052,0.20270760100000018,385452590,16,null,null,null,null,null,null,null],[0.21521219300484518,0.2150410849999993,408892984,17,null,null,null,null,null,null,null],[0.22753583099984098,0.22735460599999868,432309224,18,null,null,null,null,null,null,null],[0.23789910299819894,0.23770649300000102,452001413,19,null,null,null,null,null,null,null],[0.25045923499419587,0.2502648369999996,475864654,20,null,null,null,null,null,null,null],[0.26928186200530035,0.2690656770000004,511629312,21,null,null,null,null,null,null,null],[0.2863831520007807,0.28614335399999646,544120390,22,null,null,null,null,null,null,null],[0.3001085560026695,0.2998305869999953,570198325,23,null,null,null,null,null,null,null],[0.31689061599900015,0.3166167309999963,602084550,25,null,null,null,null,null,null,null],[0.33565128299960634,0.335338225000001,637727896,26,null,null,null,null,null,null,null],[0.3474145780055551,0.3470547940000017,660078787,27,null,null,null,null,null,null,null]]},{"reportAnalysis":{"anMean":{"estError":{"confIntLDX":2.0214769761556922e-4,"confIntUDX":1.4848505751438416e-4,"confIntCL":5.0e-2},"estPoint":1.547382196820991e-2},"anRegress":[{"regRSquare":{"estError":{"confIntLDX":3.8860730800849286e-4,"confIntUDX":3.083141884447915e-4,"confIntCL":5.0e-2},"estPoint":0.9994214827754374},"regResponder":"time","regCoeffs":{"y":{"estError":{"confIntLDX":2.459566718063007e-3,"confIntUDX":1.8356311328678744e-3,"confIntCL":5.0e-2},"estPoint":-3.352632585310556e-3},"iters":{"estError":{"confIntLDX":1.8636327388533297e-4,"confIntUDX":1.8116858527507038e-4,"confIntCL":5.0e-2},"estPoint":1.596884111763632e-2}}}],"anStdDev":{"estError":{"confIntLDX":1.1049259965506493e-4,"confIntUDX":1.2695701096172553e-4,"confIntCL":5.0e-2},"estPoint":3.978143402171812e-4},"anOutlierVar":{"ovFraction":4.1587901701323225e-2,"ovDesc":"slight","ovEffect":"Slight"},"anOverhead":2.1820495514718956e-3},"reportKDEs":[{"kdeValues":[1.449190814844687e-2,1.450530902167609e-2,1.451870989490531e-2,1.453211076813453e-2,1.454551164136375e-2,1.4558912514592971e-2,1.4572313387822191e-2,1.4585714261051411e-2,1.4599115134280631e-2,1.4612516007509851e-2,1.4625916880739071e-2,1.4639317753968291e-2,1.4652718627197511e-2,1.4666119500426731e-2,1.4679520373655951e-2,1.4692921246885171e-2,1.4706322120114391e-2,1.4719722993343612e-2,1.4733123866572832e-2,1.4746524739802052e-2,1.4759925613031272e-2,1.4773326486260492e-2,1.4786727359489712e-2,1.4800128232718932e-2,1.4813529105948152e-2,1.4826929979177372e-2,1.4840330852406592e-2,1.4853731725635812e-2,1.4867132598865032e-2,1.4880533472094252e-2,1.4893934345323472e-2,1.4907335218552692e-2,1.4920736091781912e-2,1.4934136965011132e-2,1.4947537838240352e-2,1.4960938711469573e-2,1.4974339584698793e-2,1.4987740457928013e-2,1.5001141331157233e-2,1.5014542204386453e-2,1.5027943077615673e-2,1.5041343950844893e-2,1.5054744824074113e-2,1.5068145697303333e-2,1.5081546570532553e-2,1.5094947443761773e-2,1.5108348316990993e-2,1.5121749190220213e-2,1.5135150063449433e-2,1.5148550936678653e-2,1.5161951809907873e-2,1.5175352683137093e-2,1.5188753556366313e-2,1.5202154429595533e-2,1.5215555302824754e-2,1.5228956176053974e-2,1.5242357049283194e-2,1.5255757922512414e-2,1.5269158795741634e-2,1.5282559668970854e-2,1.5295960542200074e-2,1.5309361415429296e-2,1.5322762288658514e-2,1.5336163161887736e-2,1.5349564035116954e-2,1.5362964908346176e-2,1.5376365781575394e-2,1.5389766654804616e-2,1.5403167528033834e-2,1.5416568401263056e-2,1.5429969274492276e-2,1.5443370147721496e-2,1.5456771020950716e-2,1.5470171894179936e-2,1.5483572767409156e-2,1.5496973640638376e-2,1.5510374513867596e-2,1.5523775387096816e-2,1.5537176260326037e-2,1.5550577133555257e-2,1.5563978006784477e-2,1.5577378880013697e-2,1.5590779753242917e-2,1.5604180626472137e-2,1.5617581499701357e-2,1.5630982372930577e-2,1.5644383246159795e-2,1.5657784119389017e-2,1.5671184992618235e-2,1.5684585865847457e-2,1.5697986739076675e-2,1.5711387612305897e-2,1.5724788485535116e-2,1.5738189358764337e-2,1.5751590231993556e-2,1.5764991105222777e-2,1.5778391978451996e-2,1.5791792851681218e-2,1.5805193724910436e-2,1.5818594598139658e-2,1.5831995471368876e-2,1.5845396344598098e-2,1.5858797217827316e-2,1.5872198091056538e-2,1.5885598964285756e-2,1.5898999837514978e-2,1.5912400710744196e-2,1.5925801583973418e-2,1.5939202457202636e-2,1.5952603330431858e-2,1.5966004203661077e-2,1.59794050768903e-2,1.5992805950119517e-2,1.600620682334874e-2,1.6019607696577957e-2,1.603300856980718e-2,1.6046409443036397e-2,1.605981031626562e-2,1.6073211189494837e-2,1.608661206272406e-2,1.6100012935953277e-2,1.61134138091825e-2,1.612681468241172e-2,1.614021555564094e-2,1.6153616428870157e-2,1.616701730209938e-2,1.61804181753286e-2,1.619381904855782e-2],"kdeType":"time","kdePDF":[339.3394652798866,339.3398040126309,339.3376431288003,339.32739669237077,339.3009102922482,339.247723764681,339.1554106367999,339.00998549878693,338.79636892038155,338.49889829347273,338.1018721352799,337.5901149363349,336.94954957576823,336.16776462767433,335.2345645060762,334.14249128978645,332.8873081718342,331.4684357265141,329.8893335161033,328.15782090850354,326.28633229362185,324.29210312771494,322.19728437090976,320.02898389675147,317.8192343401486,315.60488762010215,313.42743704500253,311.3327685078397,309.3708428377909,307.5953119260009,306.063071817416,304.83375658235536,303.9691774679016,303.5327125867404,303.58865322460764,304.2015137198996,305.4353127616136,307.35283482599084,310.0148812816948,313.47952138699367,317.80135392797513,323.03079055437377,329.2133719156,336.3891274498759,344.59198911288667,353.84926844237333,364.18120515195346,375.600593957622,388.11249460737326,401.7140281656252,416.39426057011894,432.1341724082433,448.9067118368043,466.67692567837355,485.4021620501326,505.0323364901117,525.5102525026635,546.771966795203,568.7471892504013,591.3597078800761,614.5278296281449,638.1648288983123,662.1793970288159,686.4760875553643,710.9557539166747,735.5159781763992,760.0514912686873,784.4545871277792,808.6155347452408,832.4229936279593,855.7644392343634,878.5266056863712,900.595953348804,921.8591687111609,942.2037033933608,961.518358039165,979.6939153894958,996.6238249891242,1012.2049398364882,1026.338302911342,1038.929978992983,1049.8919246034288,1059.1428863703215,1066.6093156988043,1072.2262854638248,1075.9383925720354,1077.7006287758888,1077.4792011204433,1075.2522829217874,1071.0106762550165,1064.7583675925548,1056.5129594848056,1046.3059629998363,1034.1829380025176,1020.2034712023833,1004.4409851613746,986.9823750386817,967.9274736572588,947.3883493909525,925.4884452710058,902.361571470757,878.1507668237224,853.0070481445114,827.0880687462661,800.5567095891997,773.5796278778657,746.3257885974294,718.965004413615,691.6665085553291,664.5975837782671,637.9222683231118,611.8001570089538,586.3853123385799,561.8252968530317,538.260334087611,515.8226014887058,494.6356546921212,474.81397877906545,456.46265864814916,439.67715759127947,424.5431906418146,411.13667735818353,399.523757475057,389.7608523315806,381.89475517986835,375.9627343682566,371.9926349382536,370.00296630346537]}],"reportKeys":["time","cpuTime","cycles","iters","allocated","numGcs","bytesCopied","mutatorWallSeconds","mutatorCpuSeconds","gcWallSeconds","gcCpuSeconds"],"reportNumber":6,"reportName":"project/project 10x1000 to 5x1000","reportOutliers":{"highSevere":0,"highMild":0,"lowMild":0,"samplesSeen":21,"lowSevere":0},"reportMeasured":[[1.507493200188037e-2,1.506444999999701e-2,28631577,1,null,null,null,null,null,null,null],[3.0044839993934147e-2,3.0011522999998874e-2,57076332,2,null,null,null,null,null,null,null],[4.602774199884152e-2,4.5973276000005114e-2,87445137,3,null,null,null,null,null,null,null],[5.9625961002893746e-2,5.957763600000021e-2,113280994,4,null,null,null,null,null,null,null],[7.525645900022937e-2,7.519037400000173e-2,142976086,5,null,null,null,null,null,null,null],[8.905667799990624e-2,8.897487000000126e-2,169198952,6,null,null,null,null,null,null,null],[0.11078702899976633,0.11069898400000255,210485926,7,null,null,null,null,null,null,null],[0.12581275300181005,0.12570637000000318,239036957,8,null,null,null,null,null,null,null],[0.14042515800247202,0.14030637199999774,266800371,9,null,null,null,null,null,null,null],[0.15486334200249985,0.15474121999999824,294230327,10,null,null,null,null,null,null,null],[0.16949182599637425,0.16934615400000297,322026203,11,null,null,null,null,null,null,null],[0.18458782800007612,0.1844472820000007,350709797,12,null,null,null,null,null,null,null],[0.2069304859978729,0.20675212399999765,393162950,13,null,null,null,null,null,null,null],[0.22282338000513846,0.22255065099999882,423354484,14,null,null,null,null,null,null,null],[0.237528261000989,0.23732342799999628,451294459,15,null,null,null,null,null,null,null],[0.25102039399644127,0.2507945950000021,476930577,16,null,null,null,null,null,null,null],[0.26663147199724335,0.2664183879999982,506590187,17,null,null,null,null,null,null,null],[0.28122573099972215,0.280993083999995,534320598,18,null,null,null,null,null,null,null],[0.295340610005951,0.2950916140000004,561138070,19,null,null,null,null,null,null,null],[0.31776399700174807,0.3175341020000033,603742588,20,null,null,null,null,null,null,null],[0.3324330129980808,0.3321678370000001,631612507,21,null,null,null,null,null,null,null],[0.34725084000092465,0.3469759039999971,659767266,22,null,null,null,null,null,null,null],[0.37028686700068647,0.3699242579999975,703537082,23,null,null,null,null,null,null,null]]},{"reportAnalysis":{"anMean":{"estError":{"confIntLDX":1.4849515604026947e-4,"confIntUDX":2.2302267966680528e-4,"confIntCL":5.0e-2},"estPoint":4.923173514046889e-2},"anRegress":[{"regRSquare":{"estError":{"confIntLDX":1.0446290147780868e-4,"confIntUDX":9.674844257745452e-5,"confIntCL":5.0e-2},"estPoint":0.9998833768007424},"regResponder":"time","regCoeffs":{"y":{"estError":{"confIntLDX":2.259559006627959e-3,"confIntUDX":1.93476793690426e-3,"confIntCL":5.0e-2},"estPoint":8.529011135507786e-4},"iters":{"estError":{"confIntLDX":3.400703549832976e-4,"confIntUDX":3.762902771172333e-4,"confIntCL":5.0e-2},"estPoint":4.922073172017738e-2}}}],"anStdDev":{"estError":{"confIntLDX":1.1789626053074169e-4,"confIntUDX":1.7027737094845103e-4,"confIntCL":5.0e-2},"estPoint":3.275115670368287e-4},"anOutlierVar":{"ovFraction":7.100591715976319e-2,"ovDesc":"slight","ovEffect":"Slight"},"anOverhead":2.1820495514718956e-3},"reportKDEs":[{"kdeValues":[4.8763763595693385e-2,4.877421973183179e-2,4.8784675867970195e-2,4.87951320041086e-2,4.8805588140247005e-2,4.881604427638541e-2,4.8826500412523816e-2,4.883695654866222e-2,4.884741268480062e-2,4.8857868820939024e-2,4.886832495707743e-2,4.8878781093215834e-2,4.888923722935424e-2,4.8899693365492644e-2,4.891014950163105e-2,4.8920605637769454e-2,4.893106177390786e-2,4.8941517910046264e-2,4.895197404618467e-2,4.8962430182323075e-2,4.897288631846148e-2,4.8983342454599885e-2,4.899379859073828e-2,4.900425472687669e-2,4.901471086301509e-2,4.90251669991535e-2,4.90356231352919e-2,4.904607927143031e-2,4.905653540756871e-2,4.906699154370712e-2,4.907744767984552e-2,4.908790381598393e-2,4.9098359952122334e-2,4.910881608826074e-2,4.9119272224399144e-2,4.912972836053755e-2,4.914018449667595e-2,4.915064063281435e-2,4.916109676895276e-2,4.917155290509116e-2,4.918200904122957e-2,4.919246517736797e-2,4.920292131350638e-2,4.921337744964478e-2,4.922383358578319e-2,4.923428972192159e-2,4.924474585806e-2,4.92552019941984e-2,4.926565813033681e-2,4.927611426647521e-2,4.928657040261361e-2,4.9297026538752016e-2,4.930748267489042e-2,4.9317938811028826e-2,4.932839494716723e-2,4.9338851083305636e-2,4.934930721944404e-2,4.9359763355582446e-2,4.937021949172085e-2,4.9380675627859257e-2,4.939113176399766e-2,4.940158790013607e-2,4.941204403627447e-2,4.942250017241288e-2,4.9432956308551275e-2,4.944341244468968e-2,4.9453868580828085e-2,4.946432471696649e-2,4.9474780853104895e-2,4.94852369892433e-2,4.9495693125381705e-2,4.950614926152011e-2,4.9516605397658515e-2,4.952706153379692e-2,4.9537517669935326e-2,4.954797380607373e-2,4.9558429942212136e-2,4.956888607835054e-2,4.957934221448894e-2,4.9589798350627344e-2,4.960025448676575e-2,4.9610710622904154e-2,4.962116675904256e-2,4.9631622895180964e-2,4.964207903131937e-2,4.9652535167457774e-2,4.966299130359618e-2,4.9673447439734585e-2,4.968390357587299e-2,4.9694359712011395e-2,4.97048158481498e-2,4.9715271984288205e-2,4.97257281204266e-2,4.973618425656501e-2,4.974664039270341e-2,4.975709652884182e-2,4.976755266498022e-2,4.977800880111863e-2,4.978846493725703e-2,4.979892107339544e-2,4.9809377209533844e-2,4.981983334567225e-2,4.9830289481810654e-2,4.984074561794906e-2,4.9851201754087464e-2,4.986165789022587e-2,4.987211402636427e-2,4.988257016250267e-2,4.989302629864108e-2,4.990348243477948e-2,4.991393857091789e-2,4.992439470705629e-2,4.99348508431947e-2,4.99453069793331e-2,4.995576311547151e-2,4.996621925160991e-2,4.997667538774832e-2,4.998713152388672e-2,4.999758766002513e-2,5.000804379616353e-2,5.001849993230194e-2,5.0028956068440336e-2,5.003941220457874e-2,5.0049868340717146e-2,5.006032447685555e-2,5.0070780612993956e-2,5.008123674913236e-2,5.009169288527077e-2],"kdeType":"time","kdePDF":[1098.1507885487008,1097.9619233817857,1097.5842312136772,1097.0177886927365,1096.2627115819625,1095.3191557024065,1094.1873181825406,1092.867439006317,1091.3598028509393,1089.6647412036432,1087.7826347451623,1085.7139159859626,1083.459072139828,1081.018648217944,1078.3932503252845,1075.5835491398614,1072.590283554232,1069.4142644576223,1066.0563786360883,1062.5175927672994,1058.7989574858525,1054.9016114944125,1050.8267856955515,1046.5758073188047,1042.150104017285,1037.551207908116,1032.780759531016,1027.8405116995527,1022.732333219919,1017.4582124525269,1012.0202606922909,1006.4207153441816,1000.6619428714358,994.746441494759,988.6768436218823,982.4559179880054,976.0865714888894,969.5718506897206,962.9149429942818,956.1191774604987,949.1880252499767,942.1250997008403,934.9341560148293,927.6190905514208,920.1839397234736,912.6328784907797,904.9702184496759,897.2004055188036,889.3280172228839,881.3577595783024,873.2944635860681,865.1430813395881,856.9086817564133,848.596445944922,840.2116622185147,831.7597207716074,823.2461080331823,814.6764007152273,806.0562595747128,797.3914229091496,788.687699806899,779.9509631746153,771.1871425650936,762.4022168298012,753.6022066210252,744.7931667693202,735.9811785623662,727.1723419518214,718.3727677149313,709.5885695978602,700.8258564676222,692.0907244994243,683.38924942587,674.7274788741564,666.1114248167496,657.5470561604609,649.0402914979433,640.5969920448158,632.2229547844832,623.9239058416803,615.7054941044108,607.5732851127132,599.5327552311303,591.5892861203489,583.7481595217655,576.0145523671652,568.3935322238881,560.8900530841606,553.5089515053812,546.254943106383,539.1326194227606,532.1464451225471,525.3007555816087,518.5997548163084,512.0475137691359,505.6479689412247,499.4049213639129,493.32203589982515,487.4028408623033,481.6507279404777,476.0689524157841,470.6606336543614,465.42875585847673,460.3761690589644,455.50559032959774,450.8196052033888,446.3206692699979,442.01110993275995,437.89312830330215,433.96880121131943,430.2400833068271,426.7088092320881,423.37669584045085,420.245344439502,417.31624303626484,414.59076856262493,412.07018905977213,409.75566580116725,407.6482553344219,405.74891142344734,404.0584868733492,402.5777352217515,401.30731228155986,400.2477775215805,399.3995952729278,398.7631357507153,398.33867588218374,398.1263999341119]}],"reportKeys":["time","cpuTime","cycles","iters","allocated","numGcs","bytesCopied","mutatorWallSeconds","mutatorCpuSeconds","gcWallSeconds","gcCpuSeconds"],"reportNumber":7,"reportName":"union/union identical 10x1000","reportOutliers":{"highSevere":0,"highMild":0,"lowMild":0,"samplesSeen":12,"lowSevere":0},"reportMeasured":[[5.00213889972656e-2,4.998460699999896e-2,95031185,1,null,null,null,null,null,null,null],[0.10105308899801457,0.10095891699999981,191990889,2,null,null,null,null,null,null,null],[0.14932909200433642,0.1491997110000014,283717109,3,null,null,null,null,null,null,null],[0.19788539900036994,0.19771486700000196,375970752,4,null,null,null,null,null,null,null],[0.245552549000422,0.24537460400000555,466539415,5,null,null,null,null,null,null,null],[0.29433757099468494,0.2941104770000038,559233974,6,null,null,null,null,null,null,null],[0.3468570469995029,0.34655869999999567,659019788,7,null,null,null,null,null,null,null],[0.39563732800161233,0.3953240969999996,751698269,8,null,null,null,null,null,null,null],[0.4421533890053979,0.4418359009999975,840083885,9,null,null,null,null,null,null,null],[0.4914517830038676,0.49105002900000017,933750741,10,null,null,null,null,null,null,null],[0.5395605520025128,0.5391937190000036,1025155452,11,null,null,null,null,null,null,null],[0.5905701550000231,0.590161234,1122074516,12,null,null,null,null,null,null,null],[0.6457649580042926,0.645225259,1226945092,13,null,null,null,null,null,null,null]]},{"reportAnalysis":{"anMean":{"estError":{"confIntLDX":1.3616114131957957e-3,"confIntUDX":6.192009813513755e-4,"confIntCL":5.0e-2},"estPoint":0.5157808375258943},"anRegress":[{"regRSquare":{"estError":{"confIntLDX":5.2562411323342495e-5,"confIntUDX":2.078751864043049e-5,"confIntCL":5.0e-2},"estPoint":0.9999792124813596},"regResponder":"time","regCoeffs":{"y":{"estError":{"confIntLDX":1.5438998001626996e-2,"confIntUDX":9.506022004642714e-3,"confIntCL":5.0e-2},"estPoint":3.1666350041647164e-3},"iters":{"estError":{"confIntLDX":6.950864203099427e-3,"confIntUDX":5.521645800035779e-3,"confIntCL":5.0e-2},"estPoint":0.5155792741992622}}}],"anStdDev":{"estError":{"confIntLDX":1.1935851498586624e-3,"confIntUDX":9.230743816508865e-5,"confIntCL":5.0e-2},"estPoint":1.1935851498586624e-3},"anOutlierVar":{"ovFraction":0.18749999999999997,"ovDesc":"moderate","ovEffect":"Moderate"},"anOverhead":2.1820495514718956e-3},"reportKDEs":[{"kdeValues":[0.5141965029831452,0.5142175476882999,0.5142385923934545,0.5142596370986091,0.5142806818037639,0.5143017265089185,0.5143227712140731,0.5143438159192277,0.5143648606243824,0.514385905329537,0.5144069500346917,0.5144279947398464,0.514449039445001,0.5144700841501556,0.5144911288553102,0.5145121735604649,0.5145332182656196,0.5145542629707742,0.5145753076759289,0.5145963523810835,0.5146173970862381,0.5146384417913927,0.5146594864965475,0.5146805312017021,0.5147015759068567,0.5147226206120114,0.514743665317166,0.5147647100223206,0.5147857547274753,0.51480679943263,0.5148278441377846,0.5148488888429392,0.5148699335480938,0.5148909782532485,0.5149120229584032,0.5149330676635578,0.5149541123687125,0.5149751570738671,0.5149962017790217,0.5150172464841763,0.5150382911893311,0.5150593358944857,0.5150803805996403,0.515101425304795,0.5151224700099496,0.5151435147151042,0.515164559420259,0.5151856041254136,0.5152066488305682,0.5152276935357228,0.5152487382408775,0.5152697829460321,0.5152908276511868,0.5153118723563415,0.5153329170614961,0.5153539617666507,0.5153750064718053,0.51539605117696,0.5154170958821147,0.5154381405872693,0.515459185292424,0.5154802299975786,0.5155012747027332,0.5155223194078878,0.5155433641130426,0.5155644088181972,0.5155854535233518,0.5156064982285065,0.5156275429336611,0.5156485876388157,0.5156696323439705,0.5156906770491251,0.5157117217542797,0.5157327664594343,0.515753811164589,0.5157748558697436,0.5157959005748983,0.515816945280053,0.5158379899852076,0.5158590346903622,0.5158800793955168,0.5159011241006715,0.5159221688058262,0.5159432135109808,0.5159642582161355,0.5159853029212901,0.5160063476264447,0.5160273923315993,0.5160484370367541,0.5160694817419087,0.5160905264470633,0.516111571152218,0.5161326158573726,0.5161536605625272,0.5161747052676819,0.5161957499728366,0.5162167946779912,0.5162378393831458,0.5162588840883005,0.5162799287934551,0.5163009734986098,0.5163220182037644,0.5163430629089191,0.5163641076140737,0.5163851523192283,0.516406197024383,0.5164272417295377,0.5164482864346923,0.5164693311398469,0.5164903758450016,0.5165114205501562,0.5165324652553108,0.5165535099604656,0.5165745546656202,0.5165955993707748,0.5166166440759294,0.5166376887810841,0.5166587334862387,0.5166797781913934,0.5167008228965481,0.5167218676017027,0.5167429123068573,0.5167639570120119,0.5167850017171666,0.5168060464223213,0.5168270911274759,0.5168481358326306,0.5168691805377852],"kdeType":"time","kdePDF":[309.38802057513465,309.4023860102444,309.4311682114648,309.4744696620986,309.53244364083116,309.60529368755556,309.69327289338037,309.7966830167308,309.9158734279286,310.0512398850909,310.2032231446485,310.372307410227,310.5590186240712,310.7639226056174,310.98762304223067,311.2307593375253,311.49400432306555,311.7780618396215,312.08366419450016,312.411569501812,312.7625589128479,313.1374337440434,313.5370125102792,313.96212787153473,314.4136235011376,314.89235088407736,315.39916605403647,315.9349262779685,316.50048669719547,317.0966969341247,317.72439767378035,318.38441722942645,319.0775681016053,319.80464353994586,320.5664141170984,321.3636243241323,322.1969891966887,323.0671909811095,323.97487584967564,324.92065067396595,325.9050798652177,326.9286822903981,327.9919282725238,329.09523668354973,330.2389721379345,331.42344229472934,332.6488952757878,333.91551720739204,335.2234298923045,336.57268861891947,337.9632801138653,339.39512064404335,340.8680542737363,342.3818512820254,343.9362067453748,345.53073928982553,347.16499001684133,348.8384216064042,350.5504176005491,352.3002818700631,354.0872382666488,355.9104304623841,357.7689219778728,359.66169640000106,361.5876577897826,363.5456312802869,365.5343638642128,367.5525253701911,369.59870962646096,371.6714358101026,373.76914997957715,375.890226787867,378.0329713731015,380.1956214231029,382.3763494098983,384.57326498981644,386.78441756441356,389.00779899707237,391.24134647977047,393.4829455441344,395.7304332105799,397.98160126899035,400.23419968409394,402.48594011838867,404.734499565207,406.977524084232,409.2126326315558,411.4374209761309,413.6494656942786,415.8463282337186,418.025559038435,420.18470172553765,422.3212973051635,424.43288843435346,426.5170236957626,428.5712618919959,430.5931763463266,432.5803592005279,434.5304257005582,436.44101846085346,438.3098116980315,440.13451542486933,441.91287959550385,443.64269819290615,445.3218132498055,446.9481187943808,448.51956471220046,450.034160516072,451.48997901566054,452.8851598789545,454.2179130778891,455.48652221068966,456.6893476937622,457.82482981624395,458.89149165062054,459.88794181312977,460.8128770679966,461.66508476988133,462.44344513927086,463.1469333659088,463.7746215357259,464.32568037711644,464.7993808227955,465.19509538387194,465.5122993331701,465.7505716952569,465.9095960410329,465.9891610851808]}],"reportKeys":["time","cpuTime","cycles","iters","allocated","numGcs","bytesCopied","mutatorWallSeconds","mutatorCpuSeconds","gcWallSeconds","gcCpuSeconds"],"reportNumber":8,"reportName":"union/union identical 10x10000","reportOutliers":{"highSevere":0,"highMild":0,"lowMild":0,"samplesSeen":3,"lowSevere":0},"reportMeasured":[[0.5213010670049698,0.5209129200000007,990462359,1,null,null,null,null,null,null,null],[1.029929477001133,1.0291960659999972,1956856394,2,null,null,null,null,null,null,null],[1.5510303970004315,1.5498950729999947,2946947849,3,null,null,null,null,null,null,null],[2.066198341002746,2.064697297000002,3925769673,4,null,null,null,null,null,null,null]]},{"reportAnalysis":{"anMean":{"estError":{"confIntLDX":1.9136268846312587e-3,"confIntUDX":1.0778112309037247e-3,"confIntCL":5.0e-2},"estPoint":0.3374978199984254},"anRegress":[{"regRSquare":{"estError":{"confIntLDX":7.048604004911141e-7,"confIntUDX":9.653846087087636e-6,"confIntCL":5.0e-2},"estPoint":0.9999903461539129},"regResponder":"time","regCoeffs":{"y":{"estError":{"confIntLDX":3.7081885020606234e-3,"confIntUDX":7.930082494565614e-3,"confIntCL":5.0e-2},"estPoint":-1.5550898497166503e-2},"iters":{"estError":{"confIntLDX":2.273477398556878e-3,"confIntUDX":2.4901846016293083e-3,"confIntCL":5.0e-2},"estPoint":0.3432690643996462}}}],"anStdDev":{"estError":{"confIntLDX":1.6965376723717264e-3,"confIntUDX":1.702861405217474e-4,"confIntCL":5.0e-2},"estPoint":1.6965376723717264e-3},"anOutlierVar":{"ovFraction":0.1875,"ovDesc":"moderate","ovEffect":"Moderate"},"anOverhead":2.1820495514718956e-3},"reportKDEs":[{"kdeValues":[0.335260849744523,0.335291401873903,0.3353219540032829,0.3353525061326629,0.3353830582620428,0.33541361039142276,0.3354441625208027,0.33547471465018264,0.3355052667795626,0.3355358189089425,0.3355663710383225,0.33559692316770245,0.33562747529708237,0.33565802742646234,0.33568857955584225,0.3357191316852222,0.3357496838146022,0.3357802359439821,0.33581078807336207,0.335841340202742,0.33587189233212195,0.3359024444615019,0.3359329965908818,0.3359635487202618,0.3359941008496417,0.3360246529790217,0.33605520510840164,0.33608575723778156,0.3361163093671615,0.33614686149654144,0.3361774136259214,0.3362079657553014,0.3362385178846813,0.33626907001406126,0.33629962214344117,0.33633017427282114,0.3363607264022011,0.336391278531581,0.336421830660961,0.3364523827903409,0.33648293491972087,0.33651348704910083,0.33654403917848075,0.3365745913078607,0.33660514343724063,0.3366356955666206,0.33666624769600056,0.3366967998253805,0.33672735195476045,0.33675790408414036,0.3367884562135203,0.3368190083429003,0.3368495604722802,0.3368801126016602,0.3369106647310401,0.33694121686042006,0.3369717689898,0.33700232111917994,0.3370328732485599,0.3370634253779398,0.3370939775073198,0.3371245296366997,0.33715508176607967,0.33718563389545964,0.33721618602483955,0.3372467381542195,0.33727729028359943,0.3373078424129794,0.33733839454235937,0.3373689466717393,0.33739949880111925,0.33743005093049916,0.3374606030598791,0.3374911551892591,0.337521707318639,0.337552259448019,0.3375828115773989,0.33761336370677886,0.3376439158361588,0.33767446796553874,0.3377050200949187,0.3377355722242986,0.3377661243536786,0.33779667648305856,0.33782722861243847,0.33785778074181844,0.33788833287119835,0.3379188850005783,0.3379494371299583,0.3379799892593382,0.33801054138871817,0.3380410935180981,0.33807164564747805,0.338102197776858,0.33813274990623793,0.3381633020356179,0.3381938541649978,0.3382244062943778,0.33825495842375775,0.33828551055313766,0.3383160626825176,0.33834661481189754,0.3383771669412775,0.3384077190706575,0.3384382712000374,0.33846882332941736,0.33849937545879727,0.33852992758817724,0.3385604797175572,0.3385910318469371,0.3386215839763171,0.338652136105697,0.33868268823507697,0.33871324036445694,0.33874379249383685,0.3387743446232168,0.33880489675259673,0.3388354488819767,0.33886600101135667,0.3388965531407366,0.33892710527011655,0.33895765739949646,0.3389882095288764,0.3390187616582564,0.3390493137876363,0.3390798659170163,0.3391104180463962,0.33914097017577616],"kdeType":"time","kdePDF":[218.94440967899624,218.95328792946546,218.97107464851806,218.99783016481234,219.03364470271197,219.07863806077597,219.13295918447588,219.19678563433106,219.27032295094506,219.35380391871573,219.4474877302688,219.55165905394765,219.6666270069562,219.79272403701768,219.9303047156654,220.07974444652592,220.241438092194,220.415798523521,220.60325509535545,220.80425205297948,221.01924687367185,221.24870854801384,221.49311580571535,221.75295529089485,222.02871969188413,222.32090583075617,222.63001271788212,222.95653957692352,223.30098384574237,223.66383915878296,224.04559331652538,224.4467262476503,224.867707969572,225.30899655300368,225.77103609620795,226.25425471455912,226.75906255100557,227.28584981296243,227.83498484109774,228.40681221538733,229.0016509037195,229.61979245821323,230.2614992642938,230.92700284742511,231.6165022422535,232.33016242874683,233.0681128397482,233.8304459441655,234.61721590983643,235.42843734988787,236.26408415620688,237.12408842340642,238.00833946644545,238.91668293481632,239.84892002597644,240.80480680043843,241.78405360068845,242.78632457582972,243.8112373135947,244.85836258108932,245.92722417537553,247.01729888471294,248.12801656102025,249.25876030383247,250.40886675576718,251.5776265092326,252.76428462384968,253.96804125378225,255.18805238391855,256.4234306735713,257.67324640612435,258.93652854278633,260.21226587838197,261.4994082968573,262.79686812395653,264.1035215742887,265.41821028979865,266.73974296643223,268.0668970655977,269.3984206068207,270.73303403781875,272.0694321780345,273.4062862315169,274.7422458648741,276.0759413458871,277.4059857382356,278.7309771476714,280.0495010148576,281.3601324500009,282.6614386043089,283.9519810732365,285.23031832641135,286.49500815908596,287.7446101599129,288.97768818981825,290.19281286672356,291.3885640508648,292.5635333254589,293.7163264674862,294.84556590338235,295.9498931444749,297.02797119704576,298.0784869419626,299.100153478892,300.09171243018943,301.05193619964774,301.97963018139274,302.87363491431853,303.73282817757786,304.5561270227706,305.3424897386085,306.09091774398223,306.80045740550736,307.47020177578815,308.09929224880443,308.686920129005,309.23232811086694,309.7348116658736,310.19372033405386,310.6084589174242,310.97848857288096,311.30332780229577,311.5825533377822,311.81580092031595,312.00276597011117,312.1432041473806,312.2369318023264,312.2838263134446]}],"reportKeys":["time","cpuTime","cycles","iters","allocated","numGcs","bytesCopied","mutatorWallSeconds","mutatorCpuSeconds","gcWallSeconds","gcCpuSeconds"],"reportNumber":9,"reportName":"join/join identical 10x100","reportOutliers":{"highSevere":0,"highMild":0,"lowMild":0,"samplesSeen":3,"lowSevere":0},"reportMeasured":[[0.32650016200204846,0.32622583200000577,620340770,1,null,null,null,null,null,null,null],[0.6722594110033242,0.6717048900000009,1277284362,2,null,null,null,null,null,null,null],[1.0153659450006671,1.014700420000004,1929185516,3,null,null,null,null,null,null,null],[1.3563615320017561,1.3553818119999974,2577077214,4,null,null,null,null,null,null,null]]},{"reportAnalysis":{"anMean":{"estError":{"confIntLDX":3.73601811220009e-4,"confIntUDX":4.425636919137138e-4,"confIntCL":5.0e-2},"estPoint":4.70336206675725e-2},"anRegress":[{"regRSquare":{"estError":{"confIntLDX":2.663144455224975e-4,"confIntUDX":1.9416582717446396e-4,"confIntCL":5.0e-2},"estPoint":0.9997071105510539},"regResponder":"time","regCoeffs":{"y":{"estError":{"confIntLDX":3.720208282599045e-3,"confIntUDX":4.150284022617402e-3,"confIntCL":5.0e-2},"estPoint":1.1118184998988514e-3},"iters":{"estError":{"confIntLDX":6.232093546506001e-4,"confIntUDX":4.343548663097649e-4,"confIntCL":5.0e-2},"estPoint":4.700242177468782e-2}}}],"anStdDev":{"estError":{"confIntLDX":2.210909475749965e-4,"confIntUDX":4.015261754837878e-4,"confIntCL":5.0e-2},"estPoint":7.389605929837668e-4},"anOutlierVar":{"ovFraction":7.100591715976322e-2,"ovDesc":"slight","ovEffect":"Slight"},"anOverhead":2.1820495514718956e-3},"reportKDEs":[{"kdeValues":[4.5342716617225436e-2,4.537034085307174e-2,4.5397965088918045e-2,4.542558932476435e-2,4.5453213560610654e-2,4.548083779645696e-2,4.5508462032303264e-2,4.553608626814957e-2,4.556371050399587e-2,4.559133473984218e-2,4.561895897568848e-2,4.564658321153479e-2,4.567420744738109e-2,4.57018316832274e-2,4.57294559190737e-2,4.5757080154920006e-2,4.578470439076631e-2,4.5812328626612615e-2,4.583995286245892e-2,4.5867577098305225e-2,4.589520133415153e-2,4.592282556999783e-2,4.595044980584413e-2,4.597807404169044e-2,4.600569827753674e-2,4.6033322513383046e-2,4.606094674922935e-2,4.6088570985075655e-2,4.611619522092196e-2,4.6143819456768265e-2,4.617144369261457e-2,4.6199067928460874e-2,4.622669216430718e-2,4.625431640015348e-2,4.628194063599979e-2,4.630956487184609e-2,4.63371891076924e-2,4.63648133435387e-2,4.639243757938501e-2,4.642006181523131e-2,4.6447686051077616e-2,4.647531028692392e-2,4.6502934522770226e-2,4.653055875861653e-2,4.6558182994462835e-2,4.658580723030914e-2,4.6613431466155444e-2,4.664105570200175e-2,4.6668679937848054e-2,4.669630417369436e-2,4.672392840954066e-2,4.675155264538697e-2,4.677917688123327e-2,4.680680111707958e-2,4.683442535292588e-2,4.686204958877219e-2,4.688967382461849e-2,4.6917298060464796e-2,4.69449222963111e-2,4.6972546532157405e-2,4.700017076800371e-2,4.7027795003850015e-2,4.705541923969632e-2,4.7083043475542624e-2,4.711066771138893e-2,4.713829194723523e-2,4.716591618308153e-2,4.7193540418927836e-2,4.722116465477414e-2,4.7248788890620445e-2,4.727641312646675e-2,4.7304037362313055e-2,4.733166159815936e-2,4.7359285834005664e-2,4.738691006985197e-2,4.7414534305698273e-2,4.744215854154458e-2,4.746978277739088e-2,4.749740701323719e-2,4.752503124908349e-2,4.75526554849298e-2,4.75802797207761e-2,4.7607903956622406e-2,4.763552819246871e-2,4.7663152428315016e-2,4.769077666416132e-2,4.7718400900007625e-2,4.774602513585393e-2,4.7773649371700234e-2,4.780127360754654e-2,4.7828897843392844e-2,4.785652207923915e-2,4.788414631508545e-2,4.791177055093176e-2,4.793939478677806e-2,4.796701902262437e-2,4.799464325847067e-2,4.802226749431698e-2,4.804989173016328e-2,4.8077515966009586e-2,4.810514020185589e-2,4.8132764437702195e-2,4.81603886735485e-2,4.8188012909394805e-2,4.821563714524111e-2,4.8243261381087414e-2,4.827088561693371e-2,4.829850985278002e-2,4.832613408862632e-2,4.8353758324472626e-2,4.838138256031893e-2,4.8409006796165235e-2,4.843663103201154e-2,4.8464255267857845e-2,4.849187950370415e-2,4.8519503739550454e-2,4.854712797539676e-2,4.8574752211243064e-2,4.860237644708937e-2,4.863000068293567e-2,4.865762491878198e-2,4.868524915462828e-2,4.871287339047459e-2,4.874049762632089e-2,4.8768121862167196e-2,4.87957460980135e-2,4.8823370333859806e-2,4.885099456970611e-2],"kdeType":"time","kdePDF":[180.7066702348903,180.9719240045234,181.50219832628855,182.29702211669093,183.35567720041018,184.67718464857958,186.26028689121557,188.10342587989197,190.20471763947612,192.5619236063687,195.17241920452054,198.0331601588513,201.14064708801422,204.49088895417466,208.0793659761974,211.9009926339555,215.95008140516987,220.22030788200254,224.70467791254836,229.39549740231462,234.28434539291874,239.3620510096893,244.6186748369565,250.04349523988074,255.6250001051848,261.35088442059885,267.20805405484504,273.18263603718617,279.25999556869925,285.4247599272309,291.66084935528124,297.95151494563567,304.27938346429937,310.6265089750045,316.97443105513565,323.30423932015566,329.59664390336394,335.83205147081725,341.9906462882729,348.05247579871656,353.99754011608786,359.8058847937328,365.45769618542874,370.93339868292287,376.213753087167,381.2799553510425,386.1137349195468,390.6974518891999,395.01419221187126,399.0478601791835,402.7832674419933,406.2062178449142,409.30358738811253,412.0633986673012,414.47488918751793,416.5285729963998,418.21629513772353,419.5312784853462,420.4681625807675,421.02303416366624,421.1934491532794,420.97844590873973,420.3785496677486,419.39576813460917,418.0335782599829,416.2969043251439,414.1920875123588,411.7268472097373,408.91023436290783,405.7525772466858,402.265420087001,398.46145501635357,394.35444789452725,389.9591585699285,385.29125619537956,380.3672302453001,375.204297908688,369.8203085541007,364.23364597874206,358.4631291638203,352.5279122624661,346.4473845447892,340.24107101713133,333.9285344194105,327.52927928574854,321.06265872959966,314.5477845854907,308.0034415056188,301.44800557111483,294.89936793520053,288.37486396902364,281.8912083310832,275.46443632822775,269.1098518806838,262.84198234586427,256.67454039631576,250.62039308653493,244.69153818204202,238.8990877624984,233.25325904934462,227.76337234786595,222.437855934309,217.28425766112548,212.3092629981241,207.51871917469725,202.91766503883875,198.51036620276332,194.30035500301904,190.29047476536158,186.4829278317167,182.87932677853706,179.4807482330505,176.28778867646864,173.30062161137337,170.51905546429037,167.9425915940039,165.5704817814179,163.4017845877428,161.43541998432605,159.67022167946666,158.10498659480345,156.73852097614758,155.56968266061475,154.597419063293,153.82080049205896,153.2390484481336,152.85155862208785,152.6579183497972]}],"reportKeys":["time","cpuTime","cycles","iters","allocated","numGcs","bytesCopied","mutatorWallSeconds","mutatorCpuSeconds","gcWallSeconds","gcCpuSeconds"],"reportNumber":10,"reportName":"group/group 10x100","reportOutliers":{"highSevere":0,"highMild":1,"lowMild":1,"samplesSeen":12,"lowSevere":0},"reportMeasured":[[4.733783099800348e-2,4.729594499999479e-2,89933067,1,null,null,null,null,null,null,null],[9.236117100226693e-2,9.229272000000321e-2,175476934,2,null,null,null,null,null,null,null],[0.1467669389967341,0.14663487400000008,278850352,3,null,null,null,null,null,null,null],[0.19217661800212227,0.19201940499999637,365128697,4,null,null,null,null,null,null,null],[0.23845176000031643,0.23822424000000098,453048611,5,null,null,null,null,null,null,null],[0.2795953179956996,0.27936914700000415,531223200,6,null,null,null,null,null,null,null],[0.32963063600618625,0.32937225999999953,626288132,7,null,null,null,null,null,null,null],[0.37576673999865307,0.37543541600000196,713946679,8,null,null,null,null,null,null,null],[0.41889376099425135,0.4185946119999997,795888891,9,null,null,null,null,null,null,null],[0.47289522900246084,0.47253408000000263,898494306,10,null,null,null,null,null,null,null],[0.5178376870026113,0.5173864999999935,983884057,11,null,null,null,null,null,null,null],[0.5629826369986404,0.5625096440000021,1069660598,12,null,null,null,null,null,null,null],[0.6169776949973311,0.6164689009999975,1172250821,13,null,null,null,null,null,null,null]]},{"reportAnalysis":{"anMean":{"estError":{"confIntLDX":2.003231136058002e-5,"confIntUDX":2.1716394519442038e-5,"confIntCL":5.0e-2},"estPoint":1.5673276303702817e-3},"anRegress":[{"regRSquare":{"estError":{"confIntLDX":2.287732357285077e-3,"confIntUDX":2.8044257401604877e-3,"confIntCL":5.0e-2},"estPoint":0.9947378540776748},"regResponder":"time","regCoeffs":{"y":{"estError":{"confIntLDX":1.695555392863235e-3,"confIntUDX":1.4411773046691034e-3,"confIntCL":5.0e-2},"estPoint":1.3698047924828793e-3},"iters":{"estError":{"confIntLDX":4.561650805884527e-5,"confIntUDX":5.800165002655105e-5,"confIntCL":5.0e-2},"estPoint":1.559488558699208e-3}}}],"anStdDev":{"estError":{"confIntLDX":8.596322276843379e-6,"confIntUDX":9.843940796524229e-6,"confIntCL":5.0e-2},"estPoint":6.970009193368111e-5},"anOutlierVar":{"ovFraction":0.30346203307926556,"ovDesc":"moderate","ovEffect":"Moderate"},"anOverhead":2.1820495514718956e-3},"reportKDEs":[{"kdeValues":[1.411207944848685e-3,1.413266956772664e-3,1.4153259686966431e-3,1.417384980620622e-3,1.419443992544601e-3,1.42150300446858e-3,1.4235620163925591e-3,1.425621028316538e-3,1.427680040240517e-3,1.429739052164496e-3,1.4317980640884752e-3,1.4338570760124541e-3,1.435916087936433e-3,1.437975099860412e-3,1.4400341117843912e-3,1.4420931237083701e-3,1.444152135632349e-3,1.446211147556328e-3,1.4482701594803072e-3,1.4503291714042861e-3,1.452388183328265e-3,1.454447195252244e-3,1.4565062071762232e-3,1.4585652191002022e-3,1.4606242310241811e-3,1.46268324294816e-3,1.4647422548721392e-3,1.4668012667961182e-3,1.4688602787200971e-3,1.4709192906440763e-3,1.4729783025680553e-3,1.4750373144920342e-3,1.4770963264160132e-3,1.4791553383399923e-3,1.4812143502639713e-3,1.4832733621879502e-3,1.4853323741119292e-3,1.4873913860359083e-3,1.4894503979598873e-3,1.4915094098838662e-3,1.4935684218078452e-3,1.4956274337318244e-3,1.4976864456558033e-3,1.4997454575797823e-3,1.5018044695037612e-3,1.5038634814277404e-3,1.5059224933517193e-3,1.5079815052756983e-3,1.5100405171996774e-3,1.5120995291236564e-3,1.5141585410476353e-3,1.5162175529716143e-3,1.5182765648955932e-3,1.5203355768195724e-3,1.5223945887435514e-3,1.5244536006675303e-3,1.5265126125915095e-3,1.5285716245154884e-3,1.5306306364394674e-3,1.5326896483634463e-3,1.5347486602874255e-3,1.5368076722114044e-3,1.5388666841353834e-3,1.5409256960593623e-3,1.5429847079833415e-3,1.5450437199073205e-3,1.5471027318312994e-3,1.5491617437552784e-3,1.5512207556792575e-3,1.5532797676032365e-3,1.5553387795272154e-3,1.5573977914511944e-3,1.5594568033751735e-3,1.5615158152991525e-3,1.5635748272231314e-3,1.5656338391471106e-3,1.5676928510710896e-3,1.5697518629950685e-3,1.5718108749190475e-3,1.5738698868430264e-3,1.5759288987670056e-3,1.5779879106909845e-3,1.5800469226149635e-3,1.5821059345389426e-3,1.5841649464629216e-3,1.5862239583869005e-3,1.5882829703108795e-3,1.5903419822348587e-3,1.5924009941588376e-3,1.5944600060828166e-3,1.5965190180067955e-3,1.5985780299307747e-3,1.6006370418547536e-3,1.6026960537787326e-3,1.6047550657027115e-3,1.6068140776266907e-3,1.6088730895506696e-3,1.6109321014746486e-3,1.6129911133986275e-3,1.6150501253226067e-3,1.6171091372465857e-3,1.6191681491705646e-3,1.6212271610945438e-3,1.6232861730185227e-3,1.6253451849425017e-3,1.6274041968664806e-3,1.6294632087904596e-3,1.6315222207144387e-3,1.6335812326384177e-3,1.6356402445623966e-3,1.6376992564863758e-3,1.6397582684103548e-3,1.6418172803343337e-3,1.6438762922583127e-3,1.6459353041822918e-3,1.6479943161062708e-3,1.6500533280302497e-3,1.6521123399542287e-3,1.6541713518782078e-3,1.6562303638021868e-3,1.6582893757261657e-3,1.660348387650145e-3,1.6624073995741239e-3,1.6644664114981028e-3,1.6665254234220818e-3,1.6685844353460607e-3,1.6706434472700399e-3,1.6727024591940188e-3],"kdeType":"time","kdePDF":[2506.6285948748873,2507.5132282578,2509.280798079016,2511.92792163584,2515.4495527478293,2519.8390149463667,2525.088045298574,2531.1868485029063,2538.1241608090195,2545.887323233859,2554.4623634697314,2563.834085809405,2573.9861683482545,2584.9012666650774,2596.561123131605,2608.946680956582,2622.03820203378,2635.815387634873,2650.2575009677985,2665.3434906093603,2681.0521138172426,2697.3620587315713,2714.252064489267,2731.70103829578,2749.6881685280428,2768.193032979295,2787.195701400504,2806.6768315440595,2826.6177579726027,2847.0005729589725,2867.80819887155,2889.0244515121776,2910.634093950855,2932.622880481539,2954.977590406378,2977.68605144037,3000.7371526145403,3024.1208466421117,3047.8281417984563,3071.851083450867,3096.1827254579407,3120.817091739638,3145.749128397688,3170.974646840721,3196.490258439435,3222.293301303016,3248.3817598290984,3274.754177734588,3301.409565324172,3328.347301795797,3355.5670334188594,3383.068568449643,3410.851769670828,3438.91644545628,3467.262240269921,3495.888525507051,3524.7942915793733,3553.9780421298,3583.4376912416087,3613.1704644772994,3643.1728045472933,3673.4402823663845,3703.9675142082447,3734.7480856143784,3765.774482655577,3797.038031080142,3828.528843816015,3860.2357772224623,3892.146396413261,3924.2469498965584,3956.5223536988397,3988.956185060931,4021.530685714876,4054.2267746710186,4087.0240703669224,4119.9009219530635,4152.834449416572,4185.800592173178,4218.774165690617,4251.728925643593,4284.637639042842,4317.4721617279265,4350.203521567257,4382.80200666823,4415.237257867336,4447.478364743365,4479.493964378187,4511.252342077685,4542.721533261936,4573.869425737178,4604.6638615737675,4635.072737833035,4665.064105412297,4694.606265310368,4723.667861655906,4752.217970886897,4780.226186521543,4807.662699017694,4834.498370279555,4860.704802435734,4886.254400581195,4911.120429246513,4935.27706243021,4958.699427103074,4981.363640166318,5003.246838917533,5024.327205148598,5044.583983067409,5063.997491299518,5082.549129285964,5100.221378448797,5116.997798545679,5132.86301967862,5147.802730459079,5161.803662861807,5174.853574322603,5186.941227650244,5198.05636933041,5208.189706798808,5217.332885252613,5225.478464553367,5232.619896751204,5238.751504729787,5243.868462434318,5247.966777101571,5251.043273862134,5253.095583031122,5254.122130345616]}],"reportKeys":["time","cpuTime","cycles","iters","allocated","numGcs","bytesCopied","mutatorWallSeconds","mutatorCpuSeconds","gcWallSeconds","gcCpuSeconds"],"reportNumber":11,"reportName":"write/write 10x1000","reportOutliers":{"highSevere":0,"highMild":0,"lowMild":0,"samplesSeen":42,"lowSevere":0},"reportMeasured":[[1.8466379988240078e-3,7.274569999964342e-4,3507547,1,null,null,null,null,null,null,null],[3.749734998564236e-3,1.2929680000013377e-3,7124480,2,null,null,null,null,null,null,null],[4.955500997311901e-3,1.607750000005126e-3,9415768,3,null,null,null,null,null,null,null],[6.903895002324134e-3,2.134022999996432e-3,13116844,4,null,null,null,null,null,null,null],[7.662063995667268e-3,2.6392199999918375e-3,14557279,5,null,null,null,null,null,null,null],[9.14627699967241e-3,3.1539210000062212e-3,17377777,6,null,null,null,null,null,null,null],[1.0610110002744477e-2,3.6542269999984e-3,20159943,7,null,null,null,null,null,null,null],[1.342409599601524e-2,4.194209999994314e-3,25506664,8,null,null,null,null,null,null,null],[1.5978417002770584e-2,4.999694999995086e-3,30365722,9,null,null,null,null,null,null,null],[1.627196399931563e-2,5.0767970000009655e-3,30906348,10,null,null,null,null,null,null,null],[1.8321754003409296e-2,6.067248999997332e-3,34814408,11,null,null,null,null,null,null,null],[1.8981221997819375e-2,6.094036999996888e-3,36053167,12,null,null,null,null,null,null,null],[1.9602098000177648e-2,6.6276209999927005e-3,37243869,13,null,null,null,null,null,null,null],[2.327671800594544e-2,7.2572819999976446e-3,44224234,14,null,null,null,null,null,null,null],[2.4468238996632863e-2,7.5967469999937975e-3,46488668,15,null,null,null,null,null,null,null],[2.6962415999150835e-2,8.19859499999609e-3,51228227,16,null,null,null,null,null,null,null],[2.748465700278757e-2,8.59233600000664e-3,52221056,17,null,null,null,null,null,null,null],[2.8489768999861553e-2,9.275811999998496e-3,54130289,18,null,null,null,null,null,null,null],[3.1534058005490806e-2,9.509088000001498e-3,59914520,19,null,null,null,null,null,null,null],[3.3379975000570994e-2,1.0019051000000445e-2,63421768,20,null,null,null,null,null,null,null],[3.21486390021164e-2,1.0772243000005233e-2,61082639,21,null,null,null,null,null,null,null],[3.4810391000064556e-2,1.1085932000000298e-2,66140774,22,null,null,null,null,null,null,null],[3.674557199701667e-2,1.138365399999941e-2,69816213,23,null,null,null,null,null,null,null],[4.020284400030505e-2,1.2410384999995472e-2,76374480,25,null,null,null,null,null,null,null],[4.22221479966538e-2,1.307710599999723e-2,80222608,26,null,null,null,null,null,null,null],[4.329287900327472e-2,1.3273174999994808e-2,82256995,27,null,null,null,null,null,null,null],[4.476459800207522e-2,1.390862699999218e-2,85052355,28,null,null,null,null,null,null,null],[4.4805204997828696e-2,1.4815548999990824e-2,85129419,30,null,null,null,null,null,null,null],[4.578064000088489e-2,1.531027100000415e-2,86983684,31,null,null,null,null,null,null,null],[5.494126000121469e-2,1.6736143000002812e-2,104386904,33,null,null,null,null,null,null,null],[5.856170300103258e-2,1.7582637999993267e-2,111266691,35,null,null,null,null,null,null,null],[5.556844300008379e-2,1.8157706000010876e-2,105579654,36,null,null,null,null,null,null,null],[5.72225259966217e-2,1.899279000001286e-2,108722481,38,null,null,null,null,null,null,null],[5.996240700187627e-2,2.0061890999997445e-2,113928361,40,null,null,null,null,null,null,null],[6.269381900347071e-2,2.0921506999997064e-2,119117391,42,null,null,null,null,null,null,null],[6.556441300199367e-2,2.1952963000003933e-2,124571593,44,null,null,null,null,null,null,null],[7.594630800304003e-2,2.3481523999990372e-2,144278413,47,null,null,null,null,null,null,null],[8.108867700502742e-2,2.4290333999999802e-2,154067861,49,null,null,null,null,null,null,null],[8.529218500189018e-2,2.583146699998906e-2,162048520,52,null,null,null,null,null,null,null],[8.946721100073773e-2,2.7083283999999708e-2,169988974,54,null,null,null,null,null,null,null],[9.48865440004738e-2,2.821290299999646e-2,180284176,57,null,null,null,null,null,null,null],[9.93107329995837e-2,2.9940874999994094e-2,188691292,60,null,null,null,null,null,null,null],[0.10492485300346743,3.141047500000127e-2,199358070,63,null,null,null,null,null,null,null],[0.10985853100282839,3.322559500000466e-2,208730998,66,null,null,null,null,null,null,null],[0.11500390100263758,3.45653819999967e-2,218507729,69,null,null,null,null,null,null,null],[0.12155503199755913,3.6797472000003495e-2,230955873,73,null,null,null,null,null,null,null],[0.11707255199871724,3.8233618000006686e-2,222432487,76,null,null,null,null,null,null,null],[0.12409541200031526,4.020329300000469e-2,235780319,80,null,null,null,null,null,null,null],[0.1282499109947821,4.197388699999749e-2,243674964,84,null,null,null,null,null,null,null],[0.1427478890036582,4.436167599999408e-2,271221846,89,null,null,null,null,null,null,null],[0.15047681400028523,4.6265106000006995e-2,285906018,93,null,null,null,null,null,null,null],[0.1592981859939755,4.917918000001009e-2,302666382,98,null,null,null,null,null,null,null],[0.16632080000272254,5.1931293999999184e-2,316009119,103,null,null,null,null,null,null,null],[0.1761690359999193,5.399041799999793e-2,334720023,108,null,null,null,null,null,null,null],[0.18700433299818542,5.68943619999942e-2,355308629,113,null,null,null,null,null,null,null],[0.19666026499908185,5.982605599999147e-2,373655007,119,null,null,null,null,null,null,null],[0.19374608200450893,6.273283400000196e-2,368117847,125,null,null,null,null,null,null,null],[0.18881391399918357,6.604477399999098e-2,358746101,131,null,null,null,null,null,null,null],[0.20665175699832616,6.900736000000052e-2,392637938,138,null,null,null,null,null,null,null],[0.2148972130016773,7.214676499999939e-2,408311504,144,null,null,null,null,null,null,null]]}];
1156− reports.map(mangulate);
1157−
1158− var benches = ["create/relation 10x100","create/relation 10x1000","create/relation 10x10000","restrict/restrict relation 10x10000 to 10x1","restrict/restrict relation 10x10000 to 10x5000","project/project 10x1000 to 1x1000","project/project 10x1000 to 5x1000","union/union identical 10x1000","union/union identical 10x10000","join/join identical 10x100","group/group 10x100","write/write 10x1000",];
1159− var ylabels = [[-0,'<a href="#b0">create/relation 10x100</a>'],[-1,'<a href="#b1">create/relation 10x1000</a>'],[-2,'<a href="#b2">create/relation 10x10000</a>'],[-3,'<a href="#b3">restrict/restrict relation 10x10000 to 10x1</a>'],[-4,'<a href="#b4">restrict/restrict relation 10x10000 to 10x5000</a>'],[-5,'<a href="#b5">project/project 10x1000 to 1x1000</a>'],[-6,'<a href="#b6">project/project 10x1000 to 5x1000</a>'],[-7,'<a href="#b7">union/union identical 10x1000</a>'],[-8,'<a href="#b8">union/union identical 10x10000</a>'],[-9,'<a href="#b9">join/join identical 10x100</a>'],[-10,'<a href="#b10">group/group 10x100</a>'],[-11,'<a href="#b11">write/write 10x1000</a>'],];
1160− var means = $.scaleTimes([5.906283388143756e-4,5.770838309782314e-3,5.784195729887314e-2,1.448797309139284e-2,8.447258684075218e-2,1.243577405705988e-2,1.547382196820991e-2,4.923173514046889e-2,0.5157808375258943,0.3374978199984254,4.70336206675725e-2,1.5673276303702817e-3,]);
1161− var stddevs = [4.502571301832575e-6,2.8815215559732134e-5,1.7121491767487851e-4,4.774249175945004e-4,1.4013810341920257e-3,4.600204612133745e-4,3.978143402171812e-4,3.275115670368287e-4,1.1935851498586624e-3,1.6965376723717264e-3,7.389605929837668e-4,6.970009193368111e-5,];
1162− stddevs = $.scaleBy(means[1], stddevs);
1163− var xs = [];
1164− var prev = null;
1165− var colors = ["#edc240","#afd8f8","#cb4b4b","#4da74d","#9440ed"];
1166− var max_time = 0;
1167− for (var i = 0; i < means[0].length; i++) {
1168− var name = benches[i].split(/\//);
1169− name.pop();
1170− name = name.join('/');
1171− if (name != prev) {
1172− var color = colors[xs.length / 2 % colors.length];
1173− xs.push({ data: [[means[0][i], -i]], label: name, color: color,
1174− bars: { show: true, horizontal: true, barWidth: 0.75,
1175− align: "center" } });
1176− xs.push({ data: [[means[0][i], -i, stddevs[i]]], color: color,
1177− lines: { show: false },
1178− points: { radius: 0, errorbars: "x",
1179− xerr: { show: true, radius: 5,
1180− lowerCap: "-", upperCap: "-" } } });
1181− prev = name;
1182− } else {
1183− xs[xs.length - 2].data.push([means[0][i], -i]);
1184− xs[xs.length - 1].data.push([means[0][i], -i, stddevs[i]]);
1185− }
1186− max_time = Math.max(max_time, means[0][i] + stddevs[i]);
1187− }
1188− var oq = $("#overview");
1189− o = $.plot(oq, xs, { grid: { borderColor: "#777", hoverable: true },
1190− legend: { show: xs.length > 1 },
1191− xaxis: { max: max_time * 1.02 },
1192− yaxis: { ticks: ylabels, tickColor: '#ffffff' },
1193− zoom: { interactive: true, amount: 1.05 },
1194− pan: { interactive: true } });
1195− if (benches.length > 3)
1196− o.getPlaceholder().height(28*benches.length);
1197− o.resize();
1198− o.setupGrid();
1199− o.draw();
1200− $.addTooltip("#overview", function(x,y) { return $.renderTime(x / means[1]); });
1201−});
1202−$(document).ready(function () {
1203− $(".time").text(function(_, text) {
1204− return $.renderTime(text);
1205− });
1206− $(".citime").text(function(_, text) {
1207− return $.renderTime(text);
1208− });
1209− $(".percent").text(function(_, text) {
1210− return (text*100).toFixed(1);
1211− });
1212− });
1213−</script>
1214−
1215− </div>
1216− </div>
1217− <div id="footer">
1218− <div class="body">
1219− <div class="footfirst">
1220− <h2>colophon</h2>
1221− <p>This report was created using the
1222− <a href="http://hackage.haskell.org/package/criterion">criterion</a>
1223− benchmark execution and performance analysis tool.</p>
1224− <p>Criterion is developed and maintained
1225− by <a href="http://www.serpentine.com/blog/">Bryan O'Sullivan</a>.</p>
1226− </div>
1227− </div>
1228− </div>
1229− </body>
1230−</html>
docs/commits_in_constant_time.markdowndeleted−134
@@ -1,134 +0,0 @@
1−# Transactional Database Commits in O(1)
2−
3−A.M.
4−
5−[Project:M36](https://github.com/agentm/project-m36)
6−
7−## Synopsis
8−
9−Common relational database management systems operate in an imperative manner by executing statements immediately. This naive strategy quickly becomes an IO-bound bottleneck. By applying Haskell's laziness-in-evaluation to database updates, new doors for optimizations based on what is queried make themselves apparent. Furthermore, by serializing thunks representing idempotent database updates, the database can commit transactions in constant time with regards to the tuple count since the tuples themselves need not be serialized. This optimization, combined with *fsync*-coalescing, can allow databases to commit to disk faster than tuples updates can be processed.
10−
11−Using this deferred execution technique, database updates can be processed in the background or, in the case when the tuples are never requested, never.
12−
13−These database update thunks and other interesting optimizations are implemented in [Project:M36](https://github.com/agentm/project-m36): an experimental, clean-room, purely Haskell implementation of an RDBMS engine based on the mathematical principles of the relational algebra.
14−
15−## Rationale
16−
17−A typical SQL RDBMS such as PostgreSQL executes a list of commands serially against a serializable representation of the database state without concern to whether or not the commands are effectively necessary to service subsequent requests. A database update which affects *n* tuples will necessitate disk writes of *O(n)* plus *O(n\*log(n))* writes for each affected index.
18−
19−By validating and serializing thunks of validated commands, Project:M36 commits can be independent of the tuple write cost. The thunks, which are flushed to non-volatile storage to complete the transaction commit, allow the DBMS to defer execution in preference to commit time.
20−
21−The deferral is, however, not required, and could be left as a option to the user or application.
22−
23−The final cost of committing in Project:M36 relates to the size of the update expression. If the update expression is, for example, a insertion of a large number of rows, then the commit cost will be *O(t)* where *t* is the number of tuples expressed in the update, but still independent of the cost of the existing tuples in the database.
24−
25−## Example and Comparison to PostgreSQL
26−
27−Let us walk through a specific example using SQL. While Project:M36 does not support SQL (and for [good reasons](https://github.com/agentm/project-m36/blob/master/docs/on_null.markdown)), comparing both databases with a common language is useful for illustrative purposes.
28−
29−Let us consider an existing database with a table/relation named "BigTable" which has 10 billion rows/tuples (an arbitrarily large number) of which one column is named "x" and represents a randomly-assigned integer. Next, assume that the user of the database will execute an update which will update every row/tuple, commit the changes, then query a subset of the resultant updated rows/tuples.
30−
31−
32−### The Update Expression
33−
34−Consider the following database update:
35−
36−```
37−UPDATE "BigTable" SET x = x + 1;
38−```
39−In PostgreSQL, the cost of executing this expression is incurred immediately upon execution. New tuples are laid down to disk (if the dataset is larger than *shared_buffers*), duplicating the entirety of the existing table/relation in storage (due to MVCC) for a cost of *O(n)* where *n* is the number of existing rows/tuples in "BigTable". If *x* is indexed, then the index writes incur an additional cost of *O(n\*log(n))* writes. Furthermore, PostgreSQL will write all changes to its write-ahead log, so the cost is multiplied by some factor.
40−
41−In Project:M36, the same expression can first be statically validated to adhere to the database constraints. The only constraint affected here is for the column/attribute *x* which requires an integer. Since adding one to any integer retains the integer type, the constraint can be determined to be unviolated without evaluating the expression, thus at a cost of *O(1)*. Project:M36 uses a novel WORM (write-once, read-many) strategy over journaled filesystems to avoid the need for a separate journal.
42−
43−*For the purpose of this example, assume that integer overflow is not a concern.*
44−
45−### The Commit
46−
47−```
48−COMMIT;
49−```
50−
51−In PostgreSQL, the write-ahead log mentioned above containing all tuples changes must now be flushed to non-volatile storage, creating a bottleneck to the slowest form of storage. A necessary checkpoint (which is configurable) could incur further writes as the tuples are flushed to disk as well.
52−
53−In Project:M36, the update expression must also be flushed to disk, but the expression is a mere few bytes appended to the transaction graph.
54−
55−### The Subsequent Query
56−
57−Finally, the user queries a subset of the updated table/relation.
58−
59−```
60−SELECT a, b, c, x FROM "BigTable" WHERE x > 10000;
61−```
62−
63−In PostgreSQL, considering that the column/attribute has an index, *O(log(n))* reads are needed to identify on which pages in the table's on-disk storage the proper values can be found. Considering that the value *x* was previously described as random, despite the restriction, in the worst case, every page of the on-disk table may need to be read because each page could contain one value matching the restriction. This would necessitate reading *O(n)* tuples previously written to disk. After reading the tuples, the tuples must be filtered by the restriction to service the query.
64−
65−In Project:M36, the state of the database is determined to be the difference of the previous state *S* (before the *x+1* update above) and *S'* (after the update). The serialized update expression can be deserialized and merged into the rewritten query:
66−
67−```
68−SELECT orig.a, orig.b, orig.c, x_orig + 1 AS x FROM (SELECT a, b, c, x AS x_orig FROM "BigTable"@S) AS orig WHERE x > 10000;
69−```
70−
71−where the *@* symbol references the state of "BigTable" at transaction state *S* in the past. The rewrite process can occur in constant time regarding the tuple count, but the execution does require reading the previous state *S* of "BigTable", filtering it as expected. The tuple read cost is equivalent to that of the same statement at *S'*: *O(log(n))* utilizing a b-tree index.
72−
73−### Summary
74−
75−| | PostgreSQL | Project:M36 |
76−|-|------------|-------------|
77−| UPDATE x+1 | *O(nlog(n))* | *O(1)* |
78−| COMMIT | flush *n* tuples to disk | flush expression to disk |
79−| SELECT x>10000 | *Ω(log(n))*, *O(n)* worst case | *O(log(n))* |
80−
81−Even if the user were to query all the tuples back, the actual IO cost in Project:M36 would be lower since the updates are only "executed" on the fly and not necessarily written to disk. However, a clever cacheing strategy could note that state *S* is queried often enough to warrant a cached version. The table's data on disk, however, is not required to answer the query.
82−
83−## Constraint Oracles
84−
85−To be able to perform an update and commit in constant or less than *O(n)* time does have some preconditions:
86−
87− * constraints must be able to be statically validated in linear or logarithmic time
88−
89−However, even if constraints lack a proper oracle such as an index or a static means of validation and, thus, cannot be validated in constant time, the user may still benefit from serialization of the database update expression since writing the validated tuples to disk can be deferred beyond commit time and could go directly into an on-disk cache.
90−
91−## Worst Case Behavior
92−
93−Every database constraint can be represented as an inclusion dependency whereby the evaluation of a relational expression `sub` must be a subset of the evaluation of relational expression `super` (`sub ⊆ super`) for the constraint to validate. Therefore, the worst case time to validate any constraint, assuming that the constraint has an ideal oracle, is O(n) in the tuple count. However, as mentioned above, there are many constraints that can be validated in constant or less-than-linear time. Furthermore, the validated tuples need not be written to disk once the constraint is found to hold.
94−
95−Since there is great variation in constraint validation cost, the RDBMS could pre-analyze and report on associated constraints costs or make use of data independence to guide storage to optimize queries needed to service the constraint checker.
96−
97−## Caveats
98−
99−Certain types of updates still take a similar amount of time to commit in Project:M36 in comparison to PostgreSQL. Specifically, any update which relies on data outside the database's purview will necessitate flushing the tuple data since the update expression contains new tuple data not based on existing tuples. For example, the equivalent of:
100−
101−```
102−INSERT INTO "BigTable"(a, b, c, x) VALUES (1,5,10,10),(20,20,21,30),.... #many tuples
103−```
104−will still necessitate a *O(n)* tuple writes to disk in both databases. Though the asymptotic costs are equivalent, the number of writes are cut in half in Project:M36 since it does not require a write-ahead log.
105−
106−While PostgreSQL makes use of MVCC (multi-version concurrency control) which marks which tuples belong to a linear progression of transaction states, Project:M36 stores a full history of database state using a transaction graph (a directed acyclic graph similar to the commit-based graph of `git`). The graph allows named branches to be created and merged which also reduce contention around a singular graph head.
107−
108−## Applying Laziness to SQL RDBMSes
109−
110−Would it be possible to apply transaction-based laziness to an SQL-based RDBMS? Certainly, with sufficient shoe-horning, it could work, but SQL includes a few malfeatures which would make it difficult, if not impossible:
111−
112− * Non-idempotent server-side functions prevent laziness because of side effects. PostgreSQL can mark functions as idempotent, but does not validate or enforce the idempotence, Project:M36, via Safe Haskell, can validate pure functions.
113− * The lack of "time travel", the ability to query database state in the past prevents reliance on previous states, prevents direct referencing of previous database states on which the state differences can be built.
114− * Tightly-coupled table-to-storage management prevents alternative data models. Indexing and constraint checking need to be statically verifiable and deferrable.
115−
116−These hurdles are not insurmountable, just perhaps not a good fit for SQL databases with a lot of historical and implementation baggage.
117−
118−## Benchmarks
119−
120−Forthcoming.
121−
122−## Conclusion
123−
124−Transactional time-to-commit is critical in ensuring that business decisions can make it to non-volatile storage as quickly as possible. By introducing Haskell-like, lazy evaluation to update expressions and serializing the resultant thunk, commits can be serialized in constant time, disregarding the number of tuples modified in the expression.
125−
126−This serialization strategy turns modern RDBMS architecture on its head since the table/relation-to-file mapping is broken, resulting in true data independence. Any on-disk representation of a relation at a specific transaction state therefore merely becomes a cached and purgeable entity, drastically shrinking on-disk cacheing requirements while expanding the scope in which said strategies can operate. Hopefully, a truly data independent architecture will result in new optimization discoveries.
127−
128−Project:M36 implements a transaction graph which can represent the entirety of database state, leaving room for any number of alternative representations, even for a single relation or relation across transaction states. A simple example could include storing two different orderings of tuples of the same relation in order to optimally serve different join queries. Common RDBMSes offer only two on-disk representations: the set of fully-evaluated tuples and indexes to those tuples, preventing data independence. Data independence paves the way towards the elimination of implementation-specific, gatekeeper roles such as database administrators.
129−
130−The promise of the relational algebra has always been the liberation of data from its data structure representation in order to be able to answer arbitrary queries. Modern DBMSes which typically map tables directly to one or more files on disk fail to live up to this promise. Project:M36 sets out to rectify this failure.
131−
132−In a greater context, applying laziness to an architecture to make use of more interesting optimizations is hardly new. The OpenGL API views its "immediate" mode as effectively deprecated. Filesystems take advantage of laziness using copy-on-write semantics. High-level programming languages can make greater, more interesting inferences about how a computation must be execute. A computer can always consider many more possible solution paths than a human can.
133−
134−The adherence to mathematical priniciples in Project:M36 results in features and optimization opportunities which have not yet been discovered. In contrast to RDBMSes designed around specific optimizations (such as indexes, specific disk layouts, or key-value lookups), Project:M36 sets out to demonstrate practically that future optimizations can only be discovered when operating within a mathematically-coherent architecture.
docs/data_independence.markdowndeleted−109
@@ -1,109 +0,0 @@
1−# Project:M36: Towards an Architecture for Data Independence
2−
3−## Introduction
4−
5−The Project:M36 relational algebra architecture sets itself apart from typical DBMSes by ensuring strict transactional isolation, a branchable/mergeable (rather than linear) transaction graph, and storage of relational expressions (rather than storage of tuples). Let's look at how these architectural features work together to make Project:M36 the first relational algebra engine to implement true data independence.
6−
7−## What is Data Independence?
8−
9−C.J. Date writes:
10−
11−`Certainly most SQL products have failed to live up to the [relational] model's full potential...in those products, what the user sees and what is physically stored are essentially the same thing... In particular, it accounts for the argument, so often heard, to the effect that we have to "denormalize for performance."`
12−
13−`In principle, logical design has absolutely nothing to do with performance at all.`
14−
15−(Date, C.J. "Database In Depth: Relational Theory for Practitioners". O'Reilly Media. 2005. pages 156-157.)
16−
17−Data independence is therefore defined as the separation of the database user's experience from the database's means of in-memory or on-disk representation. As Date points out, virtually all database products implement a one-to-one mapping of relations to files in storage.
18−
19−One advantage of high-level abstractions in programming languages is to leverage advanced algorithms which can choose optimization paths on behalf of the user which a human may never be able to discover. While the promise of ever higher-level abstractions is realized by progamming languages such as Haskell, DBMS implementors have been resistant to data independence. This is due to several legacy factors such as companies pushing one-trick-pony database technologies and middlemen such as DBAs required to play gatekeeper against "bad" schema changes. The result is customers forced to run multiple disparate databases such as one for realtime transaction processing and another for analytics and another for audit logging. This recalcitrance has also led to the rise of databases such as "document" JSON databases with weak mathematical underpinnings in the name of performance as users become frustrated when hitting performance walls and dealing with arbitrary database limitations.
20−
21−Implementations which closely tie the user interface to backend representation close the door on interesting alternative representations and optimizations. For example, SQL databases typically store a single relation as a list of tuples on disk with supplementary indexes stored in separate files. There is no reason that the same relation couldn't be on disk or in memory in any number of formats. Such a table might be useful in various formats ideal for servicing different types of queries. Data independence grants the DBMS the permission to create any number of representations- including none at all- as long as the correct answer is provided to the user. "Column-store" databases may try to slice the tuples in a different axis, but those databases simply shift the performance problems elsewhere. Only implementation details prevent a database from offering both column-oriented *and* tuple-oriented representation while allowing the database to choose.
22−
23−That is why it is critical for the user's interface to the database *not* to include features such as "query hints" which would force a specific implementation in the backend. The user's interface must be declarative (describing the state change or query rather than *how* to execute it) and sufficiently high level. Any implementation detail leakage to the user's interface is a lost potential algorithmic optimization. While the topic of providing high-level interfaces is not specific to database design, we will continue to explore the ramifications of data independence in databases.
24−
25−
26−## Transactional Isolation
27−
28−While other databases offer various transaction isolation levels with differing levels of implementation-specific surprises, Project:M36 solely suppports the maximum transaction isolation level. Instead of relying on details of [MVCC](https://www.postgresql.org/docs/current/mvcc-intro.html) which marks each tuple in a relation with a monotonically-increasing number identifying from which transaction the tuple was added or deleted, Project:M36 includes no singular backing store for tuples, instead storing a stream of state change requests. Because the transaction graph supports branching and merging (similar to version control such as git), transactions can be committed without contention at a singular head of the graph. Committing to disk can be implemented as writing a file to represent the transaction's state and
29−
30−## The Transaction Graph
31−
32−These state changes are, in fact, the idempotent relational update expressions that the user has submitted. For example, given a transaction which includes a single relation `s`:
33−
34−```
35−┌──────────┬────────┬───────────┬───────────┐
36−│city::Text│s#::Text│sname::Text│status::Int│
37−├──────────┼────────┼───────────┼───────────┤
38−│"Paris" │"S2" │"Jones" │10 │
39−└──────────┴────────┴───────────┴───────────┘
40−```
41−
42−if the user commits a transaction with an insert such as:
43−
44−```
45−insert x relation{tuple{city "Boston", s# "S3", sname "Smith", status 400}}
46−```
47−
48−then a typical database will find the file representing the relation, find some free space in it and save the new tuple along with the MVCC transaction identifier. Subsequent transactions will find the tuple and compare it to their own transaction id in order to determine its "visibility". Project:M36, on the other hand, after validating that all relational constraints (such as primary and foreign keys) still hold, will simply serialize and append the expression to the transaction graph log. By default, there is no file representing the relation.
49−
50−For those familiar with Haskell, note how serializing the update expression is similar to being able to serialize a thunk or deferred execution.
51−
52−The transaction graph also allows users to travel back to previously-committed transactions. This may be useful for audit logging or alternative schemas.
53−
54−## Storage Representations
55−
56−Given the ever-growing transaction graph based on state changes, let's examine how Project:M36 services subsequent queries.
57−
58−## Benefits
59−
60−The primary goal of a database should be to ensure data integrity. Project:M36 takes no shortcuts in achieving this goal, but choosing a backend architecture which minimizes the time which it takes to get the transaction to non-volatile storage (disk) by storing update expressions rather than attempting to shuffle tuples on disk. This architecture open the door to many optimization techniques, many of which are new to databases.
61−
62−### Multiple On-Disk Representations
63−
64−The promise of data independence allows database backends to store relations as they see fit. That can include any number of on-disk representations including none at all. For example, for a table accessed by multiple projections, the database may choose to materialize the relation in those projections. The representations are therefore created in service to the queries submitted or anticipated instead of being based on past update expressions. Because on-disk storage is obviously limited, the database must decide what is valuable to keep around for future queries. This could open a new area of research into the appropriate machine learning algorithms, but, fundamentally, this set of materialized query responses is effectively a cache which can always be refreshed.
65−
66−The alternative representations need not be a direct answer to queries- for example, a materialized relation from a transaction could be used to service a query from a later transaction if the updates since that transaction are applied.
67−
68−The database could also anticipate, for example, scheduled queries and actually materialize relations before the query is executed. On-disk cache could represent "denormalized" tuple sets while the user-facing interface shows a properly normalized schema, thereby supporting data independence.
69−
70−More research in determining just what should be in the cache is needed.
71−
72−### Transactional Commits in O(1) Time
73−
74−Because the Project:M36 backend need not save tuples into a specific file representing a relation, the backend can drastically reduce the amount of time needed to commit a transaction to disk. Specifically, following constraint validation (which can often be done in constant or logarithmic time relative to the tuple count), the fastest means of committing the transaction is to save the update expression itself. Since the previous state has already been presumably committed, any idempotent operation can be saved for deferred execution. This means that transactions can be committed to disk relative to the size of the update expression rather than the number of the tuples affected- committing can occur at a rate relative to that of update expression size (typically a few kilobytes) rather than relative to the number of tuples that the update expression happened to alter.
75−
76−This technique gets transactions to disk faster, thus drastically increasing the rate transactions can be committed overall. Note that the execution of the update expression may be deferred by this process, so the cost to evaluate it may occur later, but this processing may be performed in the background after the transaction is committed. When the data is never requested, for example, for a defunct transaction graph branch, the actual execution could be deferred indefinitely, incurring zero cost to calculate the consquence of the update.
77−
78−### Less Disk Usage
79−
80−Because Project:M36 stores a stream of update expressions rather than tuples themselves, the minimum storage requirements for a given database may be reduced. For example, if a relation with an attribute `x` of type `Integer` has 1,000,000 tuples, a subsequent update to increment all 1,000,000 values by one may be cheaper to evaluate on-demand rather than immediately generating 1,000,000 new tuples and saving them to disk. If the new tuples are requested, the database can determine that the tuples are not materialized, calculate them, and return them, all without ever having the tuples on disk. Furthermore, if only a subset of the tuples are ever requested, for example, due to a query restriction, then some of the tuples may never need to be calculated or materialized.
81−
82−### Audit Logging
83−
84−Typical databases implement various strategies for audit logging, including:
85−
86−* exposing MVCC-like values such as tuple "created at" and "created by" to the user and forcing all tables to be insert-only
87−* shuttling audit logs to a secondary database
88−
89−Project:M36, through its inherent ability to travel the append-only transaction graph, enables audit-logging by allowing users to checkout previous transaction states. Committed transaction states are immutable, so no relation pollution or secondary database is necessary.
90−
91−### Selective Caching
92−
93−Typical databases materialize entire tuple sets representing each named relation (relation variable), but there is nothing special about relations that happen to be named. Data independence allows us to cache answers to common or even anticipated queries- this allows the schema to be normalized and unmaterialized while the *denormalized* query results are materialized cached. This flexibility saves disk space and allows the cache to be much more dynamic than in a typical DBMS.
94−
95−### Never-Materialized Tuples Replace Partitions
96−
97−Queries on very large relations often very often restricted (filtered by tuple) to generate subsets which are often partitioned, for example, by an event's date. Instead of requiring DBMS users to manually partition and slice their data in one, fixed, particular way, Project:M36's cacheing system will only cache those tuples that serve the interests of the queries. With something like an LRU cache, a data independent architecture will naturally cache "partitions" of the full relation without manual intervention.
98−
99−### Elimination of DBA role
100−
101−Databases essential to a business function are often guarded by a human database administrator (DBA) whose role it is to monitor database performance and to play gatekeeper to database schema changes as the database grows. This role is necessary because database tuning can be an arcane skill, rife with pitfalls for those who don't know the database software inside-and-out. This is a direct cause of data dependence, forcing DBAs to manually enforce data partitioning and shuffling data to different servers, configuring database replicas, and making Faustian bargains to "denormalize" tables for analytical workloads.
102−
103−A data independent architecture eliminates this role by allowing the database to make the optimal choices itself. This means that the database can respond to schema changes immediately, without manual repartitioning or denormalization steps.
104−
105−## Conclusion
106−
107−Project:M36's backend architecture enables new optimizations and features that are sorely lacking in existing DBMSes. By leveraging its novel transaction graph and deferred evaluation, Project:M36 handles more DBMS use-cases.
108−
109−Project:M36's novel architecture opens the door for further database and algorithmic research.
docs/database_context_functions.markdowndeleted−167
@@ -1,167 +0,0 @@
1−# Project:M36 Database Context Functions
2−
3−## Introduction
4−
5−While "atom functions" operate on individual values and return new values (atoms), database context functions operate on pre-committed database contexts in the same context as the ```update```, ```insert```, and ```delete``` operators. The difference is that database context functions are written in Haskell and support any number of context changes.
6−
7−Other DBMS software may include a similar feature called "stored procedures". However, "stored procedures" are stored outside the transaction stream and are not versioned by the database as in Project:M36.
8−
9−In order to use compile functions at runtime in Project:M36, be sure to build your own Project:M36 library so that the optional scripting is enabled. Alternatively, precompiled database context functions can be loaded from object files.
10−
11−## Database Context Function Types
12−
13−The Haskell type of all database context functions is:
14−
15−```haskell
16−[Atom] -> DatabaseContext -> Either DatabaseContextFunctionError DatabaseContext
17−```
18−
19−That is, the function takes an array of ```Atom```s which represent the function's arguments and a context and returns an updated context or an error. Notice that this operation is idempotent ("pure" in Haskell parlance).
20−
21−The database context references all data which can be committed; this includes relation variables, atom functions, notifications, database context functions, and other versionable data. Database contexts become immutable once committed.
22−
23−## Scope of Database Context Functions
24−
25−Database context functions are committed alongside the transaction. Thus, previous versions of the functions can be explored or restored. Like all database context elements, database context functions are immutable once committed. However, the transaction graph can be branched in order to examine how database context functions changes might apply to future contexts.
26−
27−Remember that database context functions don't need to worry about locks or other synchronization. The database context is completely isolated from other ongoing transactions.
28−
29−Returning a ```DatabaseContextFunctionError``` from the function ensures that any changes made by the function are discarded.
30−
31−## TutorialD Demonstration
32−
33−Use ```adddatabasecontextfunction``` to compile and name a new database context function:
34−
35−```
36−adddatabasecontextfunction "addperson" Int -> Text -> DatabaseContext -> Either DatabaseContextFunctionError DatabaseContext """(\(age:name:_) ctx -> let newrel = MakeRelationFromExprs Nothing [TupleExpr (fromList [("name", NakedAtomExpr name),("age", NakedAtomExpr age)])] in if isRight (executeRelationalExpr (RelationVariable "person" ()) ctx) then executeDatabaseContextExpr (Insert "person" newrel) ctx else executeDatabaseContextExpr (Assign "person" newrel) ctx) :: [Atom] -> DatabaseContext -> Either DatabaseContextFunctionError DatabaseContext"""
37−```
38−
39−This function is quite dense, so let's examine its components.
40−
41−The first components are:
42−
43−```
44−adddatabasecontextfunction "addperson" Int -> Text -> DatabaseContext -> Either DatabaseContextFunctionError DatabaseContext
45−```
46−
47−which defines a function "addperson" which takes three arguments (an Int value, a Text value, and a DatabaseContext) and returns a DatabaseContext. All database context functions take as a final argument a database context and must return a database context.
48−
49−The meat of the function is obviously the Haskell, so let's lay it out:
50−
51−```haskell
52−(\(age:name:_) ctx -> let newrel = MakeRelationFromExprs Nothing [TupleExpr (fromList [("name", NakedAtomExpr name),("age", NakedAtomExpr age)])] in
53− if isRight (executeRelationalExpr (RelationVariable "person" ()) ctx) then
54− executeDatabaseContextExpr (Insert "person" newrel) ctx
55− else
56− executeDatabaseContextExpr (Assign "person" newrel) ctx)) :: [Atom] -> DatabaseContext -> Either DatabaseContextFunctionError DatabaseContext
57−```
58−
59−Line 1 sets up a new relation created from the function's arguments. In this case, we create a relation to represent a new person in our database.
60−
61−Line 2 determines if the "person" relation variable is already available in the context. If so, the function inserts the new "person" relation into the existing relation variable in line 3.
62−
63−In line 5, since the relation variable was determined not yet to be defined, we assign the new person relation directly.
64−
65−Note that there is nothing special about the Haskell above- it is indeed a full-blown Haskell environment; however, this environment operates in "Safe" mode which prohibits any non-pure function access (such as with ```unsafePerformIO```). Thus, it is safe to use as a trusted programming environment with users creating arbitrary convenience functions within the implicit sandbox.
66−
67−Users can add arbitrary (but safe and pure) calculations to these functions to capture business logic. The list of modules available within the function context can be modified at compile-time.
68−
69−Let's try the new function!
70−
71−```
72−TutorialD (master/main): execute addperson(30, "Steve")
73−TutorialD (master/main): :showexpr person
74−┌────────┬──────────┐
75−│age::Int│name::Text│
76−├────────┼──────────┤
77−│30 │"Steve" │
78−└────────┴──────────┘
79−TutorialD (master/main): execute addperson(32, "Bob")
80−TutorialD (master/main): :showexpr person
81−┌────────┬──────────┐
82−│age::Int│name::Text│
83−├────────┼──────────┤
84−│32 │"Bob" │
85−│30 │"Steve" │
86−└────────┴──────────┘
87−TutorialD (master/main):
88−```
89−
90−Here we see that the first call to ```addperson``` created the relation variable while a subsequent call added another tuple to the existing relation variable.
91−
92−## Haskell access
93−
94−Database context functions come in two varieties:
95−
96−* scripted (as above)
97−* pre-compiled
98−
99−If you are dealing with the Haskell interface directly and you don't anticipate changing the functions, the easiest option is to compile your Haskell database context function into the database. It can always be removed or supplanted by a scripted version later.
100−
101−To add a new, compiled database context function to the database, use:
102−
103−```haskell
104−executeDatabaseContextIOExpr sessionId dbconn (AddDatabaseContextFunction funcName Nothing (\(arg1:arg2:_) ctx -> ...))
105−```
106−from the ```ProjectM36.Client``` module.
107−
108−The function can be executed using:
109−
110−```haskell
111−executeDatabaseContextExpr sessionId dbconn (ExecuteDatabaseContextFunction funcName atomArgList)
112−```
113−from the same module.
114−
115−## Loading Precompiled Modules
116−
117−Database context functions compiled with GHC to object files can be loaded at runtime. Let's walk through an example:
118−
119−```haskell
120−module DynamicDatabaseContextFunctions where
121−import ProjectM36.Base
122−import ProjectM36.Relation
123−import ProjectM36.DatabaseContextFunctionError
124−import qualified ProjectM36.Attribute as A
125−
126−import qualified Data.Map as M
127−
128−
129−someDBCFunctions :: [DatabaseContextFunction]
130−someDBCFunctions = [DatabaseContextFunction {
131− dbcFuncName = "addtestrel",
132− dbcFuncType = [],
133− dbcFuncBody = DatabaseContextFunctionBody Nothing addTestRel
134− }]
135− where
136− addTestRel _ ctx = do
137− let attrs = A.attributesFromList [Attribute "word" TextAtomType]
138− eRel = mkRelationFromList attrs [[TextAtom "nice"]]
139− case eRel of
140− Left err -> Left (DatabaseContextFunctionUserError (show err))
141− Right testRel ->
142− pure $ ctx { relationVariables = M.insert "testRel" testRel (relationVariables ctx) }
143−```
144−
145−The function returns a list of `DatabaseContextFunction`s (just one in this case). The function adds a relation variable to the current database context.
146−
147−Compile it with GHC:
148−
149−```
150−cabal exec ghc -- examples/DynamicDatabaseContextFunctions.hs -package project-m36
151−```
152−
153−or invoked GHC via stack.
154−
155−Finally, connect to your database with `tutd` and load the module:
156−
157−```
158−TutorialD (master/main): loaddatabasecontextfunctions "DynamicDatabaseContextFunctions" "someDBCFunctions" "examples/DynamicDatabaseContextFunctions.o"
159−```
160−
161−If the load reports an "unknown symbol" error, double check that the installed "project-m36" package is identical to one used to link the Haskell module.
162−
163−Note that such functions do not survive a server restart; this will likely be improved in a future release.
164−
165−## Future Improvements
166−
167−There are likely a variety of convenience functions which would make sense in the context of the scripted function. If you have ideas for such functions, please open a GitHub issue.
docs/dataframes.markdowndeleted−53
@@ -1,53 +0,0 @@
1−# Project:M36 DataFrames
2−
3−Users of typical relational algebra engines have come to expect sorting and limiting of query results despite the fact that relations do not support ordering. To that end, Project:M36 supports converting relations to "data frames" to support sorting on attributes and limiting the maximum tuple count in the result set.
4−
5−The equivalent feature in SQL is invoked by the `ORDER BY`, `LIMIT`, and `OFFSET` clauses.
6−
7−## Usage
8−
9−From within the `tutd` console, converting a relation to be sorted as a data frame is invoked using the `:showdataframe` command.
10−
11−```
12−:showdataframe <relational expression> orderby {<attribute {ascending,descending}>} {offset <num>} {limit <num>}
13−```
14−
15−The default sort order is `ascending`.
16−
17−## Examples
18−
19−```
20−TutorialD (master/main): :showdataframe s orderby {status}
21−┌──┬───────────┬─────────┬────────────┬────────────────┐
22−│DF│city::Text↕│s#::Text↕│sname::Text↕│status::Integer⬆│
23−├──┼───────────┼─────────┼────────────┼────────────────┤
24−│1 │"Paris" │"S2" │"Jones" │10 │
25−│2 │"London" │"S1" │"Smith" │20 │
26−│3 │"London" │"S4" │"Clark" │20 │
27−│4 │"Athens" │"S5" │"Adams" │30 │
28−│5 │"Paris" │"S3" │"Blake" │30 │
29−└──┴───────────┴─────────┴────────────┴────────────────┘
30−TutorialD (master/main): :showdataframe s{status} orderby {status}
31−┌──┬────────────────┐
32−│DF│status::Integer⬆│
33−├──┼────────────────┤
34−│1 │10 │
35−│2 │20 │
36−│3 │30 │
37−└──┴────────────────┘
38−TutorialD (master/main): :showdataframe s{status} orderby {status descending} limit 1
39−┌──┬────────────────┐
40−│DF│status::Integer⬇│
41−├──┼────────────────┤
42−│1 │30 │
43−└──┴────────────────┘
44−TutorialD (master/main): :showdataframe s{status} orderby {status descending} offset 1 limit 3
45−┌──┬────────────────┐
46−│DF│status::Integer⬇│
47−├──┼────────────────┤
48−│1 │20 │
49−│2 │10 │
50−└──┴────────────────┘
51−
52−```
53−The arrow in the attributes indicates the sort order while the DF column indicates the row number based on the sort order. Column ordering can also be arbitrary.
docs/filesystem-persistence.markdowndeleted−128
@@ -1,128 +0,0 @@
1−# Project-M36 Filesystem Persistence (Change Proposal)
2−
3−## Introduction
4−
5−Existing database persistent storage is not suitable for Project:M36 storage for several reasons:
6−
7−* typical SQL storage doesn't support relation-valued attributes
8− * Project:M36 supports nested relations, relations as values- a useful feature of the relational algebra
9−* typical SQL storage relies on writing and rewriting files to save space
10− * Project:M36 uses a write-one-read-many strategy to support database branching, concurrency, and compression
11−* typical SQL storage maps each table to one or more files
12− * Project:M36 obviates the one-to-one mapping between relation variables and files and allows for multiple representations of a single relation variable and evaluated expressions on disk
13−* typical SQL storage maintains only the latest state of the database
14− * Project:M36 stores a graph of transactions and supports multiple heads of contention
15−* typical key-value storage is poorly typed or even schemaless
16− * Project:M36 is strongly-typed which enforces correctness and can benefit compression schemes and performance
17−
18−## Requirements
19−
20−* storage of an append-at-leaves (transaction) graph with highly concurrent read access
21−* database [durability](https://en.wikipedia.org/wiki/ACID#Durability)
22−* extensibility
23− * examples include future compression types, dynamic atom (value) types, database context extensions, new relation types (such as recurrence relations), backwards-compatibility for atom values
24−* platform-agnosticism
25− * postgresql's C-struct-to-disk design means that switching platforms requires a dump-and-restore, even if the database directory can be physically moved to the new machine- it's not always clear what constitutes a platform changes (float/int timestamps)
26−* upgradeability
27− * postgresql software upgrades require painful database dump-and-restores or pg_upgrade, causing downtime
28− * be able to read older formats to prevent costly data-rewrites
29−* backwards-compatibility
30− * no one wants to rewrite their database files during upgrades, even if it is on-the-fly like with pg_upgrade
31−* multiple remote readers and writers to the storage
32− * mutliple servers can read/write the same storage over networked filesystems as long as there are some basic locking guarantees
33− * multiple servers can read the same storage without locking guarantees
34− * we can protect WORM storage with fine-grained locking and still maintain high-concurrency
35−* singular format for data export/import (dump/restore)
36− * we won't need a pseudo-cross-platform dump format (like pg_dump's output) because the file format is already cross-platform
37− * sharing the format for internal and external usage means we can share the same tools
38− * the dump format can be a subset of the internal format
39−* existence of a Haskell-based serialization library
40−* POSIX filesystem semantics and atomicity guarantees
41−
42−## Current, Insufficient Design
43−
44−### Filesystem Requirements
45−
46−* POSIX, journaled filesystem
47− * ext3/4, xfs, etc.
48− * simulate POSIX semantics on Windows possibly with locking
49−
50−The first pass of the on-disk storage for Project:M36 was implemented with a focus on correctness, but not performance or intelligent disk storage usage. As such, it is valuable as a baseline for the new implementation.
51−
52−* uses Data.Binary to serialize entire Haskell data structures to disk
53−* includes lots of redundancy
54− * for example, each new transaction writes all current relation variables to disk- instead, we should be able to reference unchanged relvars from previous transactions (they are already safely on disk)
55−* loses the in-memory data structure sharing that was present when writing the data (one of the benefits of immutable data structures)
56−* writes a platform-specific format
57−* is not extensible, backwards-, or forwards-compatible
58−* cannot be used as a portable, exportable format
59−* compression is all-or-nothing
60−
61−### Directory Layout
62−
63−* /m36v*x* - includes a human-readable transaction graph listing. The *x* references the version of persistence format.
64−* /lockFile - an empty file used for synchronizing multiple project-m36 server contending for the transaction graph
65−* /heads - a human-readable mapping of head names to transaction ids
66−* /<transaction id> - a directory containing all data needed to reconstruct a transaction
67− * /atomfuncs - a Binary-serialized listing of `AtomFunction`s
68− * /dbcfuncs - a Binary-serialized listing of `DatabaseContextFunction`s
69− * /incdeps - a Binary-serialized listing of `InclusionDependency`s
70− * /info - a Binary-serialized listing of `TransactionInfo` (current and parent transaction ids)
71− * /relvars - a directory containing files named after the relvars with each file's contents being a serialized `Relation`
72− * dynamic names should not appear in the filesystem as the filesystem naming requirements will be different from Project:M36 naming requirements
73− * /schemas - a Binary-serialized listing of alternative isomorphic schemas
74− * /typecons - a Binary-serialized listing of `TypeConstructor`s (data types)
75−
76−## New, Shiny, Proposed Design
77−
78−### Directory Layout
79−
80−Most of the existing directory layout remains useful. The one-transaction-per-directory layout maximizes read performance using a WORM strategy. Later transactions can refer to past transactions to cut down on immediate IO. Due to the idempotence of the `DatabaseContextExpr`, we can optionally serialize the expression itself to further reduce and defer IO. Deferred updates can be resolved on-demand or in the background by replacing transaction directories, individual files, or by adding supplementary relation representations (more on these below).
81−
82−Improvements:
83−
84−* wrap up small objects together
85− * We experienced unnecessarily high disk usage when saving atom functions in individual files. Wrap up smaller data structures (especially when less than 4KB) into one file.
86−* use [cbor](https://github.com/well-typed/cborg) binary format to allow external tools to be able to read the on-disk format
87− * the cbor format allows for forwards and backwards compatibility for atom types and includes relevant built-in types
88−
89−### Relation representations
90−
91−One area where almost every DBMS has fallen flat is in *data independece*, the separation between the logical database state representation and the on-disk format. Project:M36 aims to remedy this with "relation representations" which acknowledges that every relation (including the results of relational expresssions) can have multiple on-disk or in-memory representations. The purpose of a query planner is to choose the optimal representation for the given request.
92−
93−Most DBMSes do make an inadvertent attempt to support multiple relation representations via indexes. An index can be viewed as an independent representation of a relation in a different format (optimized for certain queries), but these same DBMSes fail to hide this abstraction in the logical layer, instead forcing users to create and maintain indexes as a separate entity.
94−
95−Relational representations, however, are never presented to the user of the logical layer of the database. Such representations can be created automatically. For example, if a certain query result (always a relation) is requested often, the DBMS may choose to cache the result as a relation representation mapped to the query itself. Thereafter, if the query is requested again (within an unchanged database state, of course), the planner can choose to send the pre-computed result back. This is known as a "query cache", but we can extend this same model to any other possible representation.
96−
97−Another representation type includes alternative representations of a relation variable's value designed for specific projections or restrictions. For example, a relation may be stored on disk as a btree with the nodes representing a relation's key. This is obviously equivalent to an index (either populated with the remainder of the tuple attributes or not, if the query is merely checking for existence).
98−
99−Note that if two relation representations are isomorphic, as in the example of a btree containing the key and remaining tuple values, then all other representations of the same relation are redundant. Under storage pressure, we can delete all but one representation. Which one the DBMS chooses to delete is arbitrary. When we have adequate space, we can create additional representations in the background without affecting correctness.
100−
101−The on-disk representation need not correspond to the logical relation variables at all. Besides query caches, the DBMS can freely store multiple relations in the same file as long as there is a relational expression to distinguish between the logical relation variables. Conversely, a single relation variable's value could span multiple files, simulating what other DBMSes call sharding but without exposing the implementation details to the users.
102−
103−Considering that user involvement in the creation of relation representations is the norm, how can the DBMS create such representations and maintain them automatically? This will likely be an area of research, but we can start simply with a query cache and automatic cost-based indexing based on actual queries executed.
104−
105−When broken free from user control, the DBMS is free to create arbitrary representations with the only consideration being available IO and memory resources.
106−
107−### Deferred updates
108−
109−Virtually all DBMSes execute database updates against existing files which store tuples. However, because Project:M36 updates are idempotent, we can save expressions to disk for *deferred updates*. Database update expressions saved to disk can drastically increase the rate at which we can execute updates because the expression is likely far smaller than the number of tuples which the expression will change. Because Project:M36 uses per-transaction directories, once a deferred update is actually evaluated, the directory can be atomically replaced with the evaluated result. Of course, to save disk storage and IO, the DBMS can also choose to discard the evaluated result and continue to store the update. This is nothing novel- git does this by storing code diffs between commits. The only novelty is in recognizing the value of idempotent updates.
110−
111−### Linked relations
112−
113−Every database update creates a new state based on an old state and an update expression. In the previous section, we demonstrated how the expression along with the previous state is sufficient to create the new state. Alternatively, the DBMS can also store a "diff" (difference) in the form of a relational expr with a link to the previous state.
114−
115−For example, if we have a relation variable of employees' names and we insert another employee name, the new state is the union of the previous state of the relation variable and a relation containing the new employee's name. The evaluated expression which requests the new state is merely replaced with the union- similar to a macro.
116−
117−This strategy can also be viewed as a form of compression. In the general case where a relation variable has not changed from one transaction to the next transaction, we can merely store what amounts to a symbolic link to the relation variable in the previous state.
118−
119−### Risks of Redesign
120−
121−* cborg module has had only one release, is probably less than ready for production use, but the initial results are promising and is developed and backed by well-known Haskellers and a Haskell shop
122− * are there alternatives we should consider?
123−* increased code complexity
124− * executor needs to be separated from current relational EDSL to support scanning various types of relation representations
125− * the new EDSL may not leak its representations to the user-level EDSL
126− * query executor will need access to the full transaction graph to cover relation links and deferred updates; currently, all state is wrapped up into the `DatabaseContext`
127−* how and when to create new relation representations and when to defer updates will be an active area of research
128−* requires more consideration in reducing IO and storage requirements; this was not a major driver of the initial design
docs/import_export_csv.markdowndeleted−65
@@ -1,65 +0,0 @@
1−# Project:M36 CSV Import/Export
2−
3−Project:M36's `tutd` console supports the import and export of CSV files as a lowest-common denominator format for moving data. Because the CSV file format does not support all the features of Project:M36- most notably, nested relations- not all relation variables can be marshalled to-and-from CSV files.
4−
5−## CSV Export
6−
7−If a relation variable cannot be exported due to data types which are not supported by the CSV format- such as with a nested relation- then Project:M36 throws an error rather than export a partial file.
8−
9−### Example Export
10−
11−```
12−TutorialD (master/main): :importexample cjdate
13−TutorialD (master/main): :exportcsv s "/tmp/csv"
14−```
15−```
16−$ cat /tmp/csv
17−s#,sname,status,city
18−S2,Jones,10,Paris
19−S1,Smith,20,London
20−S4,Clark,20,London
21−S5,Adams,30,Athens
22−S3,Blake,30,Paris
23−```
24−
25−## CSV Import
26−
27−An import is equivalent to an insert and does not replace the target relation variable.
28−
29−Because relations do not have a natural ordering for their attributes, the CSV file to import must contain a header row which matches the names of attributes.
30−
31−If a value in the CSV file cannot be converted to the expected type (determined by the existing relation attributes), then the entire import is aborted rather than perform a partial import.
32−
33−### Example Import
34−```
35−$ cat /tmp/csv
36−s#,sname,status,city
37−S6,Samson,100,New York
38−```
39−```
40−TutorialD (master/main): :importexample cjdate
41−TutorialD (master/main): :showexpr s
42−┌──────────┬────────┬───────────┬───────────────┐
43−│city::Text│s#::Text│sname::Text│status::Integer│
44−├──────────┼────────┼───────────┼───────────────┤
45−│"Paris" │"S2" │"Jones" │10 │
46−│"Paris" │"S3" │"Blake" │30 │
47−│"London" │"S4" │"Clark" │20 │
48−│"London" │"S1" │"Smith" │20 │
49−│"Athens" │"S5" │"Adams" │30 │
50−└──────────┴────────┴───────────┴───────────────┘
51−TutorialD (master/main): :importcsv "/tmp/csv" s
52−TutorialD (master/main): :showexpr s
53−┌──────────┬────────┬───────────┬───────────────┐
54−│city::Text│s#::Text│sname::Text│status::Integer│
55−├──────────┼────────┼───────────┼───────────────┤
56−│"Paris" │"S3" │"Blake" │30 │
57−│"London" │"S4" │"Clark" │20 │
58−│"New York"│"S6" │"Samson" │100 │
59−│"Athens" │"S5" │"Adams" │30 │
60−│"London" │"S1" │"Smith" │20 │
61−│"Paris" │"S2" │"Jones" │10 │
62−└──────────┴────────┴───────────┴───────────────┘
63−```
64−
65−Note that relations do not have ordering, thus, no ordering from the CSV file is preserved.
docs/index.markdown+1
@@ -3,4 +3,5 @@
331. [Introduction to ProjectM36](introduction_to_projectm36.markdown)
441. [TutorialD Tutorial](tutd_tutorial.markdown)
551. [Transaction Graph Operators](transaction_graph_operators.markdown)
6+1. [Persistent Library Driver](persistent_library_driver.markdown)
671. [ProjectM36.Client Library](projectm36_client_library.markdown)
docs/introduction_to_projectm36.markdown+13−39
@@ -1,7 +1,7 @@
11# Introduction to Project:M36
22
33## What is Project:M36?
4−Project:M36 is a relational-algebra-based database management system. It can be used as a production-level database backend or for learning more about the relational algebra.
4+Project:M36 is a relational-algebra-based database management system. It can be used a production-level database backend or for learning more about the relational algebra.
55
66The principled mathematical approach to Project:M36's design sets it apart from competing DBMSs. Specifically, Project:M36 adheres strongly to the mathematics of the relational algebra and makes no compromises nor apologies in doing so. To that end, Project:M36 is implemented in the programming language "Haskell" which is itself based on the lambda calculus.
77
@@ -15,66 +15,40 @@ The relational algebra is the mathematical model underpinning Project:M36. When
1515
1616## Binary Releases
1717
18−The quickest and preferred method of installation is via docker, which works on Linux, macOS, and Windows. Docker downloads and runs preconfigured software in secure, sandboxed containers, preventing third-party software from altering the host system without your permission.
18+### Windows
19+Project:M36 now provides binary installations for Windows. Check the (releases page)[https://github.com/agentm/project-m36/releases] for downloads.
1920
20−### Install Docker:
21+### MacOS X
2122
22−* [Windows 10 Docker Installation](https://docs.docker.com/docker-for-windows/wsl/)
23−* [MacOS Docker Installation](https://docs.docker.com/docker-for-mac/install/)
24−* [Linux Docker Installation](https://docs.docker.com/engine/install/#server)
23+Binary releases are not yet available for MacOS X, but compiling from source is easy.
2524
26−### Run TutorialD from Docker Image
25+### Linux
2726
28−This downloads the docker image tagged "latest" and runs `tutd`, the TutorialD command line interface. Try the [15-Minute TutorialD Tutorial](15_minute_tutorial.markdown) and try some expressions.
29−
30−```bash
31−docker run -it projectm36/project-m36 tutd
32−```
33−
34−### Run Project:M36 Server
35−
36−The default port for the project-m36 server is 6543.
37−
38−```bash
39−docker run --network host projectm36/project-m36 project-m36-server -n <database_name>
40−```
41−
42−### Connect to Project:M36 Server
43−
44−```bash
45−docker run --network host projectm36/project-m36
46−```
27+The currently-preferred method of installation is from source. A future enhancement would be installation from deb or rpm.
4728
4829## Source Installation
4930
5031Requirements:
5132
52−To build with stack:
53−
54−* [GHC 8.6.5 or greater](https://www.haskell.org/downloads)
33+* [GHC 7.10 or greater](https://www.haskell.org/downloads)
5534* [Haskell stack](https://docs.haskellstack.org/en/stable/README/)
56−* Linux, macOS, or Microsoft Windows
35+* Linux, MacOS X, or Windows OS
5736
5837Compilation steps:
5938
6039* ```git clone https://github.com/agentm/project-m36```
6140* ```cd project-m36```
62−* ```stack --stack-yaml stack.ghc8.6.yaml build```
41+* ```stack build```
6342
6443At this point, the TutorialD interactive interpreter can be run using ```stack exec tutd```.
6544
66−Alternative building with GHC 8.6.5 or greater:
67−
68−* ```cabal new-build```
69−
70−The resultant binaries can be found in ```./dist-newstyle/build/project-m36-<version>/build```.
71−
7245## Accessing Project:M36 Databases
7346
7447Project:M36 implements a generic relational algebra DBMS backend with multiple data access frontends. Such frontends currently include:
7548
7649* TutorialD: Chris Date's interactive language for learning about the relational algebra
7750* ProjectM36.Client: a Haskell library for native access
51+* Database.Persist.ProjectM36: a driver for the Haskell persistent library
7852
7953More frontends are expected to be supported in the future.
8054
@@ -86,7 +60,7 @@ In addition to being a relational algebra engine, Project:M36 supports features
8660
8761Most DBMSs provide a way to allow the user to specify atomic database state changes. These changes are often wrapped up as "transactions" which, when applied to the database state, offer the illusion of sequential and grouped, atomic changes applied to the databases. Often the only state which can be queried is the snapshot at the time the transaction is opened.
8862
89−Project:M36 extends this transaction model with the "transaction graph". This feature can be adequately described as version control for transactions. In the legacy DBMS model, the transactions are added to a linear transaction stream where each client is contending over the "head" of the stream- the latest transactions. In the transaction graph model, clients can add named branches and add transactions to the branches, then merge changes back, if necessary.
63+Project:M36 extends this transaction model with the "transaction graph". This feture can be adequately described as version control for transactions. In the legacy DBMS model, the transactions are added to a linear transaction stream where each client is contending over the "head" of the stream- the latest transactions. In the transaction graph model, clients can add named branches and add transactions to the branches, then merge changes back, if necessary.
9064
9165This feature is useful, for example:
9266* during testing- create a testing branch which production will never see. This obviates the need for a separate production data set.
@@ -108,7 +82,7 @@ Decreasing a transaction's durability can reduce IO contention at the cost of re
10882
10983### Native Haskell Compatibility
11084
111−Any Haskell data type which implements the ```Atomable``` typeclass can be manipulated as a value in the database.
85+Any Haskell data type which implements the ```Atom``` typeclass can be manipulated as a value in the database.
11286
11387Haskell functions which operate on those values can also be added to the database.
11488
docs/introduction_to_the_relational_algebra.markdown+13−44
@@ -16,7 +16,7 @@ Let us begin by starting with the smallest units in the relational model and wor
1616
1717A value is a typed, singular unit of data.
1818
19−Common examples could be a number indicating a person's age, the number of dollars in a bank account, or a street address used for delivery. In all cases, a value must be of a specific type and must support the notion of equality.
19+Common examples could be a number indicating a person's age, the number of dollars in a bank account, or a street address used for delivery. In all cases, a value must be of a specific type and must support the notion of equality.
2020
2121As an example, it doesn't make sense to ask if a person's age is equal to a street address; the relational model can enforce this- this is called "type safety" and is the motivation for using types.
2222
@@ -38,11 +38,11 @@ An attribute is a pair containing an attribute name along with an attribute type
3838
3939Examples:
4040* An "Address" attribute name is of type "Text":
41−
41+
4242(Address, Text)
4343
4444* An "Current Balance" attribute name is of type "Dollar Amount":
45−
45+
4646(Current Balance, Dollar Amount)
4747
4848#### Tuple
@@ -62,7 +62,7 @@ In the last example, the fact that the car failed the inspection is implied by t
6262
6363#### Relation
6464
65−A relation is a container of values organized by tuples of the same type. Specifically, a relation is a set of attributes (a relation header) mapped over a set of tuples (a relation body). Note that this implies that tuples cannot appear more than once since a set can only hold unique items.
65+A relation is a container of values organized by tuples of the same type. Specifically, a relation is a set of attributes (a relation header) mapped over a set of tuples (a relation body). Note that this implies that tuples cannot appear more than once since a set can only hold unique items.
6666
6767When a tuple appears in a relation, a relation's attributes and respective types must match that of all of its tuples. Thus, a relation's header summarizes the attribute names and types of all of its constituent tuples.
6868
@@ -116,7 +116,7 @@ To reiterate, the transition from T1 to T2 replaced the "Employees" relation var
116116
117117#### Relational Operators
118118
119−Since we refer to the relational algebra as a closed algebra, all relational operators necessarily operate on and generate relations. The purpose of the operators is allow data modelers to answer questions (queries) based on the current state of the database. For example, a modeler may wish to know the ages of the employees working in the accounting department. The modeler can then compose the relational operators together to answer this and virtually any other conceivable query.
119+Since we refer to the relational algebra as a closed algebra, all relational operators necessarily operate on and generate relations. The purpose of the operators is allow data modelers to answer questions (queries) based on the current state of the database. For example, a modeler may wish to know the ages of the employees working in the accounting department. The modeler can then compose the relational operators together to answer this and virtually any other conceivable query.
120120
121121##### Project
122122
@@ -186,7 +186,7 @@ Note that rename does not alter the type of the attribute in question.
186186
187187##### Join
188188
189−One of the most essential-to-understand operators is the join operator. Unlike the previous two unary (single relation argument) operators, join operates on two (or potentially more) relations. The purpose of a join is to merge multiple relations into one relation in order to determine the relationships between data across relations. For example, there are good reasons (which have not yet been explained) why a relation representing a company's products and records of when those products were shipped should be two disparate relations. The join operators merges relation A and relation B by returning a new relation with the attribute sets of both relation headers merged and with a body of the tuples merged if-and-only-if the in-common attributes' values are equal.
189+One of the most essential-to-understand operators is the join operator. Unlike the previous two unary (single relation argument) operators, join operates on two (or potentially more) relations. The purpose of a join is to merge multiple relations into one relation in order to determine the relationships between data across relations. For example, there are good reasons (which have not yet been explained) why a relation representing a company's products and records of when those products were shipped should be two disparate relations. The join operators merges relation A and relation B by returning a new relation with the attribute sets of both relation headers merged and with a body of the tuples merged if-and-only-if the in-common attributes' values are equal.
190190
191191In the case where no attributes are in common between the relations, the join operator becomes a cross-product operator; this is not a special case, rather a logical consequence of the definition.
192192
@@ -202,13 +202,13 @@ 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|
209209|English 2|Steve|Room 104|
210210
211−["Instructor Name" is the in-common attribute]
211+["Instructor Name" is the in-common attribute]
212212===>
213213
214214|(Instructor Name, Instructor Name Type)|(Office Number, Office Number Type)|(Course Name, Course Name Type)|(Course Room Number, Room Number Type)|
@@ -259,7 +259,7 @@ Examples:
259259
260260group ("Name") as "SameAgePeople"
261261
262−| (Name, Name Type)|(Age, Age Type) |
262+|(Name, Name Type)|(Age, Age Type)|
263263|-----------------|---------------|
264264|Steve|12|
265265|Cindy|12|
@@ -301,37 +301,6 @@ ungroup ("Pets")
301301
302302Note that Bob does not appear in the result relation because he has no pets.
303303
304−#### Difference
305−
306−The difference operator ("minus" in TutorialD) receives two relations of the same type (same attributes) as arguments rvA and rvB and returns a relation which contains tuples in rvA which are not found in rvB. This operator is similar to set difference.
307−
308−Example:
309−
310−* Show a relation of non-managers by starting with the relation of employees and removing the employees found in the manager relation.
311−
312−Employees
313−
314−|(Name, Name Type)|
315−|-----------------|
316−| Bob |
317−| Jim |
318−| Steve |
319−| Bart |
320−
321−Managers
322−
323−|(Name, Name Type)|
324−|-----------------|
325−| Bob |
326−| Steve |
327−
328−====>
329−
330−|(Name, Name Type)|
331−|-----------------|
332−| Jim |
333−| Bart |
334−
335304### Displaying Relations
336305
337306Note that in the above operator examples, the order of the tuples appears to shift around. Since a relation body is a set of tuples, any ordering, such as required to represent a relation in two-dimenstional space as a table, is completely arbitrary. Note that the following two relations are two representations of *same* relation:
@@ -342,7 +311,7 @@ Note that in the above operator examples, the order of the tuples appears to shi
342311|Sam|41|
343312|Cindy|42|
344313
345−and
314+and
346315
347316|(Name, Name Type)|(Age, Age Type)|
348317|-----------------|---------------|
@@ -374,11 +343,11 @@ For most companies, its data, such as customer, employee, sales, and product inf
374343
375344## What is the advantage of having relation-valued attributes?
376345
377−Since a value can store any (immutable) type, it can certainly hold a relation. At the very least, the mathematics does not exclude the possibility. This does create a recursively-defined data structure (Relation -> Tuple -> Value -> Relation), but it turns out that relations as values can be quite useful.
346+Since a value can store any (immutable) type, it can certainly hold a relation. At the very least, the mathematics does not exclude the possibility. This does create a recursively-defined data structure (Relation -> Tuple -> Value -> Relation), but it turns out that relations as values can be quite useful.
378347
379348For example, in SQL, if one wants to collect some aggregate data over some tuples while still returning the individual tuples, in the best case, the aggregate information must be repeated for every individual tuple. In the worst case, two separate queries are required since nested tables are not supported.
380349
381−In the relational algebra, The aggregate value can be placed alongside the relation value from which the aggregate was derived.
350+In the relational algebra, The aggregate value can be placed alongside the relation value from whic the aggregate was derived.
382351
383352Example:
384353
@@ -403,7 +372,7 @@ Example:
403372
404373## Suggested Reading
405374
406−Chris Date has been researching the relational model and its consequences for over forty years. Date has published his findings in various papers but also summarizes his work in a series of introductory and advanced books. Date freely admits that his work on the relational algebra has been corrected over time, so it is best to read his latest works.
375+Chris Date has been researching the relational model and its consequences for over forty years. Date has published his findings in various papers but also summarizes his work in a series of introductory and advanced books. Date freely admits that his work on the relational algebra has been corrected over time, so it is best to read his latest works.
407376
408377Despite that fact that modern SQL databases do not adhere to the principles of relational algebra doesn't mean that the principles cannot be applied. Date often discusses and compares SQL constructions with his own "TutorialD" language. Project:M36 also supports TutorialD.
409378
docs/isomorphic_schemas.markdowndeleted−176
@@ -1,176 +0,0 @@
1−# Project:M36 Isomorphic Schemas
2−
3−## Introduction
4−
5−Project:M36 implements a unique feature called "isomorphic schemas" which allow database users to create any number of additional schemas which are completely isomorphic to the original schema.
6−
7−Two schemas which are isomorphic can have different structure, such as different relation variables, but actually represent identical information. This means that both schemas contain the same data, but the database structures such as relations are defined distinctly and in such a way as to make the schemas serve potentially different purposes. Tautologically, two schemas which are identical are isomorphic to each other.
8−
9−## Towards Solving Action-at-a-Distance
10−
11−Isomorphic schemas were designed to handle the use-case commonly covered by SQL views. SQL views allow a database user to create named SQL macros in a database schema. With many caveats, these macros can also be made "updateable", i.e. views can be the table targets of UPDATE, INSERT, or DELETE expressions.
12−
13−Chris Date elucidates on the numerous caveats involved in updateable SQL views in his "View Updating & Relational Theory" book. Of specific importance is the violation of the "Principle of Orthogonal Design" which states that two relation variables in a database should not represent the same data. Using SQL views as tables clearly violates this principle since a view can only create a duplicate view of the existing data. This same principle is violated even with materialized views.
14−
15−Furthermore, SQL views violate the "Principle of Interchangeability" because of the special nature of views. Whether views are updateable or not is at the discretion of the database user. Some SQL views are proveably not updateable such as with summary or report views which intentionally collate data. Therefore, views do not behave identically to tables/relation variables.
16−
17−SQL views violate "The Information Principle" because they represent variable storage which may behave outside the realm of what a table/relation variable could accomplish. A simple example is an SQL view which does *not* change the database state on an UPDATE (ON UPDATE DO NOTHING). A more complex example could involve a one-way hash function against database values which would be impossible to invert and thus prevent a logical update.
18−
19−Updateable SQL views necessarily allow for "action at-a-distance", i.e. when a view is updated, an unknown number of actual tables may be altered in unanticipatable ways.
20−
21−Isomorphic schemas were designed to address these violations with a mathematically-coherent design.
22−
23−## Definition
24−
25−Given a schema A containing relation variables, a given schema B is isomorphic to schema A if-and-only-if all relational expressions which can be written against schema B can be mechanically transformed to perform an operation on schema A which returns the same result relation.
26−
27−## The Use Case
28−
29−Despite their flaws, SQL views are useful for several reasons:
30−
31− * as an SQL macro language to store commonly-used queries
32− * as a means of hiding schema complexity; a set of views can be used to aggregate data across many tables, for example, to denormalize a set of table data
33− * as a means to contain different access methods to the database as the database evoles, i.e. the database schema needs to be altered, but the old access strategies can be emulated through views
34− * as a means of enforcing security access by implementing views which offer a restricted subset of the original data
35−
36−Of these use cases, isomorphic schemas only cover the schema complexity and database evolution use cases. Further research (see Conclusion) may be able to extend this design to the missing use cases.
37−
38−## Isomorphic Schema Building Blocks
39−
40−Project:M36 does not purport to be able to represent all possible isomorphic schemas, rather Project:M36 includes a set of "building blocks" from which one can create isomorphic schemas. These building blocks represent transformations needed to shift contexts from one schema to another. Currently, the building blocks are:
41−
42−* rename: a relation variable in schema A may have a different name in schema B
43−* restrict: a relation variable in schema A can be split into two relation variables in schema B given a restriction predicate
44−* union: two relation variables in schema A can be union'd and represent one
45−
46−Note that the restrict and union building blocks are inverse operations to each other.
47−
48−Clearly, there are additional limitations placed on the relation variables that can be used in the building blocks; for example, for two relations to be union-able, they must have the same header and no tuple overlap.
49−
50−## Isomorphic Schemas in Practice
51−
52−Project:M36 is the first DBMS to implement isomorphic schemas. By default, each transaction is given a special "main" schema which cannot be deleted. To create a new isomorphic schema, use the "addschema" command:
53−
54−```
55−:addschema <schema name> (<isomorphic building block>,...)
56−```
57−
58−where the building blocks are one of:
59−
60−* ```isorestrict "<new schema relvar name>" "<existing schema rel var where predicate is true>" "<existing schema rel var where predicate is false>" <predicate>```
61−* ```isounion "<new schema relvar name where predicate is true>" "<new schema relvar name where predicate is false>" "<existing schema relvar name>" <predicate>```
62−* ```isorename "<new schema relvar name>" "<existing schema relvar name>"```
63−* ```isopassthrough "<relvar name to retain in both existing and new schemas>"```
64−
65−This list of building blocks is merely what Project:M36 supports and is not meant to represent an exhaustive list of potential, mathematically-sound isomorphisms.
66−
67−To switch to an alternative schema, use the ```:setschema``` command:
68−
69−```:setschema <schema name>```
70−
71−To delete a schema, use the ```:removeschema``` command:
72−
73−```:removeschema <schema name>```
74−
75−The special "main" schema cannot be deleted.
76−
77−Full example:
78−```
79−TutorialD (master/main): x1:=relation{tuple{y 3}, tuple{y 4}}
80−TutorialD (master/main): x2:=relation{tuple{y 5}, tuple{y 6}}
81−TutorialD (master/main): :addschema spam (isorestrict "x" "x1" "x2" ^lt(@y,5), isopassthrough "true", isopassthrough "false")
82−TutorialD (master/main): :setschema spam
83−TutorialD (master/spam): :showexpr x
84−┌──────────────┐
85−│y::IntAtomType│
86−├──────────────┤
87−│4 │
88−│5 │
89−│3 │
90−│6 │
91−└──────────────┘
92−TutorialD (master/spam): :showrelvars
93−┌─────────────────────────────────────────────────────────────────┬──────────────────┐
94−│attributes::relation {attribute::TextAtomType,type::TextAtomType}│name::TextAtomType│
95−├─────────────────────────────────────────────────────────────────┼──────────────────┤
96−│┌───────────────────────┬──────────────────┐ │"true" │
97−││attribute::TextAtomType│type::TextAtomType│ │ │
98−│└───────────────────────┴──────────────────┘ │ │
99−│┌───────────────────────┬──────────────────┐ │"false" │
100−││attribute::TextAtomType│type::TextAtomType│ │ │
101−│└───────────────────────┴──────────────────┘ │ │
102−│┌───────────────────────┬──────────────────┐ │"x" │
103−││attribute::TextAtomType│type::TextAtomType│ │ │
104−│├───────────────────────┼──────────────────┤ │ │
105−││"y" │"IntAtomType" │ │ │
106−│└───────────────────────┴──────────────────┘ │ │
107−└─────────────────────────────────────────────────────────────────┴──────────────────┘
108−TutorialD (master/spam): :setschema main
109−TutorialD (master/main): :showrelvars
110−┌─────────────────────────────────────────────────────────────────┬──────────────────┐
111−│attributes::relation {attribute::TextAtomType,type::TextAtomType}│name::TextAtomType│
112−├─────────────────────────────────────────────────────────────────┼──────────────────┤
113−│┌───────────────────────┬──────────────────┐ │"true" │
114−││attribute::TextAtomType│type::TextAtomType│ │ │
115−│└───────────────────────┴──────────────────┘ │ │
116−│┌───────────────────────┬──────────────────┐ │"x1" │
117−││attribute::TextAtomType│type::TextAtomType│ │ │
118−│├───────────────────────┼──────────────────┤ │ │
119−││"y" │"IntAtomType" │ │ │
120−│└───────────────────────┴──────────────────┘ │ │
121−│┌───────────────────────┬──────────────────┐ │"false" │
122−││attribute::TextAtomType│type::TextAtomType│ │ │
123−│└───────────────────────┴──────────────────┘ │ │
124−│┌───────────────────────┬──────────────────┐ │"x2" │
125−││attribute::TextAtomType│type::TextAtomType│ │ │
126−│├───────────────────────┼──────────────────┤ │ │
127−││"y" │"IntAtomType" │ │ │
128−│└───────────────────────┴──────────────────┘ │ │
129−└─────────────────────────────────────────────────────────────────┴──────────────────┘
130−```
131−
132−Note that for schema to be isomorphic, each relation variable in the existing schema must be referenced in the building blocks, otherwise an error is thrown which prevents the creation of a non-isomorphic schema.
133−
134−If not all relation variables were referenced in the proposed isomorphism, then the schema cannot be isomorphic. Consider a schema with two relation variables, ```A``` and ```B``` and a foreign key constraint ```X``` between them. If a new schema were to be created with only ```A``` appearing, given an insert to ```A``` which violates the constraint ```X```, it would be possible to issue an insert to ```A``` which would violate a constraint on a relation variable which does not appear to exist. Therefore, such a schema would be not be isomorphic and the schema would violate the both the Closed World Assumption and the Principle of Interchangeability.
135−
136−While it would be possible to create sub-isomorphic schemas mentioning a subset of all relation variables which do not have constraints between them, this has not been implemented because most schemas typically have constraints linking all relation variables together. This could be an area of further research.
137−
138−## More on Use Cases
139−
140−Instead of SQL views which model individual relation variables, by taking the notion of a "view" to a higher level in the database structure hierarchy, we find a "view" into a given database context can be represented as an isomorphic schema.
141−
142−Isomorphic schemas can be used in lieu of views to offer different APIs to an existing database, potentially supporting legacy interfaces while allowing the database schema to evolve further.
143−
144−Because it is not possible to query across schemas in one query (only one schema is under consideration at-a-time), the Principle of Orthogonal Design is not violated.
145−
146−## Conclusion
147−
148−The existence of isomorphic schemas underscores the need for DBMSes to embrace data independence which can allow for relation variables to be sliced to suit the needs of a application without violating the relational algebra's basic principles.
149−
150−Because the schemas are isomorphic, any derived, isomorphic schema could be used to assist in an on-disk, optimal representation instead of the schema which a user happened to type in first.
151−
152−Project:M36 is the first DBMS to propose and implement isomorphic schemas.
153−
154−Further research into isomorphic schemas could include:
155−
156−* methods to determine which persistent data representation represented as a schema would be optimal for a given set of input queries against the data.
157−* restricted access sub-schemas which emulate the functionality of SQL views used for security
158−* additional isomorphic building blocks such as
159− * type constructor isomorphisms
160− * atom function isomorphisms
161− * project/extend isomorphisms
162− * join isomorphisms
163−
164−Many of the additional isomorphisms are mentioned in Date's "View Updating & Relational Theory" book but not named as such.
165−
166−Project:M36 will continue to be developed in order to implement additional isomorphisms. We offer no proof that *every* isomorphic schema can be represented by these building blocks, but, hopefully, the blocks can be used to build the most interesting/useful schemas.
167−
168−### Bibliography
169−
170−Date, C.J. "View Updating & Relational Theory: Solving the View Update Problem". O'Reilly Media, Inc. 2013.
171−
172−Date, C.J. "Database Design & Relational Theory: Normal Forms and All That Jazz". O'Reilly Media, Inc. 2012.
173−
174−### Sponsors and Contributors
175−
176−The funding covering the research and implementation of isomorphic schemas was generously provided by E.E.P.R grant #28557448. This work would not have been possible without discussions with Dr. G. Garbés, Ph.D.
docs/javascript_driver.markdowndeleted−21
@@ -1,21 +0,0 @@
1−# Project:M36 JavaScript Driver
2−
3−## Introduction
4−
5− The JavaScript database driver for Project:M36 is a fully-featured database driver for the Project:M36 Relational Algebra Engine DBMS. The driver's only dependency is a working websockets implementation which is provided by virtually any modern web browser and node.js. The API is callback-based.
6−
7− ## Usage
8−
9−1. [Download the driver](/src/bin/ProjectM36/Websocket/project-m36.js).
10−1. Connect to the websocket server with a ```new ProjectM36Connection(..)``` including the asynchronous callback functions.
11−1. When the ```openCallback``` is called, the database is ready to execute TutorialD sing the ```executeTutorialD()``` function.
12−1. Implement ```statusCallback``` to update your user interface for expected and asynchronous event handling.
13−
14−## Example
15−
16−A fully-functioning interactive websocket client is available:
17−
18−* [websocket-client.html](/src/bin/ProjectM36/Server/WebSocket/websocket-client.html)
19−* [websocket-client.js](/src/bin/ProjectM36/Server/WebSocket/websocket-client.js)
20−
21−This example also powers [try.project-m36.io](https://try.project-m36.io).
docs/jupyter_kernel.markdowndeleted−49
@@ -1,49 +0,0 @@
1−# TutorialD Jupyter Kernel for Project:M36
2−
3−## Introduction
4−
5−[The Jupyter Notebook](https://jupyter-notebook.readthedocs.io/en/stable/notebook.html) is web-based tool for experimenting with various languages. Project:M36 offers a Jupyter kernel for the TutorialD interpreter.
6−
7−The kernel automatically starts and stops its own websocket-server-based database and offers no filesystem persistence, which is similar to other jupyter kernels.
8−
9−## Installation
10−
11−To install the `tutd` kernel:
12−
13−* install the `itutd` module into your jupyter virtual environment:
14−```
15−$ cd project-m36/jupyter/itutd
16−$ pip install .
17−```
18−
19−* install `kernel.json`:
20−
21− ```$ mkdir ~/Library/Jupyter/kernels/itutd && cp project-m36/jupyter/kernel.json ~/Library/Jupyter/kernels/itutd``` (macOS)
22−
23− ```$ mkdir ~/.local/share/jupyter/kernels/tutd && cp project-m36/jupyter/kernel.json ~/.local/share/jupyter/kernels/tutd``` (Linux)
24−
25− ```$ mkdir %APPDATA%\jupyter\kernels\tutd && copy project-m36\jupyter\kernel.json %APPDATA%\jupyter\kernels\tutd``` (Windows)
26−
27−* check that the kernel is detected:
28−```
29−$ jupyter kernelspec list
30−Available kernels:
31− python2 ...
32− tutd ...
33−```
34−
35−* add `project-m36-server` to `PATH` environment variable
36−
37−```
38−$ export PATH=$PATH:<path/to/project-m36-websocket-server>
39−$ which project-m36-websocket-server
40−/path/to/project-m36-websocket-server
41−```
42−
43−From within this python virtual environment, you can now start jupyter with TutorialD support.
44−
45−## Usage
46−
47−With the kernel installed, run `jupyter notebook` for the web-based interface and click "New" at the top right of the page. The TutorialD kernel should be in the list.
48−
49−Once a new TutorialD notebook is opened, the interpreter is identical to the `tutd` command line interpreter and accepts the same commands. If you are new to Project:M36-flavored TutorialD, please [read the tutorial](/docs/tutd_tutorial.markdown).
docs/merge_transactions.markdown+8−8
@@ -58,7 +58,7 @@ Branching and merging are built-in to the Project:M36 ```tutd``` client.
5858
5959First, let's create a new branch for some new sales data.
6060```
61−TutorialD (master/main): :branch add_sales_feature
61+TutorialD (master): :branch add_sales_feature
6262TutorialD (add_sales_feature):
6363```
6464
@@ -82,15 +82,15 @@ Now, the relation variable "sales" is available on the "add_sales_feature" branc
8282
8383```
8484TutorialD (add_sales_feature): :jumphead master
85−TutorialD (master/main): :showexpr sales
85+TutorialD (master): :showexpr sales
8686ERR: RelVarNotDefinedError "sales"
8787```
8888
8989Now that we are on the "master" branch, let's add a relation variables unrelated to sales.
9090
9191```
92−TutorialD (master/main): employees := relation{tuple{name "Steve"},tuple{name "Cindy"}}
93−TutorialD (master/main): :commit
92+TutorialD (master): employees := relation{tuple{name "Steve"},tuple{name "Cindy"}}
93+TutorialD (master): :commit
9494```
9595
9696Note that the "employees" relation variable is only available on the "master" branch and not on the "add_sales_feature" branch.
@@ -98,7 +98,7 @@ Note that the "employees" relation variable is only available on the "master" br
9898Let's look at the transaction graph:
9999
100100```
101−TutorialD (master/main): :showgraph
101+TutorialD (master): :showgraph
102102┌─────────────┬───────────────────┬──────────────────────────────────────┬────────────────────────────────────────┐
103103│current::Bool│head::Text │id::Text │parents::relation {id::Text} │
104104├─────────────┼───────────────────┼──────────────────────────────────────┼────────────────────────────────────────┤
@@ -129,15 +129,15 @@ TutorialD (master/main): :showgraph
129129Now, imagine that the work on the "add_sales_merge" branch is complete, so we will merge the "add_sales_feature" branch back into the "master" branch. We say we are merging "back" because both branches share a common ancestor transaction.
130130
131131```
132−TutorialD (master/main): :mergetrans union add_sales_feature master
133−TutorialD (master/main): :showexpr employees
132+TutorialD (master): :mergetrans union add_sales_feature master
133+TutorialD (master): :showexpr employees
134134┌──────────┐
135135│name::Text│
136136├──────────┤
137137│"Steve" │
138138│"Cindy" │
139139└──────────┘
140−TutorialD (master/main): :showexpr sales
140+TutorialD (master): :showexpr sales
141141┌───────────┬─────────────┐
142142│amount::Int│product::Text│
143143├───────────┼─────────────┤
docs/merkle_transaction_graph.markdowndeleted−33
@@ -1,33 +0,0 @@
1−# Project:M36: Merkle Hashing for Transaction Graph
2−
3−## Introduction
4−
5−Project:M36 supports an append-only transaction graph model (similar to git) whereby new transactions can be added to the graph but not removed. As with any graph, each node can contain a Merkle hash which ensures not only that it's state since being added to the graph has not changed but also that none of its parent nodes all the way to the root node (initial state) have not been modified. This validation has a number of use cases.
6−
7−## Usage
8−
9−Project:M36 automatically adds Merkle hashes to every transaction. All data which represents the database state at that transaction is included in the hash including (but not limited to) relation variable definitions, atom and database context functions, constraints, and types.
10−
11−Project:M36 validates all merkle hashes at database startup. For users who need validation after the database is started, the user can issue `:validatemerklehashes` at the `tutd` command line.
12−
13−### Audit Logging
14−
15−Project:M36 supports audit logging by allowing users to travel to transactions in the past and recreate the database state at that past point-in-time. To ensure that those past states cannot be modified either by malicious on-disk or in-memory changes, each transaction is protected by its own Merkle hash. If the calculated hash does not match the stored hash, Project:M36 can immediately report which transaction triggered the tamper-proof log.
16−
17−### Reproducibility
18−
19−Since a Merkle tree is effectively immutable except to add more nodes, it can be used to save and restore a whole database with very high confidence in the results. This feature could also be used to restore a database partially; for example, to duplicate just the latest database state on a second machine for OLAP analysis.
20−
21−### High-Availability
22−
23−Merkle tree hashes can be used to assert database integrity across high-availibility or database replication. Since the hash covers all database state, it can be used to validate log-shipping-based replication. Corrupted cache tuple data can be easily detected and flushed.
24−
25−## Merkle Hashes in Other DBMSes
26−
27−While Merkle hashes have become prevalent in blockchain-style databases, they have not made many appearances in typical SQL databases. This is likely due to the fact that such databases consider any additional operations against the large tuple stores as prohibitively expensive. Project:M36 is able to skirt this cost by only hashing database update expressions rather than the result of these executed expressions. This also means that the Merkle hash can be computed against transactions which have been created but never executed.
28−
29−## Conclusion
30−
31−Merkle hashes are an obvious improvement to any graph-based transaction log and are a low-cost method of ensuring data integrity.
32−
33−A further improvement could allow users to specify an initial key provided by an admin user to salt the hash used to create the database. Additionally, a multi-user system could allow individual users to sign their committed transactions. The signature would then be included in the Merkle hash.
docs/new_datatypes.markdown+10−70
@@ -8,15 +8,13 @@ In addition, the Project:M36 runtime supports algebraic data types in the same v
88
99Project:M36 makes it easy to add any Haskell data type to the database. Any type which includes instances for a set of typeclasses can be supported.
1010
11−For storing Haskell record types as database tuples, see "[Converting data types to tuples](/docs/tupleable.markdown)."
12−
1311## Support for Runtime Types
1412
1513Use the ```tutd``` interpreter to create new type and data constructors with essentially the same syntax as in Haskell:
1614
1715```
18−TutorialD (master/main): data Hair = Bald | Brown | Blond | OtherColor Text
19−TutorialD (master/main): :showexpr relation{tuple{name "Steve", hair Blond}, tuple{name "Sam", hair OtherColor "Grey"}}
16+TutorialD (master): data Hair = Bald | Brown | Blond | OtherColor Text
17+TutorialD (master): :showexpr relation{tuple{name "Steve", hair Blond}, tuple{name "Sam", hair OtherColor "Grey"}}
2018┌─────────────────┬──────────┐
2119│hair::Hair │name::Text│
2220├─────────────────┼──────────┤
@@ -30,7 +28,7 @@ SQL's enumerations or even joins do not compare favorably to a genuine algebraic
3028Types can be forgotten as well:
3129
3230```
33−TutorialD (master/main): undata Hair
31+TutorialD (master): undata Hair
3432```
3533
3634These runtime types can therefore change between transactions. Note that the underlying data values do not change when the types change. Once changed, only new values will reflect the new data constructors.
@@ -41,71 +39,13 @@ Note that the Haskell-standard "Maybe a" and "Either a b" data types are include
4139
4240## Support for Haskell Types
4341
44−New algebraic data types can be added to the database context at any time via TutorialD or Haskell. Typeclasses for database types are not supported.
45−
46−### Implementation for Haskell Types
47−
48−Any Haskell ADT which implements the ```Atomable``` typeclass can be used directly as a database value or "atom" in Project:M36 parlance. The ```Atomable``` typeclass requires a set of prerequisite typeclasses be included, but, luckily, all of these typeclasses can be derived.
49−
50−Let's implement the ```Hair``` algebraic data type from the TutorialD example, but in Haskell. The full source code is available under the [examples directory](/examples/hair.hs).
51−
52−First, we define our data type and derive all the required typeclasses:
53−
54−```haskell
55−data Hair = Bald | Brown | Blond | OtherColor Text
56− deriving (Generic, Show, Eq, Binary, NFData, Atomable)
57−```
42+Any Haskell data type which is an instance of ```Atomable``` is a candidate for a Project:M36 value called an ```Atom```. Database tuples are composed of Atoms.
5843
59−Note that the ```Atomable``` instance can also be derived.
60−
61−After setting up the connection (which we elide here), the database context is loaded with the expression to define the data type.
62−
63−```haskell
64−executeDatabaseContextExpr sessionId conn (toAddTypeExpr (undefined :: Hair))
65−```
66−
67−Using a ```Proxy``` would also be acceptable, but the result would be the same.
68−
69−Next, we can create a relation variable named "people" containing our new data type alongside a person's name.
70−
71−```haskell
72− let blond = NakedAtomExpr (toAtom Blond)
73− executeDatabaseContextExpr sessionId conn (Assign "people" (MakeRelationFromExprs Nothing [
74− TupleExpr (M.fromList [("hair", blond), ("name", NakedAtomExpr (TextAtom "Colin"))])]))
75−```
44+Project:M36 does not yet support dynamically-loaded components, so the data type must be compiled into the Project:M36 backend.
7645
77−To demonstrate that the new value is fully integrated with the database, we can create a restriction which matches against the value in the database.
78−
79−```haskell
80−let restrictionPredicate = AttributeEqualityPredicate "hair" blond
81−peopleRelOrErr <- executeRelationalExpr sessionId conn (Restrict restrictionPredicate (RelationVariable "people" ()))
82−```
83−
84−Finally, we can print the resultant relation to show that it can be properly displayed (via the type's ```Show``` instance).
85−
86−```
87−TIO.putStrLn (showRelation peopleRel)
88−```
89−
90−```
91−┌──────────┬──────────┐
92−│hair::Hair│name::Text│
93−├──────────┼──────────┤
94−│Blond │"Colin" │
95−└──────────┴──────────┘
96−```
97−
98−Note here that ```Blond``` is not quoted because it is not a text value, but rather a real algebraic data type constructor honored by the database. The value is not a black box nor is an enumeration. Try, for example, replacing the ```Blond``` value with an ```OtherColor "Black"``` value to see how it appears and how it can be restricted against as well.
99−
100−The essential ```Atomable``` typeclass functions are:
101−
102−| Function | Purpose |
103−| -------- | ------- |
104−| ```toAtom :: a -> Atom``` | convert a Haskell data type to a database atom |
105−| ```fromAtom :: Atom -> a``` | convert a database atom to a Haskell data type |
106−| ```toAtomType :: Proxy a -> AtomType``` | generate a database AtomType for a Haskell datatype |
107−| ```toAddTypeExpr :: Proxy a -> DatabaseContextExpr``` | generate a ```DatabaseContextExpr``` which can be executed against a database context in order to add the new type |
108−
109−In addition, basic Haskell data types like ```Int```, ```Double```, ```Text```, ```Day```, ```Bool```, ```UTCTime```, and ```ByteString``` already have `Atomable` instances ready-to-go. In addition, an ```Atomable``` instance is available for lists: ```Atomable a => [a]```, though one should be very careful not to use this in a common anti-pattern. Typically, it makes more sense to store one-to-many relationships as discrete relation variables; when storing them as lists, one gives up the various query capabilities and optimizations of the relational algebra.
46+### Implementation for Haskell Types
11047
111−To be clear, these data types are not black boxes once stored in the database. These new types can be scanned and manipulated by Haskell scripts which can be created at runtime. For more information, read about [```AtomFunction```s](/docs/atomfunctions.markdown).
48+1. Create an instance of your data type for the ```Atomable``` typeclass. The ```Atomable``` typeclass implies instances for a variety of standard typeclasses.
49+1. Update the ```Binary Atom``` instance to include deserialization for your type.
50+1. Update the ```makeAtomFromText``` in ```ProjectM36/Atom.hs``` to support CSV import.
51+1. Optionally adjust ```TutorialD/Interpreter/RelationalExpression.hs``` to add support for parsing your data type in the TutorialD interpreter. Look for ```atomP```.
docs/on_null.markdown+5−5
@@ -345,10 +345,10 @@ But all we have really done is add even more NULLs. Retrieving a sensible value
345345## Runtime Types
346346
347347Project:M36 supports management of new algebraic data types at runtime. These types are associated with transactions and can changed over time whereas primitive Atoms cannot be changed.
348−
348+d
349349```
350−TutorialD (master/main): data Age = PreciseAge Int | ForgotToAsk | RefusedToDisclose | NotApplicable | ApproximateAge Int Int
351−TutorialD (master/main): :showexpr relation{tuple{name "Steve", age ApproximateAge 20 30}, tuple{name "Bob", age RefusedToDisclose}, tuple {name "Initech Corp.", age NotApplicable}}
350+TutorialD (master): data Age = PreciseAge Int | ForgotToAsk | RefusedToDisclose | NotApplicable | ApproximateAge Int Int
351+TutorialD (master): :showexpr relation{tuple{name "Steve", age ApproximateAge 20 30}, tuple{name "Bob", age RefusedToDisclose}, tuple {name "Initech Corp.", age NotApplicable}}
352352┌────────────────────┬───────────────┐
353353│age::Age │name::Text │
354354├────────────────────┼───────────────┤
@@ -361,8 +361,8 @@ TutorialD (master/main): :showexpr relation{tuple{name "Steve", age ApproximateA
361361Note that the two values which would normally be rendered as NULL in SQL are indeed proper values and can be distinguished. Three-valued logic makes no appearance. The type constructors can also have arguments:
362362
363363```
364−TutorialD (master/main): data Tree a = Node a (Tree a) (Tree a) | EmptyNode
365−TutorialD (master/main): :showexpr relation{tuple{family "Stevenson", familytree Node "Jim" (Node "Cindy" EmptyNode EmptyNode) (Node "Mike" EmptyNode EmptyNode)}}
364+TutorialD (master): data Tree a = Node a (Tree a) (Tree a) | EmptyNode
365+TutorialD (master): :showexpr relation{tuple{family "Stevenson", familytree Node "Jim" (Node "Cindy" EmptyNode EmptyNode) (Node "Mike" EmptyNode EmptyNode)}}
366366┌────────────┬───────────────────────────────────────────────────────────────────────────────┐
367367│family::Text│familytree::Tree (a::Text) │
368368├────────────┼───────────────────────────────────────────────────────────────────────────────┤
docs/persistent_library_driver.markdownnew file+18
@@ -0,0 +1,18 @@
1+# Project:M36 Persistent Library Driver
2+
3+Project:M36 includes a driver for the [persistent](https://hackage.haskell.org/package/persistent) library which offers lowest-common-denominator DBMS support for storing and retrieving Haskell-based datatypes. While the persistent library does not support every Project:M36 feature, it can nonetheless be handy for simple use-cases and database-agnostic mapping.
4+
5+For the most part, using the Project:M36 driver should be identical to using other drivers.
6+
7+## Setup
8+
9+Use ```withProjectM36Conn``` with a configuration argument to add a ReaderT to your monad stack. The, follow that with ```runProjectM36Conn``` to run the monad.
10+
11+## Usage
12+
13+At this point, all persistent functions are available. The driver always commits to the "master" branch.
14+
15+## Caveats
16+
17+* Not every persistent data type is supported yet.
18+* Tuple ordering in selects is not yet supported.
docs/projectm36_client_library.markdown+1−15
@@ -2,8 +2,6 @@
22
33The Project:M36 client library is the preferred method for interacting with Project:M36 databases. It supports all features of the DBMS while other interfaces may not.
44
5−**Note:** A less featureful but more convenient client API also is available: see [documentation](simple_api.markdown).
6−
75The client supports both in-process and remote Project:M36 access.
86
97## Setup
@@ -12,7 +10,7 @@ The client supports both in-process and remote Project:M36 access.
1210```haskell
1311import ProjectM36.Client
1412```
15−2. Create a Connection with a `ConnectionInfo` in the Either monad
13+2. Create a Connection with a ConnectionInfo in the Either monad
1614```haskell
1715conn <- connectProjectM36 (InProcessConnectionInfo NoPersistence)
1816```
@@ -32,18 +30,6 @@ maybeErr <- executeDatabaseContextExpr conn (Define "person" (attributesFromList
3230maybeErr <- executeGraphExpr conn (JumpToHead "branch2")
3331```
3432
35−## Dealing with Concurrency
36−
37−As in all databases, transactions contend concurrently for access to the the latest database state. Unlike most DBMSs, Project:M36 features multiple heads to reduce contention. Still, at a high transaction rate, Project:M36 clients would still be likely to receive lots of ```TransactionIsNotAHeadError```s because the server's head has received additional commits by the time a client wants to commit its own transaction. To reduce the incidence of this error, the server offers an ```autoMergeToHead``` function which:
38−
39−1. creates a temporary branch
40−1. commits the current disconnected transaction to the temporary branch
41−1. attempts a merge back to the original branch
42−
43−The operations above occur atomically on the server. The purpose of this "automerge" is to reduce reliance on repeated client attempts to commit when head contention is high. The trade-off is that the client must handle any merge errors or use a different merge strategy.
44−
45−This feature is similar to git's ```rebase``` functionality except that the merge occurs server side and is fully validated and committed, if possible.
46−
4733## Cleanup
4834
49351. Close the connection
docs/reaching_out_of_the_tarpit.markdown+9−8
@@ -2,11 +2,11 @@
22
33## Introduction
44
5−[Project:M36](https://github.com/agentm/project-m36) is a relational algebra database management system (RDBMS) written in the Haskell programming language whose purpose is to implement the foundation for functional relational programming as described in the excellent paper ["Out of the Tarpit"](https://github.com/papers-we-love/papers-we-love/blob/2eb8d21/design/out-of-the-tar-pit.pdf). This document describes how Project:M36 meets the design goals laid out in the paper.
5+[Project:M36](https://github.com/agentm/project-m36) is a relational algebra database management system (RDBMS) written in the Haskell programming language whose purpose is to implement the foundation for functional relational programming as described in the excellent paper ["Out of the Tarpit"](http://shaffner.us/cs/papers/tarpit.pdf). This document describes how Project:M36 meets the design goals laid out in the paper.
66
77## Why is "Out of the Tarpit" Important?
88
9−The "Out of the Tarpit" paper, written in 2006, consolidates decades of software development research and experience to explain why software written today is chock-full of software bugs. The paper categorizes sources of complexity and then proceeds to propose a software architecture which promises to reduce unnecessary software complexity so that the resultant software is maximally focused on actual business rules. It is recommended to read [the paper](https://github.com/papers-we-love/papers-we-love/blob/2eb8d21/design/out-of-the-tar-pit.pdf) before reading the remainder of this document.
9+The "Out of the Tarpit" paper, written in 2006, consolidates decades of software development research and experience to explain why software written today is chock-full of software bugs. The paper categorizes sources of complexity and then proceeds to propose a software architecture which promises to reduce unnecessary software complexity so that the resultant software is maximally focused on actual business rules. It is recommended to read [the paper](http://shaffner.us/cs/papers/tarpit.pdf) before reading the remainder of this document.
1010
1111## Laying the Foundations for Reduced Complexity
1212
@@ -21,14 +21,14 @@ The central software component of functional-relational programming is a relatio
2121* **declarative**: thus removing accidental complexity (such as accidental ordering)
2222* **restricted**: removing mistaken features; if a programming language allows a programmer to do something less-than-savory, then that misfeature will be used
2323
24−and provides ([p.37](https://github.com/papers-we-love/papers-we-love/blob/2eb8d21/design/out-of-the-tar-pit.pdf)):
24+and provides ([p.37](http://shaffner.us/cs/papers/tarpit.pdf)):
2525
2626* **structure**: a closed world system whereby all data is represented by relations
2727* **manipulation**: a means to simulate mutation of the application state over time
2828* **data integrity**: constraints which prevent illogical data constructions
2929* **data independence**: logical and physical representations of state which are clearly separated
3030
31−The relational model is a mathematical model for storing and manipulating "essential state" ([p.25](https://github.com/papers-we-love/papers-we-love/blob/2eb8d21/design/out-of-the-tar-pit.pdf)). As a mathematical model, it not beholden to any specific implementation or quirks.
31+The relational model is a mathematical model for storing and manipulating "essential state" ([p.25](http://shaffner.us/cs/papers/tarpit.pdf)). As a mathematical model, it not beholden to any specific implementation or quirks.
3232
3333Unfortunately, due to the quirks of legacy implementations, much of what developers learn about the relational model is [wrong](/docs/on_null.markdown). Project:M36 aims to rectify this situation by providing a mathematically coherent implementation of the relational model. Contrast the mathematical approach to existing databases which sacrifice or elide a mathematical model in lieu of "performance". Refer to [Knuth on premature optimization](https://en.wikiquote.org/wiki/Donald_Knuth) for additional details.
3434
@@ -51,14 +51,15 @@ Project:M36 implements multiple interfaces:
5151
5252* an interactive console implementing [TutorialD](https://en.wikipedia.org/wiki/D_%28data_language_specification%29), a small language for learning about the relational algebra
5353* a native Haskell API
54+* a database driver for the [persistent framework](http://www.yesodweb.com/book/persistent)
5455
5556### Real Estate Database Example
5657
5758To 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:
5859
5960```
60−TutorialD (master/main): :importexample cjdate
61−TutorialD (master/main): :showexpr p
61+TutorialD (master): :importexample date
62+TutorialD (master): :showexpr p
6263┌───────────────────┬────────────┬───────────────────┬────────────┬────────────┐
6364│address::Address │agent::Agent│dateRegistered::Day│photo::Text │price::Price│
6465├───────────────────┼────────────┼───────────────────┼────────────┼────────────┤
@@ -70,7 +71,7 @@ TutorialD (master/main): :showexpr p
7071
7172### Infrastructure Requirements
7273
73−Project:M36 meets or exceeds the enumerated "Infrastructure" ([p.47](https://github.com/papers-we-love/papers-we-love/blob/2eb8d21/design/out-of-the-tar-pit.pdf)) requirements (except one):
74+Project:M36 meets or exceeds the enumerated "Infrastructure" ([p.47](http://shaffner.us/cs/papers/tarpit.pdf)) requirements (except one):
7475
7576* **Infrastructure for Essential State**: relation variable manipulation, storage, and data types
7677* **Infrastructure for Essential Logic**: relational expression evaluation, functions to operate on values, a language (TutorialD or Haskell), type inference, and constraints
@@ -82,7 +83,7 @@ Derived relations, as described in the paper, are not supported in Project:M36 b
8283
8384### Feeders and Observers
8485
85−The "Out of the Tarpit" paper distinguishes between pushing data to the database and pulling data out of the database ([p.46](https://github.com/papers-we-love/papers-we-love/blob/2eb8d21/design/out-of-the-tar-pit.pdf)): "feeders" continually update the state of the database to best reflect reality and "observers" request notifications on relational state changes and take action on them.
86+The "Out of the Tarpit" paper distinguishes between pushing data to the database and pulling data out of the database ([p.46](http://shaffner.us/cs/papers/tarpit.pdf)): "feeders" continually update the state of the database to best reflect reality and "observers" request notifications on relational state changes and take action on them.
8687
8788SQL developers are already intimately familiar with "feeders"- these are merely INSERT and UPDATE statements issued to the database via some middleware.
8889
docs/replication.markdowndeleted−30
@@ -1,30 +0,0 @@
1−# Project:M36 Multi-Node Replication
2−
3−## Introduction
4−
5−The stored transaction graph feature makes Project:M36 naturally more suitable for replication. Just like with git, having access to historical transactions makes merging transactional data much more logical and unambiguous.
6−
7−## Current Multi-Master Support
8−
9−Project:M36 plans to support logical replication in the future. In the meantime, multi-master replication is supported through shared database directories. Using NFS or SMB shares where file locking is properly supported, one can run multiple ```project-m36-server``` instances on the same database directory. This is a shared-storage form of multi-master operation.
10−
11−Multi-master replication is enabled and reasonably fast due to the intentional design decision to rewrite as few files as possible. Typical databases write and rewrite the same files which back relation variables (or tables) directly which necessitates heavy use of file locking or even locks on file content regions. Project:M36 operates on a write-once, read-many (WORM) principle whereby transaction data can be written without holding locks so only the transaction graph itself needs synchronization.
12−
13−Multi-master support can also be useful for simple databases where one wishes to avoid running and maintaining a ```project-m36-server```. Instead, one can create in-process database instances which share the same database directory. This is similar to the use-case for SQLite. However, Project:M36 seamlessly supports server and in-process modes which makes moving from a small, local database to a larger server installation trivial; the storage format is identical.
14−
15−To use the simple multi-master mode, start two instances of ```project-m36-server``` which point at the same local or remote database directory over NFS or SMB. No further configuration is required.
16−
17−## Caveats
18−
19−Project:M36 does not and cannot detect if the filesystem's implementation of file locking is actually functioning.
20−
21−On Linux and macOS, any recent on-disk filesystems and NFS should support POSIX advisory locking, as required. However, sharing the database over samba (SMB) shares or mixed operating systems may result in database transaction graph corruption. The symptom will be that arbitrary, committed transactions may be missing from the transaction graph.
22−
23−On Windows, locking is implemented using mandatory locking controls which any supported version of Windows offers. Cross-platform use of locking (such as with samba server on Linux) is probably *not* safe.
24−
25−If a commit happens behind the back of another ```project-m36-server``` and one server attempts to commit, two possibilities can occur:
26−
27−1. The commits occurred on two disparate branches, so the transaction graph can be updated without conflict.
28−1. The commits occurred on the same branch, so one transaction commit will be rejected with a ```TransactionIsNotAHead``` error. This means that the head (leaf node) of the transaction graph for that branch has moved on, so the transaction needs to be re-executed and committed.
29−
30−To avoid ```TransactionIsNotAHead``` errors, branch the transaction graph and merge it to the head when ready to commit.
docs/sample_session.asciinema.jsondeleted−698
@@ -1,698 +0,0 @@
1−{
2− "width": 106,
3− "version": 1,
4− "command": "cabal run tutd",
5− "env": {
6− "TERM": "xterm",
7− "SHELL": "/bin/bash"
8− },
9− "title": null,
10− "duration": 24.316792,
11− "stdout": [
12− [
13− 0.2,
14− "Project:M36 TutorialD Interpreter v0.1\r\nType \":help\" for more information.\r\nA full tutorial is available at:\r\nhttps://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown\r\n"
15− ],
16− [
17− 0.001718,
18− "\u001b[?1h\u001b="
19− ],
20− [
21− 0.000592,
22− "TutorialD (master/main): "
23− ],
24− [
25− 0.2,
26− ":"
27− ],
28− [
29− 0.2,
30− "i"
31− ],
32− [
33− 0.055531,
34− "m"
35− ],
36− [
37− 0.192404,
38− "p"
39− ],
40− [
41− 0.11147,
42− "o"
43− ],
44− [
45− 0.071958,
46− "r"
47− ],
48− [
49− 0.080339,
50− "t"
51− ],
52− [
53− 0.2,
54− "e"
55− ],
56− [
57− 0.2,
58− "x"
59− ],
60− [
61− 0.128138,
62− "a"
63− ],
64− [
65− 0.063792,
66− "m"
67− ],
68− [
69− 0.119902,
70− "p"
71− ],
72− [
73− 0.056217,
74− "l"
75− ],
76− [
77− 0.047737,
78− "e"
79− ],
80− [
81− 0.128253,
82− " "
83− ],
84− [
85− 0.136357,
86− "d"
87− ],
88− [
89− 0.103477,
90− "a"
91− ],
92− [
93− 0.175974,
94− "t"
95− ],
96− [
97− 0.063923,
98− "e"
99− ],
100− [
101− 0.2,
102− "\r\r\n\u001b[?1l\u001b>"
103− ],
104− [
105− 0.008662,
106− "\u001b[?1h\u001b="
107− ],
108− [
109− 0.00153,
110− "TutorialD (master/main): "
111− ],
112− [
113− 0.2,
114− ":"
115− ],
116− [
117− 0.104105,
118− "s"
119− ],
120− [
121− 0.183516,
122− "h"
123− ],
124− [
125− 0.087945,
126− "o"
127− ],
128− [
129− 0.104142,
130− "w"
131− ],
132− [
133− 0.151885,
134− "e"
135− ],
136− [
137− 0.143932,
138− "x"
139− ],
140− [
141− 0.104321,
142− "p"
143− ],
144− [
145− 0.079628,
146− "r"
147− ],
148− [
149− 0.2,
150− " "
151− ],
152− [
153− 0.1122,
154− "s"
155− ],
156− [
157− 0.2,
158− "\r\r\n\u001b[?1l\u001b>┌──────────┬────────┬───────────┬───────────┐\r\n│city::Text│s#::Text│sname::Text│status::Int│\r\n├──────────┼────────┼───────────┼───────────┤\r\n│\"London\" │\"S1\" │\"Smith\" │20 │\r\n│\"Paris\" │\"S2\" │\"Jones\" │10 │\r\n│\"Athens\" │\"S5\" │\"Adams\" │30 │\r\n│\"London\" │\"S4\" │\"Clark\" │20 │\r\n│\"Paris\" │\"S3\" │\"Blake\" │30 │\r\n└──────────┴────────┴───────────┴───────────┘\r\n\u001b[?1h\u001b=TutorialD (master/main): "
159− ],
160− [
161− 0.2,
162− ":"
163− ],
164− [
165− 0.111647,
166− "c"
167− ],
168− [
169− 0.152667,
170− "o"
171− ],
172− [
173− 0.167341,
174− "m"
175− ],
176− [
177− 0.119859,
178− "m"
179− ],
180− [
181− 0.096716,
182− "i"
183− ],
184− [
185− 0.119257,
186− "t"
187− ],
188− [
189− 0.2,
190− "\r\r\n\u001b[?1l\u001b>\u001b[?1h\u001b=TutorialD (master/main): "
191− ],
192− [
193− 0.2,
194− "u"
195− ],
196− [
197− 0.167482,
198− "p"
199− ],
200− [
201− 0.096462,
202− "d"
203− ],
204− [
205− 0.111253,
206− "a"
207− ],
208− [
209− 0.184108,
210− "t"
211− ],
212− [
213− 0.064042,
214− "e"
215− ],
216− [
217− 0.2,
218− " "
219− ],
220− [
221− 0.111591,
222− "s"
223− ],
224− [
225− 0.128469,
226− " "
227− ],
228− [
229− 0.175518,
230− "w"
231− ],
232− [
233− 0.144105,
234− "h"
235− ],
236− [
237− 0.048299,
238− "e"
239− ],
240− [
241− 0.079467,
242− "r"
243− ],
244− [
245− 0.088055,
246− "e"
247− ],
248− [
249− 0.080003,
250− " "
251− ],
252− [
253− 0.135866,
254− "s"
255− ],
256− [
257− 0.135942,
258− "t"
259− ],
260− [
261− 0.144231,
262− "a"
263− ],
264− [
265− 0.151919,
266− "t"
267− ],
268− [
269− 0.072604,
270− "u"
271− ],
272− [
273− 0.119474,
274− "s"
275− ],
276− [
277− 0.2,
278− "="
279− ],
280− [
281− 0.119565,
282− "1"
283− ],
284− [
285− 0.104176,
286− "0"
287− ],
288− [
289− 0.2,
290− " "
291− ],
292− [
293− 0.2,
294− "("
295− ],
296− [
297− 0.2,
298− "s"
299− ],
300− [
301− 0.071461,
302− "n"
303− ],
304− [
305− 0.095864,
306− "a"
307− ],
308− [
309− 0.064051,
310− "m"
311− ],
312− [
313− 0.079861,
314− "e"
315− ],
316− [
317− 0.2,
318− ":"
319− ],
320− [
321− 0.2,
322− "="
323− ],
324− [
325− 0.2,
326− "\""
327− ],
328− [
329− 0.2,
330− "B"
331− ],
332− [
333− 0.2,
334− "r"
335− ],
336− [
337− 0.047915,
338− "o"
339− ],
340− [
341− 0.136296,
342− "w"
343− ],
344− [
345− 0.111536,
346− "n"
347− ],
348− [
349− 0.2,
350− "\""
351− ],
352− [
353− 0.2,
354− ")"
355− ],
356− [
357− 0.2,
358− "\r\r\n\u001b[?1l\u001b>\u001b[?1h\u001b=TutorialD (master/main): "
359− ],
360− [
361− 0.2,
362− ":"
363− ],
364− [
365− 0.16013,
366− "s"
367− ],
368− [
369− 0.177054,
370− "h"
371− ],
372− [
373− 0.126864,
374− "o"
375− ],
376− [
377− 0.080048,
378− "w"
379− ],
380− [
381− 0.152076,
382− "e"
383− ],
384− [
385− 0.151824,
386− "x"
387− ],
388− [
389− 0.087864,
390− "p"
391− ],
392− [
393− 0.112243,
394− "r"
395− ],
396− [
397− 0.119825,
398− " "
399− ],
400− [
401− 0.144166,
402− "s"
403− ],
404− [
405− 0.133271,
406− "\r\r\n\u001b[?1l\u001b>┌──────────┬────────┬───────────┬───────────┐\r\n│city::Text│s#::Text│sname::Text│status::Int│\r\n├──────────┼────────┼───────────┼───────────┤\r\n│\"London\" │\"S1\" │\"Smith\" │20 │\r\n│\"London\" │\"S4\" │\"Clark\" │20 │\r\n│\"Paris\" │\"S2\" │\"Brown\" │10 │\r\n│\"Paris\" │\"S3\" │\"Blake\" │30 │\r\n│\"Athens\" │\"S5\" │\"Adams\" │30 │\r\n└──────────┴────────┴───────────┴───────────┘\r\n\u001b[?1h\u001b=TutorialD (master/main): "
407− ],
408− [
409− 0.2,
410− ":"
411− ],
412− [
413− 0.158771,
414− "c"
415− ],
416− [
417− 0.120698,
418− "o"
419− ],
420− [
421− 0.183311,
422− "m"
423− ],
424− [
425− 0.103802,
426− "m"
427− ],
428− [
429− 0.176006,
430− "i"
431− ],
432− [
433− 0.063964,
434− "t"
435− ],
436− [
437− 0.2,
438− "\r\r\n\u001b[?1l\u001b>\u001b[?1h\u001b=TutorialD (master/main): "
439− ],
440− [
441− 0.2,
442− ":"
443− ],
444− [
445− 0.128345,
446− "s"
447− ],
448− [
449− 0.143177,
450− "h"
451− ],
452− [
453− 0.087961,
454− "o"
455− ],
456− [
457− 0.048264,
458− "w"
459− ],
460− [
461− 0.2,
462− "g"
463− ],
464− [
465− 0.039639,
466− "r"
467− ],
468− [
469− 0.17622,
470− "a"
471− ],
472− [
473− 0.039756,
474− "p"
475− ],
476− [
477− 0.199951,
478− "h"
479− ],
480− [
481− 0.2,
482− "\r\r\n\u001b[?1l\u001b>┌─────────────┬──────────┬──────────────────────────────────────┬────────────────────────────────────────┐\r\n│current::Bool│head::Text│id::Text │parents::relation {id::Text} │\r\n├─────────────┼──────────┼──────────────────────────────────────┼────────────────────────────────────────┤\r\n│False │\"\" │\"0ef17e3f-3a1d-405f-8295-8d4efedd0fbc\"│┌────────┐ │\r\n│ │ │ ││id::Text│ "
483− ],
484− [
485− 7.9e-05,
486− "│\r\n│ │ │ │└────────┘ │\r\n│False │\"\" │\"495aba99-e3a2-4b3e-9314-2ad1ae5cfb79\"│┌──────────────────────────────────────┐│\r\n│ │ │ ││id::Text ││\r\n│ │ │ │├──────────────────────────────────────┤│\r\n│ │ │ ││\"0ef17e3f-3a1d-405f-8295-8d4efedd0fbc\"││\r\n│ │ │ │└──────────────────────────────────────┘│\r\n│True │\"master\" │\"a314db18-8f"
487− ],
488− [
489− 6.4e-05,
490− "c2-40f2-b976-73d539b0361d\"│┌──────────────────────────────────────┐│\r\n│ │ │ ││id::Text ││\r\n│ │ │ │├──────────────────────────────────────┤│\r\n│ │ │ ││\"495aba99-e3a2-4b3e-9314-2ad1ae5cfb79\"││\r\n│ │ │ │└──────────────────────────────────────┘│\r\n└─────────────┴──────────┴──────────────────────────────────────┴───────────"
491− ],
492− [
493− 4.7e-05,
494− "─────────────────────────────┘\r\n\u001b[?1h\u001b=TutorialD (master/main): "
495− ],
496− [
497− 0.2,
498− ":"
499− ],
500− [
501− 0.2,
502− "j"
503− ],
504− [
505− 0.152377,
506− "u"
507− ],
508− [
509− 0.2,
510− "m"
511− ],
512− [
513− 0.039851,
514− "p"
515− ],
516− [
517− 0.2,
518− " "
519− ],
520− [
521− 0.2,
522− "495aba99-e3a2-4b3e-9314-2ad1ae5cfb79"
523− ],
524− [
525− 0.2,
526− "\r\r\n\u001b[?1l\u001b>\u001b[?1h\u001b=TutorialD (<unknown>/main): "
527− ],
528− [
529− 0.2,
530− ":"
531− ],
532− [
533− 0.143696,
534− "s"
535− ],
536− [
537− 0.167859,
538− "h"
539− ],
540− [
541− 0.104263,
542− "o"
543− ],
544− [
545− 0.071693,
546− "w"
547− ],
548− [
549− 0.151967,
550− "e"
551− ],
552− [
553− 0.168045,
554− "x"
555− ],
556− [
557− 0.144117,
558− "p"
559− ],
560− [
561− 0.2,
562− "r"
563− ],
564− [
565− 0.2,
566− " "
567− ],
568− [
569− 0.135504,
570− "s"
571− ],
572− [
573− 0.2,
574− "\r\r\n\u001b[?1l\u001b>┌──────────┬────────┬───────────┬───────────┐\r\n│city::Text│s#::Text│sname::Text│status::Int│\r\n├──────────┼────────┼───────────┼───────────┤\r\n│\"London\" │\"S1\" │\"Smith\" │20 │\r\n│\"Paris\" │\"S2\" │\"Jones\" │10 │\r\n│\"Athens\" │\"S5\" │\"Adams\" │30 │\r\n│\"London\" │\"S4\" │\"Clark\" │20 │\r\n│\"Paris\" │\"S3\" │\"Blake\" │30 │\r\n└──────────┴────────┴───────────┴───────────┘\r\n\u001b[?1h\u001b=TutorialD (<unknown>/main): "
575− ],
576− [
577− 0.2,
578− ":"
579− ],
580− [
581− 0.2,
582− "j"
583− ],
584− [
585− 0.143719,
586− "u"
587− ],
588− [
589− 0.2,
590− "m"
591− ],
592− [
593− 0.095645,
594− "p"
595− ],
596− [
597− 0.2,
598− "h"
599− ],
600− [
601− 0.056449,
602− "e"
603− ],
604− [
605− 0.103323,
606− "a"
607− ],
608− [
609− 0.096088,
610− "d"
611− ],
612− [
613− 0.09627,
614− " "
615− ],
616− [
617− 0.119791,
618− "m"
619− ],
620− [
621− 0.079863,
622− "a"
623− ],
624− [
625− 0.072117,
626− "s"
627− ],
628− [
629− 0.119772,
630− "t"
631− ],
632− [
633− 0.112046,
634− "e"
635− ],
636− [
637− 0.064171,
638− "r"
639− ],
640− [
641− 0.2,
642− "\r\r\n\u001b[?1l\u001b>\u001b[?1h\u001b=TutorialD (master/main): "
643− ],
644− [
645− 0.2,
646− ":"
647− ],
648− [
649− 0.2,
650− "s"
651− ],
652− [
653− 0.127111,
654− "h"
655− ],
656− [
657− 0.087829,
658− "o"
659− ],
660− [
661− 0.080193,
662− "w"
663− ],
664− [
665− 0.135516,
666− "e"
667− ],
668− [
669− 0.152046,
670− "x"
671− ],
672− [
673− 0.112287,
674− "p"
675− ],
676− [
677− 0.09584,
678− "r"
679− ],
680− [
681− 0.2,
682− " "
683− ],
684− [
685− 0.168135,
686− "s"
687− ],
688− [
689− 0.2,
690− "\r\r\n\u001b[?1l\u001b>┌──────────┬────────┬───────────┬───────────┐\r\n│city::Text│s#::Text│sname::Text│status::Int│\r\n├──────────┼────────┼───────────┼───────────┤\r\n│\"Paris\" │\"S3\" │\"Blake\" │30 │\r\n│\"Athens\" │\"S5\" │\"Adams\" │30 │\r\n│\"Paris\" │\"S2\" │\"Brown\" │10 │\r\n│\"London\" │\"S1\" │\"Smith\" │20 │\r\n│\"London\" │\"S4\" │\"Clark\" │20 │\r\n└──────────┴────────┴───────────┴───────────┘\r\n\u001b[?1h\u001b=TutorialD (master/main): "
691− ],
692− [
693− 0.2,
694− "\r\r\n\u001b[?1l\u001b>"
695− ]
696− ],
697− "height": 39
698−}
docs/server_mode.markdown+2−2
@@ -8,7 +8,7 @@ While Project:M36 is easy-to-use as an interactive, in-process database manageme
88
99To start the Project:M36 server to serve the local host with a database named "mydbname", run ```cabal run project-m36-server -- --database mydbname --hostname 127.0.0.1``` in the project-m36 source directory. The double-dash indicates that the arguments should be passed to ```project-m36-server``` instead of ```cabal```. Under normal conditions, this command will print nothing and block indefinitely to serve incoming requests on the default port 6543.
1010
11−Note that the above invocation will serve an in-memory, transient "mydbname" database. The database is deleted when the server exits. To serve a database with filesystem persistence, invoke ```cabal run project-m36-server -- --database mydbname --hostname 127.0.0.1 --database-directory /path/to/dbdirectory --fsync```.
11+Note that the above invocation will serve and in-memory, transient "mydbname" database. The database is deleted when the server exits. To serve a database with filesystem persistence, invoke ```cabal run project-m36-server -- --database mydbname --hostname 127.0.0.1 --database-directory /path/to/dbdirectory --fsync```.
1212
1313## Connecting an Interactive Client
1414
@@ -16,6 +16,6 @@ To start an interactive session with the server, run ```cabal run tutd -- --data
1616
1717## Connecting a Haskell Client
1818
19−Connecting to a local or remote database uses the same API found in ```ProjectM36.Client```. See [this annotated example](../examples/SimpleClient.hs) for more information.
19+Connecting to a local or remote database uses the same API found in ```ProjectM36.Client```. See [this annotated example](examples/SimpleClient.hs) for more information.
2020
2121
docs/simple_api.markdowndeleted−42
@@ -1,42 +0,0 @@
1−# The Project:M36 Simple Client Interface
2−
3−## Introduction
4−
5−For common use cases, the `ProjectM36.Client.Simple` API can assist in transaction management. The API is designed to be less overwhelming than the full-featured `ProjectM36.Client` (see [documentation](projectm36_client_library.markdown)).
6−
7−As such, not all features are available through the simple API, but, because the simple API is a thin layer over the complete API, the user may dip into the complete API at any time.
8−
9−## Usage
10−
11− 1. Create a `DbConn` to connect to the database:
12−
13− ```haskell
14− import ProjectM36.Client.Simple
15− ...
16− let connInfo = InProcessConnectionInfo (CrashSafePersistence "my.db") emptyNotificationCallback []
17− eDbconn <- simpleConnectProjectM36 connInfo
18− ```
19−
20− The result is `Either` a `DbError` or a connection linked to the `"master"` branch of the database.
21−
22− 1. Run the `Db` monad using `withTransaction`:
23−
24− ```haskell
25− withTransaction dbconn $ do
26− execute $ Assign "x" (ExistingRelation relationTrue)
27− query $ RelationVariable "x" ()
28− ```
29−
30− If there is an error in the above update or query, then an exception is thrown behind the scenes which cancels the transactions, rolls back any changes, and the error is returned by `withTransaction`.
31−
32− `query` is used with `RelationalExpr` queries which read the current database state.
33−
34− `execute` is used with `DatabaseContextExpr` values which write the current database state.
35−
36− To execute a query without cancelling the transaction on an error, use the `queryOrErr` and `executeOrErr` variants.
37−
38− 1. Close the connection:
39−
40− ```haskell
41− close dbconn
42− ```
docs/transaction_graph_operators.markdown+25−47
@@ -10,11 +10,23 @@ When a new database is created, a new transaction graph is created for it with o
1010
1111As the user interactively alters the database context such as by adding a new relation variable, the database context is no longer equal to that of the first transactions. This is called "database context divergence" because many of the same components exist in both the updated context and the context of the first transaction.
1212
13−![Initial database starting state](http://g.gravizo.com/g?%20digraph%20G%20{%20base[label=%22base%20transaction%22,shape=rectangle];%20new[label=%22mutable%20database%20context%22];%20new%20-%3E%20base;%20})
13+![Initial database starting state](http://g.gravizo.com/g?
14+digraph G {
15+ base[label="base transaction",shape=rectangle];
16+ new[label="mutable database context"];
17+ new -> base;
18+})
1419
1520Once the user decides that the changes in the updated database context are worth adding to the transaction graph, the user issues a "commit" request. The commit operation converts the current database context into a new transaction which is then added to the graph with the parent transaction set to the same parent transaction as the database context. The user's mutable database context is shifted to be a copy of the context of the newly-committed transaction.
1621
17−![Freshly committed transaction](http://g.gravizo.com/g?%20digraph%20G%20{%20base[label=%22base%20transaction%22,shape=rectangle];%20discon[label=%22mutable%20database%20context%22];%20fresh[label=%22newly%20committed%20transaction%22,shape=rectangle];%20fresh%20-%3E%20base;%20discon%20-%3E%20fresh;%20})
22+![Freshly committed transaction](http://g.gravizo.com/g?
23+digraph G {
24+ base[label="base transaction",shape=rectangle];
25+ discon[label="mutable database context"];
26+ fresh[label="newly committed transaction",shape=rectangle];
27+ fresh -> base;
28+ discon -> fresh;
29+})
1830
1931It can be handy to attempt to modify the database without altering the data that others may wish to continue to use and modify. If a set of transactions may diverge from another use-case for the data, the user may choose to "branch" the transaction graph. Branching allows the user to assign an arbitrary name to a series of transactions and then potentially merge the set of transactions back to the originating branch. Project:M36 creates a "master" branch when the transaction graph is first created.
2032
@@ -25,7 +37,7 @@ Note that this transaction graph approach is different from that of most SQL DBM
2537To convert a mutable database context into a transaction, it must be "committed" to the transaction graph. The equivalent in SQL is COMMIT.
2638
2739```
28−TutorialD (master/main): :commit
40+TutorialD (master): :commit
2941```
3042
3143Once committed, the transaction's database context becomes immutable. Internally, Project:M36 uniquely identifies each transaction with a UUID.
@@ -35,7 +47,7 @@ Once committed, the transaction's database context becomes immutable. Internally
3547Sometimes, the user determines that the changes in the mutable database context can be discarded and the context reset to be a copy of its parent's transaction. This is called a "rollback" because it rolls back to a previous known state. The equivalent in SQL is ROLLBACK.
3648
3749```
38−TutorialD (master/main): :rollback
50+TutorialD (master): :rollback
3951```
4052
4153#### Show Transaction Graph
@@ -43,31 +55,27 @@ TutorialD (master/main): :rollback
4355In order to navigate the transaction graph, one must specify transaction UUIDs. Viewing the entirety of the transaction graph as a relation is a single command.
4456
4557```
46−┌─────────────┬────────────────────────────────────────────┬──────────┬──────────────────────────────────────┬────────────────────────────────────────┬─────────────────────────────────┐
47−│current::Bool│hash::ByteString │head::Text│id::Text │parents::relation {id::Text} │stamp::DateTime │
48−├─────────────┼────────────────────────────────────────────┼──────────┼──────────────────────────────────────┼────────────────────────────────────────┼─────────────────────────────────┤
49−
50−
58+TutorialD (master): :showgraph
59+┌───────┬──────┬────────────────────────────────────┬───────┐
60+│current│head │id │parents│
61+├───────┼──────┼────────────────────────────────────┼───────┤
5162<big result elided>
5263```
5364The "current" attribute is a boolean value. If true, the transaction is the parent of the current database context. Commits will be children of this transaction.
5465
55−The "hash" attribute contains the merkle tree hash for the given transaction. This can be used to ensure that the transaction graph has been used in an append-only fashion, ensuring historical state and audit log integrity.
56−
57−The "head" attribute is a boolean value indicating whether or not the transaction is a "head" node of its graph. Head nodes are nodes which have no children.
66+The "head attribute is a boolean value indicating whether or not the transaction is a "head" node of its graph. Head nodes are nodes which have no children.
5867
5968The "id" attribute is the UUID needed in order to navigate the graph.
6069
6170The "parents" attribute is a subrelation holding all parent transaction UUIDs for the given transaction.
6271
63−The "stamp" attribute marks the time when the transaction was opened.
6472
6573#### Branch
6674
6775A new branch can be create from any point in the transaction. A branch associates a human-readable name with a set of transactions diverging from a parent transaction. After a branch, there are two heads to which one could commit.
6876
6977```
70−TutorialD (master/main): :branch testing_data_2005
78+TutorialD (master): :branch testing_data_2005
7179TutorialD (testing_data_2005):
7280```
7381
@@ -81,7 +89,7 @@ Note that jumping to another head implies losing any changes in the current data
8189
8290```
8391TutorialD (testing_data_2005): :jumphead master
84−TutorialD (master/main):
92+TutorialD (master):
8593```
8694
8795Further commits will be added to the target branch.
@@ -96,42 +104,12 @@ Instead of jumping to the head of a branch for the purpose of adding more commit
96104If one jumps to a non-head transaction, committing new transactions are no longer possible because the past transactions cannot be overwritten.
97105
98106```
99−TutorialD (master/main): :jump 11b601c9-f46b-42b0-a2ce-cf18ced31b7f
100−TutorialD (11b601c9-f46b-42b0-a2ce-cf18ced31b7f):
107+TutorialD (master): :jump 11b601c9-f46b-42b0-a2ce-cf18ced31b7f
108+TutorialD (11b601c9-f46b-42b0-a2ce-cf18ced31b7f):
101109```
102110
103111Note that the ```tutd``` prompt now indicates that the mutable database context now refers to a specific transaction by UUID.
104112
105−#### Walk Back To Time
106−
107−Each transaction is committed along with a creation timestamp. From any point in the graph, one can "walk back" until the commit timestamp is past a given timestamp threshold.
108−
109−```
110−TutorialD (master/main): x:=true
111−TutorialD (master/main): :commit
112−TutorialD (master/main): :showgraph
113−┌─────────────┬──────────┬──────────────────────────────────────┬────────────────────────────────────────┬──────────────────────────────┐
114−│current::Bool│head::Text│id::Text │parents::relation {id::Text} │stamp::DateTime │
115−├─────────────┼──────────┼──────────────────────────────────────┼────────────────────────────────────────┼──────────────────────────────┤
116−│True │"master" │"b4c3bd0a-c594-456f-8e1b-8e296c939df4"│┌──────────────────────────────────────┐│2017-08-10 16:45:34.635582 UTC│
117−│ │ │ ││id::Text ││ │
118−│ │ │ │├──────────────────────────────────────┤│ │
119−│ │ │ ││"5e441752-f78d-4a0d-b7f6-b2716ab82a4d"││ │
120−│ │ │ │└──────────────────────────────────────┘│ │
121−│False │"" │"5e441752-f78d-4a0d-b7f6-b2716ab82a4d"│┌────────┐ │2017-08-10 16:43:59.160044 UTC│
122−│ │ │ ││id::Text│ │ │
123−│ │ │ │└────────┘ │ │
124−└─────────────┴──────────┴──────────────────────────────────────┴────────────────────────────────────────┴──────────────────────────────┘
125−
126−TutorialD (master/main): :walkbacktotime "2017-08-10 16:44:00"
127−TutorialD (<unknown>/main): :showexpr x
128−ERR: RelVarNotDefinedError "x"
129−```
130−
131−In the above example, we start with a fresh database and commit relvar ```x```. Then, using the displayed graph, we walk back to a time before the stamp provided from the graph display and discover that, indeed, ```x``` was not defined in that point in time.
132113
133−Note that all timestamps are in UTC time.
134114
135−If you choose to walk back in time before the database existed, you will see a ```RootTransactionTraversalError```.
136115
137−Note that some transactions, specifically merge transactions, can have multiple parents. In such walk back scenarios, an arbitrary parent is chosen to continue the search. For more precise control, use the other search/jump strategies to set your current transaction behind the merge transaction and then walk back.
docs/transgraphrelationalexpr.markdowndeleted−61
@@ -1,61 +0,0 @@
1−# Trans-Graph Relational Expressions
2−
3−## Introduction
4−
5−A standard relational expression queries the state of the database at a single point in time. This point-in-time is represented by an atomic transaction.
6−
7−In contrast, a trans-graph relational expression can refer to any transaction's state in the entire history of the database. For example, a trans-graph relational expression could be used to determine how a relation variable has changed over time.
8−
9−## Motivation
10−
11−Common SQL DBMSs contend all database changes (INSERTs, UPDATEs, DELETEs) on a single state. The DBMS is responsible for simulating serialized access to this ever-changing state. Access to previous states is impossible- the only state visible is the one which is available when the client initiated the transaction.
12−
13−In constrast, Project:M36 allows queries against current *and* past transactions. This is useful for learning how a database has changed over time. One essential use for this feature is for "auditing", whereby the database can be queried to explain how, when, and by whom certain changes were made.
14−
15−## TutorialD Usage
16−
17−In practice, trans-graph relational expressions are very similar to normal relational expressions except that the database context for trans-graph relational expressions is **not** implied. This means that any reference to data in the database context must be marked with a transaction marker. This includes data such as relation variables and atom functions.
18−
19−In ```tutd```, here are two equivalent queries (assuming that ```s``` and ```sp``` are relation variables which have been committed to the ```master``` branch):
20−```
21−TutorialD (master/main): :showexpr s join sp
22−```
23−```
24−TutorialD (master/main): :showtransgraphexpr s@master join sp@master
25−```
26−
27−Note that the only difference is that the second expression explicitly references which transaction the relation variable is referencing. In the first relational expression, this marker is implicit because the query can only reference the current in-flight transaction.
28−
29−Naturally, the trans-graph relational expression is most useful when querying across multiple transactions. This can be accomplished by specifying the transaction id (UUID) or using head name backtracking which is intentionally similar to the git traversal syntax.
30−
31−```
32−TutorialD (master/main): :showtransgraphexpr s@master~ join sp@master
33−```
34−
35−The transaction marker ```master~``` indicates that we wish to reference the first parent of the transaction at the head of the "master" branch. Then, we wish to join it with the relation variable ```sp``` at the head transaction of the master branch. Thusly, we can join two relations from two different transactions.
36−
37−Since transactions can have multiple parents due to merge commits, the ```^x``` syntax can be used to specify the ```x```-th parent of the referenced transaction.
38−
39−These markers can be freely mixed to traverse the graph from a head, as in the following example:
40−
41−```
42−TutorialD (master/main): :showtransgraphexpr s@improveheadlights~^2
43−```
44−
45−This query asks to return relation variable ```s``` at the transaction context from the second parent of the first parent of the head of the "improveheadlights" branch.
46−
47−## Reference
48−
49−Note that relational expressions can query the current in-flight state (called the "disconnected transaction" because it is not committed), while the trans-graph relational expression can only query against committed transactions.
50−
51−Note that the caret operator relies on a notion of parent transaction ordering (the n-th parent transaction of a merge transaction). While this ordering is stable, it is arbitrary, so it is up to the user to verify that the correct branch is traversed.
52−
53−The same ```@``` syntax can be used with relation variables, atom functions and type constructors.
54−
55−Other than the following markers, trans-graph relational expressions share identical syntax with relational expressions.
56−
57−| Syntax | Example | Meaning |
58−|--------|---------|---------|
59−| &lt;uuid&gt; | ```rv@dc385ccc-387e-407d-b65f-e3681cf221a9``` | The relation variable ```rv``` at the state of transaction referred to by explicit unique identifier.|
60−| ^[&lt;n-th parent&gt;] | ```rv@addcustomer^2``` | The relation variable ```rv``` at the state of the second parent transaction of the head transaction of the branch ```addcustomer```. |
61−| ~[&lt;steps&gt;] | ```rv@addcustomer~3``` | The relation variable ```rv``` at the state of the great-grandparent of the head transaction of branch ```addcustomer```. The tilde operator always traverses the "first" parent transaction of any merge transaction.|
docs/tupleable.markdowndeleted−68
@@ -1,68 +0,0 @@
1−# Marshaling Haskell Data Types to Database Tuples
2−
3−## Introduction
4−
5−Typical ORMs map certain data types to tuples within a relation variable. Because Project:M36 supports Haskell data types natively, any record data type which derives the ```Generic``` typeclass can be marshaled to a database tuple using the ```Tupleable``` typeclass. These marshaled database values can be operated on within the database using Haskell as well.
6−
7−## Setup
8−
9−Let's imagine we have a Haskell record type "Person" which we wish to map to a tuple in a relation variable called "person". Using ```GHC.Generics```, creating this mapping is trivial. Any record fields which are ```Atomable```, including algebraic data types, are supported.
10−
11−```haskell
12−import ProjectM36.Tupleable
13−
14−data Person = Person {
15− name :: Text,
16− employeeNumber :: Int,
17− likesHorses :: Bool
18−}
19−deriving Generic
20−
21−instance Tupleable Person
22−```
23−
24−Now, ```Person``` values can be marshaled between the database and the client. The attribute names appearing in the Haskell data type will appear identically in the server with the same types.
25−
26−### Changing Options
27−
28−If our field names don't exactly match attribute names, but follow a common pattern, we can derive Tupleable with custom options. Let's say each field on person has a prefix "person", but we still want to use the attribute names without the prefix. We can make use of the ProjectM36.Tupleable module to accomplish our goal like so:
29−
30−```haskell
31−import ProjectM36.Tupleable.Deriving
32−
33−data Person = Person {
34− personName :: Text,
35− personEmployeeNumber :: Int,
36− personLikesHorses :: Bool
37− }
38− deriving stock Generic
39− deriving Tupleable
40− via Codec (Field (DropPrefix "person" >>> CamelCase)) Person
41−```
42−
43−The extensions DerivingGeneric, DerivingVia, TypeOperators, and DataKinds must be enabled for this code to compile. See the documentation on Hackage for all available options.
44−
45−## Usage
46−
47−The ```Tupleable``` module includes the following functions:
48−
49− * ```toInsertExpr :: forall a t. (Tupleable a, Traversable t) => t a -> RelVarName -> Either RelationalError DatabaseContextExpr```
50− * creates an ```Insert``` expression which can be used to insert a set of ```Tupleable``` values into the relation variable named by the ```RelVarName```
51− * ```toUpdateExpr :: forall a. Tupleable a => RelVarName -> [AttributeName] -> a -> Either RelationalError DatabaseContextExpr```
52− * create an `Update` expression which updates the tuples with the attribute values of the argument `Tupleable` using the list of attribute names as the key to the underlying relation variable
53− * ```toDeleteExpr :: forall a. Tupleable a => RelVarName -> [AttributeName] -> a -> Either RelationalError DatabaseContextExpr```
54− * create a `Delete` expression which will remove the tuples from the relation variable matching the values of the argument `Tupleable` using the attribute name list as the matching key
55− * ```toAttributes :: proxy a -> Attributes```
56− * generates ```Attributes``` from a ```Tupleable``` value- can be used with ```undefined```, so an actual value is not necessary
57− * ```toTuple :: a -> RelationTuple```
58− * converts a ```Tupleable``` value to a tuple for use in queries
59− * ```fromTuple :: RelationTuple -> Either RelationalError a```
60− * converts a tuple to ```Tupleable``` value, unless there is an error such as a missing attribute
61−
62−For example usage, see the [Out of the Tarpit example](/examples/out_of_the_tarpit.hs).
63−
64−## Comparison to Other DBMSes
65−
66−The most annoying misfeature of the so-called object-relational model (ORM) is the data type impedance mismatch. This is especially egregious for Haskell clients which must contend with down-sampling the quality of Haskell data structures. For example, most DBMSes don't support algebraic data types, so the ORM can't represent them or it must represent them as binary or JSON blobs in the database which precludes such types from database-level type safety, constraints, and value queries.
67−
68−Project:M36 solves this mismatch by supporting algebraic data types as database-level values, Haskell scripting of database- and value-level server-side functions, and automatic and lossless marshaling of Haskell algebraic data types to values and tuples. Because the mapping between client data types and database-level data types is one-to-one, the mismatch is eliminated- any expression which could be evaluated against the data type on the client side can also be evaluated server-side.
docs/tutd_cheatsheet.markdowndeleted−99
@@ -1,99 +0,0 @@
1−# Tutorial D Cheatsheet
2−
3−The following tables list examples of expressions for `tutd`, Project:M36's "Tutorial D" implementation.
4−
5−## Relational Expressions
6−
7−Relational expressions query database state without being able to change it.
8−
9−|Relational Expression |Description |
10−|------------------------------------------------------|---------------------------------------|
11−|`:showexpr p`|Display the relation variable `p`|
12−|`:showexpr s rename {city as town}`|Display the result after renaming a relational attribute|
13−|`:showexpr p{color,city}`|Display the result of the projection on the `color` and `city` attributes|
14−|`:showexpr p{all but city}`|Display the result of the projection of all attribute of `p` except `city`|
15−|`:showexpr p join sp`|Display the result of the relational expression `p` joined against `sp` (equivalent to `NATURAL JOIN` in SQL)|
16−|`:showexpr (s join sp){all from s}`|Display the result of a join but only include attributes from `s`|
17−|`:showexpr s semijoin sp`|Equivalent to `(s join sp){all from s}`|
18−|`:showexpr s antijoin sp`|Display the result of all tuples in `s` which do not match appear in the result of `s semijoin sp`|
19−|`:showexpr s union s`| Display the result of `s` unioned with itself (which is equivalent to `s`)|
20−|`:showexpr s:{status2:=add(10,@status)}`| Display the result of extending the `s` relation variable with a new attribute which adds 10 to each `status` attribute|
21−|`:showexpr s group ({sname,status,s#} as subrel)`| Display the result of grouping the `sname`, `status`, and `s#` into a subrel for each tuple in the `s` relation where the `city` attribute (not mentioned) is the grouping criteria|
22−|`:showexpr (s group ({sname,status,s#} as subrel)) ungroup subrel`| Display the result of unwrapping a subrelation to create one new tuple for each subrelation tuple in the result|
23−|`:showexpr s minus s`|Display the result after removing all tuples that match the second argument. `x minus x` is equivalent to `x where false`|
24−|`:showexpr relation{tuple{name "Mike",age 6},tuple{name "Sam",age 10}}`|Display an unnamed relation using manually constructed tuples|
25−|`:showexpr relation{a Integer, b Text}`|Display an empty-tupled relation of a specified type|
26−|`:showexpr relation{a Integer, b Text}{tuple{a 4, b "four"}}`|Display a relation bound by the specified types and containing one or more tuples|
27−|`:showexpr s group ({s#,sname,status} as subrel):{citycount:=count(@subrel)}`|Display a result which groups `s` by `city` and extends the relation by a count for each city.|
28−|`:showrelvars`|Display a list of relation variables in the current context along with their types (attributes)|
29−
30−## Built-In Types
31−
32−|Example Value Expression |Type |Explanation|
33−|------------------------------------------------------|---------------------------------------|-----------|
34−|`"abc"`|Text|UTF-8 string|
35−|`123`|Integer|an integer of limitless size (using gmp)|
36−|`int(456)`|Int|machine-word-based integer|
37−|`12.56`|Double|64-bit IEEE 754 floating point number|
38−|`dateTimeFromEpochSeconds(1502304846)`|DateTime||
39−|`fromGregorian(2017,05,30)`|Date||
40−|`t`|Bool|`t` or `f`|
41−|`bytestring("dGVzdGRhdGE=")`|Bytestring|base-64-encoded string of bytes|
42−|`interval(3,5,f,f)`|Interval(Integer)|the constructor function includes two bounds and two boolean flags for inclusiveness|
43−
44−## Database Context Expressions
45−
46−Database context expressions take the current database context as input and alter it to create a new
47−
48−|Database Context Expression |Description |
49−|------------------------------------------------------|---------------------------------------|
50−|`:importexample cjdate`|Imports a precooked schema from Chris Date's books resulting in relvars `s`, `sp`, and `p`|
51−|`:importtutd "file:///home/agentm/project-m36/scripts/emp.tutd"`|Imports TutorialD from file URI|
52−|`:importtutd "https://raw.githubusercontent.com/agentm/project-m36/master/scripts/emp.tutd" "effe32b247586dc3ac0079fc241b9618d41d189afcaeb7907edbe5a8b45992a4"`| Imports TutorialD from HTTP or HTTPS URI|
53−|`newrelvar:=relation{tuple{age 3}}`|Assign a new relation variable named `newrelvar`|
54−|`undefine s`|Remove a relation variable|
55−|`insert s relation{tuple{city "Boston",s# "S10",sname "Gonzalez",status 10}}`| Append to an existing relation variable with another relational expression|
56−|`update s where status=20 (sname:="Mr. Twenty")`|Replace one or more values in matching tuples with a new value|
57−|`delete sp where s#="S4"`|Remove tuples matching the criteria|
58−|`key s_key_constraint {s#} s`|Add a constraint named `s_key_constraint` on relation variable `s` ensuring that `s#` is unique|
59−|`foreign key s#_in_sp sp{s#} in s{s#}`|Add a foreign key constraint that ensures that `sp`'s `s#` attribute always references a `s#` value in `s`|
60−|`constraint s_status_less_than_50 (s where ^lt(50,@status)){} in false`|Add a constraint that stipulates that the `status` values in `s` are less than 50|
61−|`createarbitraryrelation employee {name Text, empid Int, hired DateTime} 3-100`|Create a relation variable with random values with between 3-100 tuples- useful for testing|
62−|`notify steve_change person where name="Steve" true (person where name="Steve"){address}`|Notify the current connection with an asynchronous event if any committed tuples matching `person where name="Steve"` with `true` for the pre-change state and `person where name="Steve"){address}` for the post-change state- these states will be sent along with the notification|
63−|`data Hair = Bald | Brown | Blond | OtherColor Text`|Create a new algebraic data type for use with values inside tuples|
64−|`undata Hair`|Delete the `Hair` custom type|
65−
66−
67−## Transaction Graph Expressions
68−
69−Transaction graph expressions alter the state of the transaction graph by append new states.
70−
71−|Transaction Graph Expression |Description |
72−|------------------------------------------------------|---------------------------------------|
73−|`:commit`|Save the current database context to a new transaction and add it to the transaction graph|
74−|`:rollback`|Return the database context to the state before any alterations were made|
75−|`:branch experimental`|Create a new branch from the existing branch and switch the current context to be able to commit to the new branch|
76−|`:jumphead master`|Discard any changes in the current context and jump to the head of a different branch|
77−|`:jump 11b601c9-f46b-42b0-a2ce-cf18ced31b7f`|Jump to the specific transaction by UUID- useful for introspecting past states|
78−|`:showgraph`|Display a representation of the transaction graph|
79−|`:walkbacktotime "2017-08-10 16:44:00"`|Walk back in time from the current branch until a transaction less than or equal to the time is found and switch the current context to that past transaction- useful for auditing|
80−
81−## Data Frame Expressions
82−
83−In contrast to relational expressions, data frame expressions generate ordered tuples.
84−
85−|Data Frame Expression |Description |
86−|------------------------------------------------------|---------------------------------------|
87−|`:showdataframe s orderby {status}`|Display a data frame result for the relational expression `s` and sort the tuples by `status`|
88−|`:showdataframe s{status} orderby {status descending} offset 1 limit 3`|Display a data frame result for `s{status}` but ordered by `status` values descending, skip the first tuple, and return no more than 3 tuples|
89−
90−## Trans-Graph Relational Expressions
91−
92−Trans-graph relational expressions allow queries spanning multiple transactions.
93−
94−|Trans-Graph Relational Expressions |Description |
95−|------------------------------------------------------|---------------------------------------|
96−|`:showtransgraphexpr s@master join sp@master`|Display a result for joining `s` and `sp` on the branch `master`|
97−|`:showtransgraphexpr s@master~ join sp@master`|Display a result for joining `s` on the parent transaction of `master`'s current head and `sp` on master|
98−|`:showtransgraphexpr s@master~^2`|Display a result for `s` two parents previous to the parent of the current `master`'s head|
99−
docs/tutd_tutorial.markdown+213−369
@@ -9,69 +9,30 @@ It is presumed that the audience for this tutorial has at least some minimal bac
99From the project-m36 source directory, execute ```cabal run tutd``` to start the interactive TutorialD interpreter. You will be greeted by the interactive prompt:
1010
1111```
12−TutorialD (master/main):
12+TutorialD (master):
1313```
1414
1515"master" refers to the name of the branch to which the current transaction will be potentially committing.
1616
17−### Date's Sample Relations
18−
19−The examples in this tutorial can be executed after loading Chris Date's sample relations using:
20−
21−```
22−:importexample cjdate
23−```
24−
25−Each section assumes a fresh instance of the Date examples. The relation variables created in the script are:
26−
27−|Relation Variable Name|Description|
28−|----------------------|-----------|
29−|s|suppliers|
30−|p|parts|
31−|sp|contains mapping of which suppliers supply which parts|
32−
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−
5117### Types
5218
5319TutorialD is strongly-typed. The basic built-in types are:
5420
5521|Type Name|Explanation|Example|
5622|---------|-----------|-------|
57−|Text|arbitrary text|"The Old Man and the Sea"|
58−|Integer|arbitarily-sized integer|-4|
59−|Int|machine word integer|int(10)|
60−|DateTime|timestamp UTC|dateTimeFromEpochSeconds(1502304846)|
61−|Date|calendar date|fromGregorian(2017,05,30)|
62−|Double|floating point number|3.1459|
63−|Bool|boolean value|t|
64−|Bytestring|arbitrary-length string of bytes- input is base64-encoded|bytestring("dGVzdGRhdGE=")|
65−|Interval x|interval/range type for ints, doubles, datetimes, and dates|interval(3,5,f,f)|
23+|char|arbitrary text|"The Old Man and the Sea"|
24+|int|any integer|-4|
25+|datetime|timestamp UTC|"2015-02-02 04:05:02"::datetime|
26+|double|floating point number|3.1459|
27+|bool|boolean value|t|
28+|bytestring|arbitrary-length string of bytes- input is base64-encoded|"dGVzdGRhdGE="::bytestring|
6629
6730With regards to boolean values, be sure not to conflate ```t``` or ```f``` as a boolean value with ```true``` and ```false``` which are relation variables.
6831
69−The ```interval``` function last two arguments are boolean values indicating whether the interval is open at the start point and end point respectively.
70−
7132Project:M36 will complain loudly if the expected types do not match. Automatic type coercion does not exist.
7233
7334```
74−TutorialD (master/main): :showexpr s:{more:=add(10,@sname)}
35+TutorialD (master): :showexpr S:{more:=add(10,@sname)}
7536ERR: AtomFunctionTypeError "add" 2 IntAtomType StringAtomType
7637```
7738
@@ -83,7 +44,7 @@ Relation Variables are named cells which reference relations within a transactio
8344
8445Definition of a relation variable:
8546```
86−products :: {name Text, age Integer}
47+products :: {name char, age int}
8748```
8849This expression creates a new relation variable in the current context which can refer to any relation with the header of "name" of type "char" and "age" of type int.
8950
@@ -102,12 +63,28 @@ Chris Date refers to these relations as "TABLE_DUM" and "TABLE_DEE" but such arb
10263products{}
10364```
10465
66+### Date's Sample Relations
67+
68+The examples in this tutorial can be executed after loading Chris Date's sample relations using:
69+
70+```
71+:importexample date
72+```
73+
74+Each section assumes a fresh instance of the Date examples. The relation variables created in the script are:
75+
76+|Relation Variable Name|Description|
77+|----------------------|-----------|
78+|s|suppliers|
79+|p|parts|
80+|sp|contains mapping of which suppliers supply which parts|
81+
10582### Relational Expressions
10683
10784A relational expression combines relational operators to create a new relation. ```tutd``` can display the result of executing a relational expression with ":showexpr".
10885
10986```
110−TutorialD (master/main): :showexpr p
87+TutorialD (master): :showexpr p
11188┌──────┬─────┬──┬─────┬──────┐
11289│city │color│p#│pname│weight│
11390├──────┼─────┼──┼─────┼──────┤
@@ -123,7 +100,7 @@ TutorialD (master/main): :showexpr p
123100To show all relation variables in the current session, use ```:showrelvars```:
124101
125102```
126−TutorialD (master/main): :showrelvars
103+TutorialD (master): :showrelvars
127104┌─────────────────────────────────────────────────┬──────────┐
128105│attributes::relation {attribute::Text,type::Text}│name::Text│
129106├─────────────────────────────────────────────────┼──────────┤
@@ -169,16 +146,16 @@ Relational operators generate new relations from existing relations. The operato
169146The unary rename operator outputs a new relation with chosen attributes renamed. In SQL, the equivalent is to use "AS" in the column name list of SELECTS.
170147
171148```
172−TutorialD (master/main): :showexpr s rename {city as town}
173−┌────────┬───────────┬───────────────┬──────────┐
174−│s#::Text│sname::Text│status::Integer│town::Text│
175−├────────┼───────────┼───────────────┼──────────┤
176−│"S3" │"Blake" │30 │"Paris" │
177−│"S4" │"Clark" │20 │"London" │
178−│"S5" │"Adams" │30 │"Athens" │
179−│"S1" │"Smith" │20 │"London" │
180−│"S2" │"Jones" │10 │"Paris" │
181−└────────┴───────────┴───────────────┴──────────┘
149+TutorialD (master): :showexpr s rename {city as town}
150+┌──┬─────┬──────┬──────┐
151+│s#│sname│status│town │
152+├──┼─────┼──────┼──────┤
153+│S3│Blake│30 │Paris │
154+│S4│Clark│20 │London│
155+│S5│Adams│30 │Athens│
156+│S1│Smith│20 │London│
157+│S2│Jones│10 │Paris │
158+└──┴─────┴──────┴──────┘
182159```
183160
184161#### Projection
@@ -188,154 +165,79 @@ Projection is applied by adding curly braces and attribute names following a rel
188165For example:
189166
190167```
191−TutorialD (master/main): :showexpr p{color,city}
192−┌──────────┬───────────┐
193−│city::Text│color::Text│
194−├──────────┼───────────┤
195−│"London" │"Red" │
196−│"Paris" │"Green" │
197−│"Oslo" │"Blue" │
198−│"Paris" │"Blue" │
199−└──────────┴───────────┘
200−
201−```
202−
203−Projection attributes can also be inverted using `all but`:
204−
205−```
206−TutorialD (master/main): :showexpr s{all but city}
207−┌────────┬───────────┬───────────────┐
208−│s#::Text│sname::Text│status::Integer│
209−├────────┼───────────┼───────────────┤
210−│"S2" │"Jones" │10 │
211−│"S3" │"Blake" │30 │
212−│"S1" │"Smith" │20 │
213−│"S5" │"Adams" │30 │
214−│"S4" │"Clark" │20 │
215−└────────┴───────────┴───────────────┘
216−```
217−
218−Projection attributes can be derived from a relational expression using `all from`:
219−
220−```
221−TutorialD (master/main): :showexpr (s join sp){all from s}
222−┌──────────┬────────┬───────────┬───────────────┐
223−│city::Text│s#::Text│sname::Text│status::Integer│
224−├──────────┼────────┼───────────┼───────────────┤
225−│"London" │"S1" │"Smith" │20 │
226−│"London" │"S4" │"Clark" │20 │
227−│"Paris" │"S2" │"Jones" │10 │
228−│"Paris" │"S3" │"Blake" │30 │
229−└──────────┴────────┴───────────┴───────────────┘
230−```
231−
232−Above, we join `s` and `sp` but project the result back onto the attributes of `s`.
233−
234−Projection attributes can be unioned from multiple sources using `union of`:
235−
236−```
237−TutorialD (master/main): :showexpr (s join sp){union of {all from s} {all but p#}}
238−┌──────────┬────────────┬────────┬───────────┬───────────────┐
239−│city::Text│qty::Integer│s#::Text│sname::Text│status::Integer│
240−├──────────┼────────────┼────────┼───────────┼───────────────┤
241−│"Paris" │400 │"S2" │"Jones" │10 │
242−│"London" │400 │"S1" │"Smith" │20 │
243−│"Paris" │200 │"S3" │"Blake" │30 │
244−│"London" │200 │"S4" │"Clark" │20 │
245−│"London" │200 │"S1" │"Smith" │20 │
246−│"Paris" │300 │"S2" │"Jones" │10 │
247−│"London" │100 │"S1" │"Smith" │20 │
248−│"London" │300 │"S4" │"Clark" │20 │
249−│"London" │300 │"S1" │"Smith" │20 │
250−│"London" │400 │"S4" │"Clark" │20 │
251−└──────────┴────────────┴────────┴───────────┴───────────────┘
168+TutorialD (master): :showexpr p{color,city}
169+┌──────┬─────┐
170+│city │color│
171+├──────┼─────┤
172+│London│Red │
173+│Paris │Blue │
174+│Oslo │Blue │
175+│Paris │Green│
176+└──────┴─────┘
252177```
253178
254−Here, after joining `s` and `p`, the union of all attributes from `s` and all attributes from `p` except for `p#` are returned.all
255−
256−Finally, projection attributes can be intersected using `intersection of`:
257−
258−```
259−TutorialD (master/main): :showexpr (s join sp){intersection of {all from s} {all from p}}
260−┌──────────┐
261−│city::Text│
262−├──────────┤
263−│"London" │
264−│"Paris" │
265−└──────────┘
266−```
267−
268−Here, after joining `s` and `p`, we project on the intersection of attributes from `s` and `p` which happens to be `city`.
269−
270179#### Restriction
271180
272181Restriction is applied using a "where" clause, much like in SQL.
273182
274183```
275−TutorialD (master/main): :showexpr p where color="Blue" and city="Paris"
276−┌──────────┬───────────┬────────┬───────────┬───────────────┐
277−│city::Text│color::Text│p#::Text│pname::Text│weight::Integer│
278−├──────────┼───────────┼────────┼───────────┼───────────────┤
279−│"Paris" │"Blue" │"P5" │"Cam" │12 │
280−└──────────┴───────────┴────────┴───────────┴───────────────┘
184+TutorialD (master): :showexpr p where color="Blue" and city="Paris"
185+┌─────┬─────┬──┬─────┬──────┐
186+│city │color│p#│pname│weight│
187+├─────┼─────┼──┼─────┼──────┤
188+│Paris│Blue │P5│Cam │12 │
189+└─────┴─────┴──┴─────┴──────┘
281190```
282191
283192The restriction predicate can be built from "and", "not", and "or". Boolean atom functions can also appear in a restriction as long as they are preceded by "^". For example:
284193
285194```
286−TutorialD (master/main): :showexpr s where ^lt(@status,20)
287−┌──────────┬────────┬───────────┬───────────────┐
288−│city::Text│s#::Text│sname::Text│status::Integer│
289−├──────────┼────────┼───────────┼───────────────┤
290−│"Paris" │"S2" │"Jones" │10 │
291−└──────────┴────────┴───────────┴───────────────┘
195+TutorialD (master): :showexpr s where ^lt(@status,20)
196+┌─────┬──┬─────┬──────┐
197+│city │s#│sname│status│
198+├─────┼──┼─────┼──────┤
199+│Paris│S2│Jones│10 │
200+└─────┴──┴─────┴──────┘
292201```
293202
294203#### Join
295204
296−Joins are binary operators and are applied with the "join" keyword. The equivalent in SQL would be a "NATURAL JOIN". To join attributes which are not identically-named, use the `rename` operator.
205+Joins are binary operators and are applied with the "join" keyword. The equivalent in SQL would be a "NATURAL JOIN". To join attributes which are not identically-named, use the rename operator
297206
298207```
299−TutorialD (master/main): :showexpr s join sp
300−┌──────────┬────────┬────────────┬────────┬───────────┬───────────────┐
301−│city::Text│p#::Text│qty::Integer│s#::Text│sname::Text│status::Integer│
302−├──────────┼────────┼────────────┼────────┼───────────┼───────────────┤
303−│"London" │"P2" │200 │"S1" │"Smith" │20 │
304−│"London" │"P6" │100 │"S1" │"Smith" │20 │
305−│"London" │"P3" │400 │"S1" │"Smith" │20 │
306−│"Paris" │"P2" │400 │"S2" │"Jones" │10 │
307−│"London" │"P5" │400 │"S4" │"Clark" │20 │
308−│"Paris" │"P1" │300 │"S2" │"Jones" │10 │
309−│"London" │"P1" │300 │"S1" │"Smith" │20 │
310−│"Paris" │"P2" │200 │"S3" │"Blake" │30 │
311−│"London" │"P4" │300 │"S4" │"Clark" │20 │
312−│"London" │"P2" │200 │"S4" │"Clark" │20 │
313−│"London" │"P4" │200 │"S1" │"Smith" │20 │
314−│"London" │"P5" │100 │"S1" │"Smith" │20 │
315−└──────────┴────────┴────────────┴────────┴───────────┴───────────────┘
208+TutorialD (master): :showexpr s join sp
209+┌──────┬──┬───┬──┬─────┬──────┐
210+│city │p#│QTY│s#│sname│status│
211+├──────┼──┼───┼──┼─────┼──────┤
212+│London│P6│100│S1│Smith│20 │
213+│London│P3│400│S1│Smith│20 │
214+│London│P5│400│S4│Clark│20 │
215+│London│P1│300│S1│Smith│20 │
216+│Paris │P2│200│S3│Blake│30 │
217+│Paris │P1│300│S2│Jones│10 │
218+│London│P5│100│S1│Smith│20 │
219+│London│P4│300│S4│Clark│20 │
220+│Paris │P2│400│S2│Jones│10 │
221+│London│P2│200│S1│Smith│20 │
222+│London│P4│200│S1│Smith│20 │
223+└──────┴──┴───┴──┴─────┴──────┘
316224```
317225
318−As a convenience, `tutd` also supports semijoin (`matching`) and antijoin (`not matching`) syntax.
319−
320−`s matching sp` or `s semijoin sp` is equivalent to `(s join sp){all from s}` which returns all tuples in `s` which appear in the join of `s` and `sp`.
321−
322−`s not matching sp` or `s antijoin sp` is equivalent to `s minus (s matching sp)` which returns all tuples in `s` which do not appear in the join of `s` and `sp`. Thus, semjoin and antijoin are inverses of each other.
323−
324226#### Union
325227
326228The binary union operator merges tuples from both relations if-and-only-if the attributes of both relations are identical. The SQL equivalent is the "UNION" operator. Unlike SQL, however, duplicate tuples are not tolerated, so there is no "UNION ALL" equivalent in the relational algebra.
327229
328230```
329−TutorialD (master/main): :showexpr s union s
330−┌──────────┬────────┬───────────┬───────────────┐
331−│city::Text│s#::Text│sname::Text│status::Integer│
332−├──────────┼────────┼───────────┼───────────────┤
333−│"Paris" │"S3" │"Blake" │30 │
334−│"Athens" │"S5" │"Adams" │30 │
335−│"London" │"S1" │"Smith" │20 │
336−│"Paris" │"S2" │"Jones" │10 │
337−│"London" │"S4" │"Clark" │20 │
338−└──────────┴────────┴───────────┴───────────────┘
231+TutorialD (master): :showexpr S union S
232+┌──────┬──┬─────┬──────┐
233+│city │s#│sname│status│
234+├──────┼──┼─────┼──────┤
235+│Paris │S3│Blake│30 │
236+│London│S4│Clark│20 │
237+│Athens│S5│Adams│30 │
238+│London│S1│Smith│20 │
239+│Paris │S2│Jones│10 │
240+└──────┴──┴─────┴──────┘
339241```
340242
341243The union of any relation with itself is itself.
@@ -345,16 +247,16 @@ The union of any relation with itself is itself.
345247The extend unary operator adds an attribute to a relation's header and body and is represented by a colon ":". The equivalent in SQL is a subselect in a SELECT column list. Typically, extend is used to add information derived from relation.
346248
347249```
348−TutorialD (master/main): :showexpr s:{status2:=add(10,@status)}
349−┌──────────┬────────┬───────────┬───────────────┬────────────────┐
350−│city::Text│s#::Text│sname::Text│status::Integer│status2::Integer│
351−├──────────┼────────┼───────────┼───────────────┼────────────────┤
352−│"Paris" │"S2" │"Jones" │10 │20 │
353−│"Athens" │"S5" │"Adams" │30 │40 │
354−│"London" │"S4" │"Clark" │20 │30 │
355−│"Paris" │"S3" │"Blake" │30 │40 │
356−│"London" │"S1" │"Smith" │20 │30 │
357−└──────────┴────────┴───────────┴───────────────┴────────────────┘
250+TutorialD (master): :showexpr s:{status2:=add(10,@status)}
251+┌──────┬──┬─────┬──────┬───────┐
252+│city │s#│sname│status│status2│
253+├──────┼──┼─────┼──────┼───────┤
254+│Paris │S2│Jones│10 │20 │
255+│Athens│S5│Adams│30 │40 │
256+│Paris │S3│Blake│30 │40 │
257+│London│S1│Smith│20 │30 │
258+│London│S4│Clark│20 │30 │
259+└──────┴──┴─────┴──────┴───────┘
358260```
359261
360262The "@" is required in the above query in order to distinguish the attribute's name from a relation's name.
@@ -376,31 +278,29 @@ The unary group operator groups the argument attributes into subrelations for ea
376278
377279Grouping is useful for aggregate operations (see below) or for summarizing data against a set of attributes; for example, "display all employees grouped by boss name".
378280
379−The group operator can also be used to emulate functionality similar to SQL's OUTER JOIN but without relying on overloading the meaning of NULL.
380−
381−```
382−TutorialD (master/main): :showexpr s group ({sname,status,s#} as subrel)
383−┌──────────┬───────────────────────────────────────────────────────┐
384−│city::Text│subrel::relation {s#::Text,sname::Text,status::Integer}│
385−├──────────┼───────────────────────────────────────────────────────┤
386−│"Athens" │┌────────┬───────────┬───────────────┐ │
387−│ ││s#::Text│sname::Text│status::Integer│ │
388−│ │├────────┼───────────┼───────────────┤ │
389−│ ││"S5" │"Adams" │30 │ │
390−│ │└────────┴───────────┴───────────────┘ │
391−│"Paris" │┌────────┬───────────┬───────────────┐ │
392−│ ││s#::Text│sname::Text│status::Integer│ │
393−│ │├────────┼───────────┼───────────────┤ │
394−│ ││"S2" │"Jones" │10 │ │
395−│ ││"S3" │"Blake" │30 │ │
396−│ │└────────┴───────────┴───────────────┘ │
397−│"London" │┌────────┬───────────┬───────────────┐ │
398−│ ││s#::Text│sname::Text│status::Integer│ │
399−│ │├────────┼───────────┼───────────────┤ │
400−│ ││"S4" │"Clark" │20 │ │
401−│ ││"S1" │"Smith" │20 │ │
402−│ │└────────┴───────────┴───────────────┘ │
403−└──────────┴───────────────────────────────────────────────────────┘
281+```
282+TutorialD (master): :showexpr s group ({sname,status,s#} as subrel)
283+┌──────┬─────────────────┐
284+│city │subrel │
285+├──────┼─────────────────┤
286+│Athens│┌──┬─────┬──────┐│
287+│ ││s#│sname│status││
288+│ │├──┼─────┼──────┤│
289+│ ││S5│Adams│30 ││
290+│ │└──┴─────┴──────┘│
291+│London│┌──┬─────┬──────┐│
292+│ ││s#│sname│status││
293+│ │├──┼─────┼──────┤│
294+│ ││S1│Smith│20 ││
295+│ ││S4│Clark│20 ││
296+│ │└──┴─────┴──────┘│
297+│Paris │┌──┬─────┬──────┐│
298+│ ││s#│sname│status││
299+│ │├──┼─────┼──────┤│
300+│ ││S3│Blake│30 ││
301+│ ││S2│Jones│10 ││
302+│ │└──┴─────┴──────┘│
303+└──────┴─────────────────┘
404304```
405305
406306#### Ungroup
@@ -408,35 +308,18 @@ TutorialD (master/main): :showexpr s group ({sname,status,s#} as subrel)
408308The unary ungroup operator "unwraps" subrelations in a relation-valued attribute. There is no equivalent in SQL.
409309
410310```
411−TutorialD (master/main): :showexpr (s group ({sname,status,s#} as subrel)) ungroup subrel
412−┌──────────┬────────┬───────────┬───────────────┐
413−│city::Text│s#::Text│sname::Text│status::Integer│
414−├──────────┼────────┼───────────┼───────────────┤
415−│"Paris" │"S2" │"Jones" │10 │
416−│"Paris" │"S3" │"Blake" │30 │
417−│"London" │"S4" │"Clark" │20 │
418−│"London" │"S1" │"Smith" │20 │
419−│"Athens" │"S5" │"Adams" │30 │
420−└──────────┴────────┴───────────┴───────────────┘
421−```
422−
423−#### Minus
424−
425−The binary minus operator takes two relation variables of the same type and returns the tuples which appear in the first relation variable but not in the second relation.
426−
427−```
428−TutorialD (master/main): x:=relation{tuple{name "Steve"},tuple{name "Bob"},tuple{name "Jim"},tuple{name "Bart"}}
429−TutorialD (master/main): y:=relation{tuple{name "Jim"},tuple{name "Bart"}}
430−TutorialD (master/main): :showexpr x minus y
431−┌──────────┐
432−│name::Text│
433−├──────────┤
434−│"Steve" │
435−│"Bob" │
436−└──────────┘
311+TutorialD (master): :showexpr (s group ({sname,status,s#} as subrel)) ungroup subrel
312+┌──────┬──┬─────┬──────┐
313+│city │s#│sname│status│
314+├──────┼──┼─────┼──────┤
315+│Paris │S3│Blake│30 │
316+│London│S4│Clark│20 │
317+│Athens│S5│Adams│30 │
318+│London│S1│Smith│20 │
319+│Paris │S2│Jones│10 │
320+└──────┴──┴─────┴──────┘
437321```
438322
439−
440323## State Operators
441324
442325While relational operators compose to relational expressions representing queries of the database, state operators change the state of the database.
@@ -448,13 +331,13 @@ While relational operators compose to relational expressions representing querie
448331The relation variable assignment mentioned above certainly changes the state of the database.
449332
450333```
451−TutorialD (master/main): newrelvar:=relation{tuple{age 3}}
452−TutorialD (master/main): :showexpr newrelvar
453−┌────────────┐
454−│age::Integer│
455−├────────────┤
456−│3 │
457−└────────────┘
334+TutorialD (master): newrelvar:=relation{tuple{age 3}}
335+TutorialD (master): :showexpr newrelvar
336+┌───┐
337+│age│
338+├───┤
339+│3 │
340+└───┘
458341```
459342
460343All further operators are convenience operators and could be implemented with simple assignment. SQL has no equivalent to relational assignment; instead, one must issue "CREATE TABLE" commands and insert rows into the resultant tables.
@@ -464,8 +347,8 @@ All further operators are convenience operators and could be implemented with si
464347To signal that a relation variable should be forgotten, undefine it.
465348
466349```
467−TutorialD (master/main): undefine s
468−TutorialD (master/main): :showexpr s
350+TutorialD (master): undefine s
351+TutorialD (master): :showexpr s
469352ERR: RelVarNotDefinedError "s"
470353```
471354
@@ -474,18 +357,18 @@ ERR: RelVarNotDefinedError "s"
474357The insert operators accepts a relation variable and a relation of the same type (a relation having an identical header), and replaces the relation referenced by the relation variable with the union of the previous relation value and the argument's relation value.
475358
476359```
477−TutorialD (master/main): insert s relation{tuple{city "Boston",s# "S10",sname "Gonzalez",status 10}}
478−TutorialD (master/main): :showexpr s
479−┌──────────┬────────┬───────────┬───────────────┐
480−│city::Text│s#::Text│sname::Text│status::Integer│
481−├──────────┼────────┼───────────┼───────────────┤
482−│"Athens" │"S5" │"Adams" │30 │
483−│"Paris" │"S2" │"Jones" │10 │
484−│"Boston" │"S10" │"Gonzalez" │10 │
485−│"London" │"S4" │"Clark" │20 │
486−│"London" │"S1" │"Smith" │20 │
487−│"Paris" │"S3" │"Blake" │30 │
488−└──────────┴────────┴───────────┴───────────────┘
360+TutorialD (master): insert s relation{tuple{city "Boston",s# "S10",sname "Gonzalez",status 10}}
361+TutorialD (master): :showexpr s
362+┌──────┬───┬────────┬──────┐
363+│city │s# │sname │status│
364+├──────┼───┼────────┼──────┤
365+│Paris │S3 │Blake │30 │
366+│London│S4 │Clark │20 │
367+│Athens│S5 │Adams │30 │
368+│London│S1 │Smith │20 │
369+│Paris │S2 │Jones │10 │
370+│Boston│S10│Gonzalez│10 │
371+└──────┴───┴────────┴──────┘
489372```
490373
491374This insertion operation is equivalent to:
@@ -498,33 +381,33 @@ s:=s union relation{tuple{city "Boston",s# "S10",sname "Gonzalez",status 10}}
498381The update operator accepts a relation argument and a predicate, optionally filters and creates new tuples based on the original relation.
499382
500383```
501−TutorialD (master/main): update s where status=20 (sname:="Mr. Twenty")
502−TutorialD (master/main): :showexpr s
503−┌──────────┬────────┬────────────┬───────────────┐
504−│city::Text│s#::Text│sname::Text │status::Integer│
505−├──────────┼────────┼────────────┼───────────────┤
506−│"Paris" │"S2" │"Jones" │10 │
507−│"London" │"S1" │"Mr. Twenty"│20 │
508−│"Paris" │"S3" │"Blake" │30 │
509−│"London" │"S4" │"Mr. Twenty"│20 │
510−│"Athens" │"S5" │"Adams" │30 │
511−└──────────┴────────┴────────────┴───────────────┘
384+TutorialD (master): update s where status=20 (sname:="Mr. Twenty")
385+TutorialD (master): :showexpr s
386+┌──────┬──┬──────────┬──────┐
387+│city │s#│sname │status│
388+├──────┼──┼──────────┼──────┤
389+│Paris │S3│Blake │30 │
390+│London│S1│Mr. Twenty│20 │
391+│Athens│S5│Adams │30 │
392+│Paris │S2│Jones │10 │
393+│London│S4│Mr. Twenty│20 │
394+└──────┴──┴──────────┴──────┘
512395```
513396
514397This is logically equivalent to:
515398
516399```
517−TutorialD (master/main): s:=(((s where status=20){city,s#,status}):{sname:="Mr. Twenty"}) union (s where not status=20)
518−TutorialD (master/main): :showexpr s
519−┌──────────┬────────┬────────────┬───────────────┐
520−│city::Text│s#::Text│sname::Text │status::Integer│
521−├──────────┼────────┼────────────┼───────────────┤
522−│"Paris" │"S2" │"Jones" │10 │
523−│"London" │"S1" │"Mr. Twenty"│20 │
524−│"Paris" │"S3" │"Blake" │30 │
525−│"London" │"S4" │"Mr. Twenty"│20 │
526−│"Athens" │"S5" │"Adams" │30 │
527−└──────────┴────────┴────────────┴───────────────┘
400+TutorialD (master): s:=(((s where status=20){city,s#,status}):{sname:="Mr. Twenty"}) union (s where not status=20)
401+TutorialD (master): :showexpr s
402+┌──────┬──┬──────────┬──────┐
403+│city │s#│sname │status│
404+├──────┼──┼──────────┼──────┤
405+│Paris │S3│Blake │30 │
406+│London│S1│Mr. Twenty│20 │
407+│Athens│S5│Adams │30 │
408+│Paris │S2│Jones │10 │
409+│London│S4│Mr. Twenty│20 │
410+└──────┴──┴──────────┴──────┘
528411```
529412
530413This query means: "Drop the sname attribute from S filtered where status equals 20, extend the resultant relation by sname with value 'Mr. Twenty', then union the resultant relation with S filtered by status not equaling 20, and assign that to S."
@@ -534,27 +417,27 @@ This query means: "Drop the sname attribute from S filtered where status equals
534417The delete operator accepts a relation argument and a filtering predicate, creates a new relation with only the tuples which do not match the predicate, and stores the result in the relation variable argument.
535418
536419```
537−TutorialD (master/main): delete sp where s#="S4"
538−TutorialD (master/main): :showexpr sp
539−┌────────┬────────────┬────────┐
540−│p#::Text│qty::Integer│s#::Text│
541−├────────┼────────────┼────────┤
542−│"P2" │200 │"S3" │
543−│"P2" │400 │"S2" │
544−│"P1" │300 │"S1" │
545−│"P5" │100 │"S1" │
546−│"P4" │200 │"S1" │
547−│"P1" │300 │"S2" │
548−│"P3" │400 │"S1" │
549−│"P2" │200 │"S1" │
550−│"P6" │100 │"S1" │
551−└────────┴────────────┴────────┘
420+TutorialD (master): delete sp where s#="S4"
421+TutorialD (master): :showexpr sp
422+┌──┬───┬──┐
423+│p#│QTY│s#│
424+├──┼───┼──┤
425+│P3│400│S1│
426+│P4│200│S1│
427+│P2│400│S2│
428+│P2│200│S1│
429+│P6│100│S1│
430+│P1│300│S1│
431+│P2│200│S3│
432+│P1│300│S2│
433+│P5│100│S1│
434+└──┴───┴──┘
552435```
553436
554437This is logically equivalent to:
555438
556439```
557−TutorialD (master/main): sp:=sp where not s#="S4"
440+TutorialD (master): sp:=sp where not s#="S4"
558441```
559442
560443Note the inverted predicate.
@@ -570,7 +453,7 @@ Chris Date identified that all constraints can be represented as inclusion depen
570453Uniqueness constraints ensure that a set of attributes' values are unique throughout a relational expression. For example, it is useful to ensure that all products' identifiers are unique. The equivalent in SQL is the UNIQUE expression found in table creation.
571454
572455```
573−TutorialD (master/main): key s_key_constraint {s#} s
456+TutorialD (master): key s_key_constraint {s#} s
574457```
575458
576459This expression creates a constraint named "S_key_constraint" and ensure that the values of the "s#" attribute are unique in the "S" relational expression.
@@ -580,35 +463,21 @@ This expression creates a constraint named "S_key_constraint" and ensure that th
580463Foreign keys are constraints which require that certain values appearing in one relation variable must appear in another. The equivalent in SQL is the FOREIGN KEY() construction in table creation.
581464
582465```
583−TutorialD (master/main): foreign key s#_in_sp sp{s#} in s{s#}
466+TutorialD (master): foreign key s#_in_sp sp{s#} in s{s#}
584467```
585468
586−This expression ensure that any sp{s#} must also appear as a value in s{s#}. Note that the sub-expression (on the left of "in") and the super-expression (on the right) must be of the same relation type- the generated relation values' attribute names and types must be equal. Use `rename` to make attribute names identical.
587−
588−#### Functional dependencies
589−
590−Unlike SQL databases, Project:M36 includes first-class support for functional dependencies. A functional dependency for an attribute set ```A``` to attribute set ```B``` ensures that for every unique appearance of a value for ```A``` there is only one possible value for ```B```.
591−
592−To create a functional dependency:
593−
594−```
595−TutorialD (master/main): funcdep sname_status (sname) -> (status) s
596−```
597−
598−In this example, the functional dependency is named "sname_status" and creates a constraint which ensures that the "sname" value is functionally determines "status" value in the relation variable "s", though the final argument can be any relational expression. Multiple attribute names are separated by a comma.
469+This expression ensure that any sp{s#} must also appear as a value in s{s#}.
599470
600471#### Other Constraints
601472
602473All other constraints can be represented by a set of inclusion dependencies.
603474
604475```
605−TutorialD (master/main): constraint s_status_less_than_50 (s where ^lt(50,@status)){} in false
476+TutorialD (master): constraint s_status_less_than_50 (s where ^lt(50,@status)){} in false
606477```
607478
608479This expression ensures that the relation variable's relation can never include a tuple with status greater than 50.
609480
610−Internally, *all* constraints are converted and stored as inclusion dependencies.
611−
612481## Aggregate Queries
613482
614483Aggregate queries in TutorialD are able to provide much more information than SQL queries due to the support for relation-valued attributes. For example, a single query can return aggregate results alongside its constituent tuples.
@@ -616,28 +485,28 @@ Aggregate queries in TutorialD are able to provide much more information than SQ
616485SQL supports aggregate queries using aggregate functions (SUM(), COUNT(), AVERAGE(), etc.) and GROUP BY while the aggregate functions in the relational algebra simply accept relation values as arguments.
617486
618487```
619−TutorialD (master/main): :showexpr s group ({s#,sname,status} as subrel):{citycount:=count(@subrel)}
620−┌──────────┬──────────────────┬───────────────────────────────────────────────────────┐
621−│city::Text│citycount::Integer│subrel::relation {s#::Text,sname::Text,status::Integer}│
622−├──────────┼──────────────────┼───────────────────────────────────────────────────────┤
623−│"Athens" │1 │┌────────┬───────────┬───────────────┐ │
624−│ │ ││s#::Text│sname::Text│status::Integer│ │
625−│ │ │├────────┼───────────┼───────────────┤ │
626−│ │ ││"S5" │"Adams" │30 │ │
627−│ │ │└────────┴───────────┴───────────────┘ │
628−│"Paris" │2 │┌────────┬───────────┬───────────────┐ │
629−│ │ ││s#::Text│sname::Text│status::Integer│ │
630−│ │ │├────────┼───────────┼───────────────┤ │
631−│ │ ││"S2" │"Jones" │10 │ │
632−│ │ ││"S3" │"Blake" │30 │ │
633−│ │ │└────────┴───────────┴───────────────┘ │
634−│"London" │2 │┌────────┬───────────┬───────────────┐ │
635−│ │ ││s#::Text│sname::Text│status::Integer│ │
636−│ │ │├────────┼───────────┼───────────────┤ │
637−│ │ ││"S4" │"Clark" │20 │ │
638−│ │ ││"S1" │"Smith" │20 │ │
639−│ │ │└────────┴───────────┴───────────────┘ │
640−└──────────┴──────────────────┴───────────────────────────────────────────────────────┘
488+TutorialD (master): :showexpr s group ({s#,sname,status} as subrel):{citycount:=count(@subrel)}
489+┌──────┬─────────┬─────────────────┐
490+│city │citycount│subrel │
491+├──────┼─────────┼─────────────────┤
492+│Paris │2 │┌──┬─────┬──────┐│
493+│ │ ││s#│sname│status││
494+│ │ │├──┼─────┼──────┤│
495+│ │ ││S3│Blake│30 ││
496+│ │ ││S2│Jones│10 ││
497+│ │ │└──┴─────┴──────┘│
498+│London│2 │┌──┬─────┬──────┐│
499+│ │ ││s#│sname│status││
500+│ │ │├──┼─────┼──────┤│
501+│ │ ││S1│Smith│20 ││
502+│ │ ││S4│Clark│20 ││
503+│ │ │└──┴─────┴──────┘│
504+│Athens│1 │┌──┬─────┬──────┐│
505+│ │ ││s#│sname│status││
506+│ │ │├──┼─────┼──────┤│
507+│ │ ││S5│Adams│30 ││
508+│ │ │└──┴─────┴──────┘│
509+└──────┴─────────┴─────────────────┘
641510```
642511
643512In this query result, we can simultaneously answer how many suppliers are located in each city and which suppliers they are. The expression is constructed by first grouping to isolate the city, then extending the query to add a attribute containing the tuple count for each subrelation.
@@ -648,28 +517,3 @@ In this query result, we can simultaneously answer how many suppliers are locate
648517|sum(relation{int})|return the int sum of the relation's values|
649518|max(relation{int})|return the maximum int from all the relation's values|
650519|min(relation{int})|return the minimum int from all the relation's values|
651−
652−#### Arbitrary Relation Variables
653−
654−For testing purposes, it can be useful to populate a database with randomly generated data. Project:M36 can automatically create such data based solely on the type of the relation.
655−
656−```
657−TutorialD (master/main): createarbitraryrelation employee {name Text, empid Int, hired DateTime} 3-100
658−TutorialD (master/main): :showexpr employee
659−┌──────────┬───────────────────────┬──────────┐
660−│empid::Int│hired::DateTime │name::Text│
661−├──────────┼───────────────────────┼──────────┤
662−│23 │1858-11-04 10:50:14 UTC│"LLL" │
663−│22 │1858-12-10 14:53:37 UTC│"LLL" │
664−│25 │1858-11-07 01:14:15 UTC│"SSS" │
665−│-12 │1858-11-06 06:20:57 UTC│"VVV" │
666−│-6 │1858-11-01 16:26:38 UTC│"SSS" │
667−│-1 │1858-10-31 14:41:26 UTC│"DDD" │
668−│-15 │1858-11-26 04:14:03 UTC│"VVV" │
669−│-18 │1858-12-17 00:01:09 UTC│"AAA" │
670−│-9 │1858-10-31 08:36:53 UTC│"XXX" │
671−│4 │1858-11-23 01:48:04 UTC│"VVV" │
672−└──────────┴───────────────────────┴──────────┘
673−```
674−
675−The `createarbitraryrelation` syntax specifies the name of the relation variable, the type for the relation, and then an acceptable range for the tuple count.
docs/using_notifications.markdown+25−29
@@ -9,9 +9,8 @@ As an example, consider an email application. Users of the applications will wan
99A Project:M36 notification is comprised of three user-selected parts:
1010
11111. an arbitrary notification name: used to uniquely identify the notification in the server and client
12−1. a trigger relational expression: when the outcome of this relational expression changes between two transactions, the notification is fired
13−1. a report relational expression for the pre-change context: when the notification fires, the expression is evaluated in the old context and passed along
14−1. a report relational expression for the post-change context: when the notification fires, the expression is evaluated in the new context and passed along
12+2. a trigger relational expression: when the outcome of this relational expression changes between two transactions, the notification is fired
13+3. a report relational expression: when the notification fires, the expression is evaluated and passed along
1514
1615By separating the "trigger" and "report" expressions, database users control what kind of reporting they receive when the outcome of a relational expression changes.
1716
@@ -22,7 +21,7 @@ Currently, notifications are sent to all connected clients and not only to the c
2221Notifications can be created in the ```tutd``` TutorialD interpreter with the following syntax:
2322
2423```
25−notify <notification name> <trigger relational expression> <report relational expression (pre-change)> <report relational expression (post-change)>
24+notify <notification name> <trigger relational expression> <report relational expression>
2625```
2726
2827## Deleting a Notification
@@ -38,44 +37,41 @@ unnotify <notification name>
3837Consider the following ```person``` relation variable where "name" is a key:
3938
4039```
41−TutorialD (master/main): person:=relation{tuple{name "Steve",address "Main St."},tuple{name "John", address "Elm St."}}
42−TutorialD (master/main): :showexpr person
43−┌─────────────┬──────────┐
44−│address::Text│name::Text│
45−├─────────────┼──────────┤
46−│"Main St." │"Steve" │
47−│"Elm St." │"John" │
48−└─────────────┴──────────┘
40+TutorialD (master): person:=relation{tuple{name "Steve",address "Main St."},tuple{name "John", address "Elm St."}}
41+TutorialD (master): :showexpr person
42+┌────────┬─────┐
43+│address │name │
44+├────────┼─────┤
45+│Elm St. │John │
46+│Main St.│Steve│
47+└────────┴─────┘
4948```
5049
5150If a remote application is currently the address in the tuple for "Steve", then it would install a notification for that tuple's key:
5251
5352```
54−TutorialD (master/main): notify steve_change person where name="Steve" true (person where name="Steve"){address}
55−TutorialD (master/main): :commit
53+TutorialD (master): notify steve_change person where name="Steve" (person where name="Steve"){address}
54+TutorialD (master): :commit
5655```
5756
58−In this case, we pass `true` as the old context report expression because we plan to ignore the result.
59−
6057Then, when any client including the initiating client updates the "Steve" tuple, an asynchronous notification is fired:
6158
6259```
63−TutorialD (master/main): update person where name="Steve" (address:="Grove St.")
64−TutorialD (master/main): :commit
65−TutorialD (master/main): Notification received "steve_change": ...
60+TutorialD (master): update person where name="Steve" (address:="Grove St.")
61+TutorialD (master): :commit
62+TutorialD (master): Notification received "steve_change": ...
6663```
6764
68−The asynchronously-received notification contains the result from the evaluated report relational expression. The expression, in this case, is the result of the report expression evaluated against the new transaction:
65+The asynchronously-received notification contains the result from the evaluated report relational expression. The expression, in this case, is the result of the report expression evaluated against the parent transactoin
6966
7067```
71−TutorialD (master/main): Notification received "steve_change":
68+TutorialD (master): Notification received "steve_change":
7269Project (AttributeNames (fromList ["address"])) (Restrict (AttributeEqualityPredicate "name" (NakedAtomExpr Atom "Steve")) (RelationVariable "person"))
73−┌─────────────┐
74−│address::Text│
75−├─────────────┤
76−│"Grove St." │
77−└─────────────┘
78−
70+┌────────┐
71+│address │
72+├────────┤
73+│Main St.│
74+└────────┘
7975```
8076
8177## Notifications with ProjectM36.Client
@@ -84,10 +80,10 @@ First, implement a ```NotificationCallback``` function to perform an IO action w
8480
8581Each ProjectM36 Connection can only have one callback and it cannot be changed after Connection creation.
8682
87−Then, create a DatabaseContextExpr using the AddNotification constructor:
83+Then, create a DatabaseExpr using the AddNotification constructor:
8884
8985```
90−AddNotification <notification name::Text> <change expression::RelationalExpr> <report old context expression::RelationalExpr> <report new context expression::RelationalExpr>
86+AddNotification <notification name::Text> <change expression::RelationalExpr> <report expression::RelationalExpr>
9187```
9288
9389and execute it using ```executeDatabaseContextExpr```. In order for a notification to take effect, it must be committed as well.
docs/websocket_server.markdown+3−3
@@ -6,7 +6,7 @@ The Project:M36 WebSocket server makes it easy to connect non-Haskell programs t
66
77## Setup
88
9−The websocket server is started with the same arguments as the normal [Project:M36 server](server_mode.markdown):
9+The websocket server is started with the same arguments as the normal [Project:M36 server](docs/server_mode.markdown):
1010
1111```
1212cabal run project-m36-websocket-server -- --database mydbname --hostname 127.0.0.1
@@ -16,8 +16,8 @@ except that the websocket server is now listening for websocket connections on p
1616
1717## Client Connection
1818
19−A [simple JavaScript library](/src/bin/ProjectM36/Server/WebSocket/project-m36.js) to manage the WebSocket connection is available.
19+A [simple JavaScript library](ProjectM36/Server/WebSocket/project-m36.js) to manage the WebSocket connection is available.
2020
2121## Sample Application
2222
23−The [WebSocket example application](/src/bin/ProjectM36/Server/WebSocket/websocket-client.html) can be used to learn TutorialD and for remote database access from the web browser.
23+The [WebSocket example application](ProjectM36/Server/WebSocket/websocket-client.html) can be used to learn TutorialD and for remote database access from the web browser.
examples/CustomTupleable.hsdeleted−67
@@ -1,67 +0,0 @@
1−{-# LANGUAGE DeriveGeneric, OverloadedStrings #-}
2−--this example shows how to implement a non-generics-defined Tupleable instance which is required in scenarios where Haskell-side types are not supported server-side or where one wishes to represent a nested relation
3−import ProjectM36.Client
4−import ProjectM36.Tuple
5−import ProjectM36.Tupleable
6−import ProjectM36.Relation
7−import ProjectM36.Atom
8−import ProjectM36.Attribute as A
9−import qualified Data.Set as S
10−import qualified Data.Map as M
11−import Data.Text (Text)
12−import GHC.Generics
13−import Data.Proxy
14−
15−--in this contrived example, we wish to represent one relation with a nested relation of comments
16−data Blog = Blog {
17− title :: Text,
18− comments :: S.Set Comment
19− } deriving (Show)
20−
21−data Comment = Comment {
22− authorName :: Text,
23− comment :: Text
24− } deriving (Eq, Show, Generic, Ord)
25−
26−instance Tupleable Comment
27−
28−instance Tupleable Blog where
29− toTuple blogentry =
30− mkRelationTupleFromMap (M.fromList [("title", TextAtom (title blogentry)),
31− ("comments", RelationAtom relFromComments)])
32− where
33− commentTuples = map toTuple (S.toList (comments blogentry))
34− relFromComments = case mkRelationFromTuples (toAttributes (Proxy :: Proxy Comment)) commentTuples of
35− Left err -> error (show err)
36− Right rel -> rel
37−
38− fromTuple tupIn = do
39− titleAtom <- atomForAttributeName "title" tupIn
40− commentsAtom <- atomForAttributeName "comments" tupIn
41− commentsRel <- relationForAtom commentsAtom
42− comments' <- mapM fromTuple (tuplesList commentsRel)
43− pure Blog {
44− title = atomToText titleAtom,
45− comments = S.fromList comments'}
46−
47− toAttributes _ = A.attributesFromList [Attribute "title" TextAtomType,
48− Attribute "comments" $ RelationAtomType (toAttributes (Proxy :: Proxy Comment))]
49−
50−main :: IO ()
51−main = do
52− let exampleBlog = Blog { title = "Cat Pics",
53− comments = S.fromList [Comment {authorName = "Steve",
54− comment = "great"},
55− Comment {authorName = "Bob",
56− comment = "enough"}
57− ]}
58− print (toTuple exampleBlog)
59− print (fromTuple (toTuple exampleBlog) :: Either RelationalError Blog)
60−
61−
62−
63−
64−
65−
66−
67−
examples/DerivingCustomTupleable.hsdeleted−54
@@ -1,54 +0,0 @@
1−{-# LANGUAGE DeriveGeneric, DerivingVia, GeneralizedNewtypeDeriving, TypeOperators, DataKinds, OverloadedStrings #-}
2−
3−import ProjectM36.Tupleable.Deriving
4−import ProjectM36.Atomable (Atomable)
5−import Control.DeepSeq (NFData)
6−import Data.Text (Text)
7−import GHC.Generics (Generic)
8−import Codec.Winery
9−
10−newtype BlogId = BlogId { getBlogId :: Int }
11− deriving stock (Eq, Ord, Show, Generic)
12− deriving newtype (Num)
13− deriving Serialise via WineryRecord BlogId
14−
15−instance NFData BlogId
16−instance Atomable BlogId
17−
18−data Blog = Blog
19− { blogId :: BlogId
20− , blogTitle :: Text
21− , blogAuthorName :: Text
22− }
23− deriving stock (Show, Generic)
24− deriving (Tupleable)
25− via Codec (Field (DropPrefix "blog" >>> CamelCase)) Blog
26− deriving Serialise via WineryRecord Blog
27−
28−data Comment = Comment
29− { commentAuthorName :: Text
30− , commentComment :: Text
31− , commentFor :: BlogId
32− }
33− deriving stock (Show, Generic)
34− deriving (Tupleable)
35− via Codec (Field (DropPrefix "comment" >>> CamelCase)) Comment
36− deriving Serialise via WineryRecord Comment
37−
38−main :: IO ()
39−main = do
40− let exampleBlog = Blog
41− { blogId = 0
42− , blogTitle = "Cat Pics"
43− , blogAuthorName = "Alice"
44− }
45− exampleComment = Comment
46− { commentAuthorName = "Bob"
47− , commentComment = "great"
48− , commentFor = 0
49− }
50− print exampleBlog
51− print (toTuple exampleBlog)
52− putStrLn ""
53− print exampleComment
54− print (toTuple exampleComment)
examples/DynamicAtomFunctions.hsdeleted−12
@@ -1,12 +0,0 @@
1−{-# LANGUAGE OverloadedStrings #-}
2−--compile with `cabal exec ghc -- examples/DynamicAtomFunctions.hs -package project-m36`
3−--load with `loadatomfunctions "DynamicAtomFunctions" "someAtomFunctions" "examples/DynamicAtomFunctions.o"`
4−
5−module DynamicAtomFunctions where
6−import ProjectM36.Base
7−
8−someAtomFunctions :: [AtomFunction]
9−someAtomFunctions = [AtomFunction{
10− atomFuncName = "constTrue",
11− atomFuncType = [TypeVariableType "a", BoolAtomType],
12− atomFuncBody = AtomFunctionBody Nothing (\(x:_) -> pure (BoolAtom True))}]
examples/DynamicDatabaseContextFunctions.hsdeleted−26
@@ -1,26 +0,0 @@
1−{-# LANGUAGE OverloadedStrings #-}
2−--compile with `cabal exec ghc -- examples/DynamicDatabaseContextFunctions.hs -package project-m36`
3−--load with `loaddatabasecontextfunctions "DynamicDatabaseContextFunctions" "someDBCFunctions" "examples/DynamicDatabaseContextFunctions.o"`
4−module DynamicDatabaseContextFunctions where
5−import ProjectM36.Base
6−import ProjectM36.Relation
7−import ProjectM36.DatabaseContextFunctionError
8−import qualified ProjectM36.Attribute as A
9−
10−import qualified Data.Map as M
11−
12−
13−someDBCFunctions :: [DatabaseContextFunction]
14−someDBCFunctions = [DatabaseContextFunction {
15− dbcFuncName = "addtestrel",
16− dbcFuncType = [],
17− dbcFuncBody = DatabaseContextFunctionBody Nothing addTestRel
18− }]
19− where
20− addTestRel _ ctx = do
21− let attrs = A.attributesFromList [Attribute "word" TextAtomType]
22− eRel = mkRelationFromList attrs [[TextAtom "nice"]]
23− case eRel of
24− Left err -> Left (DatabaseContextFunctionUserError (show err))
25− Right testRel ->
26− pure $ ctx { relationVariables = M.insert "testRel" testRel (relationVariables ctx) }
examples/Hospital.hs+5−5
@@ -25,7 +25,7 @@ failFastMaybe :: (Show a) => Maybe a -> IO ()
2525failFastMaybe (Just err) = error (show err)
2626failFastMaybe Nothing = return ()
2727
28−failFastEither :: Show a => Either a b -> IO b
28+failFastEither :: (Show a) => Either a b -> IO (b)
2929failFastEither (Left err) = error (show err)
3030failFastEither (Right val) = return val
3131
@@ -53,11 +53,11 @@ runExample = do
5353 Nothing -> error "not a singleton relation!"
5454 Just tuple -> do
5555 (Atom age_value_out) <- failFastEither $ atomForAttributeName "age" tuple
56− print age_value_in
57− print age_value_out
56+ putStrLn (show age_value_in)
57+ putStrLn (show age_value_out)
5858 case cast age_value_out of
5959 Nothing -> error "wrong datatype"
60− Just age_value_out' ->
61− print (age_value_in == age_value_out')
60+ Just age_value_out' -> do
61+ putStrLn (show (age_value_in == age_value_out'))
6262
6363
examples/PersistClient.hsnew file+55
@@ -0,0 +1,55 @@
1+{-# LANGUAGE TemplateHaskell, QuasiQuotes, TypeFamilies, GADTs, EmptyDataDecls, TypeSynonymInstances, FlexibleInstances, FlexibleContexts, RankNTypes, MultiParamTypeClasses, GeneralizedNewtypeDeriving #-}
2+{-# OPTIONS_GHC -fno-warn-orphans #-}
3+{- A simple example of using the persistent-ProjectM36 driver. -}
4+import Database.Persist.ProjectM36 hiding (executeDatabaseContextExpr)
5+import ProjectM36.Client
6+import ProjectM36.DataTypes.Primitive
7+import System.Exit
8+import System.IO
9+import Database.Persist
10+import Database.Persist.TH
11+import Language.Haskell.TH.Syntax
12+import Control.Monad.Reader
13+
14+--1. declare the models with Template Haskell
15+let projectM36PersistSettings = mkPersistSettings (ConT ''ProjectM36Backend)
16+ in
17+ share [mkPersist projectM36PersistSettings] [persistLowerCase|
18+Person
19+ name String Eq
20+ age Int
21+ UniqueName name
22+ deriving Show
23+|]
24+
25+errDie :: String -> IO ()
26+errDie out = hPutStrLn stderr out >> exitFailure
27+
28+defPersonRel :: SessionId -> Connection -> IO ()
29+defPersonRel sessionId conn = do
30+ let attrList = [Attribute "name" textAtomType, Attribute "age" intAtomType, Attribute "id" textAtomType]
31+ maybeErr <- executeDatabaseContextExpr sessionId conn (Define "person" (map NakedAttributeExpr attrList))
32+ case maybeErr of
33+ Nothing -> return ()
34+ Just err -> errDie (show err)
35+
36+main :: IO ()
37+main = do
38+ --1. create the database connection
39+ let connInfo = InProcessConnectionInfo NoPersistence emptyNotificationCallback
40+ withProjectM36Conn connInfo $ runProjectM36Conn $ do
41+ --2. use the underlying client connection and session to define a relation variable
42+ (sessionId, conn) <- ask
43+ liftIO $ defPersonRel sessionId conn
44+ --3. insert some data
45+ _ <- insert $ Person "Michael" 33
46+ _ <- insert $ Person "Steve" 20
47+ --4. query on a unique key
48+ michael <- getBy $ UniqueName "Michael"
49+ liftIO $ putStrLn (show michael)
50+ --5. other queries
51+ youngerThan30Users <- selectList [PersonAge <. 30] []
52+ liftIO $ putStrLn (show youngerThan30Users)
53+ -- Updates and deletes operate by normal persistent APIs.
54+ -- Sorting results is not yet supported.
55+
examples/Plantfarm.hsdeleted−446
@@ -1,446 +0,0 @@
1−{-# LANGUAGE DeriveGeneric #-}
2−
3−{-# LANGUAGE OverloadedStrings #-}
4−
5−{-# LANGUAGE DeriveAnyClass #-}
6−
7−{-# LANGUAGE DerivingVia #-}
8−
9−
10−import Codec.Winery (Serialise, WineryVariant(WineryVariant))
11−import Control.DeepSeq (NFData)
12−import Data.Aeson (FromJSON, ToJSON(toEncoding, toJSON))
13−import Data.Data (Proxy(Proxy))
14−import Data.Either (lefts, rights)
15−import Data.Functor (($>))
16−import Data.Text as T (Text)
17−import qualified Data.Text.Lazy as TL (pack)
18−import GHC.Generics (Generic)
19−import qualified ProjectM36.Base as Base
20−import ProjectM36.Client
21− ( AtomExprBase(NakedAtomExpr)
22− , Atomable(toAddTypeExpr, toAtom)
23− , AttributeName
24− , Connection
25− , ConnectionInfo(InProcessConnectionInfo)
26− , DatabaseContextExpr
27− , DatabaseContextExprBase(Delete)
28− , PersistenceStrategy(NoPersistence)
29− , RelationalError
30− , RelationalExprBase(RelationVariable, Restrict)
31− , RestrictionPredicateExprBase(AttributeEqualityPredicate)
32− , SessionId
33− , close
34− , commit
35− , connectProjectM36
36− , createSessionAtHead
37− , databaseContextExprForUniqueKey
38− , defaultHeadName
39− , emptyNotificationCallback
40− , executeDatabaseContextExpr
41− , executeRelationalExpr
42− , withTransaction
43− )
44−import qualified ProjectM36.Relation as Relation
45−import ProjectM36.Tupleable
46− ( Tupleable(fromTuple)
47− , toDefineExpr
48− , toDeleteExpr
49− , toInsertExpr
50− , toUpdateExpr
51− )
52−import qualified System.Random as R
53−
54−
55−import Control.Monad.IO.Class (MonadIO(liftIO))
56−import qualified Web.Scotty as S
57−
58−-- | This is an example showcasing the updating of data
59−-- with the help of plants. \\
60−-- This is a very simple example and of course not how
61−-- plants grow in nature. \\
62−-- The main goal of this example is to showcase the updating
63−-- of data and the different options of persistence.
64−-- You can just pipe the output from curl into jq:
65−--
66−-- curl -X POST -H 'Accept: application/json' http://localhost:8001/plant/water/angu | jq -r '.stage'
67−
68−
69−data Stage = Seed | Sprout | Seedling | Adult | Dead
70− deriving (Show, Eq, Ord, Generic, NFData, Atomable)
71− deriving Serialise via WineryVariant Stage
72−
73−
74−instance ToJSON Stage where -- The where can be removed and the implementation commented out
75− -- if the ascii values are not wanted
76− toJSON s = toJSON $ show s <> "\nascii only provided for visualisation:\n" <> stagetoAscii s
77−
78− toEncoding s = toEncoding $ show s <> "\nascii only provided for visualisation:\n" <> stagetoAscii s
79−
80−instance FromJSON Stage
81−
82−instance S.Parsable Stage where
83− parseParam t
84− | t == "seed" || t == "Seed" = Right Seed
85− | t == "sprout" || t == "Sprout" = Right Sprout
86− | t == "seedling" || t == "Seedling" = Right Seedling
87− | t == "adult" || t == "Adult" = Right Adult
88− | t == "dead" || t == "Dead" = Right Dead
89− | otherwise = Left t
90−
91−
92−-- Just for ToJSON for ilustration of stage
93−type ASCIIStage = String
94−
95−seedStr :: ASCIIStage
96−seedStr = "<>\n\
97− \'''\n"
98−sproutStr :: ASCIIStage
99−sproutStr = " ..\n\
100− \<|>\n\
101− \''''\n"
102−seedlingStr :: ASCIIStage
103−seedlingStr = " `\\⁄o \n\
104− \ v|/\n\
105− \'´;'''\n"
106−adultStr :: ASCIIStage
107−adultStr = "*~(#)~\n\
108− \ \\,Y,e\n\
109− \ \\|/\n\
110− \''+'\\''\n"
111−deadStr :: ASCIIStage
112−deadStr = " ,__:<\n\
113− \'/'''''\n"
114−
115−-- Just used for ToJSON illustration of stages
116−stagetoAscii :: Stage -> ASCIIStage
117−stagetoAscii Seed = seedStr
118−stagetoAscii Sprout = sproutStr
119−stagetoAscii Seedling = seedlingStr
120−stagetoAscii Adult = adultStr
121−stagetoAscii Dead = deadStr
122−
123−-- used for update stage
124−next :: Stage -> Stage
125−next Seed = Sprout
126−next Sprout = Seedling
127−next Seedling = Adult
128−next s = s
129−
130−data Plant = Plant { name :: Text, species :: Text, stage :: Stage, waterings:: Integer } deriving (Show, Generic)
131−instance Tupleable Plant
132−instance ToJSON Plant
133−instance FromJSON Plant
134−
135−
136−main :: IO ()
137−main = do
138− putStrLn "Connecting to plant farm"
139− c <- dbConnection
140− _ <- createSchema c
141− putStrLn "Planting some plants"
142− _ <- insertSampleData c
143− let port = 8001
144− putStrLn $ "Started Plant farm at " <> show port
145− S.scotty port $ do
146−
147− -- retrieve a plant by name
148− S.get "/plant/:name" $ do
149− n <- S.param "name"
150− e <- liftIO $ getPlant c n
151− p <- handleWebError e
152− S.json p
153−
154−
155− -- save a plant providing it as json data
156− S.post "/plant" $ do
157− pl <- S.jsonData :: S.ActionM Plant
158− e <- liftIO $ savePlant c [pl]
159− p <- handleWebError e
160− S.json p
161−
162− -- updating a plant providing it as json data
163− S.put "/plant" $ do
164− pl <- S.jsonData :: S.ActionM Plant
165− e <- liftIO $ updatePlantFst c pl
166− p <- handleWebError e
167− S.json p
168−
169− -- watering the plant having the provided name.
170− -- This will water the plant and might let it progress to the next stage. It might also die.
171− S.post "/plant/water/:name" $ do
172− n <- S.param "name"
173− e <- liftIO $ waterPlant c n
174− p <- handleWebError e
175− S.json p
176−
177− -- retriving all the plants as json data
178− S.get "/plants" $ do
179− e <- liftIO $ getAllPlants c
180− ps <- handleWebErrors e
181− S.json ps
182−
183− -- saving many plants at the same time
184− S.post "/plants" $ do
185− pl <- S.jsonData :: S.ActionM [Plant]
186− e <- liftIO $ savePlant c pl
187− p <- handleWebError e
188− S.json p
189−
190− -- deleting all plants at a specific stage
191− S.delete "/plants?stage=:stage" $ do
192− s <- S.param "stage"
193− e <- liftIO $ deletePlantsByStage c s
194− p <- handleWebError e
195− S.json p
196−
197− -- deleting all plants at a specific stage
198− S.delete "/plants" $ do
199− s <- S.param "name"
200− e <- liftIO $ deletePlantByName c s
201− p <- handleWebError e
202− S.json p
203−
204− -- deleting all dead plants
205− S.delete "/plants/clear" $ do
206− e <- liftIO $ clearDeadPlants c
207− ps <- handleWebErrors e
208− S.json ps
209−
210−handleWebError :: Either Err b -> S.ActionM b
211−handleWebError (Left e) = S.raise (TL.pack $ "An error occurred:\n" <> show e)
212−handleWebError (Right v) = pure v
213−
214−handleWebErrors :: [Either Err b] -> S.ActionM [b]
215−handleWebErrors e = do
216− case lefts e of
217− [] -> pure (rights e)
218− l -> S.raise (TL.pack $ "Errors occurred:\n" <> concatMap ((<>"\n") . show) l)
219−
220−
221−-- | watering a plant and thereby possibly updating its stage
222−waterPlant :: DBConnection -> Text -> IO (Either Err Plant)
223−waterPlant db n = do
224− p <- getPlant db n
225− case p of
226− Left e -> pure $ Left e
227− Right v -> updateStage db $ v { waterings = waterings v + 1 }
228−
229−-- | used by 'waterPlant' updates the stage depending on random numbers
230−updateStage :: DBConnection -> Plant -> IO (Either Err Plant)
231−updateStage db p@(Plant _ _ Dead _ ) = do
232− tmp <- updatePlantFst db p
233− case tmp of
234− Left e -> pure $ Left e
235− Right _ -> pure $ Right p
236−updateStage db p = do
237− res <- calculateStage p
238− tmp <- updatePlantFst db res
239− case tmp of
240− Left e -> pure $ Left e
241− Right _ -> pure $ Right res
242− where calculateStage p' = do
243− r1 <- R.randomRIO (1, 10) :: IO Integer
244− let np = if r1 < waterings p' then p' { stage = next $ stage p', waterings = 0 } else p'
245− r2 <- R.randomRIO (1, 20)
246− pure $ if r2 < waterings np then np { stage = Dead, waterings = 0 } else np
247−
248−-- | deletes all plants with Stage = Dead
249−clearDeadPlants :: DBConnection -> IO [Either Err Plant]
250−clearDeadPlants db = do
251− _ <- deletePlantsByStage db Dead
252− getAllPlants db
253−
254−
255−-- ****************************
256−-- | *Database functions* :
257−-- ****************************
258−
259−
260−-- | Error type for passing. It is not very specific.
261−-- Just minimal and non optimal for this example.
262−data Err = NotSpecified | NotFound deriving (Show ,Generic)
263−
264−instance ToJSON Err
265−
266−-- | Just for convinience for passing around the SessionId
267−-- and the Connection
268−data DBConnection = DB SessionId Connection
269−
270−
271−-- | Getting plants by their name.\
272−-- Because plant has name as primary key \
273−-- we can assume will get at most one result. \
274−-- Alternatively we could return a list.
275−getPlant :: DBConnection -> Text -> IO (Either Err Plant)
276−getPlant db n = defaultHead (Left NotFound) <$> (
277− get db
278− ( Restrict -- Restrict can be thought of as similar to "WITH" in SQL
279− (AttributeEqualityPredicate "name" (NakedAtomExpr (toAtom n))) -- This is the Predicate we are "restricting" our RelationalExprBase with
280− (RelationVariable "plants" ())
281− )
282− :: IO [Either Err Plant] -- this is needed because our 'get' function is
283− )
284−
285−defaultHead :: a -> [a] -> a
286−defaultHead d [] = d
287−defaultHead _ (x:_) = x
288−
289−-- | Getting all the plants
290−getAllPlants :: DBConnection -> IO [Either Err Plant]
291−getAllPlants db = get db (RelationVariable "plants" ())
292−
293−-- | Getting all the plants that satisfy the restrictions
294−getAllPlantsWith :: DBConnection -> Base.RestrictionPredicateExpr -> IO [Either Err Plant]
295−getAllPlantsWith db ex = get db (Restrict ex (RelationVariable "plants" ()))
296−
297−
298−-- | Saving a plant
299−savePlant :: (Traversable t) => DBConnection -> t Plant -> IO (Either Err ())
300−savePlant db sps = insert db sps "plants"
301−
302−-- | An alternative to update alone because due to updates
303−-- not being cached yet \
304−-- they have to be calculated every update. \
305−-- This seems like an alternative until caching is implemented.
306−updatePlantFst :: DBConnection -> Plant -> IO (Either Err ())
307−updatePlantFst db pln = do
308− _ <- delete db pln ["name"] "plants"
309− savePlant db [pln]
310−
311−-- | Updating a plant. Due to the way project 36 works, \
312−-- updates have to be executed every time.\
313−-- This is slow but won't be an issue soon because they will
314−-- be cached.\
315−-- But because of this project 36 can provide O(1) commits.
316−updatePlant :: DBConnection -> Plant -> IO (Either Err ())
317−updatePlant db sps = update
318− db -- db connection
319− sps -- plant value
320− ["name"] -- the attributes to be updated by (in case of unique key)
321− "plants" -- the relation we want to update on
322−
323−
324−-- | deleting all plants that have given name.
325−deletePlantByName :: DBConnection -> Text -> IO (Either Err ())
326−deletePlantByName db s = executeWithTransaction db $ Right $ Delete "plants" $ AttributeEqualityPredicate "name" (NakedAtomExpr (toAtom s))
327−
328−-- | deleting all plants that have given stage.
329−deletePlantsByStage :: DBConnection -> Stage -> IO (Either Err ())
330−deletePlantsByStage db s = executeWithTransaction db $ Right $ Delete "plants" $ AttributeEqualityPredicate "stage" (NakedAtomExpr (toAtom s))
331−
332−
333−-- | Inserting the schema into the DB
334−createSchema :: DBConnection -> IO ()
335−createSchema (DB sessionId conn) = do
336− _ <- handleIOErrorsAndQuit $ mapM (executeDatabaseContextExpr sessionId conn) [
337− toAddTypeExpr (Proxy :: Proxy Stage) -- Adds the Type Stage as data to the DB
338− , toDefineExpr (Proxy :: Proxy Plant) "plants" -- Creates the plants relation
339− , databaseContextExprForUniqueKey "plants" ["name"] -- Makes name of the plants relation a uniqe Key,
340− -- Foreign Key restrictions are available too
341− ]
342− pure ()
343−
344−
345−-- | inserting some sample data
346−insertSampleData :: DBConnection -> IO (Either Err ())
347−insertSampleData (DB sid conn) = do
348− insert (DB sid conn) [
349− Plant "angu" "Caladenia angustata" Seed 0
350− , Plant "thely" "Thelymitra alcockiae" Seed 0
351− , Plant "monstera" "Araceae" Seed 0
352− ] "plants"
353−
354−dbConnection :: IO DBConnection
355−dbConnection = do
356− -- connect to the database
357− let connInfo = InProcessConnectionInfo NoPersistence emptyNotificationCallback []
358− -- The code below persists the data in a DB with the name "base". \\
359−-- let connInfo = InProcessConnectionInfo (CrashSafePersistence "base") emptyNotificationCallback [] \\
360− -- In addition minimal persistance is available. \\
361−-- let connInfo = InProcessConnectionInfo (MinimalPersistence "base") emptyNotificationCallback []
362− conn <- handleIOErrorAndQuit $ connectProjectM36 connInfo
363− --create a database session at the default branch of the database
364− sessionId <- handleIOErrorAndQuit $ createSessionAtHead conn defaultHeadName
365− pure (DB sessionId conn)
366−
367−
368−-- | A polymorphic function to insert data (a traversable of data) into the DB
369−insert :: (Tupleable a, Traversable t) => DBConnection -> t a -> Base.RelVarName -> IO (Either Err ())
370−insert db rlv rlvName = executeWithTransaction db $ toInsertExpr rlv rlvName
371−
372−-- | A polymorphic function to update data in the DB.
373−-- An update in one funtion would take:
374−--
375−-- - SessionId
376−-- - Connection
377−-- - Tuplable a -- the Tuplable you want to update
378−-- - [AttributeName] -- the Attributes of the Tuplable you want to update those are of StringType
379−-- - RelVarName -- the name of the relation
380−--
381−-- With that you can via 'toUpdateExpr' create a 'DatabaseContextExpr' to be executed. \\
382−-- For inserting its very similarly done with 'toInsertExpr'.
383−update :: (Tupleable a) => DBConnection -> a -> [AttributeName]-> Base.RelVarName -> IO (Either Err ())
384−update db rlv attr rlvName = executeWithTransaction db $ toUpdateExpr rlvName attr rlv
385−
386−-- | A polymorphic function to delete data in the DB
387−delete :: (Tupleable a) => DBConnection -> a -> [AttributeName]-> Base.RelVarName -> IO (Either Err ())
388−delete db rlv attr rlvName = executeWithTransaction db $ toDeleteExpr rlvName attr rlv
389−
390−-- | A convenience function to make executing DBContextExpr with commiting simpler. \\
391−-- In particular for expr that just insert, delete and update.
392−-- Therefor ultimately return Either _ ()
393−executeWithTransaction :: DBConnection -> Either RelationalError DatabaseContextExpr -> IO (Either Err ())
394−executeWithTransaction (DB sid conn) expr = do
395− iEx <- handleError expr
396− case iEx of
397− Left e -> pure $ Left e
398− Right v -> handleIOError $ withTransaction sid conn (executeDatabaseContextExpr sid conn v) (commit sid conn)
399−
400−-- | A polymorphic function to get data (a list of data and possibly errors) from the DB
401−get :: Tupleable b => DBConnection -> Base.RelationalExpr -> IO [Either Err b]
402−get (DB sessionId conn) q = do
403− eRel <- executeRelationalExpr sessionId conn q
404− e <- handleError eRel
405− case e of
406− Left err -> pure [Left err]
407− Right pRel -> do
408− ws <- Relation.toList pRel
409− mapM (handleError . fromTuple) ws
410−
411−-- | for closing the DB connection.
412−-- Not really needed when using in-memory DB
413−closeConn :: DBConnection -> IO ()
414−closeConn (DB _ conn) = close conn
415−
416−
417−-- | Error handling is heavily inspired by 'blog.hs' the blog example \\
418−-- by (agentm)[https://github.com/agentm] (https://github.com/agentm/project-m36, commit: f8432522adaafeae7c32bc2b8b6cb09c00396fc6). \\
419−-- As stated there, your application should have proper error handling.
420−handleIOErrorAndQuit :: Show e => IO (Either e a) -> IO a
421−handleIOErrorAndQuit m = do
422− v <- m
423− handleErrorAndQuit v
424−
425−handleError :: Show e => Either e a -> IO (Either Err a)
426−handleError eErr = case eErr of
427− Left err -> print err $> Left NotSpecified
428− Right v -> pure $ Right v
429−
430−handleIOError :: Show e => IO (Either e a) -> IO (Either Err a)
431−handleIOError m = do
432− v <- m
433− handleError v
434−
435−handleErrorAndQuit :: Show e => Either e a -> IO a
436−handleErrorAndQuit eErr = case eErr of
437− Left err -> print err >> error "Quit."
438− Right v -> pure v
439−
440−handleIOErrorsAndQuit :: Show e => IO [Either e a] -> IO [a]
441−handleIOErrorsAndQuit m = do
442− eErrs <- m
443− case lefts eErrs of
444− [] -> pure (rights eErrs)
445− err:_ -> handleErrorAndQuit (Left err)
446−
examples/SimpleClient.hs+16−14
@@ -1,39 +1,41 @@
11import ProjectM36.Client
22import ProjectM36.TupleSet
3+import ProjectM36.Atom
4+import ProjectM36.DataTypes.Primitive
5+import ProjectM36.Base
36import ProjectM36.Relation.Show.Term
4−import Data.Text.IO as TIO
57
68main :: IO ()
79main = do
810 -- 1. create a ConnectionInfo
9− let connInfo = RemoteConnectionInfo "mytestdb" "127.0.0.1" (show defaultServerPort) emptyNotificationCallback
11+ let connInfo = RemoteProcessConnectionInfo "mytestdb" (createNodeId "127.0.0.1" defaultServerPort) emptyNotificationCallback
1012 -- 2. conncted to the remote database
1113 eConn <- connectProjectM36 connInfo
1214 case eConn of
13− Left err -> print err
15+ Left err -> putStrLn (show err)
1416 Right conn -> do
1517 --3. create a session on the "master" branch
16− eSessionId <- createSessionAtHead conn "master"
18+ eSessionId <- createSessionAtHead "master" conn
1719 case eSessionId of
18− Left err -> print err
20+ Left err -> putStrLn (show err)
1921 Right sessionId -> do
2022 --4. define a new relation variable with a DatabaseContext expression
21− let attrList = [Attribute "name" TextAtomType,
22− Attribute "age" IntAtomType]
23+ let attrList = [Attribute "name" textAtomType,
24+ Attribute "age" intAtomType]
2325 attrs = attributesFromList attrList
2426 mErr1 <- executeDatabaseContextExpr sessionId conn (Define "person" (map NakedAttributeExpr attrList))
25− print mErr1
27+ putStrLn (show mErr1)
2628 --5. add a tuple to the relation referenced by the relation variable
27− let (Right tupSet) = mkTupleSetFromList attrs [[TextAtom "Bob", IntAtom 45]]
29+ let (Right tupSet) = mkTupleSetFromList attrs [[textAtom "Bob", intAtom 45]]
2830 mErr2 <- executeDatabaseContextExpr sessionId conn (Insert "person" (MakeStaticRelation attrs tupSet))
29− print mErr2
31+ putStrLn (show mErr2)
3032
3133 --6. execute a relational algebra query
32− let restrictionPredicate = AttributeEqualityPredicate "name" (NakedAtomExpr (TextAtom "Steve"))
33− eRel <- executeRelationalExpr sessionId conn (Restrict restrictionPredicate (RelationVariable "person" ()))
34+ let restrictionPredicate = AttributeEqualityPredicate "name" (NakedAtomExpr (textAtom "Steve"))
35+ eRel <- executeRelationalExpr sessionId conn (Restrict restrictionPredicate (RelationVariable "person"))
3436 case eRel of
35− Left err -> print err
36− Right rel -> TIO.putStrLn (showRelation rel)
37+ Left err -> putStrLn (show err)
38+ Right rel -> putStrLn (show $ showRelation rel)
3739
3840 --7. close the connection
3941 close conn
examples/blog.hsdeleted−221
@@ -1,221 +0,0 @@
1−-- a simple example of a blog schema
2−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings, CPP, DerivingVia #-}
3−
4−import ProjectM36.Client
5−import ProjectM36.Base
6−import ProjectM36.Relation
7−import ProjectM36.Tupleable
8−import ProjectM36.Atom (relationForAtom)
9−import ProjectM36.Tuple (atomForAttributeName)
10−
11−import Data.Either
12−import GHC.Generics
13−import qualified Data.Text as T
14−import qualified Data.Text.Lazy as TL
15−import Data.Time.Clock
16−import Data.Time.Calendar
17−import Control.DeepSeq
18−import Data.Proxy
19−#if __GLASGOW_HASKELL__ < 804
20−import Data.Monoid
21−#endif
22−import Data.List
23−import Control.Monad (when, forM_)
24−import Codec.Winery
25−
26−import Web.Scotty as S
27−import Text.Blaze.Html5 (h1, h2, h3, p, form, input, (!), toHtml, Html, a, toValue, hr, textarea)
28−import Text.Blaze.Html5.Attributes (name, href, type_, method, action, value)
29−import Text.Blaze.Html.Renderer.Text
30−import Control.Monad.IO.Class (liftIO)
31−import Network.HTTP.Types.Status
32−import Data.Time.Format
33−
34−--define your data types
35−data Blog = Blog {
36− title :: T.Text,
37− entry :: T.Text,
38− tstamp :: UTCTime,
39− category :: Category --note that this type is an algebraic data type
40− }
41− deriving (Generic, Show) --derive Generic so that Tupleable can use default instances
42−
43−--instantiate default Tupleable instances
44−instance Tupleable Blog
45−
46−data Comment = Comment {
47− blogTitle :: T.Text,
48− commentTime :: UTCTime,
49− contents :: T.Text
50− } deriving (Generic, Show)
51−
52−instance Tupleable Comment
53−
54−data Category = Food | Cats | Photos | Other T.Text -- note that this data type could not be represented by an "enumeration" as found in SQL databases
55− deriving (Atomable, Eq, Show, NFData, Generic) -- derive Atomable so that values of this type can be stored as a database value
56− deriving Serialise via WineryVariant Category -- derive Serialisable to be able to transmit this data remotely
57−
58−-- add some short-hand error handling- your application should have proper handling
59−handleIOError :: Show e => IO (Either e a) -> IO a
60−handleIOError m = do
61− v <- m
62− handleError v
63−
64−handleError :: Show e => Either e a -> IO a
65−handleError eErr = case eErr of
66− Left err -> print err >> error "Died due to errors."
67− Right v -> pure v
68−
69−handleIOErrors :: Show e => IO [Either e a] -> IO [a]
70−handleIOErrors m = do
71− eErrs <- m
72− case lefts eErrs of
73− [] -> pure (rights eErrs)
74− err:_ -> handleError (Left err)
75−
76−main :: IO ()
77−main = do
78− --connect to the database
79− let connInfo = InProcessConnectionInfo NoPersistence emptyNotificationCallback []
80− conn <- handleIOError $ connectProjectM36 connInfo
81−
82− sessionId <- handleIOError $ createSessionAtHead conn "master"
83−
84− createSchema sessionId conn
85− insertSampleData sessionId conn
86− --create the web routes
87− scotty 3000 $ do
88− S.get "/" (listBlogs sessionId conn)
89− S.get "/blog/:blogid" (showBlogEntry sessionId conn)
90− S.post "/comment" (addComment sessionId conn)
91−
92−--define the schema with the new Category atom (data) type, blog relvar, a comment relvar, and a foreign key relationship between them
93−createSchema :: SessionId -> Connection -> IO ()
94−createSchema sessionId conn = do
95− _ <- handleIOErrors $ mapM (executeDatabaseContextExpr sessionId conn) [
96− toAddTypeExpr (Proxy :: Proxy Category),
97− toDefineExpr (Proxy :: Proxy Blog) "blog",
98− toDefineExpr (Proxy :: Proxy Comment) "comment",
99− databaseContextExprForForeignKey "blog_comment" ("comment", ["blogTitle"]) ("blog", ["title"]),
100− databaseContextExprForUniqueKey "blog" ["title"]
101− ]
102− pure ()
103−
104−--create some sample values and insert them into the database's relation variables
105−insertSampleData :: SessionId -> Connection -> IO ()
106−insertSampleData sessionId conn = do
107− let blogs = [Blog { title = "Haskell Lenses",
108− entry = "I wear Haskell rose-colored lenses.",
109− tstamp = UTCTime (fromGregorian 2017 5 8) (secondsToDiffTime 1000),
110− category = Food },
111− Blog { title = "Haskell Monad Analogy",
112− entry = "Monads are like burritos going through intestines.",
113− tstamp = UTCTime (fromGregorian 2017 6 10) (secondsToDiffTime 2000),
114− category = Cats }
115− ]
116− comments = [Comment { blogTitle = "Haskell Lenses",
117− commentTime = UTCTime (fromGregorian 2017 7 8) (secondsToDiffTime 3000),
118− contents = "You suck!" },
119− Comment {blogTitle = "Haskell Lenses",
120− commentTime = UTCTime (fromGregorian 2017 7 9) (secondsToDiffTime 2000),
121− contents = "I find your ideas intriguing and would like to subscribe to your newsletter."}
122− ]
123− insertBlogsExpr <- handleError $ toInsertExpr blogs "blog"
124− handleIOError $ executeDatabaseContextExpr sessionId conn insertBlogsExpr
125−
126− insertCommentsExpr <- handleError $ toInsertExpr comments "comment"
127− handleIOError $ executeDatabaseContextExpr sessionId conn insertCommentsExpr
128−
129−-- handle relational errors with scotty
130−handleWebError :: Either RelationalError a -> ActionM a
131−handleWebError (Left err) = render500 (toHtml (show err)) >> pure (error "bad")
132−handleWebError (Right v) = pure v
133−
134−-- show a page with all the blog entries
135−listBlogs :: SessionId -> Connection -> ActionM ()
136−listBlogs sessionId conn = do
137− eRel <- liftIO $ executeRelationalExpr sessionId conn (RelationVariable "blog" ())
138− case eRel of
139− Left err -> render500 (toHtml (show err))
140− Right blogRel -> do
141− blogs <- liftIO (toList blogRel) >>= mapM (handleWebError . fromTuple) :: ActionM [Blog]
142− let sortedBlogs = sortBy (\b1 b2 -> tstamp b1 `compare` tstamp b2) blogs
143− html . renderHtml $ do
144− h1 "Blog Posts"
145− forM_ sortedBlogs $ \blog -> a ! href (toValue $ "/blog/" <> title blog) $ h2 (toHtml (title blog))
146−
147−render500 :: Html -> ActionM ()
148−render500 msg = do
149− html . renderHtml $ do
150− h1 "Internal Server Error"
151− p msg
152− status internalServerError500
153−
154−--display one blog post along with its comments
155−showBlogEntry :: SessionId -> Connection -> ActionM ()
156−showBlogEntry sessionId conn = do
157− blogid <- param "blogid"
158− --query the database to return the blog entry with a relation-valued attribute of the associated comments
159− let blogRestrictionExpr = AttributeEqualityPredicate "title" (NakedAtomExpr (TextAtom blogid))
160− extendExpr = AttributeExtendTupleExpr "comments" (RelationAtomExpr commentsRestriction)
161− commentsRestriction = Restrict
162− (AttributeEqualityPredicate "blogTitle" (AttributeAtomExpr "title"))
163− (RelationVariable "comment" ())
164− eRel <- liftIO $ executeRelationalExpr sessionId conn (Extend extendExpr
165− (Restrict
166− blogRestrictionExpr
167− (RelationVariable "blog" ())))
168− let render = html . renderHtml
169− formatStamp = formatTime defaultTimeLocale (iso8601DateFormat (Just "%H:%M:%S"))
170− case eRel of
171− Left err -> render500 (toHtml (show err))
172− --handle successful query execution
173− Right rel -> case singletonTuple rel of
174− Nothing -> do --no results for this blog id
175− render (h1 "No such blog post")
176− status status404
177− Just blogTuple -> case fromTuple blogTuple of --just one blog post found- it's a match!
178− Left err -> render500 (toHtml (show err))
179− Right blog -> do
180− --extract comments for the blog
181− commentsAtom <- handleWebError (atomForAttributeName "comments" blogTuple)
182− commentsRel <- handleWebError (relationForAtom commentsAtom)
183− comments <- liftIO (toList commentsRel) >>= mapM (handleWebError . fromTuple) :: ActionM [Comment]
184− let commentsSorted = sortBy (\c1 c2 -> commentTime c1 `compare` commentTime c2) comments
185− render $ do
186− --show blog details
187− h1 (toHtml (title blog))
188− p (toHtml ("Posted at " <> formatStamp (tstamp blog) <> " under " <> show (category blog)))
189− p (toHtml (entry blog))
190− hr
191− h3 "Comments"
192− --list the comments
193− forM_ commentsSorted $ \comment -> do
194− p (toHtml ("Commented at " <> formatStamp (commentTime comment)))
195− p (toHtml (contents comment))
196− when (null comments) (p "No comments.")
197− --add a comment form
198− h3 "Add a Comment"
199− form ! method "POST" ! action "/comment" $ do
200− input ! type_ "hidden" ! name "blogid" ! value (toValue blogid)
201− textarea ! name "contents" $ ""
202− input ! type_ "submit"
203−
204−--add a comment to a blog post
205−addComment :: SessionId -> Connection -> ActionM ()
206−addComment sessionId conn = do
207− blogid <- param "blogid"
208− commentText <- param "contents"
209− now <- liftIO getCurrentTime
210−
211− case toInsertExpr [Comment {blogTitle = blogid,
212− commentTime = now,
213− contents = commentText }] "comment" of
214− Left err -> handleWebError (Left err)
215− Right insertExpr -> do
216− eRet <- liftIO (withTransaction sessionId conn (executeDatabaseContextExpr sessionId conn insertExpr) (commit sessionId conn))
217− case eRet of
218− Left err -> handleWebError (Left err)
219− Right _ ->
220− redirect (TL.fromStrict ("/blog/" <> blogid))
221−
examples/hair.hsdeleted−44
@@ -1,44 +0,0 @@
1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings, DerivingVia #-}
2−import ProjectM36.Client
3−import ProjectM36.Relation.Show.Term
4−import GHC.Generics
5−import Data.Text
6−import Control.DeepSeq
7−import qualified Data.Map as M
8−import qualified Data.Text.IO as TIO
9−import Data.Proxy
10−import Codec.Winery
11−
12−data Hair = Bald | Brown | Blond | OtherColor Text
13− deriving (Generic, Show, Eq, NFData, Atomable)
14− deriving Serialise via WineryVariant Hair
15−
16−main :: IO ()
17−main = do
18− --connect to the database
19− let connInfo = InProcessConnectionInfo NoPersistence emptyNotificationCallback []
20− eCheck v = do
21− x <- v
22− case x of
23− Left err -> error (show err)
24− Right x' -> pure x'
25− conn <- eCheck $ connectProjectM36 connInfo
26−
27− --create a database session at the default branch of the fresh database
28− sessionId <- eCheck $ createSessionAtHead conn "master"
29−
30− --create the data type in the database context
31− eCheck $ executeDatabaseContextExpr sessionId conn (toAddTypeExpr (Proxy :: Proxy Hair))
32−
33− --create a relation with the new Hair AtomType
34− let blond = NakedAtomExpr (toAtom Blond)
35− eCheck $ executeDatabaseContextExpr sessionId conn
36− (Assign "people"
37− (MakeRelationFromExprs Nothing $ TupleExprs () [
38− TupleExpr (M.fromList [("hair", blond), ("name", NakedAtomExpr (TextAtom "Colin"))])]))
39−
40− let restrictionPredicate = AttributeEqualityPredicate "hair" blond
41− peopleRel <- eCheck $ executeRelationalExpr sessionId conn (Restrict restrictionPredicate (RelationVariable "people" ()))
42−
43− TIO.putStrLn (showRelation peopleRel)
44−
examples/out_of_the_tarpit.hs+59−239
@@ -1,264 +1,84 @@
11-- the Out-of-the-Tarpit example in Haskell and Project:M36
2−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings, DerivingVia #-}
2+{-# LANGUAGE DeriveAnyClass #-}
33import ProjectM36.Client
4−import ProjectM36.DataTypes.Primitive
5−import ProjectM36.Tupleable
6−import ProjectM36.Relation
7−import ProjectM36.Error
8−import Data.Either
9−import GHC.Generics
10−import Control.DeepSeq
114import qualified Data.Text as T
12−import Data.Time.Calendar
5+import ProjectM36.Atom
136import Data.Proxy
14−import Codec.Winery
157
16−--create various database value (atom) types
17−type Price = Double
8+type Text = T.Text
189
19−type Name = T.Text
10+--custom types cannot yet be made due to hardcoding in the Atom Binary implementation
11+type Address = Text
12+type Agent = Text
13+type Name = Text
14+type Price = Double
15+type FileName = Text
16+data RoomType = Kitchen | Bathroom | LivingRoom deriving (Atomable)
17+roomTypeAtomType = atomTypeForProxy (Proxy :: RoomType)
2018
21−type Address = T.Text
19+data PriceBand = Low | Medium | High | Premium
20+priceBandAtomType = atomTypeForProxy (Proxy :: PriceBand)
2221
23−data RoomType = Kitchen | Bathroom | LivingRoom
24− deriving (Generic, Atomable, Eq, Show, NFData)
25− deriving Serialise via WineryVariant RoomType
26−
27−data PriceBand = Low | Medium | High | Premium
28− deriving (Generic, Atomable, Eq, Show, NFData)
29− deriving Serialise via WineryVariant PriceBand
30−
3122data AreaCode = City | Suburban | Rural
32− deriving (Generic, Atomable, Eq, Show, NFData)
33− deriving Serialise via WineryVariant AreaCode
23+areaCodeAtomType = atomTypeForProxy (Proxy :: AreaCode)
3424
35−data SpeedBand = VeryFastBand | FastBand | MediumBand | SlowBand
36− deriving (Generic, Atomable, Eq, Show, NFData)
37− deriving Serialise via WineryVariant SpeedBand
25+data SpeedBand = VeryFastBand | FastBand | MediumBand | SlowBand
26+speedBandAtomType = atomTypeForProxy (Proxy :: SpeedBand)
3827
28+
3929main :: IO ()
4030main = do
41− --connect to the database
42− let connInfo = InProcessConnectionInfo NoPersistence emptyNotificationCallback []
31+ let connInfo = InProcessConnectionInfo emptyNotificationCallback
4332 check x = case x of
4433 Left err -> error (show err)
4534 Right x' -> x'
4635 eConn <- connectProjectM36 connInfo
4736 let conn = check eConn
4837
49− --create a database session at the default branch of the fresh database
50− eSessionId <- createSessionAtHead conn "master"
38+ eSessionId <- createSessionAtHead "master" conn
5139 let sessionId = check eSessionId
52−
53− createSchema sessionId conn
54− insertSampleData sessionId conn
55−
56−data Property = Property {
57− address :: T.Text,
58− price :: Price,
59− photo :: T.Text,
60− dateRegistered :: Day
61− }
62− deriving (Generic, Eq, Show)
63−
64−instance Tupleable Property
65−
66−data Offer = Offer {
67− offerAddress :: Address,
68− offerPrice :: Price,
69− offerDate :: Day,
70− bidderName :: Name,
71− bidderAddress :: Address,
72− decisionDate :: Day,
73− accepted :: Bool
74− }
75− deriving (Generic, Eq)
76−
77−instance Tupleable Offer
78−
79−data Decision = Decision {
80− decAddress :: Address,
81− decOfferDate :: Day, --the dec prefix is needed until OverloadedRecordFields is available
82− decBidderName :: Name,
83− decBidderAddress :: Address,
84− decDecisionDate :: Day,
85− decAccepted :: Bool
86− }
87− deriving (Generic, Eq)
88−
89−instance Tupleable Decision
90−
91−data Room = Room {
92− roomAddress :: Address,
93− roomName :: Name,
94− width :: Double,
95− breadth :: Double,
96− roomType :: RoomType
97− }
98− deriving (Generic, Eq)
99−
100−instance Tupleable Room
101−
102−data Floor = Floor {
103− floorAddress :: Address,
104− floorRoomName :: Name,
105− floorNum :: Integer
106− }
107− deriving (Generic, Eq)
108−
109−instance Tupleable Floor
110−
111−data Commission = Commission {
112− priceBand :: PriceBand,
113− areaCode :: AreaCode,
114− saleSpeed :: SpeedBand,
115− commission :: Price
116− } deriving (Generic, Eq)
117−
118−instance Tupleable Commission
119−
120−createSchema :: SessionId -> Connection -> IO ()
121−createSchema sessionId conn = do
122− --create attributes for relvars
123− let
124− --create uniqueness constraints
125− incDepKeys = map (uncurry databaseContextExprForUniqueKey)
126− [("property", ["address"]),
127− ("offer", ["offerAddress", "offerDate", "bidderName", "bidderAddress"]),
128− ("decision", ["decAddress", "decOfferDate", "decBidderName", "decBidderAddress"]),
129− ("room", ["roomAddress", "roomName"]),
130− ("floor", ["floorAddress", "floorRoomName"]),
131− --"commision" misspelled in OotT
132− ("commission", ["priceBand", "areaCode", "saleSpeed"])
133− ]
134− --create foreign key constraints
135− foreignKeys = [("offer_property_fk",
136− ("offer", ["offerAddress"]),
137− ("property", ["address"])),
138− ("decision_offer_fk",
139− ("decision", ["decAddress", "decOfferDate", "decBidderName", "decBidderAddress"]),
140− ("offer", ["offerAddress", "offerDate", "bidderName", "bidderAddress"])),
141− ("room_property_fk",
142− ("room", ["roomAddress"]),
143− ("property", ["address"])),
144− ("floor_property_fk",
145− ("floor", ["floorAddress"]),
146− ("property", ["address"]))
147− ]
148− incDepForeignKeys = map (\(n, a, b) -> databaseContextExprForForeignKey n a b) foreignKeys
149− --define the relvars
150− rvExprs = [toDefineExpr (Proxy :: Proxy Property) "property",
151− toDefineExpr (Proxy :: Proxy Offer) "offer",
152− toDefineExpr (Proxy :: Proxy Decision) "decision",
153− toDefineExpr (Proxy :: Proxy Room) "room",
154− toDefineExpr (Proxy :: Proxy Floor) "floor",
155− toDefineExpr (Proxy :: Proxy Commission) "commission"]
156− --create the new algebraic data types
157− new_adts = [toAddTypeExpr (Proxy :: Proxy RoomType),
158− toAddTypeExpr (Proxy :: Proxy PriceBand),
159− toAddTypeExpr (Proxy :: Proxy AreaCode),
160− toAddTypeExpr (Proxy :: Proxy SpeedBand)]
161− --create the stored atom functions
162− priceBandScript = "(\\(DoubleAtom price:_) -> do\n let band = if price < 10000.0 then \"Low\" else if price < 20000.0 then \"Medium\" else if price < 30000.0 then \"High\" else \"Premium\"\n let aType = ConstructedAtomType \"PriceBand\" empty\n pure (ConstructedAtom band aType [])) :: [Atom] -> Either AtomFunctionError Atom"
163− areaCodeScript = "(\\(TextAtom address:_) -> let aType = ConstructedAtomType \"AreaCode\" empty in if address == \"90210\" then pure (ConstructedAtom \"City\" aType []) else pure (ConstructedAtom \"Rural\" aType [])) :: [Atom] -> Either AtomFunctionError Atom"
164− speedBandScript = "(\\(DayAtom d1:DayAtom d2:_) -> do\n let aType = ConstructedAtomType \"SpeedBand\" empty\n (_, month1, _) = toGregorian d1\n (_, month2, _) = toGregorian d2\n if month1 == 11 && month2 == 11 then pure (ConstructedAtom \"VeryFast\" aType []) else pure (ConstructedAtom \"MediumBand\" aType [])) :: [Atom] -> Either AtomFunctionError Atom"
165− atomFuncs = [createScriptedAtomFunction "priceBandForPrice" [doubleTypeConstructor] (ADTypeConstructor "PriceBand" []) priceBandScript,
166− createScriptedAtomFunction "areaCodeForAddress" [textTypeConstructor] (ADTypeConstructor "AreaCode" []) areaCodeScript,
167− createScriptedAtomFunction "datesToSpeedBand" [dayTypeConstructor, dayTypeConstructor] (ADTypeConstructor "SpeedBand" []) speedBandScript
168− ]
169− --gather up and execute all database updates
170− putStrLn "load relvars"
171− _ <- handleIOErrors $ mapM (executeDatabaseContextExpr sessionId conn) (new_adts ++ rvExprs ++ incDepKeys ++ incDepForeignKeys)
17240
173− putStrLn "load atom functions"
174− _ <- handleIOErrors $ mapM (executeDatabaseContextIOExpr sessionId conn) atomFuncs
175− pure ()
176−
177−insertSampleData :: SessionId -> Connection -> IO ()
178−insertSampleData sessionId conn = do
179− --insert a bunch of records
180− putStrLn "load data"
181− let properties = [Property { address = "123 Main St.",
182− price = 200000,
183− photo = "123_main.jpg",
184− dateRegistered = fromGregorian 2016 4 3},
185− Property { address = "456 Main St.",
186− price = 150000,
187− photo = "456_main.jpg",
188− dateRegistered = fromGregorian 2016 5 6}]
189− insertPropertiesExpr <- handleError $ toInsertExpr properties "property"
190− handleIOError $ executeDatabaseContextExpr sessionId conn insertPropertiesExpr
191−
192− let offers = [Offer { offerAddress = "123 Main St.",
193− offerPrice = 180000,
194− offerDate = fromGregorian 2017 1 2,
195− bidderName = "Steve",
196− bidderAddress = "789 Main St.",
197− decisionDate = fromGregorian 2017 2 2,
198− accepted = False }]
199−
200− insertOffersExpr <- handleError $ toInsertExpr offers "offer"
201− handleIOError $ executeDatabaseContextExpr sessionId conn insertOffersExpr
202−
203− let rooms = [Room { roomAddress = "123 Main St.",
204− roomName = "Fabulous Kitchen",
205− width = 10,
206− breadth = 10,
207− roomType = Kitchen },
208− Room { roomAddress = "123 Main St.",
209− roomName = "Clean Bathroom",
210− width = 7,
211− breadth = 5,
212− roomType = Bathroom }]
213−
214− insertRoomsExpr <- handleError $ toInsertExpr rooms "room"
215− handleIOError $ executeDatabaseContextExpr sessionId conn insertRoomsExpr
216−
217− let decisions = [Decision { decAddress = "123 Main St.",
218− decOfferDate = fromGregorian 2017 1 2,
219− decBidderName = "Steve",
220− decBidderAddress = "789 Main St.",
221− decDecisionDate = fromGregorian 2017 05 04,
222− decAccepted = False }]
223− insertDecisionsExpr <- handleError $ toInsertExpr decisions "decision"
224− handleIOError $ executeDatabaseContextExpr sessionId conn insertDecisionsExpr
225−
226− let floors = [Floor { floorAddress = "123 Main St.",
227− floorRoomName = "Bathroom",
228− floorNum = 1
229− }]
230− insertFloorsExpr <- handleError $ toInsertExpr floors "floor"
231− handleIOError $ executeDatabaseContextExpr sessionId conn insertFloorsExpr
41+ createSchema sessionId conn
23242
233− let commissions = [Commission { priceBand = Medium,
234− areaCode = City,
235− saleSpeed = MediumBand,
236− commission = 10000 }]
237− insertCommissionsExpr <- handleError $ toInsertExpr commissions "commission"
238− handleIOError $ executeDatabaseContextExpr sessionId conn insertCommissionsExpr
43+createSchema :: Connection -> IO ()
44+createSchema conn = do
45+ let propertyAttrs = [Attribute "address" addressAtomType,
46+ Attribute "price" priceAtomType
47+ Attribute "photo" fileNameAtomType,
48+ Attribute "dateRegistered" dateAtomType]
49+ offerAttrs = [Attribute "address" addressAtomType,
50+ Attribute "offerPrice" priceAtomType,
51+ Attribute "offerDate" dateAtomType,
52+ Attribute "bidderName" nameAtomType,
53+ Attribute "bidderAddress" addressAtomType,
54+ Attribute "decisionDate" dateAtomType,
55+ Attribute "accepted" boolAtomType]
56+ decisionAttrs = [Attribute "address" addressAtomType,
57+ Attribute "offerDate" dateAtomType,
58+ Attribute "bidderName" nameAtomType,
59+ Attribute "bidderAddress" addressAtomType,
60+ Attribute "decisionDate" dateAtomType,
61+ Attribute "accepted" boolAtomType]
62+ roomAttrs = [Attribute "address" addressAtomType,
63+ Attribute "roomName" stringAtomType,
64+ Attribute "width" doubleAtomType,
65+ Attribute "breadth" doubleAtomType,
66+ Attribute "type" roomTypeAtomType]
67+ floorAttrs = [Attribute "address" addressAtomType,
68+ Attribute "roomName" stringAtomType,
69+ Attribute "floor" intAtomType]
70+ commissionAttrs = [Attribute "priceBand" priceBandAtomType,
71+ Attribute "areaCode" areaCodeAtomType,
72+ Attribute "saleSpeed" speedBandAtomType,
73+ Attribute "commission" doubleAtomType]
74+ relvarMap = [("property", propertyAttrs),
75+ ("offer", offerAttrs),
76+ ("decision", decisionAttrs),
77+ ("room", roomAttrs),
78+ ("floor", floorAttrs),
79+ ("commission", commissionAttrs)]
80+ dbcontextExprs = map (\(name, attrs) -> Define name (attributesFromList attrs)) relvarMap
81+ mapM executeDatabaseContextExpr dbcontextExprs
23982
240− --query some records, marshal them back to Haskell
241−
242− properties' <- handleIOError $ executeRelationalExpr sessionId conn (RelationVariable "property" ())
24383
244− props <- toList properties' >>= mapM (handleError . fromTuple) :: IO [Property]
245− print props
246−
247−handleError :: Either RelationalError a -> IO a
248−handleError eErr = case eErr of
249− Left err -> print err >> error "Died due to errors."
250− Right v -> pure v
251−
252−handleIOError :: IO (Either RelationalError a) -> IO a
253−handleIOError m = do
254− e <- m
255− handleError e
256−
257−handleIOErrors :: IO [Either RelationalError a] -> IO [a]
258−handleIOErrors m = do
259− eErrs <- m
260− case lefts eErrs of
261− [] -> pure (rights eErrs)
262− errs -> handleError (Left (someErrors errs))
263−
26484
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
h2svg.shdeleted−1
@@ -1 +0,0 @@
1−./.cabal-sandbox/bin/ghc-prof-flamegraph < bigrel.prof | perl ~/Dev/flamegraph.pl
hp2svg.shdeleted−2
@@ -1,2 +0,0 @@
1−cabal run bigrel -- --attribute-count 10 --tuple-count 10000 -d "x:=x" +RTS -h > /dev/null
2−./.cabal-sandbox/bin/hp2pretty bigrel.hp
install_tools.shdeleted−3
@@ -1,3 +0,0 @@
1−cabal install --enable-profiling --enable-tests
2−cabal install ghc-prof-flamegraph
3−cabal install hp2pretty
jupyter/TutorialD Notebook Walkthrough.ipynbdeleted−794
@@ -1,794 +0,0 @@
1−{
2− "cells": [
3− {
4− "cell_type": "markdown",
5− "metadata": {},
6− "source": [
7− "# Introduction to TutorialD via Jupyter Notebook\n",
8− "\n",
9− "Thanks for trying Project:M36 via this Jupyter notebook. TutorialD is a language for interacting with relational algebra databases, similar to SQL but without the historical cruft. This notebook is based on the [TutorialD Tutorial](https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown). \n",
10− "\n",
11− "[Project:M36](https://github.com/agentm/project-m36) is a feature-rich database management system (DBMS) which casts off the baggage of legacy DBMSes by adhering strictly to the mathematics of the relational algebra.\n",
12− "\n",
13− "Please refer to the [Project:M36 documentation](https://github.com/agentm/project-m36#documentation) for more detailed examples. Let's get started!\n",
14− "\n",
15− "First, let's import the Chris Date example relation variables. The relation variables provided in the example are:\n",
16− "\n",
17− "* `s` suppliers\n",
18− "* `sp` supplier-parts\n",
19− "* `p` parts"
20− ]
21− },
22− {
23− "cell_type": "code",
24− "execution_count": 1,
25− "metadata": {},
26− "outputs": [
27− {
28− "data": {
29− "text/html": [
30− "ok"
31− ],
32− "text/plain": [
33− "ok"
34− ]
35− },
36− "metadata": {},
37− "output_type": "display_data"
38− }
39− ],
40− "source": [
41− ":importexample cjdate"
42− ]
43− },
44− {
45− "cell_type": "markdown",
46− "metadata": {},
47− "source": [
48− "If you see an error in the previous cell regarding `project-m36-websocket-server` not being in your `PATH`, add the binary to your `PATH` and restart the jupyter server.\n",
49− "\n",
50− "Let's take a look at the relation variables."
51− ]
52− },
53− {
54− "cell_type": "code",
55− "execution_count": 2,
56− "metadata": {},
57− "outputs": [
58− {
59− "data": {
60− "text/html": [
61− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>s#::Text</th><th>sname::Text</th><th>status::Integer</th><th>city::Text</th></tr><tr><td>\"S3\"</td><td>\"Blake\"</td><td>30</td><td>\"Paris\"</td></tr><tr><td>\"S5\"</td><td>\"Adams\"</td><td>30</td><td>\"Athens\"</td></tr><tr><td>\"S4\"</td><td>\"Clark\"</td><td>20</td><td>\"London\"</td></tr><tr><td>\"S1\"</td><td>\"Smith\"</td><td>20</td><td>\"London\"</td></tr><tr><td>\"S2\"</td><td>\"Jones\"</td><td>10</td><td>\"Paris\"</td></tr><tfoot><tr><td colspan=\"100%\">Finite 5 tuples</td></tr></tfoot></table>"
62− ],
63− "text/plain": [
64− "┌──────────┬────────┬───────────┬───────────────┐\n",
65− "│city::Text│s#::Text│sname::Text│status::Integer│\n",
66− "├──────────┼────────┼───────────┼───────────────┤\n",
67− "│\"Paris\" │\"S2\" │\"Jones\" │10 │\n",
68− "│\"London\" │\"S1\" │\"Smith\" │20 │\n",
69− "│\"London\" │\"S4\" │\"Clark\" │20 │\n",
70− "│\"Athens\" │\"S5\" │\"Adams\" │30 │\n",
71− "│\"Paris\" │\"S3\" │\"Blake\" │30 │\n",
72− "└──────────┴────────┴───────────┴───────────────┘"
73− ]
74− },
75− "metadata": {},
76− "output_type": "display_data"
77− }
78− ],
79− "source": [
80− ":showexpr s"
81− ]
82− },
83− {
84− "cell_type": "code",
85− "execution_count": 3,
86− "metadata": {},
87− "outputs": [
88− {
89− "data": {
90− "text/html": [
91− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>s#::Text</th><th>p#::Text</th><th>qty::Integer</th></tr><tr><td>\"S1\"</td><td>\"P2\"</td><td>200</td></tr><tr><td>\"S1\"</td><td>\"P1\"</td><td>300</td></tr><tr><td>\"S3\"</td><td>\"P2\"</td><td>200</td></tr><tr><td>\"S2\"</td><td>\"P2\"</td><td>400</td></tr><tr><td>\"S4\"</td><td>\"P5\"</td><td>400</td></tr><tr><td>\"S1\"</td><td>\"P5\"</td><td>100</td></tr><tr><td>\"S1\"</td><td>\"P6\"</td><td>100</td></tr><tr><td>\"S2\"</td><td>\"P1\"</td><td>300</td></tr><tr><td>\"S1\"</td><td>\"P4\"</td><td>200</td></tr><tr><td>\"S4\"</td><td>\"P4\"</td><td>300</td></tr><tr><td>\"S4\"</td><td>\"P2\"</td><td>200</td></tr><tr><td>\"S1\"</td><td>\"P3\"</td><td>400</td></tr><tfoot><tr><td colspan=\"100%\">Finite 12 tuples</td></tr></tfoot></table>"
92− ],
93− "text/plain": [
94− "┌────────┬────────────┬────────┐\n",
95− "│p#::Text│qty::Integer│s#::Text│\n",
96− "├────────┼────────────┼────────┤\n",
97− "│\"P3\" │400 │\"S1\" │\n",
98− "│\"P2\" │200 │\"S4\" │\n",
99− "│\"P4\" │300 │\"S4\" │\n",
100− "│\"P4\" │200 │\"S1\" │\n",
101− "│\"P1\" │300 │\"S2\" │\n",
102− "│\"P6\" │100 │\"S1\" │\n",
103− "│\"P5\" │100 │\"S1\" │\n",
104− "│\"P5\" │400 │\"S4\" │\n",
105− "│\"P2\" │400 │\"S2\" │\n",
106− "│\"P2\" │200 │\"S3\" │\n",
107− "│\"P1\" │300 │\"S1\" │\n",
108− "│\"P2\" │200 │\"S1\" │\n",
109− "└────────┴────────────┴────────┘"
110− ]
111− },
112− "metadata": {},
113− "output_type": "display_data"
114− }
115− ],
116− "source": [
117− ":showexpr sp"
118− ]
119− },
120− {
121− "cell_type": "code",
122− "execution_count": 4,
123− "metadata": {
124− "scrolled": true
125− },
126− "outputs": [
127− {
128− "data": {
129− "text/html": [
130− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>p#::Text</th><th>pname::Text</th><th>color::Text</th><th>weight::Integer</th><th>city::Text</th></tr><tr><td>\"P3\"</td><td>\"Screw\"</td><td>\"Blue\"</td><td>17</td><td>\"Oslo\"</td></tr><tr><td>\"P2\"</td><td>\"Bolt\"</td><td>\"Green\"</td><td>17</td><td>\"Paris\"</td></tr><tr><td>\"P4\"</td><td>\"Screw\"</td><td>\"Red\"</td><td>14</td><td>\"London\"</td></tr><tr><td>\"P6\"</td><td>\"Cog\"</td><td>\"Red\"</td><td>19</td><td>\"London\"</td></tr><tr><td>\"P1\"</td><td>\"Nut\"</td><td>\"Red\"</td><td>12</td><td>\"London\"</td></tr><tr><td>\"P5\"</td><td>\"Cam\"</td><td>\"Blue\"</td><td>12</td><td>\"Paris\"</td></tr><tfoot><tr><td colspan=\"100%\">Finite 6 tuples</td></tr></tfoot></table>"
131− ],
132− "text/plain": [
133− "┌──────────┬───────────┬────────┬───────────┬───────────────┐\n",
134− "│city::Text│color::Text│p#::Text│pname::Text│weight::Integer│\n",
135− "├──────────┼───────────┼────────┼───────────┼───────────────┤\n",
136− "│\"Paris\" │\"Blue\" │\"P5\" │\"Cam\" │12 │\n",
137− "│\"London\" │\"Red\" │\"P1\" │\"Nut\" │12 │\n",
138− "│\"London\" │\"Red\" │\"P6\" │\"Cog\" │19 │\n",
139− "│\"London\" │\"Red\" │\"P4\" │\"Screw\" │14 │\n",
140− "│\"Paris\" │\"Green\" │\"P2\" │\"Bolt\" │17 │\n",
141− "│\"Oslo\" │\"Blue\" │\"P3\" │\"Screw\" │17 │\n",
142− "└──────────┴───────────┴────────┴───────────┴───────────────┘"
143− ]
144− },
145− "metadata": {},
146− "output_type": "display_data"
147− }
148− ],
149− "source": [
150− "\n",
151− ":showexpr p"
152− ]
153− },
154− {
155− "cell_type": "markdown",
156− "metadata": {},
157− "source": [
158− "## Relational Operators\n",
159− "\n",
160− "### Restriction\n",
161− "\n",
162− "We can see that there is a many-to-many relationship between `s` (suppliers) and `p` (parts) via the `sp` relation variable.\n",
163− "\n",
164− "Let's look at the suppliers who are in London. This is called \"restriction\".\n",
165− "\n",
166− "Note that the relation attributes have appropriate types which restrict the values which they can contain."
167− ]
168− },
169− {
170− "cell_type": "code",
171− "execution_count": 5,
172− "metadata": {},
173− "outputs": [
174− {
175− "data": {
176− "text/html": [
177− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>s#::Text</th><th>sname::Text</th><th>status::Integer</th><th>city::Text</th></tr><tr><td>\"S4\"</td><td>\"Clark\"</td><td>20</td><td>\"London\"</td></tr><tr><td>\"S1\"</td><td>\"Smith\"</td><td>20</td><td>\"London\"</td></tr><tfoot><tr><td colspan=\"100%\">Finite 2 tuples</td></tr></tfoot></table>"
178− ],
179− "text/plain": [
180− "┌──────────┬────────┬───────────┬───────────────┐\n",
181− "│city::Text│s#::Text│sname::Text│status::Integer│\n",
182− "├──────────┼────────┼───────────┼───────────────┤\n",
183− "│\"London\" │\"S1\" │\"Smith\" │20 │\n",
184− "│\"London\" │\"S4\" │\"Clark\" │20 │\n",
185− "└──────────┴────────┴───────────┴───────────────┘"
186− ]
187− },
188− "metadata": {},
189− "output_type": "display_data"
190− }
191− ],
192− "source": [
193− ":showexpr s where city=\"London\""
194− ]
195− },
196− {
197− "cell_type": "markdown",
198− "metadata": {},
199− "source": [
200− "### Join And Projection\n",
201− "\n",
202− "Let's examine which parts the London suppliers offer. In the following expression, we make use of the relational join operator (equivalent to `NATURAL JOIN` in SQL) and projection using the trailing curly brackets to only return the relation attributes which interest us."
203− ]
204− },
205− {
206− "cell_type": "code",
207− "execution_count": 6,
208− "metadata": {},
209− "outputs": [
210− {
211− "data": {
212− "text/html": [
213− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>qty::Integer</th><th>pname::Text</th><th>p#::Text</th></tr><tr><td>100</td><td>\"Cog\"</td><td>\"P6\"</td></tr><tr><td>300</td><td>\"Nut\"</td><td>\"P1\"</td></tr><tr><td>300</td><td>\"Screw\"</td><td>\"P4\"</td></tr><tr><td>200</td><td>\"Screw\"</td><td>\"P4\"</td></tr><tfoot><tr><td colspan=\"100%\">Finite 4 tuples</td></tr></tfoot></table>"
214− ],
215− "text/plain": [
216− "┌────────┬───────────┬────────────┐\n",
217− "│p#::Text│pname::Text│qty::Integer│\n",
218− "├────────┼───────────┼────────────┤\n",
219− "│\"P4\" │\"Screw\" │200 │\n",
220− "│\"P4\" │\"Screw\" │300 │\n",
221− "│\"P1\" │\"Nut\" │300 │\n",
222− "│\"P6\" │\"Cog\" │100 │\n",
223− "└────────┴───────────┴────────────┘"
224− ]
225− },
226− "metadata": {},
227− "output_type": "display_data"
228− }
229− ],
230− "source": [
231− ":showexpr ((s where city=\"London\") join sp join p){p#,pname,qty}"
232− ]
233− },
234− {
235− "cell_type": "markdown",
236− "metadata": {},
237− "source": [
238− "### Extend and Atom Functions\n",
239− "\n",
240− "We can also execute server-side functions on values and add them to our result relation."
241− ]
242− },
243− {
244− "cell_type": "code",
245− "execution_count": 7,
246− "metadata": {},
247− "outputs": [
248− {
249− "data": {
250− "text/html": [
251− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>s#::Text</th><th>status::Integer</th><th>statusplus10::Integer</th></tr><tr><td>\"S1\"</td><td>20</td><td>30</td></tr><tr><td>\"S4\"</td><td>20</td><td>30</td></tr><tr><td>\"S5\"</td><td>30</td><td>40</td></tr><tr><td>\"S3\"</td><td>30</td><td>40</td></tr><tr><td>\"S2\"</td><td>10</td><td>20</td></tr><tfoot><tr><td colspan=\"100%\">Finite 5 tuples</td></tr></tfoot></table>"
252− ],
253− "text/plain": [
254− "┌────────┬───────────────┬─────────────────────┐\n",
255− "│s#::Text│status::Integer│statusplus10::Integer│\n",
256− "├────────┼───────────────┼─────────────────────┤\n",
257− "│\"S2\" │10 │20 │\n",
258− "│\"S3\" │30 │40 │\n",
259− "│\"S5\" │30 │40 │\n",
260− "│\"S4\" │20 │30 │\n",
261− "│\"S1\" │20 │30 │\n",
262− "└────────┴───────────────┴─────────────────────┘"
263− ]
264− },
265− "metadata": {},
266− "output_type": "display_data"
267− }
268− ],
269− "source": [
270− ":showexpr (s:{statusplus10:=add(@status,10)}){s#,status,statusplus10}"
271− ]
272− },
273− {
274− "cell_type": "markdown",
275− "metadata": {},
276− "source": [
277− "### Group and Ungroup\n",
278− "\n",
279− "Unlike most databases, Project:M36 supports relation-valued attributes. This means that database values (atoms) can also be relations. Relation-valued attributes can be represented in the notebook as nested tables of values. Note that the nested relation's type is `relation {qty::Integer,pname::Text,s#::Text}`. \n",
280− "\n",
281− "Relation-valued attributes reduce tuple duplication by clearly associating certain values with their related multiple tuples. The `group` operator can also be used to create the SQL equivalent of `OUTER JOIN` but without the need for representing `NULL` in any form.\n",
282− "\n",
283− "Let's list the available counts for each supplier for each part."
284− ]
285− },
286− {
287− "cell_type": "code",
288− "execution_count": 8,
289− "metadata": {},
290− "outputs": [
291− {
292− "data": {
293− "text/html": [
294− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>p#::Text</th><th>availability::relation {qty::Integer,pname::Text,s#::Text}</th></tr><tr><td>\"P6\"</td><td><style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>qty::Integer</th><th>pname::Text</th><th>s#::Text</th></tr><tr><td>100</td><td>\"Cog\"</td><td>\"S1\"</td></tr><tfoot><tr><td colspan=\"100%\">Finite 1 tuples</td></tr></tfoot></table></td></tr><tr><td>\"P1\"</td><td><style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>qty::Integer</th><th>pname::Text</th><th>s#::Text</th></tr><tr><td>300</td><td>\"Nut\"</td><td>\"S2\"</td></tr><tr><td>300</td><td>\"Nut\"</td><td>\"S1\"</td></tr><tfoot><tr><td colspan=\"100%\">Finite 2 tuples</td></tr></tfoot></table></td></tr><tr><td>\"P2\"</td><td><style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>qty::Integer</th><th>pname::Text</th><th>s#::Text</th></tr><tr><td>200</td><td>\"Bolt\"</td><td>\"S4\"</td></tr><tr><td>200</td><td>\"Bolt\"</td><td>\"S1\"</td></tr><tr><td>400</td><td>\"Bolt\"</td><td>\"S2\"</td></tr><tr><td>200</td><td>\"Bolt\"</td><td>\"S3\"</td></tr><tfoot><tr><td colspan=\"100%\">Finite 4 tuples</td></tr></tfoot></table></td></tr><tr><td>\"P4\"</td><td><style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>qty::Integer</th><th>pname::Text</th><th>s#::Text</th></tr><tr><td>200</td><td>\"Screw\"</td><td>\"S1\"</td></tr><tr><td>300</td><td>\"Screw\"</td><td>\"S4\"</td></tr><tfoot><tr><td colspan=\"100%\">Finite 2 tuples</td></tr></tfoot></table></td></tr><tr><td>\"P3\"</td><td><style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>qty::Integer</th><th>pname::Text</th><th>s#::Text</th></tr><tr><td>400</td><td>\"Screw\"</td><td>\"S1\"</td></tr><tfoot><tr><td colspan=\"100%\">Finite 1 tuples</td></tr></tfoot></table></td></tr><tr><td>\"P5\"</td><td><style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>qty::Integer</th><th>pname::Text</th><th>s#::Text</th></tr><tr><td>400</td><td>\"Cam\"</td><td>\"S4\"</td></tr><tr><td>100</td><td>\"Cam\"</td><td>\"S1\"</td></tr><tfoot><tr><td colspan=\"100%\">Finite 2 tuples</td></tr></tfoot></table></td></tr><tfoot><tr><td colspan=\"100%\">Finite 6 tuples</td></tr></tfoot></table>"
295− ],
296− "text/plain": [
297− "┌──────────────────────────────────────────────────────────┬────────┐\n",
298− "│availability::relation {qty::Integer,pname::Text,s#::Text}│p#::Text│\n",
299− "├──────────────────────────────────────────────────────────┼────────┤\n",
300− "│┌───────────┬────────────┬────────┐ │\"P5\" │\n",
301− "││pname::Text│qty::Integer│s#::Text│ │ │\n",
302− "│├───────────┼────────────┼────────┤ │ │\n",
303− "││\"Cam\" │100 │\"S1\" │ │ │\n",
304− "││\"Cam\" │400 │\"S4\" │ │ │\n",
305− "│└───────────┴────────────┴────────┘ │ │\n",
306− "│┌───────────┬────────────┬────────┐ │\"P3\" │\n",
307− "││pname::Text│qty::Integer│s#::Text│ │ │\n",
308− "│├───────────┼────────────┼────────┤ │ │\n",
309− "││\"Screw\" │400 │\"S1\" │ │ │\n",
310− "│└───────────┴────────────┴────────┘ │ │\n",
311− "│┌───────────┬────────────┬────────┐ │\"P4\" │\n",
312− "││pname::Text│qty::Integer│s#::Text│ │ │\n",
313− "│├───────────┼────────────┼────────┤ │ │\n",
314− "││\"Screw\" │300 │\"S4\" │ │ │\n",
315− "││\"Screw\" │200 │\"S1\" │ │ │\n",
316− "│└───────────┴────────────┴────────┘ │ │\n",
317− "│┌───────────┬────────────┬────────┐ │\"P2\" │\n",
318− "││pname::Text│qty::Integer│s#::Text│ │ │\n",
319− "│├───────────┼────────────┼────────┤ │ │\n",
320− "││\"Bolt\" │200 │\"S3\" │ │ │\n",
321− "││\"Bolt\" │400 │\"S2\" │ │ │\n",
322− "││\"Bolt\" │200 │\"S1\" │ │ │\n",
323− "││\"Bolt\" │200 │\"S4\" │ │ │\n",
324− "│└───────────┴────────────┴────────┘ │ │\n",
325− "│┌───────────┬────────────┬────────┐ │\"P1\" │\n",
326− "││pname::Text│qty::Integer│s#::Text│ │ │\n",
327− "│├───────────┼────────────┼────────┤ │ │\n",
328− "││\"Nut\" │300 │\"S1\" │ │ │\n",
329− "││\"Nut\" │300 │\"S2\" │ │ │\n",
330− "│└───────────┴────────────┴────────┘ │ │\n",
331− "│┌───────────┬────────────┬────────┐ │\"P6\" │\n",
332− "││pname::Text│qty::Integer│s#::Text│ │ │\n",
333− "│├───────────┼────────────┼────────┤ │ │\n",
334− "││\"Cog\" │100 │\"S1\" │ │ │\n",
335− "│└───────────┴────────────┴────────┘ │ │\n",
336− "└──────────────────────────────────────────────────────────┴────────┘"
337− ]
338− },
339− "metadata": {},
340− "output_type": "display_data"
341− }
342− ],
343− "source": [
344− ":showexpr (p join sp){qty,pname,s#,p#} group ({s#,pname,qty} as availability)"
345− ]
346− },
347− {
348− "cell_type": "markdown",
349− "metadata": {},
350− "source": [
351− "We can flatten the relation-valued attributes, thereby generating more top-level tuples."
352− ]
353− },
354− {
355− "cell_type": "code",
356− "execution_count": 9,
357− "metadata": {},
358− "outputs": [
359− {
360− "data": {
361− "text/html": [
362− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>qty::Integer</th><th>pname::Text</th><th>s#::Text</th><th>p#::Text</th></tr><tr><td>400</td><td>\"Screw\"</td><td>\"S1\"</td><td>\"P3\"</td></tr><tr><td>200</td><td>\"Bolt\"</td><td>\"S4\"</td><td>\"P2\"</td></tr><tr><td>100</td><td>\"Cog\"</td><td>\"S1\"</td><td>\"P6\"</td></tr><tr><td>100</td><td>\"Cam\"</td><td>\"S1\"</td><td>\"P5\"</td></tr><tr><td>300</td><td>\"Nut\"</td><td>\"S2\"</td><td>\"P1\"</td></tr><tr><td>400</td><td>\"Cam\"</td><td>\"S4\"</td><td>\"P5\"</td></tr><tr><td>300</td><td>\"Screw\"</td><td>\"S4\"</td><td>\"P4\"</td></tr><tr><td>200</td><td>\"Bolt\"</td><td>\"S1\"</td><td>\"P2\"</td></tr><tr><td>200</td><td>\"Screw\"</td><td>\"S1\"</td><td>\"P4\"</td></tr><tr><td>200</td><td>\"Bolt\"</td><td>\"S3\"</td><td>\"P2\"</td></tr><tr><td>300</td><td>\"Nut\"</td><td>\"S1\"</td><td>\"P1\"</td></tr><tr><td>400</td><td>\"Bolt\"</td><td>\"S2\"</td><td>\"P2\"</td></tr><tfoot><tr><td colspan=\"100%\">Finite 12 tuples</td></tr></tfoot></table>"
363− ],
364− "text/plain": [
365− "┌────────┬───────────┬────────────┬────────┐\n",
366− "│p#::Text│pname::Text│qty::Integer│s#::Text│\n",
367− "├────────┼───────────┼────────────┼────────┤\n",
368− "│\"P2\" │\"Bolt\" │400 │\"S2\" │\n",
369− "│\"P1\" │\"Nut\" │300 │\"S1\" │\n",
370− "│\"P2\" │\"Bolt\" │200 │\"S3\" │\n",
371− "│\"P4\" │\"Screw\" │200 │\"S1\" │\n",
372− "│\"P2\" │\"Bolt\" │200 │\"S1\" │\n",
373− "│\"P4\" │\"Screw\" │300 │\"S4\" │\n",
374− "│\"P5\" │\"Cam\" │400 │\"S4\" │\n",
375− "│\"P1\" │\"Nut\" │300 │\"S2\" │\n",
376− "│\"P5\" │\"Cam\" │100 │\"S1\" │\n",
377− "│\"P6\" │\"Cog\" │100 │\"S1\" │\n",
378− "│\"P2\" │\"Bolt\" │200 │\"S4\" │\n",
379− "│\"P3\" │\"Screw\" │400 │\"S1\" │\n",
380− "└────────┴───────────┴────────────┴────────┘"
381− ]
382− },
383− "metadata": {},
384− "output_type": "display_data"
385− }
386− ],
387− "source": [
388− ":showexpr ((p join sp){qty,pname,s#,p#} group ({s#,pname,qty} as availability)) ungroup availability"
389− ]
390− },
391− {
392− "cell_type": "markdown",
393− "metadata": {},
394− "source": [
395− "## Database State Operators\n",
396− "\n",
397− "Thus far, we have only been inspecting the database state. Next, let's cover some database update operators. These operators are all similar to SQL operators, so we don't need a lot of exposition."
398− ]
399− },
400− {
401− "cell_type": "markdown",
402− "metadata": {},
403− "source": [
404− "### Insert"
405− ]
406− },
407− {
408− "cell_type": "code",
409− "execution_count": 10,
410− "metadata": {},
411− "outputs": [
412− {
413− "data": {
414− "text/html": [
415− "ok"
416− ],
417− "text/plain": [
418− "ok"
419− ]
420− },
421− "metadata": {},
422− "output_type": "display_data"
423− }
424− ],
425− "source": [
426− "insert s relation{tuple{s# \"S6\", sname \"Bob\", status 50, city \"Boston\"}}"
427− ]
428− },
429− {
430− "cell_type": "code",
431− "execution_count": 11,
432− "metadata": {},
433− "outputs": [
434− {
435− "data": {
436− "text/html": [
437− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>city::Text</th><th>s#::Text</th><th>sname::Text</th><th>status::Integer</th></tr><tr><td>\"Boston\"</td><td>\"S6\"</td><td>\"Bob\"</td><td>50</td></tr><tr><td>\"Paris\"</td><td>\"S3\"</td><td>\"Blake\"</td><td>30</td></tr><tr><td>\"Athens\"</td><td>\"S5\"</td><td>\"Adams\"</td><td>30</td></tr><tr><td>\"London\"</td><td>\"S4\"</td><td>\"Clark\"</td><td>20</td></tr><tr><td>\"London\"</td><td>\"S1\"</td><td>\"Smith\"</td><td>20</td></tr><tr><td>\"Paris\"</td><td>\"S2\"</td><td>\"Jones\"</td><td>10</td></tr><tfoot><tr><td colspan=\"100%\">Finite 6 tuples</td></tr></tfoot></table>"
438− ],
439− "text/plain": [
440− "┌──────────┬────────┬───────────┬───────────────┐\n",
441− "│city::Text│s#::Text│sname::Text│status::Integer│\n",
442− "├──────────┼────────┼───────────┼───────────────┤\n",
443− "│\"Paris\" │\"S2\" │\"Jones\" │10 │\n",
444− "│\"London\" │\"S1\" │\"Smith\" │20 │\n",
445− "│\"London\" │\"S4\" │\"Clark\" │20 │\n",
446− "│\"Athens\" │\"S5\" │\"Adams\" │30 │\n",
447− "│\"Paris\" │\"S3\" │\"Blake\" │30 │\n",
448− "│\"Boston\" │\"S6\" │\"Bob\" │50 │\n",
449− "└──────────┴────────┴───────────┴───────────────┘"
450− ]
451− },
452− "metadata": {},
453− "output_type": "display_data"
454− }
455− ],
456− "source": [
457− ":showexpr s"
458− ]
459− },
460− {
461− "cell_type": "markdown",
462− "metadata": {},
463− "source": [
464− "### Delete"
465− ]
466− },
467− {
468− "cell_type": "code",
469− "execution_count": 12,
470− "metadata": {},
471− "outputs": [
472− {
473− "data": {
474− "text/html": [
475− "ok"
476− ],
477− "text/plain": [
478− "ok"
479− ]
480− },
481− "metadata": {},
482− "output_type": "display_data"
483− }
484− ],
485− "source": [
486− "delete s where sname=\"Bob\""
487− ]
488− },
489− {
490− "cell_type": "code",
491− "execution_count": 13,
492− "metadata": {},
493− "outputs": [
494− {
495− "data": {
496− "text/html": [
497− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>city::Text</th><th>s#::Text</th><th>sname::Text</th><th>status::Integer</th></tr><tr><td>\"Paris\"</td><td>\"S3\"</td><td>\"Blake\"</td><td>30</td></tr><tr><td>\"Athens\"</td><td>\"S5\"</td><td>\"Adams\"</td><td>30</td></tr><tr><td>\"London\"</td><td>\"S4\"</td><td>\"Clark\"</td><td>20</td></tr><tr><td>\"London\"</td><td>\"S1\"</td><td>\"Smith\"</td><td>20</td></tr><tr><td>\"Paris\"</td><td>\"S2\"</td><td>\"Jones\"</td><td>10</td></tr><tfoot><tr><td colspan=\"100%\">Finite 5 tuples</td></tr></tfoot></table>"
498− ],
499− "text/plain": [
500− "┌──────────┬────────┬───────────┬───────────────┐\n",
501− "│city::Text│s#::Text│sname::Text│status::Integer│\n",
502− "├──────────┼────────┼───────────┼───────────────┤\n",
503− "│\"Paris\" │\"S2\" │\"Jones\" │10 │\n",
504− "│\"London\" │\"S1\" │\"Smith\" │20 │\n",
505− "│\"London\" │\"S4\" │\"Clark\" │20 │\n",
506− "│\"Athens\" │\"S5\" │\"Adams\" │30 │\n",
507− "│\"Paris\" │\"S3\" │\"Blake\" │30 │\n",
508− "└──────────┴────────┴───────────┴───────────────┘"
509− ]
510− },
511− "metadata": {},
512− "output_type": "display_data"
513− }
514− ],
515− "source": [
516− ":showexpr s"
517− ]
518− },
519− {
520− "cell_type": "markdown",
521− "metadata": {},
522− "source": [
523− "### Update"
524− ]
525− },
526− {
527− "cell_type": "code",
528− "execution_count": 14,
529− "metadata": {},
530− "outputs": [
531− {
532− "data": {
533− "text/html": [
534− "ok"
535− ],
536− "text/plain": [
537− "ok"
538− ]
539− },
540− "metadata": {},
541− "output_type": "display_data"
542− }
543− ],
544− "source": [
545− "update s where city=\"London\" (status:=90)"
546− ]
547− },
548− {
549− "cell_type": "code",
550− "execution_count": 15,
551− "metadata": {},
552− "outputs": [
553− {
554− "data": {
555− "text/html": [
556− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>city::Text</th><th>s#::Text</th><th>sname::Text</th><th>status::Integer</th></tr><tr><td>\"London\"</td><td>\"S1\"</td><td>\"Smith\"</td><td>90</td></tr><tr><td>\"Paris\"</td><td>\"S3\"</td><td>\"Blake\"</td><td>30</td></tr><tr><td>\"Athens\"</td><td>\"S5\"</td><td>\"Adams\"</td><td>30</td></tr><tr><td>\"London\"</td><td>\"S4\"</td><td>\"Clark\"</td><td>90</td></tr><tr><td>\"Paris\"</td><td>\"S2\"</td><td>\"Jones\"</td><td>10</td></tr><tfoot><tr><td colspan=\"100%\">Finite 5 tuples</td></tr></tfoot></table>"
557− ],
558− "text/plain": [
559− "┌──────────┬────────┬───────────┬───────────────┐\n",
560− "│city::Text│s#::Text│sname::Text│status::Integer│\n",
561− "├──────────┼────────┼───────────┼───────────────┤\n",
562− "│\"Paris\" │\"S2\" │\"Jones\" │10 │\n",
563− "│\"London\" │\"S4\" │\"Clark\" │90 │\n",
564− "│\"Athens\" │\"S5\" │\"Adams\" │30 │\n",
565− "│\"Paris\" │\"S3\" │\"Blake\" │30 │\n",
566− "│\"London\" │\"S1\" │\"Smith\" │90 │\n",
567− "└──────────┴────────┴───────────┴───────────────┘"
568− ]
569− },
570− "metadata": {},
571− "output_type": "display_data"
572− }
573− ],
574− "source": [
575− ":showexpr s"
576− ]
577− },
578− {
579− "cell_type": "markdown",
580− "metadata": {},
581− "source": [
582− "### Assign"
583− ]
584− },
585− {
586− "cell_type": "code",
587− "execution_count": 16,
588− "metadata": {},
589− "outputs": [
590− {
591− "data": {
592− "text/html": [
593− "ok"
594− ],
595− "text/plain": [
596− "ok"
597− ]
598− },
599− "metadata": {},
600− "output_type": "display_data"
601− }
602− ],
603− "source": [
604− "london_suppliers := s where city=\"London\""
605− ]
606− },
607− {
608− "cell_type": "code",
609− "execution_count": 17,
610− "metadata": {},
611− "outputs": [
612− {
613− "data": {
614− "text/html": [
615− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>city::Text</th><th>s#::Text</th><th>sname::Text</th><th>status::Integer</th></tr><tr><td>\"London\"</td><td>\"S1\"</td><td>\"Smith\"</td><td>90</td></tr><tr><td>\"London\"</td><td>\"S4\"</td><td>\"Clark\"</td><td>90</td></tr><tfoot><tr><td colspan=\"100%\">Finite 2 tuples</td></tr></tfoot></table>"
616− ],
617− "text/plain": [
618− "┌──────────┬────────┬───────────┬───────────────┐\n",
619− "│city::Text│s#::Text│sname::Text│status::Integer│\n",
620− "├──────────┼────────┼───────────┼───────────────┤\n",
621− "│\"London\" │\"S4\" │\"Clark\" │90 │\n",
622− "│\"London\" │\"S1\" │\"Smith\" │90 │\n",
623− "└──────────┴────────┴───────────┴───────────────┘"
624− ]
625− },
626− "metadata": {},
627− "output_type": "display_data"
628− }
629− ],
630− "source": [
631− ":showexpr london_suppliers"
632− ]
633− },
634− {
635− "cell_type": "markdown",
636− "metadata": {},
637− "source": [
638− "## Constraints\n",
639− "\n",
640− "Project:M36 supports too many features to cover in one notebook, but constraints are certainly essential.\n",
641− "\n",
642− "Let's examine the current constraints."
643− ]
644− },
645− {
646− "cell_type": "code",
647− "execution_count": 18,
648− "metadata": {},
649− "outputs": [
650− {
651− "data": {
652− "text/html": [
653− "<style>.pm36relation {empty-cells: show;} .pm36relation tbody td, .pm36relation th { border: 1px solid black;}</style><table class=\"pm36relation\"\"><tr><th>name::Text</th><th>sub::Text</th><th>super::Text</th></tr><tr><td>\"p_pkey\"</td><td>\"NotEquals (Project (AttributeNames (fromList [\\\"b\\\"])) (Extend (AttributeExtendTupleExpr \\\"b\\\" (FunctionAtomExpr \\\"count\\\" [AttributeAtomExpr \\\"a\\\"] ())) (Extend (AttributeExtendTupleExpr \\\"a\\\" (RelationAtomExpr (RelationVariable \\\"p\\\" ()))) (ExistingRelation (Relation [] (RelationTupleSet {asList = [RelationTuple [] []]})))))) (Project (AttributeNames (fromList [\\\"b\\\"])) (Extend (AttributeExtendTupleExpr \\\"b\\\" (FunctionAtomExpr \\\"count\\\" [AttributeAtomExpr \\\"a\\\"] ())) (Extend (AttributeExtendTupleExpr \\\"a\\\" (RelationAtomExpr (Project (AttributeNames (fromList [\\\"p#\\\"])) (RelationVariable \\\"p\\\" ())))) (ExistingRelation (Relation [] (RelationTupleSet {asList = [RelationTuple [] []]}))))))\"</td><td>\"ExistingRelation (Relation [] (RelationTupleSet {asList = []}))\"</td></tr><tr><td>\"s_pkey\"</td><td>\"NotEquals (Project (AttributeNames (fromList [\\\"b\\\"])) (Extend (AttributeExtendTupleExpr \\\"b\\\" (FunctionAtomExpr \\\"count\\\" [AttributeAtomExpr \\\"a\\\"] ())) (Extend (AttributeExtendTupleExpr \\\"a\\\" (RelationAtomExpr (RelationVariable \\\"s\\\" ()))) (ExistingRelation (Relation [] (RelationTupleSet {asList = [RelationTuple [] []]})))))) (Project (AttributeNames (fromList [\\\"b\\\"])) (Extend (AttributeExtendTupleExpr \\\"b\\\" (FunctionAtomExpr \\\"count\\\" [AttributeAtomExpr \\\"a\\\"] ())) (Extend (AttributeExtendTupleExpr \\\"a\\\" (RelationAtomExpr (Project (AttributeNames (fromList [\\\"s#\\\"])) (RelationVariable \\\"s\\\" ())))) (ExistingRelation (Relation [] (RelationTupleSet {asList = [RelationTuple [] []]}))))))\"</td><td>\"ExistingRelation (Relation [] (RelationTupleSet {asList = []}))\"</td></tr><tr><td>\"sp_pkey\"</td><td>\"NotEquals (Project (AttributeNames (fromList [\\\"b\\\"])) (Extend (AttributeExtendTupleExpr \\\"b\\\" (FunctionAtomExpr \\\"count\\\" [AttributeAtomExpr \\\"a\\\"] ())) (Extend (AttributeExtendTupleExpr \\\"a\\\" (RelationAtomExpr (RelationVariable \\\"sp\\\" ()))) (ExistingRelation (Relation [] (RelationTupleSet {asList = [RelationTuple [] []]})))))) (Project (AttributeNames (fromList [\\\"b\\\"])) (Extend (AttributeExtendTupleExpr \\\"b\\\" (FunctionAtomExpr \\\"count\\\" [AttributeAtomExpr \\\"a\\\"] ())) (Extend (AttributeExtendTupleExpr \\\"a\\\" (RelationAtomExpr (Project (AttributeNames (fromList [\\\"p#\\\",\\\"s#\\\"])) (RelationVariable \\\"sp\\\" ())))) (ExistingRelation (Relation [] (RelationTupleSet {asList = [RelationTuple [] []]}))))))\"</td><td>\"ExistingRelation (Relation [] (RelationTupleSet {asList = []}))\"</td></tr><tfoot><tr><td colspan=\"100%\">Finite 3 tuples</td></tr></tfoot></table>"
654− ],
655− "text/plain": [
656− "┌──────────┬───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─────────────────────────────────────────────────────────────────┐\n",
657− "│name::Text│sub::Text │super::Text │\n",
658− "├──────────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────┤\n",
659− "│\"sp_pkey\" │\"NotEquals (Project (AttributeNames (fromList [\\\"b\\\"])) (Extend (AttributeExtendTupleExpr \\\"b\\\" (FunctionAtomExpr \\\"count\\\" [AttributeAtomExpr \\\"a\\\"] ())) (Extend (AttributeExtendTupleExpr \\\"a\\\" (RelationAtomExpr (RelationVariable \\\"sp\\\" ()))) (ExistingRelation (Relation [] (RelationTupleSet {asList = [RelationTuple [] []]})))))) (Project (AttributeNames (fromList [\\\"b\\\"])) (Extend (AttributeExtendTupleExpr \\\"b\\\" (FunctionAtomExpr \\\"count\\\" [AttributeAtomExpr \\\"a\\\"] ())) (Extend (AttributeExtendTupleExpr \\\"a\\\" (RelationAtomExpr (Project (AttributeNames (fromList [\\\"p#\\\",\\\"s#\\\"])) (RelationVariable \\\"sp\\\" ())))) (ExistingRelation (Relation [] (RelationTupleSet {asList = [RelationTuple [] []]}))))))\"│\"ExistingRelation (Relation [] (RelationTupleSet {asList = []}))\"│\n",
660− "│\"s_pkey\" │\"NotEquals (Project (AttributeNames (fromList [\\\"b\\\"])) (Extend (AttributeExtendTupleExpr \\\"b\\\" (FunctionAtomExpr \\\"count\\\" [AttributeAtomExpr \\\"a\\\"] ())) (Extend (AttributeExtendTupleExpr \\\"a\\\" (RelationAtomExpr (RelationVariable \\\"s\\\" ()))) (ExistingRelation (Relation [] (RelationTupleSet {asList = [RelationTuple [] []]})))))) (Project (AttributeNames (fromList [\\\"b\\\"])) (Extend (AttributeExtendTupleExpr \\\"b\\\" (FunctionAtomExpr \\\"count\\\" [AttributeAtomExpr \\\"a\\\"] ())) (Extend (AttributeExtendTupleExpr \\\"a\\\" (RelationAtomExpr (Project (AttributeNames (fromList [\\\"s#\\\"])) (RelationVariable \\\"s\\\" ())))) (ExistingRelation (Relation [] (RelationTupleSet {asList = [RelationTuple [] []]}))))))\" │\"ExistingRelation (Relation [] (RelationTupleSet {asList = []}))\"│\n",
661− "│\"p_pkey\" │\"NotEquals (Project (AttributeNames (fromList [\\\"b\\\"])) (Extend (AttributeExtendTupleExpr \\\"b\\\" (FunctionAtomExpr \\\"count\\\" [AttributeAtomExpr \\\"a\\\"] ())) (Extend (AttributeExtendTupleExpr \\\"a\\\" (RelationAtomExpr (RelationVariable \\\"p\\\" ()))) (ExistingRelation (Relation [] (RelationTupleSet {asList = [RelationTuple [] []]})))))) (Project (AttributeNames (fromList [\\\"b\\\"])) (Extend (AttributeExtendTupleExpr \\\"b\\\" (FunctionAtomExpr \\\"count\\\" [AttributeAtomExpr \\\"a\\\"] ())) (Extend (AttributeExtendTupleExpr \\\"a\\\" (RelationAtomExpr (Project (AttributeNames (fromList [\\\"p#\\\"])) (RelationVariable \\\"p\\\" ())))) (ExistingRelation (Relation [] (RelationTupleSet {asList = [RelationTuple [] []]}))))))\" │\"ExistingRelation (Relation [] (RelationTupleSet {asList = []}))\"│\n",
662− "└──────────┴───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────┘"
663− ]
664− },
665− "metadata": {},
666− "output_type": "display_data"
667− }
668− ],
669− "source": [
670− ":constraints"
671− ]
672− },
673− {
674− "cell_type": "markdown",
675− "metadata": {},
676− "source": [
677− "Constraints are represented as \"inclusion dependencies\". An inclusion dependency is a generalization of all possible constraints on the database and can represent keys, uniqueness constraints, foreign key constraints, as well as span multiple relation variables.\n",
678− "\n",
679− "An inclusion dependency requires that the result of relational expression `sub` is a subset of relational expression `super`.\n",
680− "\n",
681− "Project:M36 includes some utilities to generate inclusion dependencies."
682− ]
683− },
684− {
685− "cell_type": "code",
686− "execution_count": 19,
687− "metadata": {},
688− "outputs": [
689− {
690− "data": {
691− "text/html": [
692− "ok"
693− ],
694− "text/plain": [
695− "ok"
696− ]
697− },
698− "metadata": {},
699− "output_type": "display_data"
700− }
701− ],
702− "source": [
703− "sandwich := relation{tuple{name \"Cheese\", price 4},tuple{name \"Tuna\", price 5}}"
704− ]
705− },
706− {
707− "cell_type": "code",
708− "execution_count": 20,
709− "metadata": {},
710− "outputs": [
711− {
712− "data": {
713− "text/html": [
714− "ok"
715− ],
716− "text/plain": [
717− "ok"
718− ]
719− },
720− "metadata": {},
721− "output_type": "display_data"
722− }
723− ],
724− "source": [
725− "key sandwich_name{name} sandwich"
726− ]
727− },
728− {
729− "cell_type": "code",
730− "execution_count": 21,
731− "metadata": {},
732− "outputs": [
733− {
734− "ename": "TutorialDError",
735− "evalue": "",
736− "output_type": "error",
737− "traceback": [
738− "InclusionDependencyCheckError \"sandwich_name\""
739− ]
740− }
741− ],
742− "source": [
743− "insert sandwich relation{tuple{name \"Tuna\", price 6}}"
744− ]
745− },
746− {
747− "cell_type": "markdown",
748− "metadata": {},
749− "source": [
750− "## Jupyter Kernel Features\n",
751− "\n",
752− "By default, the TutorialD kernel will automatically start a `project-m36-websocket-server` when the first TutorialD command is executed. For this to work, `project-m36-websocket-server` must be in the jupyter server's `PATH` environment variable.\n",
753− "\n",
754− "### Magic\n",
755− "\n",
756− "Like the python kernel, the TutorialD kernel includes some commands to interact directly with the kernel. These commands are not passed to the TutorialD interpreter.\n",
757− "\n",
758− "* `%help` brings up some help which includes links to additional documentation\n",
759− "* `%connect ws://<host>:<port> <dbname>` connects to the `project-m36-websocket-server` already running. For example:\n",
760− " ```\n",
761− " %connect ws://localhost:64000 employees\n",
762− " ```\n",
763− " connects to the websocket server running on the localhost on port 64000 and selects the database named \"employees\". Note that the database name is not part of the websocket URL.\n",
764− " \n",
765− "## Conclusion\n",
766− "\n",
767− "[Project:M36](https://github.com/agentm/project-m36) is a fully-featured relational algebra engine suitable for use a database. It sets out to prove that sticking to the mathematical underpinnings of the relational algebra is straightforward and results in improved correctness and performance.\n",
768− "\n",
769− "If you would like to learn more, please refer to the [documentation](https://github.com/agentm/project-m36#documentation) and join our welcoming [community](https://github.com/agentm/project-m36#community) to ask questions."
770− ]
771− },
772− {
773− "cell_type": "code",
774− "execution_count": null,
775− "metadata": {},
776− "outputs": [],
777− "source": []
778− }
779− ],
780− "metadata": {
781− "kernelspec": {
782− "display_name": "TutorialD (Project:M36)",
783− "language": "TutorialD",
784− "name": "tutd"
785− },
786− "language_info": {
787− "file_extension": ".tutd",
788− "mimetype": "text/x-tutd",
789− "name": "TutorialD"
790− }
791− },
792− "nbformat": 4,
793− "nbformat_minor": 2
794−}
jupyter/itutd/ITutorialDKernel.pydeleted−179
@@ -1,179 +0,0 @@
1−from ipykernel.kernelbase import Kernel
2−import subprocess
3−from websocket import create_connection, WebSocketConnectionClosedException, WebSocketBadStatusException
4−import time
5−import select
6−import json
7−import socket
8−import errno
9−import urlparse
10−
11−class ITutorialDKernel(Kernel):
12− implementation = 'ITutorialD'
13− implementation_version = '0.1'
14−
15− banner = 'TutorialD kernel using Project:M36 https://github.com/agentm/project-m36'
16−
17− language = 'TutorialD'
18− language_version = '0.3'
19− language_info = {
20− 'name': 'TutorialD',
21− 'mimetype': 'text/x-tutd',
22− 'file_extension': '.tutd',
23− }
24− dbserver = None
25− ws = None
26−
27−# todo: implement wrong database name handling
28− def runtutd(self, tutd):
29− #setup server
30− dbname = 'jupyter'
31− port = 63000
32− if not self.ws and not self.dbserver:
33− try:
34− self.dbserver = subprocess.Popen(['project-m36-websocket-server',
35− '--database', dbname,
36− '--port', str(port)],
37− )
38− except OSError as err:
39− if err.errno == errno.ENOENT:
40− return ('"project-m36-websocket-server" is not in the PATH environment variable and could not be started.', None)
41− else:
42− raise
43− res = self.connect_ws('ws://127.0.0.1:63000', dbname, retries=10)
44− if res:
45− return ('Connection failed: {}'.format(res), None)
46−
47− self.ws.send('executetutd/html+text:' + tutd)
48− try:
49− jsonresult = self.discard_prompts()
50− except WebSocketConnectionClosedException:
51− self.ws = None
52− return ('Websocket server closed the connection.',None)
53− res = json.loads(jsonresult)
54− if 'displayerror' in res:
55− return (res['displayerror']['text'], None)
56− elif 'acknowledged' in res:
57− return (None, {'html':'ok', 'text':'ok'})
58− else:
59− return (None, res['displayrelation'])
60−
61− def connect_ws(self, url, dbname, retries=0):
62− while 1:
63− try:
64− ws = create_connection(url)
65− except socket.error as err:
66− if err.errno in (errno.ECONNREFUSED, ):
67− time.sleep(1.0)
68− if retries == 0:
69− return 'Failed to connect to websocket.'
70− retries -= 1
71− else:
72− raise
73− except WebSocketBadStatusException:
74− return 'Failed to negotiate websocket connection.'
75− else:
76− break
77− self.ws = ws
78− self.ws.send('connectdb:{}'.format(dbname))
79− msg = json.loads(self.ws.recv())
80− if 'displayerror' in msg:
81− return msg['displayerror']['tag']
82− return None
83−
84− def discard_prompts(self):
85− #read from the websocket until a non-prompt message is received
86− while 1:
87− sel = select.select([self.ws.sock],[],[],0)
88− if len(sel[0]) > 0:
89− #there is something to read
90− msg = self.ws.recv()
91− if 'promptInfo' not in msg:
92− return msg
93−
94− def send_error(self, msg):
95− stream_content = {'ename':'TutorialDError',
96− 'traceback':[msg],
97− 'evalue':''}
98− self.send_response(self.iopub_socket, 'error', stream_content)
99−
100−
101− def process_magic(self, code):
102− #handle "magic" processing of commands which are not sent to the tutd interpreter
103− cmds = code.split(' ')
104− ok = {'text':'ok', 'html':'ok'}
105−
106− if cmds[0] == '%connect' and len(cmds) == 3:
107− #connect to alternate database
108− url = urlparse.urlparse(cmds[1])
109− dbname = cmds[2]
110− if not url.scheme.startswith('ws'):
111− return ('Rejected attempt to connect to non-websocket. Use ws:// or wss:// scheme',None)
112− res = self.connect_ws(url.geturl(), dbname)
113− if res: #error from connection
114− return (res, None, None)
115− else: #connection successful
116− return (None, ok, None)
117− elif cmds[0] == '%help' and len(cmds) == 1:
118− #display some help
119− return (None, ok, self.show_help())
120− elif cmds[0].startswith('%'):
121− return ('Invalid magic command.', None)
122−
123− def do_execute(self, code, silent,
124− store_history=True,
125− user_expressions=False,
126− allow_stdin=False):
127− magic = self.process_magic(code)
128− payload = None
129− if magic:
130− (err, result, payload) = magic
131− else:
132− (err, result) = self.runtutd(code)
133− if not silent:
134− if err:
135− status = 'error'
136− self.send_error(err)
137− else:
138− status = 'ok'
139− display_content = {
140− 'data':{'text/html':result['html'],
141− 'text/plain':result['text']},
142− 'metadata':{},
143− 'transient':{}
144− }
145− self.send_response(self.iopub_socket, 'display_data', display_content)
146− ret ={'status': status,
147− 'execution_count': self.execution_count,
148− 'payload':[payload],
149− 'user_expressions':{}}
150− if payload:
151− ret['payload'] = [payload]
152− return ret
153−
154− def do_shutdown(self, restart):
155− if self.dbserver:
156− self.dbserver.terminate()
157− self.dbserver.kill()
158−
159− def show_help(self):
160− return {'source': 'page',
161− 'start':0,
162− 'data':{'text/html':'''<h1>Project:M36 TutorialD Jupyter Kernel Help</h1>
163−<p>TutorialD is an interactive language for the relational algebra.</p>
164−
165−<p><a href="https://github.com/agentm/project-m36/blob/master/docs/15_minute_tutorial.markdown">15 Minute TutorialD Introduction</a></p>
166−<p><a href="https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown">TutorialD Documentation</a></p>
167−''',
168− 'text/plain':
169−'''Project:M36 TutorialD Jupyter Kernel Help
170−
171−TutorialD is an interactive language for the relational algebra.
172−
173−15 Minute TutorialD Introduction: https://github.com/agentm/project-m36/blob/master/docs/15_minute_tutorial.markdown
174−TutorialD Documentation: https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown
175−'''}}
176−
177−if __name__ == '__main__':
178− from ipykernel.kernelapp import IPKernelApp
179− IPKernelApp.launch_instance(kernel_class=ITutorialDKernel)
jupyter/itutd/__init__.pydeleted−1
@@ -1 +0,0 @@
1−
jupyter/itutd/__main__.pydeleted−4
@@ -1,4 +0,0 @@
1−from ipykernel.kernelapp import IPKernelApp
2−from . import ITutorialDKernel
3−
4−IPKernelApp.launch_instance(kernel_class=ITutorialDKernel)
jupyter/kernel.jsondeleted−5
@@ -1,5 +0,0 @@
1−{
2− "language":"TutorialD",
3− "display_name":"TutorialD (Project:M36)",
4− "argv":["python", "-m", "itutd.ITutorialDKernel", "-f", "{connection_file}"]
5−}
jupyter/setup.pydeleted−19
@@ -1,19 +0,0 @@
1−from setuptools import setup
2−
3−setup(
4− name='itutd',
5− version='0.1',
6− packages=['itutd'],
7− description='TutorialD Jupyter kernel for Project:M36',
8− author='AgentM',
9− author_email='agentm@themactionfaction.com',
10− url='https://github.com/agentm/project-m36/jupyter/',
11− install_requires=[
12− 'jupyter_client', 'IPython', 'ipykernel', 'websocket-client'
13− ],
14− classifiers=[
15− 'Intended Audience :: Developers',
16− 'License :: OSI Approved :: Public Domain',
17− 'Programming Language :: Python :: 2',
18− ],
19−)
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); }
posts/2015-12-07-tu-quoque.htmldeleted−44
@@ -1,44 +0,0 @@
1−<!doctype html>
2−<html lang="en">
3− <head>
4− <meta charset="utf-8">
5− <meta http-equiv="x-ua-compatible" content="ie=edge">
6− <meta name="viewport" content="width=device-width, initial-scale=1">
7− <title>Project:M36 Blog - Tu Quoque</title>
8− <link rel="stylesheet" href="../css/brooklyn.css" />
9− </head>
10− <body>
11− <div id="header">
12− <div id="logo">
13− <a href="../">Project:M36 Blog</a>
14− </div>
15− <div id="navigation">
16− <a href="../">Home</a>
17− <a href="../about.html">About</a>
18− <a href="../contact.html">Contact</a>
19− <a href="../archive.html">Archive</a>
20− </div>
21− </div>
22−
23− <div id="content">
24− <div class="info">
25− Posted on December 7, 2015
26−
27− by Julius
28−
29−</div>
30−
31−<p>Vestibulum leo turpis, dignissim quis ultrices sit amet, iaculis ac ligula. Pellentesque tristique, velit eget scelerisque scelerisque, est dolor ultrices arcu, quis ullamcorper justo arcu luctus mauris. Integer congue molestie nisi id posuere. Fusce pellentesque gravida tempus. Integer viverra tortor nec eros mollis quis convallis sem laoreet. Nulla id libero ac erat varius laoreet. Proin sed est est. Curabitur lacinia fermentum lorem, elementum malesuada ipsum malesuada ut. Donec suscipit elit id leo vehicula mattis non sed leo. Morbi varius eleifend varius. Nulla vestibulum, neque vitae aliquam eleifend, nisi tellus placerat nunc, quis suscipit elit turpis eu tortor. Etiam euismod convallis lectus quis venenatis. Phasellus laoreet magna in nibh cursus eu egestas nulla convallis. Aliquam vel ullamcorper risus. Fusce dictum, massa id consequat viverra, nulla ante tristique est, a faucibus nisi enim nec dui. Donec metus ligula, condimentum at porttitor eget, lobortis at quam.</p>
32−<p>Aenean vel libero in magna ultricies congue in a odio. Donec faucibus rutrum ornare. Fusce dictum eleifend fermentum. Vestibulum vel nibh a metus porttitor rhoncus. Pellentesque id quam neque, eget molestie arcu. Integer in elit vel neque viverra ultricies in eget massa. Nam ut convallis est. Pellentesque eros eros, sodales non vehicula et, tincidunt ut odio. Cras suscipit ultrices metus sit amet molestie. Fusce enim leo, vehicula sed sodales quis, adipiscing at ipsum.</p>
33−<p>Nunc tempor dignissim enim, sed tincidunt eros bibendum quis. Curabitur et dolor augue, id laoreet mi. Nulla cursus felis id dui vehicula vitae ornare lorem blandit. Cras eget dui nec odio volutpat pharetra. Fusce hendrerit justo justo, vel imperdiet enim. Vivamus elit risus, interdum ultrices accumsan eleifend, vestibulum vitae sapien. Integer bibendum ullamcorper tristique. Nulla quis odio lectus, quis eleifend augue. Integer a ligula mauris. Aenean et tempus tortor. Quisque at tortor mi. Vivamus accumsan feugiat est a blandit. Sed vitae enim ut dolor semper sodales. Duis tristique, ante et placerat elementum, nulla tellus pellentesque sapien, quis posuere velit mi eget nulla. Sed vestibulum nunc non est porttitor ut rutrum nibh semper. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.</p>
34−<p>Nulla adipiscing ultricies lobortis. Vivamus iaculis nisl vitae tellus laoreet vitae aliquet lacus mollis. Phasellus ut lacus urna, sed sagittis ante. Etiam consectetur pretium nisl sed dignissim. Pellentesque convallis, nisl eget commodo mollis, sem magna consequat arcu, sed pretium ipsum arcu sit amet neque. Aliquam erat volutpat. Morbi sed mi sed urna vestibulum placerat vitae vel metus. Fusce ac ante at justo pharetra vehicula. Vivamus vel tortor eget augue aliquet aliquet at vel odio. Nunc venenatis, magna quis facilisis fringilla, augue tellus varius neque, in vulputate est eros ut tortor. Duis lorem neque, aliquam congue posuere id, condimentum non dui. Phasellus ut dui massa, porttitor suscipit augue. Praesent quis tellus quam, vel volutpat metus. Vivamus enim est, aliquam in imperdiet et, sagittis eu ligula. Vestibulum hendrerit placerat orci et aliquet. Cras pharetra, dolor placerat lobortis tempor, metus odio cursus ligula, et posuere lacus ligula quis dui.</p>
35−<p>Donec a lectus eu nibh malesuada aliquam. Proin at metus quam, et tincidunt leo. Quisque lacus justo, scelerisque sodales pulvinar sed, dignissim ut sapien. Vivamus diam felis, adipiscing sollicitudin ultricies id, accumsan ac felis. In eu posuere ligula. Suspendisse potenti. Donec porttitor dictum dui id vehicula. Integer ante velit, congue id dictum et, adipiscing a tortor.</p>
36−
37− </div>
38−
39− <div id="footer">
40− Site proudly generated by
41− <a href="http://jaspervdj.be/hakyll">Hakyll</a>
42− </div>
43− </body>
44−</html>
project-m36.cabal+483−321
@@ -1,173 +1,153 @@
1−Cabal-Version: 2.2
21Name: project-m36
3−Version: 0.9.3
4−License: MIT
5−--note that this license specification is erroneous and only labeled MIT to appease hackage which does not recognize public domain packages in cabal >2.2- Project:M36 is dedicated to the public domain
2+Version: 0.1
3+License: PublicDomain
64Build-Type: Simple
75Homepage: https://github.com/agentm/project-m36
86Bug-Reports: https://github.com/agentm/project-m36/issues
97Author: AgentM
108Stability: experimental
119Category: Relational Algebra
12−Maintainer: agentm@themactionfaction.com
10+Cabal-Version: >= 1.10
1311Synopsis: Relational Algebra Engine
1412Description: A relational algebra engine which can be used to persist and query Haskell data types.
15−Extra-Source-Files: Changelog.markdown README.markdown
16−
17−Source-Repository head
18− Type: git
19− location: https://github.com/agentm/project-m36
20−
21−Flag profiler
22− Description: Enable Haskell-specific profiling support
23− Default: False
24− Manual: True
25−
26−--flag to allow stack to use its older, pinned packages
27−Flag stack
28− Description: build with stack and stackage
29− Manual: True
30− Default: False
31−
32−Flag haskell-scripting
33− Description: enables Haskell scripting which links against GHC as a library
34− Manual: True
35− Default: True
3613
3714Library
38− Build-Depends: base>=4.8 && < 4.15, ghc-paths, mtl, containers, unordered-containers, hashable, haskeline, directory, MonadRandom, random-shuffle, uuid >= 1.3.12, cassava >= 0.4.5.1 && < 0.6, text, bytestring, deepseq, deepseq-generics, vector, parallel, monad-parallel, exceptions, transformers, gnuplot, filepath, zlib, directory, temporary, stm, time, hashable-time, old-locale, rset, attoparsec, either, base64-bytestring, data-interval, extended-reals, aeson >= 1.1, path-pieces, conduit, resourcet, http-api-data, semigroups, QuickCheck, quickcheck-instances, list-t, stm-containers >= 0.2.15, foldl, optparse-applicative, Glob, cryptohash-sha256, text-manipulate >= 0.2.0.1 && < 0.4, winery, curryer-rpc, network, async, vector-instances, recursion-schemes, streamly >= 0.7.2, convertible
39− if flag(haskell-scripting)
40− Build-Depends: ghc >= 8.2 && < 8.11
41− CPP-Options: -DPM36_HASKELL_SCRIPTING
42− if impl(ghc>= 8) && flag(haskell-scripting)
43− build-depends:
44− ghc-boot, ghci
45− if impl(ghc>= 8.6)
46− Build-Depends: deferred-folds
15+ Build-Depends: base>=4.8 && < 4.9
16+ ,ghc >= 7.8 && <= 8.0.1
17+ ,ghc-paths
18+ ,mtl
19+ ,containers
20+ ,unordered-containers
21+ ,parsec
22+ ,hashable
23+ ,haskeline
24+ ,directory
25+ --critical uuid bug in lesser versions https://www.reddit.com/r/haskell/comments/4myot5/psa_make_sure_to_use_uuid_1312/
26+ ,uuid >= 1.3.12
27+ ,cassava ==0.4.*
28+ ,text
29+ ,bytestring
30+ ,deepseq
31+ ,deepseq-generics
32+ ,vector
33+ ,parallel
34+ ,monad-parallel
35+ ,transformers
36+ ,gnuplot
37+ ,binary
38+ ,filepath
39+ ,directory
40+ ,vector-binary-instances
41+ ,temporary
42+ ,stm
43+ ,time
44+ ,hashable-time
45+ ,old-locale
46+ ,attoparsec
47+ ,either
48+ ,base64-bytestring
49+ ,data-interval
50+ ,extended-reals
51+ ,network-transport
52+--required for persistent db driver
53+ ,persistent >= 2.2 && < 2.3
54+ ,persistent-template
55+ ,aeson
56+ ,path-pieces
57+ ,conduit
58+ ,resourcet
59+ ,http-api-data
60+--needed for remote access
61+ ,distributed-process-client-server
62+ ,distributed-process-extras
63+ ,distributed-process-async
64+ ,distributed-process
65+ ,network-transport-tcp
66+ ,network-transport
67+ ,distributed-process
68+ ,stm-containers
69+ ,list-t
4770 Exposed-Modules: ProjectM36.Error,
4871 ProjectM36.Transaction,
4972 ProjectM36.TransactionGraph,
5073 ProjectM36.TransactionGraph.Show,
5174 ProjectM36.TransactionGraph.Persist,
52− ProjectM36.TransactionGraph.Merge,
53− ProjectM36.TransGraphRelationalExpression,
5475 ProjectM36.Base,
55− ProjectM36.Serialise.Base,
56− ProjectM36.Serialise.Error,
57− ProjectM36.DataFrame,
5876 ProjectM36.Attribute,
5977 ProjectM36.AttributeNames,
6078 ProjectM36.Tuple,
6179 ProjectM36.TupleSet,
6280 ProjectM36.Atom,
6381 ProjectM36.AtomFunction,
64− ProjectM36.AtomFunctionError,
65− ProjectM36.ScriptSession,
66− ProjectM36.Shortcuts,
67− ProjectM36.DatabaseContextFunction,
68− ProjectM36.DatabaseContextFunctionError,
69− ProjectM36.DatabaseContextFunctionUtils,
7082 ProjectM36.Key,
71− ProjectM36.FunctionalDependency,
7283 ProjectM36.DatabaseContext,
73− ProjectM36.DateExamples,
74− ProjectM36.DisconnectedTransaction,
75− ProjectM36.AtomFunctionBody,
7684 ProjectM36.RelationalExpression,
7785 ProjectM36.Relation.Show.HTML,
7886 ProjectM36.StaticOptimizer,
7987 ProjectM36.Relation.Show.Term,
80− ProjectM36.WCWidth,
8188 ProjectM36.Relation.Show.CSV,
8289 ProjectM36.Relation.Show.Gnuplot,
8390 ProjectM36.Relation.Parse.CSV,
84− ProjectM36.IsomorphicSchema,
85− ProjectM36.InclusionDependency,
86− ProjectM36.MerkleHash,
8791 ProjectM36.Client,
88− ProjectM36.Client.Simple,
8992 ProjectM36.Persist,
9093 ProjectM36.AtomType,
91− ProjectM36.AttributeExpr,
9294 ProjectM36.AtomFunctions.Basic,
9395 ProjectM36.AtomFunctions.Primitive,
94− ProjectM36.Atomable,
95− ProjectM36.Tupleable,
96− ProjectM36.Tupleable.Deriving,
96+ ProjectM36.ConcreteTypeRep,
9797 ProjectM36.DataConstructorDef,
9898 ProjectM36.DataTypes.Basic,
99− ProjectM36.DataTypes.Sorting,
10099 ProjectM36.DataTypes.Day,
101− ProjectM36.DataTypes.DateTime,
102100 ProjectM36.DataTypes.Either,
103101 ProjectM36.DataTypes.Maybe,
104− ProjectM36.DataTypes.List,
105− ProjectM36.DataTypes.NonEmptyList,
106102 ProjectM36.DataTypes.Primitive,
107− ProjectM36.DataTypes.Interval,
108− ProjectM36.DataTypes.ByteString,
109103 ProjectM36.MiscUtils,
110104 ProjectM36.Notifications,
111105 ProjectM36.Relation,
112− ProjectM36.Server,
113− ProjectM36.Server.Config,
114− ProjectM36.Server.EntryPoints,
115− ProjectM36.Server.ParseArgs,
116106 ProjectM36.Server.RemoteCallTypes,
117− ProjectM36.Serialise.AtomFunctionError,
118− ProjectM36.Serialise.DataFrame,
119− ProjectM36.Serialise.DatabaseContextFunctionError,
120− ProjectM36.Serialise.IsomorphicSchema,
121107 ProjectM36.Session,
122108 ProjectM36.Sessions,
123109 ProjectM36.Transaction.Persist,
124110 ProjectM36.TypeConstructor,
125111 ProjectM36.TypeConstructorDef,
126− ProjectM36.FileLock,
127− ProjectM36.FSType,
128− ProjectM36.Arbitrary,
129− ProjectM36.GraphRefRelationalExpr,
130− ProjectM36.NormalizeExpr,
131− ProjectM36.TransactionInfo,
132− ProjectM36.WithNameExpr
133− GHC-Options: -Wall -rdynamic
112+ ProjectM36.TransactionGraph.Merge,
113+ Database.Persist.ProjectM36
114+ GHC-Options: -Wall -rtsopts
134115 if os(windows)
135− Build-Depends: Win32 >= 2.5.4.1
116+ Build-Depends: Win32 >= 2.3 && < 2.4
136117 Other-Modules: ProjectM36.Win32Handle
137118 else
138− --219- too many exported symbols under Windows and GHC 8.4
139− GHC-Options: -rdynamic -fexternal-interpreter
140− C-sources: cbits/DirectoryFsync.c, cbits/darwin_statfs.c
119+ C-sources: ProjectM36/DirectoryFsync.c
141120 Build-Depends: unix
142− CC-Options: -fPIC
143− Hs-Source-Dirs: ./src/lib
144121 Default-Language: Haskell2010
145− Default-Extensions: OverloadedStrings, CPP
146− if !flag(stack)
147− Build-Depends: deferred-folds
122+ Default-Extensions: OverloadedStrings
148123
149124Executable tutd
150− if flag(haskell-scripting)
151− Build-Depends: ghc >= 8.2 && < 8.11
152− Build-Depends: base >=4.8 && <5.0,
125+ Build-Depends: base >=4.8 && <4.9,
126+ ghc >= 7.8 && <= 8.0.1,
153127 ghc-paths,
154− project-m36,
155128 containers,
156129 unordered-containers,
157130 hashable,
158131 transformers,
159− semigroups,
160132 mtl,
161133 uuid,
162134 deepseq-generics,
163− MonadRandom, MonadRandom,
164135 vector,
165136 text,
137+ vector-binary-instances,
166138 time,
167139 hashable-time,
168140 bytestring,
141+ distributed-process-client-server,
142+ distributed-process-extras,
143+ distributed-process-async,
144+ distributed-process,
145+ network-transport-tcp,
146+ network-transport,
147+ distributed-process,
169148 stm,
170149 deepseq,
150+ binary,
171151 data-interval,
172152 parallel,
173153 cassava,
@@ -175,56 +155,96 @@ Executable tutd
175155 directory,
176156 filepath,
177157 temporary,
178− megaparsec >= 5.2.0 && < 10,
158+ parsec,
179159 haskeline,
180− random, MonadRandom,
181160 base64-bytestring,
182161 optparse-applicative,
183162 attoparsec,
184− stm-containers >= 1.0.0,
185− list-t,
186− parser-combinators,
187− curryer-rpc,
188− prettyprinter,
189− cryptohash-sha256,
190− --due to decode signature change
191− base16-bytestring >= 1.0.0.0,
192− http-conduit,
193− modern-uri,
194− http-types
195− Other-Modules: TutorialD.Interpreter,
163+ stm-containers,
164+ list-t
165+ Other-Modules: ProjectM36.Error,
166+ ProjectM36.Base,
167+ ProjectM36.RelationalExpression,
168+ ProjectM36.Transaction,
169+ TutorialD.Interpreter,
196170 TutorialD.Interpreter.Base,
197171 TutorialD.Interpreter.DatabaseContextExpr,
198172 TutorialD.Interpreter.RODatabaseContextOperator,
199173 TutorialD.Interpreter.TransactionGraphOperator,
174+ TutorialD.Interpreter.DataTypes.Interval,
175+ TutorialD.Interpreter.DataTypes.DateTime,
176+ ProjectM36.Atom,
177+ ProjectM36.AtomFunction,
178+ ProjectM36.AtomFunctions.Basic,
179+ ProjectM36.AtomFunctions.Primitive,
180+ ProjectM36.AtomType,
181+ ProjectM36.Attribute,
182+ ProjectM36.AttributeNames,
183+ ProjectM36.Client,
184+ ProjectM36.ConcreteTypeRep,
185+ ProjectM36.DataConstructorDef,
186+ ProjectM36.DataTypes.Basic,
187+ ProjectM36.DataTypes.Day,
188+ ProjectM36.DataTypes.Either,
189+ ProjectM36.DataTypes.Maybe,
190+ ProjectM36.DataTypes.Primitive,
191+ ProjectM36.DatabaseContext,
192+ ProjectM36.Key,
193+ ProjectM36.MiscUtils,
194+ ProjectM36.Notifications,
195+ ProjectM36.Persist,
196+ ProjectM36.Relation,
197+ ProjectM36.Relation.Parse.CSV,
198+ ProjectM36.Relation.Show.CSV,
199+ ProjectM36.Relation.Show.Gnuplot,
200+ ProjectM36.Relation.Show.Term,
201+ ProjectM36.Server.RemoteCallTypes,
202+ ProjectM36.Session,
203+ ProjectM36.Sessions,
204+ ProjectM36.StaticOptimizer,
205+ ProjectM36.Transaction.Persist,
206+ ProjectM36.TransactionGraph,
207+ ProjectM36.TransactionGraph.Persist,
208+ ProjectM36.Tuple,
209+ ProjectM36.TupleSet,
210+ ProjectM36.TypeConstructor,
211+ ProjectM36.TypeConstructorDef,
212+ ProjectM36.TransactionGraph.Merge,
213+ ProjectM36.DateExamples,
200214 TutorialD.Interpreter.Import.BasicExamples,
201215 TutorialD.Interpreter.InformationOperator,
202216 TutorialD.Interpreter.Export.Base,
203217 TutorialD.Interpreter.Export.CSV,
204− TutorialD.Interpreter.DatabaseContextIOOperator,
205218 TutorialD.Interpreter.Import.Base,
206219 TutorialD.Interpreter.Import.CSV,
207220 TutorialD.Interpreter.Import.TutorialD,
208221 TutorialD.Interpreter.RelationalExpr,
209− TutorialD.Interpreter.Types,
210− TutorialD.Interpreter.SchemaOperator,
211− TutorialD.Interpreter.TransGraphRelationalOperator,
212− TutorialD.Interpreter.SchemaOperator
213− TutorialD.Printer
222+ TutorialD.Interpreter.Types
214223 main-is: TutorialD/tutd.hs
224+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
215225 CC-Options: -fPIC
216− GHC-Options: -Wall -threaded
217− Hs-Source-Dirs: ./src/bin
226+ GHC-Options: -Wall
218227 Default-Language: Haskell2010
219228 Default-Extensions: OverloadedStrings
229+ if os(windows)
230+ Build-Depends: Win32 >= 2.3 && < 2.4
231+ Other-Modules: ProjectM36.Win32Handle
232+ else
233+ C-sources: ProjectM36/DirectoryFsync.c
234+ Build-Depends: unix
235+
220236
221237Executable project-m36-server
222− if flag(haskell-scripting)
223− Build-Depends: ghc >= 8.2 && < 8.11
224238 Build-Depends: base,
225− ghc-paths,
239+ distributed-process-client-server,
240+ distributed-process-extras,
241+ distributed-process-async,
242+ distributed-process,
243+ network-transport-tcp,
244+ network-transport,
245+ distributed-process,
246+ binary,
226247 transformers,
227− project-m36,
228248 temporary,
229249 data-interval,
230250 deepseq,
@@ -237,6 +257,7 @@ Executable project-m36-server
237257 optparse-applicative,
238258 hashable-time,
239259 time,
260+ vector-binary-instances,
240261 text,
241262 deepseq-generics,
242263 mtl,
@@ -248,267 +269,408 @@ Executable project-m36-server
248269 stm-containers,
249270 list-t,
250271 base64-bytestring
251− Main-Is: ./src/bin/ProjectM36/Server/project-m36-server.hs
272+ Main-Is: ProjectM36/Server/project-m36-server.hs
273+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
252274 GHC-Options: -Wall -threaded -rtsopts
253− if flag(profiler)
254− GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
275+ GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
255276 Default-Language: Haskell2010
256277 Default-Extensions: OverloadedStrings
278+ Other-Modules: ProjectM36.Atom,
279+ ProjectM36.AtomFunction,
280+ ProjectM36.AtomFunctions.Basic,
281+ ProjectM36.AtomFunctions.Primitive,
282+ ProjectM36.AtomType,
283+ ProjectM36.Attribute,
284+ ProjectM36.AttributeNames,
285+ ProjectM36.Base,
286+ ProjectM36.Client,
287+ ProjectM36.ConcreteTypeRep,
288+ ProjectM36.DataConstructorDef,
289+ ProjectM36.DataTypes.Basic,
290+ ProjectM36.DataTypes.Day,
291+ ProjectM36.DataTypes.Either,
292+ ProjectM36.DataTypes.Maybe,
293+ ProjectM36.DataTypes.Primitive,
294+ ProjectM36.DatabaseContext,
295+ ProjectM36.Error,
296+ ProjectM36.MiscUtils,
297+ ProjectM36.Notifications,
298+ ProjectM36.Persist,
299+ ProjectM36.Relation,
300+ ProjectM36.RelationalExpression,
301+ ProjectM36.Server,
302+ ProjectM36.Server.Config,
303+ ProjectM36.Server.EntryPoints,
304+ ProjectM36.Server.ParseArgs,
305+ ProjectM36.Server.RemoteCallTypes,
306+ ProjectM36.Session,
307+ ProjectM36.Sessions,
308+ ProjectM36.StaticOptimizer,
309+ ProjectM36.Transaction,
310+ ProjectM36.Transaction.Persist,
311+ ProjectM36.TransactionGraph,
312+ ProjectM36.TransactionGraph.Persist,
313+ ProjectM36.TransactionGraph.Merge,
314+ ProjectM36.Tuple,
315+ ProjectM36.TupleSet,
316+ ProjectM36.TypeConstructor,
317+ ProjectM36.TypeConstructorDef
318+ if os(windows)
319+ Build-Depends: Win32 >= 2.3 && < 2.4
320+ Other-Modules: ProjectM36.Win32Handle
321+ else
322+ C-sources: ProjectM36/DirectoryFsync.c
323+ Build-Depends: unix
324+
257325
258326Executable bigrel
259327 Default-Language: Haskell2010
260328 Default-Extensions: OverloadedStrings
261− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups, parser-combinators
262− Other-Modules: TutorialD.Interpreter.Base,
329+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t
330+ Other-Modules: ProjectM36.Base,
331+ ProjectM36.Relation
332+ ProjectM36.Tuple,
333+ ProjectM36.Error,
334+ ProjectM36.Relation.Show.CSV,
335+ ProjectM36.Atom,
336+ ProjectM36.AtomFunction,
337+ ProjectM36.AtomFunctions.Basic,
338+ ProjectM36.AtomFunctions.Primitive,
339+ ProjectM36.AtomType,
340+ ProjectM36.Attribute,
341+ ProjectM36.AttributeNames,
342+ ProjectM36.ConcreteTypeRep,
343+ ProjectM36.DataConstructorDef,
344+ ProjectM36.DataTypes.Basic,
345+ ProjectM36.DataTypes.Day,
346+ ProjectM36.Relation.Show.Term,
347+ ProjectM36.DataTypes.Either,
348+ ProjectM36.DataTypes.Maybe,
349+ ProjectM36.DataTypes.Primitive,
350+ ProjectM36.DatabaseContext,
351+ ProjectM36.DateExamples,
352+ ProjectM36.Key,
353+ ProjectM36.MiscUtils,
354+ ProjectM36.Relation.Show.HTML,
355+ ProjectM36.RelationalExpression,
356+ ProjectM36.StaticOptimizer,
357+ ProjectM36.TupleSet,
358+ ProjectM36.TypeConstructor,
359+ ProjectM36.TypeConstructorDef,
360+ TutorialD.Interpreter.Base,
263361 TutorialD.Interpreter.DatabaseContextExpr,
264362 TutorialD.Interpreter.RelationalExpr,
265363 TutorialD.Interpreter.Types
266364 main-is: benchmark/bigrel.hs
267365 GHC-Options: -Wall -threaded -rtsopts
268− HS-Source-Dirs: ./src/bin
269− if flag(profiler)
270− GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
366+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
367+ GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
368+ if os(windows)
369+ Build-Depends: Win32 >= 2.3 && < 2.4
370+ Other-Modules: ProjectM36.Win32Handle
371+ else
372+ C-sources: ProjectM36/DirectoryFsync.c
373+ Build-Depends: unix
271374
272−Common commontest
273− Default-Language: Haskell2010
274− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators, winery, curryer-rpc, prettyprinter, base64-bytestring, modern-uri, http-types, http-conduit, base16-bytestring,cryptohash-sha256
275− Default-Extensions: OverloadedStrings
276− GHC-Options: -Wall -threaded
277− Hs-Source-Dirs: test, src/bin
278375
279−Benchmark basic-benchmark
376+Test-Suite test-tutoriald
280377 Default-Language: Haskell2010
281378 Default-Extensions: OverloadedStrings
282− Build-Depends: base, criterion, project-m36, text, vector, transformers, containers, temporary, directory, filepath
283− Main-Is: benchmark/Basic.hs
284− Type: exitcode-stdio-1.0
285− GHC-Options: -Wall -threaded -rtsopts
286− HS-Source-Dirs: ./src/bin
287− if flag(profiler)
288− GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
289−
290−--benchmark inserts, updates, deletes for a basic use-case to shake out any space leaks
291−Benchmark update-exprs
292− Default-Language: Haskell2010
293− Default-Extensions: OverloadedStrings
294− Build-Depends: base, criterion, project-m36, text, winery
295− Main-Is: benchmark/Server.hs
296− Type: exitcode-stdio-1.0
297− GHC-Options: -Wall -threaded -rtsopts
298− HS-Source-Dirs: ./src/bin
299− if flag(profiler)
300− GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall -fexternal-interpreter
301−
302−Test-Suite test-tutoriald
303− import: commontest
304− type: exitcode-stdio-1.0
305− main-is: TutorialD/InterpreterTest.hs
306− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer
307− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, list-t, project-m36, random, MonadRandom, semigroups, parser-combinators, prettyprinter
308−
309−Test-Suite test-tutoriald-atomfunctionscript
310− import: commontest
311379 type: exitcode-stdio-1.0
312− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer
313− main-is: TutorialD/Interpreter/AtomFunctionScript.hs
314−
315−Test-Suite test-tutoriald-databasecontextfunctionscript
316− import: commontest
317− type: exitcode-stdio-1.0
318− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer
319− main-is: TutorialD/Interpreter/DatabaseContextFunctionScript.hs
380+ main-is: test/TutorialD/Interpreter.hs
381+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, stm-containers, list-t
382+ Other-Modules: ProjectM36.Atom, ProjectM36.AtomFunction, ProjectM36.AtomFunctions.Basic, ProjectM36.AtomFunctions.Primitive, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.Client, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Basic, ProjectM36.DataTypes.Day, ProjectM36.DataTypes.Either, ProjectM36.DataTypes.Maybe, ProjectM36.DataTypes.Primitive, ProjectM36.DatabaseContext, ProjectM36.DateExamples, ProjectM36.Error, ProjectM36.Key, ProjectM36.MiscUtils, ProjectM36.Notifications, ProjectM36.Persist, ProjectM36.Relation, ProjectM36.Relation.Parse.CSV, ProjectM36.Relation.Show.CSV, ProjectM36.Relation.Show.Gnuplot, ProjectM36.Relation.Show.Term, ProjectM36.RelationalExpression, ProjectM36.Server.RemoteCallTypes, ProjectM36.Session, ProjectM36.Sessions, ProjectM36.StaticOptimizer, ProjectM36.Transaction, ProjectM36.Transaction.Persist, ProjectM36.TransactionGraph, ProjectM36.TransactionGraph.Persist, ProjectM36.TransactionGraph.Merge, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef, 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
383+ GHC-Options: -Wall
384+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
385+ if os(windows)
386+ Build-Depends: Win32 >= 2.3 && < 2.4
387+ Other-Modules: ProjectM36.Win32Handle
388+ else
389+ C-sources: ProjectM36/DirectoryFsync.c
390+ Build-Depends: unix
391+
320392
321393Test-Suite test-relation
322− import: commontest
394+ Default-Language: Haskell2010
395+ Default-Extensions: OverloadedStrings
323396 type: exitcode-stdio-1.0
324− main-is: Relation/Basic.hs
397+ main-is: test/Relation/Basic.hs
398+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, stm-containers
399+ Other-Modules: ProjectM36.Atom, ProjectM36.AtomFunction, ProjectM36.AtomFunctions.Basic, ProjectM36.AtomFunctions.Primitive, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Basic, ProjectM36.DataTypes.Day, ProjectM36.DataTypes.Either, ProjectM36.DataTypes.Maybe, ProjectM36.DataTypes.Primitive, ProjectM36.DatabaseContext, ProjectM36.DateExamples, ProjectM36.Error, ProjectM36.Key, ProjectM36.MiscUtils, ProjectM36.Relation, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef, ProjectM36.RelationalExpression
400+ GHC-Options: -Wall
401+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
325402
326403Test-Suite test-static-optimizer
327− import: commontest
404+ Default-Language: Haskell2010
405+ Default-Extensions: OverloadedStrings
328406 type: exitcode-stdio-1.0
329− main-is: Relation/StaticOptimizer.hs
407+ main-is: test/Relation/StaticOptimizer.hs
408+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, stm-containers
409+ Other-Modules: ProjectM36.Atom, ProjectM36.AtomFunction, ProjectM36.AtomFunctions.Basic, ProjectM36.AtomFunctions.Primitive, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Basic, ProjectM36.DataTypes.Day, ProjectM36.DataTypes.Either, ProjectM36.DataTypes.Maybe, ProjectM36.DataTypes.Primitive, ProjectM36.DatabaseContext, ProjectM36.DateExamples, ProjectM36.Error, ProjectM36.Key, ProjectM36.MiscUtils, ProjectM36.Relation, ProjectM36.RelationalExpression, ProjectM36.StaticOptimizer, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef
410+ GHC-Options: -Wall
411+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
330412
331413Test-Suite test-transactiongraph-persist
332− import: commontest
414+ Default-Language: Haskell2010
415+ Default-Extensions: OverloadedStrings
333416 type: exitcode-stdio-1.0
334− main-is: TransactionGraph/Persist.hs
335− Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Printer
417+ main-is: test/TransactionGraph/Persist.hs
418+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, stm-containers
419+ Other-Modules: ProjectM36.Atom, ProjectM36.AtomFunction, ProjectM36.AtomFunctions.Basic, ProjectM36.AtomFunctions.Primitive, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Basic, ProjectM36.DataTypes.Day, ProjectM36.DataTypes.Either, ProjectM36.DataTypes.Maybe, ProjectM36.DataTypes.Primitive, ProjectM36.DatabaseContext, ProjectM36.DateExamples, ProjectM36.Error, ProjectM36.Key, ProjectM36.MiscUtils, ProjectM36.Persist, ProjectM36.Relation, ProjectM36.RelationalExpression, ProjectM36.StaticOptimizer, ProjectM36.Transaction, ProjectM36.Transaction.Persist, ProjectM36.TransactionGraph, ProjectM36.TransactionGraph.Persist, ProjectM36.TransactionGraph.Merge, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef, TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples
420+ GHC-Options: -Wall
421+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
422+ if os(windows)
423+ Build-Depends: Win32 >= 2.3 && < 2.4
424+ Other-Modules: ProjectM36.Win32Handle
425+ else
426+ C-sources: ProjectM36/DirectoryFsync.c
427+ Build-Depends: unix
428+
336429
337430Test-Suite test-relation-import-csv
338− import: commontest
431+ Default-Language: Haskell2010
432+ Default-Extensions: OverloadedStrings
339433 type: exitcode-stdio-1.0
340− main-is: Relation/Import/CSV.hs
434+ main-is: test/Relation/Import/CSV.hs
435+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, stm-containers
436+ Other-Modules: ProjectM36.Atom, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Primitive, ProjectM36.Error, ProjectM36.MiscUtils, ProjectM36.Relation, ProjectM36.Relation.Parse.CSV, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef
437+ GHC-Options: -Wall
438+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
341439
342440Test-Suite test-tutoriald-import-tutoriald
343− import: commontest
441+ Default-Language: Haskell2010
442+ Default-Extensions: OverloadedStrings
344443 type: exitcode-stdio-1.0
345− main-is: TutorialD/Interpreter/Import/ImportTest.hs
346− Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Printer
444+ main-is: test/TutorialD/Interpreter/Import/TutorialD.hs
445+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, stm-containers
446+ Other-Modules: ProjectM36.Atom, ProjectM36.AtomFunction, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Primitive, ProjectM36.Error, ProjectM36.Key, ProjectM36.MiscUtils, ProjectM36.Relation, ProjectM36.RelationalExpression, ProjectM36.StaticOptimizer, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef, ProjectM36.Relation.Show.Term, TutorialD.Interpreter.Base, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples
447+ GHC-Options: -Wall
448+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
347449
348450Test-Suite test-relation-export-csv
349− import: commontest
451+ Default-Language: Haskell2010
452+ Default-Extensions: OverloadedStrings
350453 type: exitcode-stdio-1.0
351− main-is: Relation/Export/CSV.hs
454+ main-is: test/Relation/Export/CSV.hs
455+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, stm-containers
456+ Other-Modules: ProjectM36.Atom, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Primitive, ProjectM36.Error, ProjectM36.MiscUtils, ProjectM36.Relation, ProjectM36.Relation.Parse.CSV, ProjectM36.Relation.Show.CSV, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef
457+ GHC-Options: -Wall
458+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
352459
353−Test-Suite test-transactiongraph-merge
354− import: commontest
460+Test-Suite test-persistent-driver
461+ Default-Language: Haskell2010
462+ Default-Extensions: OverloadedStrings
355463 type: exitcode-stdio-1.0
356− main-is: TransactionGraph/Merge.hs
357−
358−
359−Test-Suite test-prettyprinter
360− import: commontest
464+ main-is: test/persistent-driver/test.hs
465+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, template-haskell, transformers, aeson, persistent-template, conduit, persistent >= 2.2 && < 2.3, either, path-pieces, http-api-data, stm-containers, list-t
466+ GHC-Options: -Wall
467+ Other-Modules: Database.Persist.ProjectM36, ProjectM36.Atom, ProjectM36.AtomFunction, ProjectM36.AtomFunctions.Basic, ProjectM36.AtomFunctions.Primitive, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.Client, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Basic, ProjectM36.DataTypes.Day, ProjectM36.DataTypes.Either, ProjectM36.DataTypes.Maybe, ProjectM36.DataTypes.Primitive, ProjectM36.DatabaseContext, ProjectM36.Error, ProjectM36.MiscUtils, ProjectM36.Notifications, ProjectM36.Persist, ProjectM36.Relation, ProjectM36.RelationalExpression, ProjectM36.Server.RemoteCallTypes, ProjectM36.Session, ProjectM36.Sessions, ProjectM36.StaticOptimizer, ProjectM36.Transaction, ProjectM36.Transaction.Persist, ProjectM36.TransactionGraph, ProjectM36.TransactionGraph.Persist, ProjectM36.TransactionGraph.Merge, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef
468+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
469+ if os(windows)
470+ Build-Depends: Win32 >= 2.3 && < 2.4
471+ Other-Modules: ProjectM36.Win32Handle
472+ else
473+ C-sources: ProjectM36/DirectoryFsync.c
474+ Build-Depends: unix
475+
476+Test-Suite test-transactiongraph-merge
477+ Default-Language: Haskell2010
478+ Default-Extensions: OverloadedStrings
361479 type: exitcode-stdio-1.0
362− main-is: TutorialD/PrinterTest.hs
363− Other-Modules: TutorialD.Printer, TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types
480+ main-is: test/TransactionGraph/Merge.hs
481+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, template-haskell, transformers, aeson, persistent-template, conduit, persistent, either, path-pieces, http-api-data, stm-containers, list-t
482+ Other-Modules: ProjectM36.Atom, ProjectM36.AtomFunction, ProjectM36.AtomFunctions.Basic, ProjectM36.AtomFunctions.Primitive, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Basic, ProjectM36.DataTypes.Day, ProjectM36.DataTypes.Either, ProjectM36.DataTypes.Maybe, ProjectM36.DataTypes.Primitive, ProjectM36.DatabaseContext, ProjectM36.DateExamples, ProjectM36.Error, ProjectM36.Key, ProjectM36.MiscUtils, ProjectM36.Relation, ProjectM36.RelationalExpression, ProjectM36.Transaction, ProjectM36.TransactionGraph, ProjectM36.TransactionGraph.Merge, ProjectM36.TransactionGraph.Show, ProjectM36.TransactionGraph.Show.Dot, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef, ProjectM36.Relation.Show.Term
483+ GHC-Options: -Wall
484+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
485+ if os(windows)
486+ Build-Depends: Win32 >= 2.3 && < 2.4
487+ Other-Modules: ProjectM36.Win32Handle
488+ else
489+ C-sources: ProjectM36/DirectoryFsync.c
490+ Build-Depends: unix
491+
364492
365493benchmark bench
366− import: commontest
494+ Default-Language: Haskell2010
495+ Default-Extensions: OverloadedStrings
367496 type: exitcode-stdio-1.0
368497 main-is: benchmark/Relation.hs
498+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, criterion, stm-containers
499+ GHC-Options: -Wall -rtsopts
500+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
369501
370502Test-Suite test-server
371− import: commontest
503+ Default-Language: Haskell2010
504+ Default-Extensions: OverloadedStrings
372505 type: exitcode-stdio-1.0
373− main-is: Server/Main.hs
374−
506+ main-is: test/Server/Main.hs
507+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t
508+ GHC-Options: -Wall
509+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
510+ Other-Modules: ProjectM36.Atom, ProjectM36.AtomFunction, ProjectM36.AtomFunctions.Basic, ProjectM36.AtomFunctions.Primitive, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.Client, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Basic, ProjectM36.DataTypes.Day, ProjectM36.DataTypes.Either, ProjectM36.DataTypes.Maybe, ProjectM36.DataTypes.Primitive, ProjectM36.DatabaseContext, ProjectM36.Error, ProjectM36.MiscUtils, ProjectM36.Notifications, ProjectM36.Persist, ProjectM36.Relation, ProjectM36.RelationalExpression, ProjectM36.Server, ProjectM36.Server.Config, ProjectM36.Server.EntryPoints, ProjectM36.Server.RemoteCallTypes, ProjectM36.Session, ProjectM36.Sessions, ProjectM36.StaticOptimizer, ProjectM36.Transaction, ProjectM36.Transaction.Persist, ProjectM36.TransactionGraph, ProjectM36.TransactionGraph.Persist, ProjectM36.TransactionGraph.Merge, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef
511+ if os(windows)
512+ Build-Depends: Win32 >= 2.3 && < 2.4
513+ Other-Modules: ProjectM36.Win32Handle
514+ else
515+ C-sources: ProjectM36/DirectoryFsync.c
516+ Build-Depends: unix
517+
518+
375519
376520Executable Example-SimpleClient
377521 Default-Language: Haskell2010
378522 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
523+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t
380524 Main-Is: examples/SimpleClient.hs
381− GHC-Options: -Wall -threaded
382−
383−Executable Example-OutOfTheTarpit
384− Default-Language: Haskell2010
385− 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
387− Main-Is: examples/out_of_the_tarpit.hs
388− GHC-Options: -Wall -threaded
389−
390−Executable Example-Blog
391− Default-Language: Haskell2010
392− 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
394− Main-Is: examples/blog.hs
395− GHC-Options: -Wall -threaded
396−
397−Executable Example-Hair
398− Default-Language: Haskell2010
399− 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
401− Main-Is: examples/hair.hs
402− GHC-Options: -Wall -threaded
525+ GHC-Options: -Wall
526+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
527+ Other-Modules: ProjectM36.Atom,
528+ ProjectM36.AtomFunction,
529+ ProjectM36.AtomFunctions.Basic,
530+ ProjectM36.AtomFunctions.Primitive,
531+ ProjectM36.AtomType,
532+ ProjectM36.Attribute,
533+ ProjectM36.AttributeNames,
534+ ProjectM36.Base,
535+ ProjectM36.Client,
536+ ProjectM36.ConcreteTypeRep,
537+ ProjectM36.DataConstructorDef,
538+ ProjectM36.DataTypes.Basic,
539+ ProjectM36.DataTypes.Day,
540+ ProjectM36.DataTypes.Either,
541+ ProjectM36.DataTypes.Maybe,
542+ ProjectM36.DataTypes.Primitive,
543+ ProjectM36.DatabaseContext,
544+ ProjectM36.Error,
545+ ProjectM36.MiscUtils,
546+ ProjectM36.Notifications,
547+ ProjectM36.Persist,
548+ ProjectM36.Relation,
549+ ProjectM36.Relation.Show.Term,
550+ ProjectM36.RelationalExpression,
551+ ProjectM36.Server.RemoteCallTypes,
552+ ProjectM36.Session,
553+ ProjectM36.Sessions,
554+ ProjectM36.StaticOptimizer,
555+ ProjectM36.Transaction,
556+ ProjectM36.Transaction.Persist,
557+ ProjectM36.TransactionGraph,
558+ ProjectM36.TransactionGraph.Persist,
559+ ProjectM36.TransactionGraph.Merge,
560+ ProjectM36.Tuple,
561+ ProjectM36.TupleSet,
562+ ProjectM36.TypeConstructor,
563+ ProjectM36.TypeConstructorDef
564+ if os(windows)
565+ Build-Depends: Win32 >= 2.3 && < 2.4
566+ Other-Modules: ProjectM36.Win32Handle
567+ else
568+ C-sources: ProjectM36/DirectoryFsync.c
569+ Build-Depends: unix
570+
571+
403572
404−Executable Example-Plantfarm
573+Executable Example-PersistClient
405574 Default-Language: Haskell2010
406575 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−
411−Executable Example-CustomTupleable
576+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, persistent, aeson, path-pieces, either, conduit, http-api-data, template-haskell, persistent-template
577+ Main-Is: examples/PersistClient.hs
578+ GHC-Options: -Wall
579+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
580+ Other-Modules: Database.Persist.ProjectM36,
581+ ProjectM36.Atom,
582+ ProjectM36.AtomFunction,
583+ ProjectM36.AtomFunctions.Basic,
584+ ProjectM36.AtomFunctions.Primitive,
585+ ProjectM36.AtomType,
586+ ProjectM36.Attribute,
587+ ProjectM36.AttributeNames,
588+ ProjectM36.Base,
589+ ProjectM36.Client,
590+ ProjectM36.ConcreteTypeRep,
591+ ProjectM36.DataConstructorDef,
592+ ProjectM36.DataTypes.Basic,
593+ ProjectM36.DataTypes.Day,
594+ ProjectM36.DataTypes.Either,
595+ ProjectM36.DataTypes.Maybe,
596+ ProjectM36.DataTypes.Primitive,
597+ ProjectM36.DatabaseContext,
598+ ProjectM36.Error,
599+ ProjectM36.MiscUtils,
600+ ProjectM36.Notifications,
601+ ProjectM36.Persist,
602+ ProjectM36.Relation,
603+ ProjectM36.RelationalExpression,
604+ ProjectM36.Server.RemoteCallTypes,
605+ ProjectM36.Session,
606+ ProjectM36.Sessions,
607+ ProjectM36.StaticOptimizer,
608+ ProjectM36.Transaction,
609+ ProjectM36.Transaction.Persist,
610+ ProjectM36.TransactionGraph,
611+ ProjectM36.TransactionGraph.Persist,
612+ ProjectM36.TransactionGraph.Merge,
613+ ProjectM36.Tuple,
614+ ProjectM36.TupleSet,
615+ ProjectM36.TypeConstructor,
616+ ProjectM36.TypeConstructorDef
617+ if os(windows)
618+ Build-Depends: Win32 >= 2.3 && < 2.4
619+ Other-Modules: ProjectM36.Win32Handle
620+ else
621+ C-sources: ProjectM36/DirectoryFsync.c
622+ Build-Depends: unix
623+
624+Test-Suite test-scripts
412625 Default-Language: Haskell2010
413626 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
415− Main-Is: examples/CustomTupleable.hs
416− GHC-Options: -Wall -threaded
417−
418−Executable Example-DerivingCustomTupleable
419− if impl(ghc>=8.6)
420− Buildable: True
627+ type: exitcode-stdio-1.0
628+ main-is: test/scripts.hs
629+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t
630+ Other-Modules: ProjectM36.Atom, ProjectM36.AtomFunction, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Primitive, ProjectM36.Error, ProjectM36.Key, ProjectM36.MiscUtils, ProjectM36.Relation, ProjectM36.RelationalExpression, ProjectM36.StaticOptimizer, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef, ProjectM36.Relation.Show.Term, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.Import.BasicExamples
631+ GHC-Options: -Wall
632+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
633+ if os(windows)
634+ Build-Depends: Win32 >= 2.3 && < 2.4
635+ Other-Modules: ProjectM36.Win32Handle
421636 else
422− Buildable: False
423− Default-Language: Haskell2010
424− Build-Depends: base, text, deepseq, project-m36, winery
425− Main-Is: examples/DerivingCustomTupleable.hs
426− GHC-Options: -Wall -threaded
637+ C-sources: ProjectM36/DirectoryFsync.c
638+ Build-Depends: unix
427639
428−Test-Suite test-scripts
429− import: commontest
430− type: exitcode-stdio-1.0
431− main-is: scripts.hs
432− Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Printer
640+Executable dud
641+ Default-Language: Haskell2010
642+ Build-Depends: ghc >= 7.8 && <= 8.0.1, base, ghc-paths, mtl, haskeline
643+ Main-Is: test.hs
644+ GHC-Options: -Wall
645+ CPP-Options: -DGHCI
433646
434647Executable project-m36-websocket-server
435648 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
437− Main-Is: ProjectM36/Server/WebSocket/websocket-server.hs
438− Other-Modules: ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer
439− GHC-Options: -Wall -threaded
440− Hs-Source-Dirs: ./src/bin
649+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, persistent, aeson, path-pieces, either, conduit, http-api-data, template-haskell, persistent-template, websockets, aeson, uuid-aeson, optparse-applicative
650+ Other-Modules: ProjectM36.Atom, ProjectM36.AtomFunction, ProjectM36.AtomFunctions.Basic, ProjectM36.AtomFunctions.Primitive, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.Client, ProjectM36.Client.Json, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Basic, ProjectM36.DataTypes.Day, ProjectM36.DataTypes.Either, ProjectM36.DataTypes.Maybe, ProjectM36.DataTypes.Primitive, ProjectM36.DatabaseContext, ProjectM36.DateExamples, ProjectM36.Error, ProjectM36.Key, ProjectM36.MiscUtils, ProjectM36.Notifications, ProjectM36.Persist, ProjectM36.Relation, ProjectM36.Relation.Parse.CSV, ProjectM36.Relation.Show.CSV, ProjectM36.Relation.Show.Gnuplot, ProjectM36.Relation.Show.Term, ProjectM36.RelationalExpression, ProjectM36.Server, ProjectM36.Server.Config, ProjectM36.Server.EntryPoints, ProjectM36.Server.ParseArgs, ProjectM36.Server.RemoteCallTypes, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, ProjectM36.Session, ProjectM36.Sessions, ProjectM36.StaticOptimizer, ProjectM36.Transaction, ProjectM36.Transaction.Persist, ProjectM36.TransactionGraph, ProjectM36.TransactionGraph.Merge, ProjectM36.TransactionGraph.Persist, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, 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
651+ Main-Is: ProjectM36/Server/WebSocket/Main.hs
652+ GHC-Options: -Wall
653+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
441654 Default-Extensions: OverloadedStrings
655+ if os(windows)
656+ Build-Depends: Win32 >= 2.3 && < 2.4
657+ Other-Modules: ProjectM36.Win32Handle
658+ else
659+ C-sources: ProjectM36/DirectoryFsync.c
660+ Build-Depends: unix
442661
443662Test-Suite test-websocket-server
444− import: commontest
445− type: exitcode-stdio-1.0
446− main-is: Server/WebSocket.hs
447− Other-Modules: TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.TransactionGraphOperator, ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer
448−
449−Test-Suite test-isomorphic-schemas
450− import: commontest
451− type: exitcode-stdio-1.0
452− main-is: IsomorphicSchema.hs
453−
454−Test-Suite test-atomable
455− import: commontest
456− type: exitcode-stdio-1.0
457− main-is: Relation/Atomable.hs
458− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Printer
459−
460−Test-Suite test-multiprocess-access
461− import: commontest
462− type: exitcode-stdio-1.0
463− main-is: MultiProcessDatabaseAccess.hs
464−
465−Test-Suite test-transactiongraph-automerge
466− import: commontest
467− type: exitcode-stdio-1.0
468− main-is: TransactionGraph/Automerge.hs
469− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Printer
470−
471−Test-Suite test-tupleable
472− import: commontest
473− type: exitcode-stdio-1.0
474− main-is: Relation/Tupleable.hs
475−
476−Test-Suite test-client-simple
477− import: commontest
478− Main-Is: Client/Simple.hs
479− type: exitcode-stdio-1.0
480−
481−-- test for file handle leaks
482−Executable handles
483663 Default-Language: Haskell2010
484− 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
486− main-is: benchmark/Handles.hs
487− Other-Modules: TutorialD.Interpreter,
488− TutorialD.Interpreter.Base,
489− TutorialD.Interpreter.DatabaseContextExpr,
490− TutorialD.Interpreter.DatabaseContextIOOperator,
491− TutorialD.Interpreter.Export.Base,
492− TutorialD.Interpreter.Export.CSV,
493− TutorialD.Interpreter.Import.Base,
494− TutorialD.Interpreter.Import.BasicExamples,
495− TutorialD.Interpreter.Import.CSV,
496− TutorialD.Interpreter.Import.TutorialD,
497− TutorialD.Interpreter.InformationOperator,
498− TutorialD.Interpreter.RODatabaseContextOperator,
499− TutorialD.Interpreter.RelationalExpr,
500− TutorialD.Interpreter.SchemaOperator,
501− TutorialD.Interpreter.TransGraphRelationalOperator,
502− TutorialD.Interpreter.TransactionGraphOperator,
503− TutorialD.Interpreter.Types
504− TutorialD.Printer
505− GHC-Options: -Wall -threaded -rtsopts
506− HS-Source-Dirs: ./src/bin
507− if flag(profiler)
508− GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall
509−
510−Test-Suite test-dataframe
511− import: commontest
512664 type: exitcode-stdio-1.0
513− Main-Is: DataFrame.hs
514− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Printer
665+ main-is: test/Server/WebSocket.hs
666+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, distributed-process, distributed-process-extras, distributed-process-client-server, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, parsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, uuid-aeson
667+ Other-Modules: ProjectM36.Atom, ProjectM36.AtomFunction, ProjectM36.AtomType, ProjectM36.Attribute, ProjectM36.AttributeNames, ProjectM36.Base, ProjectM36.ConcreteTypeRep, ProjectM36.DataConstructorDef, ProjectM36.DataTypes.Primitive, ProjectM36.Error, ProjectM36.Key, ProjectM36.MiscUtils, ProjectM36.Relation, ProjectM36.RelationalExpression, ProjectM36.StaticOptimizer, ProjectM36.Tuple, ProjectM36.TupleSet, ProjectM36.TypeConstructor, ProjectM36.TypeConstructorDef, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, ProjectM36.AtomFunctions.Basic, ProjectM36.AtomFunctions.Primitive, ProjectM36.Client, ProjectM36.Client.Json, ProjectM36.DataTypes.Basic, ProjectM36.DataTypes.Day, ProjectM36.DataTypes.Either, ProjectM36.DataTypes.Maybe, ProjectM36.DatabaseContext, ProjectM36.DateExamples, ProjectM36.Notifications, ProjectM36.Persist, ProjectM36.Relation.Parse.CSV, ProjectM36.Relation.Show.CSV, ProjectM36.Relation.Show.Gnuplot, ProjectM36.Relation.Show.Term, ProjectM36.Server, ProjectM36.Server.Config, ProjectM36.Server.EntryPoints, ProjectM36.Server.RemoteCallTypes, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, ProjectM36.Session, ProjectM36.Sessions, ProjectM36.Transaction, ProjectM36.Transaction.Persist, ProjectM36.TransactionGraph, ProjectM36.TransactionGraph.Merge, ProjectM36.TransactionGraph.Persist, TutorialD.Interpreter, 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
668+ Default-Extensions: OverloadedStrings
669+ GHC-Options: -Wall
670+ CPP-Options: -DPROJECTM36_VERSION="v0.1"
671+ if os(windows)
672+ Build-Depends: Win32 >= 2.3 && < 2.4
673+ Other-Modules: ProjectM36.Win32Handle
674+ else
675+ C-sources: ProjectM36/DirectoryFsync.c
676+ Build-Depends: unix
release.nixdeleted−36
@@ -1,36 +0,0 @@
1−{ compiler ? "ghc8104"
2−, sources ? import ./nix/sources.nix
3−, pkgs ? import sources.nixpkgs { }
4−}:
5−let
6− doJailbreak = pkgs.haskell.lib.doJailbreak;
7− needsCocoa = drv:
8− if pkgs.stdenv.isDarwin
9− then drv.overrideDerivation (old:
10− { buildInputs = [ pkgs.darwin.apple_sdk.frameworks.Cocoa ] ++ old.buildInputs; }
11− )
12− else drv;
13−
14− haskellPackages = pkgs.haskell.packages.${compiler}.override {
15− overrides = self: super: {
16− curryer-rpc = self.callCabal2nix "curryer-rpc" sources.curryer { };
17− streamly = doJailbreak (needsCocoa (self.callCabal2nix "streamly" sources.streamly { }));
18− project-m36 = ((self.callCabal2nixWithOptions "project-m36" ./. "-f-haskell-scripting" { }));
19− };
20− };
21−in
22−{
23− project = haskellPackages.project-m36;
24−
25− shell = haskellPackages.shellFor {
26− packages = p: [
27− p.project-m36
28− ];
29− buildInputs = [
30− haskellPackages.ghcid
31− haskellPackages.hlint
32− pkgs.docker
33− ];
34− withHoogle = true;
35− };
36−}
runghcid.shdeleted−2
@@ -1,2 +0,0 @@
1−#!/bin/sh
2−~/.cabal/bin/ghcid --command="cabal new-repl $1"
scripts/DateExamples.tutd+5−26
@@ -1,26 +1,5 @@
1−s := relation{tuple{s# "S1",sname "Smith",status 20, city "London"},
2− tuple{s# "S2",sname "Jones",status 10,city "Paris"},
3− tuple{s# "S3",sname "Blake",status 30,city "Paris"},
4− tuple{s# "S4",sname "Clark",status 20,city "London"},
5− tuple{s# "S5",sname "Adams",status 30,city "Athens"}};
6−p := relation{tuple{p# "P1",pname "Nut",color "Red",weight 12,city "London"},
7− tuple{p# "P2",pname "Bolt",color "Green",weight 17,city "Paris"},
8− tuple{p# "P3",pname "Screw",color "Blue",weight 17,city "Oslo"},
9− tuple{p# "P4",pname "Screw",color "Red",weight 14,city "London"},
10− tuple{p# "P5",pname "Cam",color "Blue",weight 12,city "Paris"},
11− tuple{p# "P6", pname "Cog", color "Red",weight 19,city "London"}};
12−sp := relation{tuple{s# "S1",p# "P1",qty 300},
13− tuple{s# "S1",p# "P2",qty 200},
14− tuple{s# "S1",p# "P3",qty 400},
15− tuple{s# "S1",p# "P4",qty 200},
16− tuple{s# "S1",p# "P5",qty 100},
17− tuple{s# "S1",p# "P6",qty 100},
18− tuple{s# "S2",p# "P1",qty 300},
19− tuple{s# "S2",p# "P2",qty 400},
20− tuple{s# "S3",p# "P2",qty 200},
21− tuple{s# "S4",p# "P4",qty 300},
22− tuple{s# "S4",p# "P5",qty 400}};
23−key s_pkey {s#} s;
24−key p_key {p#} p;
25−foreign key s_sp_fk sp{s#} in s{s#};
26−foreign key p_sp_fk sp{p#} in p{p#};
1+s := relation{tuple{s# "S1",sname "Smith",status 20, city "London"}, tuple{s# "S2",sname "Jones",status 10,city "Paris"}, tuple{s# "S3",sname "Blake",status 30,city "Paris"}, tuple{s# "S4",sname "Clark",status 20,city "London"}, tuple{s# "S5",sname "Adams",status 30,city "Athens"}}
2+p := relation{tuple{p# "P1",pname "Nut",color "Red",weight 12,city "London"}, tuple{p# "P2",pname "Bolt",color "Green",weight 17,city "Paris"}, tuple{p# "P3",pname "Screw",color "Blue",weight 17,city "Oslo"}, tuple{p# "P4",pname "Screw",color "Red",weight 14,city "London"}, tuple{p# "P5",pname "Cam",color "Blue",weight 12,city "Paris"}, tuple{p# "P6", pname "Cog", color "Red",weight 19,city "London"}}
3+sp := relation{tuple{s# "S1",p# "P1",qty 300}, tuple{s# "S1",p# "P2",qty 200}, tuple{s# "S1",p# "P3",qty 400}, tuple{s# "S1",p# "P4",qty 200}, tuple{s# "S1",p# "P5",qty 100}, tuple{s# "S1",p# "P6",qty 100}, tuple{s# "S2",p# "P1",qty 300}, tuple{s# "S2",p# "P2",qty 400}, tuple{s# "S3",p# "P2",qty 200}, tuple{s# "S4",p# "P4",qty 300}, tuple{s# "S4",p# "P5",qty 400}}
4+foreign key sp2s sp{s#} in s{s#}
5+foreign key sp2p sp{p#} in p{p#}
scripts/multiline.tutddeleted−2
@@ -1,2 +0,0 @@
1−x:=relation{
2−tuple{ x 2}} -- nice
shell.nixdeleted−1
@@ -1 +0,0 @@
1−(import ./release.nix { }).shell
src/bin/ProjectM36/Server/RemoteCallTypes/Json.hsdeleted−185
@@ -1,185 +0,0 @@
1−--create a bunch of orphan instances for use with the websocket server
2−{-# LANGUAGE FlexibleInstances #-}
3−{-# OPTIONS_GHC -fno-warn-orphans #-}
4−module ProjectM36.Server.RemoteCallTypes.Json where
5−import ProjectM36.AtomFunctionError
6−import ProjectM36.Base
7−import ProjectM36.DataFrame
8−import ProjectM36.DatabaseContextFunctionError
9−import ProjectM36.DataTypes.Primitive
10−import ProjectM36.Error
11−import ProjectM36.IsomorphicSchema
12−import ProjectM36.Server.RemoteCallTypes
13−import ProjectM36.MerkleHash
14−import ProjectM36.Attribute as A
15−
16−import Data.Aeson
17−import Data.ByteString.Base64 as B64
18−import Data.Text.Encoding
19−import Data.Time.Calendar
20−
21−instance ToJSON RelationalExpr
22−instance FromJSON RelationalExpr
23−
24−instance ToJSON TupleExpr
25−instance FromJSON TupleExpr
26−
27−instance ToJSON TupleExprs
28−instance FromJSON TupleExprs
29−
30−instance ToJSON RestrictionPredicateExpr
31−instance FromJSON RestrictionPredicateExpr
32−
33−instance ToJSON AtomExpr
34−instance FromJSON AtomExpr
35−
36−instance ToJSON RelationTupleSet
37−instance FromJSON RelationTupleSet
38−
39−instance ToJSON RelationTuple
40−instance FromJSON RelationTuple
41−
42−instance ToJSON ExecuteRelationalExpr
43−instance FromJSON ExecuteRelationalExpr
44−
45−instance ToJSON Relation
46−instance FromJSON Relation
47−
48−instance ToJSON Attribute where
49− toJSON (Attribute attrName aType) = object [ "name" .= attrName
50− , "type" .= toJSON aType ]
51−instance FromJSON Attribute where
52− parseJSON = withObject "Attribute" $ \v -> Attribute <$> v .: "name" <*> v .: "type"
53−
54−instance ToJSON ExtendTupleExpr
55−instance FromJSON ExtendTupleExpr
56−
57−instance ToJSON AttributeNames
58−instance FromJSON AttributeNames
59−
60−instance ToJSON AttributeExpr
61−instance FromJSON AttributeExpr
62−
63−instance ToJSON AtomType
64−instance FromJSON AtomType
65−
66−instance ToJSON TypeConstructor
67−instance FromJSON TypeConstructor
68−
69−instance ToJSON SchemaExpr
70−instance FromJSON SchemaExpr
71−
72−instance ToJSON SchemaIsomorph
73−instance FromJSON SchemaIsomorph
74−
75−instance ToJSON DataFrame
76−instance FromJSON DataFrame
77−
78−instance ToJSON DataFrameTuple
79−instance FromJSON DataFrameTuple
80−
81−instance ToJSON AttributeOrder
82−instance FromJSON AttributeOrder
83−
84−instance ToJSON Order
85−instance FromJSON Order
86−
87−instance ToJSON Atom where
88− toJSON atom@(IntegerAtom i) = object [ "type" .= atomTypeForAtom atom,
89− "val" .= i ]
90− toJSON atom@(IntAtom i) = object [ "type" .= atomTypeForAtom atom,
91− "val" .= i ]
92− toJSON atom@(DoubleAtom i) = object [ "type" .= atomTypeForAtom atom,
93− "val" .= i ]
94− toJSON atom@(TextAtom i) = object [ "type" .= atomTypeForAtom atom,
95− "val" .= i ]
96− toJSON atom@(DayAtom i) = object [ "type" .= atomTypeForAtom atom,
97− "val" .= toGregorian i ]
98− toJSON atom@(DateTimeAtom i) = object [ "type" .= atomTypeForAtom atom,
99− "val" .= i ]
100− toJSON atom@(ByteStringAtom i) = object [ "type" .= atomTypeForAtom atom,
101− "val" .= decodeUtf8 (B64.encode i) ]
102− toJSON atom@(BoolAtom i) = object [ "type" .= atomTypeForAtom atom,
103− "val" .= i ]
104− toJSON atom@(RelationAtom i) = object [ "type" .= atomTypeForAtom atom,
105− "val" .= i ]
106− toJSON atom@(RelationalExprAtom i) = object [ "type" .= atomTypeForAtom atom,
107− "val" .= i ]
108− toJSON (ConstructedAtom dConsName atomtype atomlist) = object [
109− "dataconstructorname" .= dConsName,
110− "type" .= toJSON atomtype,
111− "atomlist" .= toJSON atomlist
112− ]
113−
114−instance FromJSON Atom where
115− parseJSON = withObject "atom" $ \o -> do
116− atype <- o .: "type"
117− case atype of
118− TypeVariableType _ -> fail "cannot pass TypeVariableType over the wire"
119− caType@(ConstructedAtomType _ _) -> ConstructedAtom <$> o .: "dataconstructorname" <*> pure caType <*> o .: "atom"
120− RelationAtomType _ -> RelationAtom <$> o .: "val"
121− IntAtomType -> IntAtom <$> o .: "val"
122− IntegerAtomType -> IntegerAtom <$> o .: "val"
123− DoubleAtomType -> DoubleAtom <$> o .: "val"
124− TextAtomType -> TextAtom <$> o .: "val"
125− DayAtomType -> do
126− (y, m, d) <- o .: "val"
127− pure (DayAtom (fromGregorian y m d))
128− DateTimeAtomType -> DateTimeAtom <$> o .: "val"
129− ByteStringAtomType -> do
130− b64bs <- fmap encodeUtf8 (o .: "val")
131− case B64.decode b64bs of
132− Left err -> fail ("Failed to parse base64-encoded ByteString: " ++ err)
133− Right bs -> pure (ByteStringAtom bs)
134− BoolAtomType -> BoolAtom <$> o .: "val"
135− RelationalExprAtomType -> RelationalExprAtom <$> o .: "val"
136−
137−instance ToJSON Notification
138−instance FromJSON Notification
139−
140−instance ToJSON ScriptCompilationError
141−instance FromJSON ScriptCompilationError
142−
143−instance ToJSON MerkleHash where
144− toJSON h = object [ "merklehash" .= decodeUtf8 (B64.encode (_unMerkleHash h))]
145−instance FromJSON MerkleHash where
146− parseJSON = withObject "merklehash" $ \o -> do
147− b64bs <- encodeUtf8 <$> o .: "merklehash"
148− case B64.decode b64bs of
149− Left err -> fail ("Failed to parse merkle hash: " ++ err)
150− Right bs -> pure (MerkleHash bs)
151−
152−instance ToJSON Attributes where
153− toJSON attrs = object ["attributes" .= map toJSON (A.toList attrs)]
154−instance FromJSON Attributes where
155− parseJSON = withObject "Attributes" $ \o ->
156− A.attributesFromList <$> o .: "attributes"
157−
158−instance ToJSON RelationalError
159−instance FromJSON RelationalError
160−
161−instance ToJSON SchemaError
162−instance FromJSON SchemaError
163−
164−instance ToJSON MergeError
165−instance FromJSON MergeError
166−
167−instance ToJSON ImportError'
168−instance FromJSON ImportError'
169−
170−instance ToJSON DatabaseContextFunctionError
171−instance FromJSON DatabaseContextFunctionError
172−
173−instance ToJSON MergeStrategy
174−instance FromJSON MergeStrategy
175−
176−instance ToJSON PersistenceError
177−instance FromJSON PersistenceError
178−
179−instance ToJSON AtomFunctionError
180−instance FromJSON AtomFunctionError
181−
182−instance ToJSON WithNameExpr
183−instance FromJSON WithNameExpr
184−
185−
src/bin/ProjectM36/Server/WebSocket.hsdeleted−146
@@ -1,146 +0,0 @@
1−{-# LANGUAGE LambdaCase, CPP #-}
2−module ProjectM36.Server.WebSocket where
3−-- while the tutd client performs TutorialD parsing on the client, the websocket server will pass tutd to be parsed and executed on the server- otherwise I have to pull in ghcjs as a dependency to allow client-side parsing- that's not appealing because then the frontend is not language-agnostic, but this could change in the future, perhaps by sending different messages over the websocket
4−-- ideally, the wire protocol should not be exposed to a straight string-based API ala SQL, so we could make perhaps a javascript DSL which compiles to the necessary JSON- anaylyze tradeoffs
5−
6−-- launch the project-m36-server
7−-- proxy all connections to it through ProjectM36.Client
8−import Control.Monad (forever)
9−import qualified Data.Text as T
10−import qualified Network.WebSockets as WS
11−import ProjectM36.Server.RemoteCallTypes.Json ()
12−import ProjectM36.Client.Json ()
13−import ProjectM36.DataFrame
14−import ProjectM36.Relation.Show.Term
15−import ProjectM36.Relation.Show.HTML
16−import Data.Aeson
17−import TutorialD.Interpreter
18−import TutorialD.Interpreter.Base (TutorialDOperatorResult(..))
19−import ProjectM36.Client
20−import Control.Exception
21−import Data.Attoparsec.Text
22−import Control.Applicative
23−import Text.Megaparsec.Error
24−import Data.Functor
25−import Data.Either (fromRight)
26−
27−#if MIN_VERSION_megaparsec(7,0,0)
28−import Data.List.NonEmpty as NE
29−#endif
30−
31−websocketProxyServer :: Port -> Hostname -> WS.ServerApp
32−websocketProxyServer port host pending = do
33− conn <- WS.acceptRequest pending
34− let unexpectedMsg = WS.sendTextData conn ("messagenotexpected" :: T.Text)
35− --phase 1- accept database name for connection
36− dbmsg <- WS.receiveData conn :: IO T.Text
37− let connectdbmsg = "connectdb:"
38− if not (connectdbmsg `T.isPrefixOf` dbmsg) then unexpectedMsg >> WS.sendClose conn ("" :: T.Text)
39− else do
40− let dbname = T.unpack $ T.drop (T.length connectdbmsg) dbmsg
41− bracket (createConnection conn dbname port host)
42− (\case
43− Right dbconn -> close dbconn
44− Left _ -> pure ()) $ \case
45− Left err -> sendError conn err
46− Right dbconn -> do
47− eSessionId <- createSessionAtHead dbconn "master"
48− case eSessionId of
49− Left err -> sendError conn err
50− Right sessionId -> do
51− --phase 2- accept tutoriald commands
52− _ <- forever $ do
53− pInfo <- promptInfo sessionId dbconn
54− --figure out why sending three times during startup is necessary
55− sendPromptInfo pInfo conn
56− sendPromptInfo pInfo conn
57− msg <- WS.receiveData conn :: IO T.Text
58− case parseOnly parseExecuteMessage msg of
59− Left _ -> unexpectedMsg
60− Right (presentation, tutdString) ->
61− case parseTutorialD tutdString of
62− Left err -> handleOpResult conn dbconn presentation
63−#if MIN_VERSION_megaparsec(7,0,0)
64− (DisplayErrorResult
65− ("parse error: " `T.append` T.pack
66− (parseErrorPretty . NE.head . bundleErrors $ err)))
67−#else
68− (DisplayErrorResult ("parse error: " `T.append` T.pack (parseErrorPretty err)))
69−#endif
70− Right parsed -> do
71− let timeoutFilter exc = if exc == RequestTimeoutException
72− then Just exc
73− else Nothing
74− responseHandler = do
75− result <- evalTutorialD sessionId dbconn SafeEvaluation parsed
76− pInfo' <- promptInfo sessionId dbconn
77− sendPromptInfo pInfo' conn
78− handleOpResult conn dbconn presentation result
79− catchJust timeoutFilter responseHandler (\_ -> handleOpResult conn dbconn presentation (DisplayErrorResult "Request Timed Out."))
80− pure ()
81−
82−notificationCallback :: WS.Connection -> NotificationCallback
83−notificationCallback conn notifName evaldNotif = WS.sendTextData conn (encode (object ["notificationname" .= notifName,
84− "evaldnotification" .= evaldNotif
85− ]))
86−
87−--this creates a new database for each connection- perhaps not what we want (?)
88−createConnection :: WS.Connection -> DatabaseName -> Port -> Hostname -> IO (Either ConnectionError Connection)
89−createConnection wsconn dbname port host = connectProjectM36 (RemoteConnectionInfo dbname host (show port) (notificationCallback wsconn))
90−
91−sendError :: (ToJSON a) => WS.Connection -> a -> IO ()
92−sendError conn err = WS.sendTextData conn (encode (object ["displayerror" .= err]))
93−
94−handleOpResult :: WS.Connection -> Connection -> Presentation -> TutorialDOperatorResult -> IO ()
95−handleOpResult conn db _ QuitResult = WS.sendClose conn ("close" :: T.Text) >> close db
96−handleOpResult conn _ _ (DisplayResult out) = WS.sendTextData conn (encode (object ["display" .= out]))
97−handleOpResult _ _ _ (DisplayIOResult ioout) = ioout
98−handleOpResult conn _ presentation (DisplayErrorResult err) = do
99− let jsono = ["json" .= err | jsonPresentation presentation]
100− texto = ["text" .= err | textPresentation presentation]
101− htmlo = ["html" .= err | htmlPresentation presentation]
102− WS.sendTextData conn (encode (object ["displayerror" .= object (jsono ++ texto ++ htmlo)]))
103−handleOpResult conn _ _ (DisplayParseErrorResult _ err) = WS.sendTextData conn (encode (object ["displayparseerrorresult" .= show err]))
104−handleOpResult conn _ _ QuietSuccessResult = WS.sendTextData conn (encode (object ["acknowledged" .= True]))
105−handleOpResult conn _ presentation (DisplayRelationResult rel) = do
106− let jsono = ["json" .= rel | jsonPresentation presentation]
107− texto = ["text" .= showRelation rel | textPresentation presentation]
108− htmlo = ["html" .= relationAsHTML rel | htmlPresentation presentation]
109− WS.sendTextData conn (encode (object ["displayrelation" .= object (jsono ++ texto ++ htmlo)]))
110−handleOpResult conn _ presentation (DisplayDataFrameResult df) = do
111− let jsono = ["json" .= df | jsonPresentation presentation]
112− texto = ["text" .= showDataFrame df | textPresentation presentation]
113− htmlo = ["html" .= dataFrameAsHTML df | htmlPresentation presentation]
114− WS.sendTextData conn (encode (object ["displaydataframe" .= object (jsono ++ texto ++ htmlo)]))
115−
116−-- get current schema and head name for client
117−promptInfo :: SessionId -> Connection -> IO (HeadName, SchemaName)
118−promptInfo sessionId conn = do
119− eHeadName <- headName sessionId conn
120− eSchemaName <- currentSchemaName sessionId conn
121− pure (fromRight "<unknown>" eHeadName, fromRight "<no schema>" eSchemaName)
122−
123−sendPromptInfo :: (HeadName, SchemaName) -> WS.Connection -> IO ()
124−sendPromptInfo (hName, sName) conn = WS.sendTextData conn (encode (object ["promptInfo" .= object ["headname" .= hName, "schemaname" .= sName]]))
125−
126−--a returning relation can be returned as JSON, Text (for consoles), or HTML
127−data Presentation = Presentation {
128− jsonPresentation :: Bool,
129− textPresentation :: Bool,
130− htmlPresentation :: Bool }
131−
132−data PresentationFlag = JSONFlag | TextFlag | HTMLFlag
133−
134−parseExecuteMessage :: Parser (Presentation, T.Text)
135−parseExecuteMessage = do
136− _ <- string "executetutd/"
137− flags <- sepBy ((string "json" $> JSONFlag) <|>
138− (string "text" $> TextFlag) <|>
139− (string "html" $> HTMLFlag)) "+"
140− let presentation = foldr (\flag acc -> case flag of
141− JSONFlag -> acc {jsonPresentation = True}
142− TextFlag -> acc {textPresentation = True}
143− HTMLFlag -> acc {htmlPresentation = True}) (Presentation False False False) flags
144− _ <- char ':'
145− tutd <- T.pack <$> manyTill anyChar endOfInput
146− pure (presentation, tutd)
src/bin/ProjectM36/Server/WebSocket/websocket-config.jsdeleted−5
@@ -1,5 +0,0 @@
1−var defaultConfig = { 'protocol': 'wss',
2− 'host': 'try.project-m36.io',
3− 'port': '',
4− 'path': 'ws/',
5− 'dbname': 'test' }
src/bin/ProjectM36/Server/WebSocket/websocket-server.hsdeleted−63
@@ -1,63 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−
3−import Control.Concurrent
4−import Control.Exception
5−import Control.Monad (when)
6−import Data.Maybe (isJust)
7−import Data.String (fromString)
8−import Network.HTTP.Types (status400)
9−import Network.Socket
10−import Network.Wai (Application, responseLBS)
11−import Network.Wai.Handler.Warp
12−import Network.Wai.Handler.WarpTLS (runTLS, tlsSettings)
13−import qualified Network.Wai.Handler.WebSockets as WS
14−import Network.WebSockets (defaultConnectionOptions)
15−import ProjectM36.Server
16−import ProjectM36.Server.Config
17−import ProjectM36.Server.ParseArgs
18−import ProjectM36.Server.WebSocket
19−
20−main :: IO ()
21−main = do
22− -- launch normal project-m36-server
23− addressMVar <- newEmptyMVar
24− wsConfig <- parseWSConfigWithDefaults (defaultServerConfig {bindPort = 8000, bindHost = "127.0.0.1"})
25−
26− --usurp the serverConfig for our websocket server and make the proxied server run locally
27− let serverConfig = wsServerConfig wsConfig
28− wsHost = bindHost serverConfig
29− wsPort = bindPort serverConfig
30− serverHost = "127.0.0.1"
31− 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−
38− _ <- forkFinally (launchServer serverConfig' (Just addressMVar) >> pure ()) (either throwIO pure)
39− --wait for server to be listening
40− addr <- takeMVar addressMVar
41− let port =
42− case addr of
43− SockAddrInet port' _ -> fromIntegral port'
44− _ -> error "unsupported socket address (IPv4 only currently)"
45− wsApp = websocketProxyServer port serverHost
46− waiApp = WS.websocketsOr defaultConnectionOptions wsApp backupApp
47− settings = warpSettings wsHost (fromIntegral wsPort)
48−
49− case (configCertificateFile, configKeyFile) of
50− (Just certificate, Just key) -> runTLS (tlsSettings certificate key) settings waiApp
51− _ -> runSettings settings waiApp
52−
53−backupApp :: Application
54−backupApp _ respond = respond $ responseLBS status400 [] "Not a WebSocket request"
55−
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.hsdeleted−272
@@ -1,272 +0,0 @@
1−{-# LANGUAGE GADTs, LambdaCase, CPP #-}
2−module TutorialD.Interpreter where
3−import TutorialD.Interpreter.Base
4−import TutorialD.Interpreter.RODatabaseContextOperator
5−import TutorialD.Interpreter.DatabaseContextExpr
6−import TutorialD.Interpreter.TransactionGraphOperator
7−import TutorialD.Interpreter.InformationOperator
8−import TutorialD.Interpreter.DatabaseContextIOOperator
9−import TutorialD.Interpreter.TransGraphRelationalOperator
10−import TutorialD.Interpreter.SchemaOperator
11−
12−import TutorialD.Interpreter.Import.CSV
13−import TutorialD.Interpreter.Import.TutorialD
14−import TutorialD.Interpreter.Import.BasicExamples
15−import TutorialD.Interpreter.Import.Base
16−
17−import TutorialD.Interpreter.Export.CSV
18−import TutorialD.Interpreter.Export.Base
19−
20−import ProjectM36.Base
21−import ProjectM36.Error
22−import ProjectM36.Relation.Show.Term
23−import ProjectM36.TransactionGraph
24−import qualified ProjectM36.Client as C
25−import ProjectM36.Relation (attributes)
26−
27−import System.Console.Haskeline
28−import System.Directory (getHomeDirectory)
29−import qualified Data.Text as T
30−import System.IO (hPutStrLn, stderr)
31−#if __GLASGOW_HASKELL__ < 804
32−import Data.Monoid
33−#endif
34−import Data.List (isPrefixOf)
35−import Control.Exception
36−import System.Exit
37−import Data.Either (fromRight)
38−
39−{-
40−context ops are read-only operations which only operate on the database context (relvars and constraints)
41−database ops are read-write operations which change the database context (such as relvar assignment)
42−graph ops are read-write operations which change the transaction graph
43−-}
44−data ParsedOperation = RODatabaseContextOp RODatabaseContextOperator |
45− DatabaseContextExprOp DatabaseContextExpr |
46− DatabaseContextIOExprOp DatabaseContextIOExpr |
47− InfoOp InformationOperator |
48− GraphOp TransactionGraphOperator |
49− ConvenienceGraphOp ConvenienceTransactionGraphOperator |
50− ROGraphOp ROTransactionGraphOperator |
51− ImportRelVarOp RelVarDataImportOperator |
52− ImportDBContextOp DatabaseContextDataImportOperator |
53− ImportBasicExampleOp ImportBasicExampleOperator |
54− RelVarExportOp RelVarDataExportOperator |
55− TransGraphRelationalOp TransGraphRelationalOperator |
56− SchemaOp SchemaOperator
57− deriving (Show)
58−
59−interpreterParserP :: Parser ParsedOperation
60−interpreterParserP = safeInterpreterParserP <|>
61− fmap ImportRelVarOp (importCSVP <* eof) <|>
62− fmap ImportDBContextOp (tutdImportP <* eof) <|>
63− fmap RelVarExportOp (exportCSVP <* eof) <|>
64− fmap DatabaseContextIOExprOp (dbContextIOExprP <* eof)
65−
66−-- the safe interpreter never reads or writes the file system
67−safeInterpreterParserP :: Parser ParsedOperation
68−safeInterpreterParserP = fmap RODatabaseContextOp (roDatabaseContextOperatorP <* eof) <|>
69− fmap InfoOp (infoOpP <* eof) <|>
70− fmap GraphOp (transactionGraphOpP <* eof) <|>
71− fmap ConvenienceGraphOp (convenienceTransactionGraphOpP <* eof) <|>
72− fmap ROGraphOp (roTransactionGraphOpP <* eof) <|>
73− fmap DatabaseContextExprOp (databaseExprOpP <* eof) <|>
74− fmap ImportBasicExampleOp (importBasicExampleOperatorP <* eof) <|>
75− fmap TransGraphRelationalOp (transGraphRelationalOpP <* eof) <|>
76− fmap SchemaOp (schemaOperatorP <* eof)
77−
78−promptText :: Either RelationalError HeadName -> Either RelationalError SchemaName -> StringType
79−promptText eHeadName eSchemaName = "TutorialD (" <> transInfo <> "): "
80− where
81− transInfo = fromRight "<unknown>" eHeadName <> "/" <> fromRight "<no schema>" eSchemaName
82−
83−parseTutorialD :: T.Text -> Either ParserError ParsedOperation
84−parseTutorialD = parse interpreterParserP ""
85−
86−--only parse tutoriald which doesn't result in file I/O
87−safeParseTutorialD :: T.Text -> Either ParserError ParsedOperation
88−safeParseTutorialD = parse safeInterpreterParserP ""
89−
90−data SafeEvaluationFlag = SafeEvaluation | UnsafeEvaluation deriving (Eq)
91−
92−type InteractiveConsole = Bool
93−
94−evalTutorialD :: C.SessionId -> C.Connection -> SafeEvaluationFlag -> ParsedOperation -> IO TutorialDOperatorResult
95−evalTutorialD sessionId conn safe = evalTutorialDInteractive sessionId conn safe False
96−
97−--execute the operation and display result
98−evalTutorialDInteractive :: C.SessionId -> C.Connection -> SafeEvaluationFlag -> InteractiveConsole -> ParsedOperation -> IO TutorialDOperatorResult
99−evalTutorialDInteractive sessionId conn safe interactive expr = case expr of
100− --this does not pass through the ProjectM36.Client library because the operations
101− --are specific to the interpreter, though some operations may be of general use in the future
102− (RODatabaseContextOp execOp) -> do
103− res <- evalRODatabaseContextOp sessionId conn execOp
104− case res of
105− QuitResult -> if safe == UnsafeEvaluation && interactive then
106− putStrLn "Goodbye." >> exitSuccess
107− else
108− pure res
109− _ -> pure res
110−
111− (DatabaseContextExprOp execOp) ->
112− eHandler $ C.executeDatabaseContextExpr sessionId conn execOp
113−
114− (DatabaseContextIOExprOp execOp) ->
115− if needsSafe then
116− unsafeError
117− else
118− eHandler $ C.executeDatabaseContextIOExpr sessionId conn execOp
119−
120− (GraphOp execOp) -> do
121− -- warn if the graph op could cause uncommited changes to be discarded
122− eIsDirty <- C.disconnectedTransactionIsDirty sessionId conn
123− let runGraphOp = eHandler $ C.executeGraphExpr sessionId conn execOp
124− settings = Settings {complete = noCompletion,
125− historyFile = Nothing,
126− autoAddHistory = False}
127− case eIsDirty of
128− Left err -> barf err
129− Right False -> runGraphOp
130− Right True -> do
131− cancel <- runInputT settings $ do
132− let promptDiscardChanges = do
133− isatty <- haveTerminalUI
134− if isatty && interactive && execOp /= Commit && execOp /= Rollback then do
135− mYesOrNo <- getInputLine "The current transaction has uncommitted changes. If you continue, the changes will be lost. Continue? (Y/n): "
136− case mYesOrNo of
137− Nothing -> promptDiscardChanges
138− Just "" -> promptDiscardChanges
139− Just yesOrNo -> pure (not ("Y" `isPrefixOf` yesOrNo))
140− else
141− pure False
142− promptDiscardChanges
143− if cancel then
144− pure (DisplayErrorResult "Graph operation cancelled.")
145− else
146− runGraphOp
147−
148− (ConvenienceGraphOp execOp) ->
149− eHandler $ evalConvenienceGraphOp sessionId conn execOp
150−
151− (ROGraphOp execOp) -> do
152− opResult <- evalROGraphOp sessionId conn execOp
153− case opResult of
154− Left err -> barf err
155− Right rel -> pure (DisplayRelationResult rel)
156−
157− (SchemaOp execOp) ->
158− eHandler $ evalSchemaOperator sessionId conn execOp
159−
160− (ImportRelVarOp execOp@(RelVarDataImportOperator relVarName _ _)) ->
161− if needsSafe then
162− unsafeError
163− else do
164− -- collect attributes from relvar name
165− -- is there a race condition here? The attributes of the relvar may have since changed, no?
166− eImportType <- C.typeForRelationalExpr sessionId conn (RelationVariable relVarName ())
167− case eImportType of
168− Left err -> barf err
169− Right importType -> do
170− eTConsMap <- C.typeConstructorMapping sessionId conn
171− case eTConsMap of
172− Left err -> barf err
173− Right tConsMap -> do
174− exprErr <- evalRelVarDataImportOperator execOp tConsMap (attributes importType)
175− case exprErr of
176− Left err -> barf err
177− Right dbexpr -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexpr)
178−
179− (ImportDBContextOp execOp) ->
180− if needsSafe then
181− unsafeError
182− else do
183− eErr <- evalDatabaseContextDataImportOperator execOp
184− case eErr of
185− Left err -> barf err
186− Right dbexprs -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexprs)
187−
188− (InfoOp execOp) ->
189− if needsSafe then
190− unsafeError
191− else
192− case evalInformationOperator execOp of
193− Left err -> pure (DisplayErrorResult err)
194− Right info -> pure (DisplayResult info)
195−
196− (RelVarExportOp execOp@(RelVarDataExportOperator relExpr _ _)) ->
197− --eval relexpr to relation and pass to export function
198− if needsSafe then
199− unsafeError
200− else do
201− eRel <- C.executeRelationalExpr sessionId conn relExpr
202− case eRel of
203− Left err -> barf err
204− Right rel -> do
205− exportResult <- evalRelVarDataExportOperator execOp rel
206− case exportResult of
207− Just err -> barf err
208− Nothing -> pure QuietSuccessResult
209− (ImportBasicExampleOp execOp) -> do
210− let dbcontextexpr = evalImportBasicExampleOperator execOp
211− evalTutorialD sessionId conn safe (DatabaseContextExprOp dbcontextexpr)
212− (TransGraphRelationalOp execOp) ->
213− evalTransGraphRelationalOp sessionId conn execOp
214− where
215− needsSafe = safe == SafeEvaluation
216− unsafeError = pure $ DisplayErrorResult "File I/O operation prohibited."
217− barf :: RelationalError -> IO TutorialDOperatorResult
218− barf (ScriptError (OtherScriptCompilationError errStr)) = pure (DisplayErrorResult (T.pack errStr))
219− barf (ParseError err) = pure (DisplayErrorResult err)
220− barf err = return $ DisplayErrorResult (T.pack (show err))
221− eHandler io = do
222− eErr <- io
223− case eErr of
224− Left err -> barf err
225− Right () -> return QuietSuccessResult
226−
227−type GhcPkgPath = String
228−type TutorialDExec = String
229−type CheckFS = Bool
230−
231−data InterpreterConfig = LocalInterpreterConfig PersistenceStrategy HeadName (Maybe TutorialDExec) [GhcPkgPath] CheckFS |
232− RemoteInterpreterConfig C.Hostname C.Port C.DatabaseName HeadName (Maybe TutorialDExec) CheckFS
233−
234−outputNotificationCallback :: C.NotificationCallback
235−outputNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received " ++ show notName ++ ":\n" ++ "\n" ++ prettyEvaluatedNotification evaldNot
236−
237−prettyEvaluatedNotification :: C.EvaluatedNotification -> String
238−prettyEvaluatedNotification eNotif = let eRelShow eRel = case eRel of
239− Left err -> show err
240− Right reportRel -> T.unpack (showRelation reportRel) in
241− eRelShow (C.reportOldRelation eNotif) <> "\n" <> eRelShow (C.reportNewRelation eNotif)
242−
243−reprLoop :: InterpreterConfig -> C.SessionId -> C.Connection -> IO ()
244−reprLoop config sessionId conn = do
245− homeDirectory <- getHomeDirectory
246− let settings = defaultSettings {historyFile = Just (homeDirectory ++ "/.tutd_history")}
247− eHeadName <- C.headName sessionId conn
248− eSchemaName <- C.currentSchemaName sessionId conn
249− let prompt = promptText eHeadName eSchemaName
250− catchInterrupt = handleJust (\case
251− UserInterrupt -> Just Nothing
252− _ -> Nothing) (\_ -> do
253− hPutStrLn stderr "Statement cancelled. Use \":quit\" to exit tutd."
254− pure (Just ""))
255− maybeLine <- catchInterrupt $ runInputT settings $ getInputLine (T.unpack prompt)
256− case maybeLine of
257− Nothing -> return ()
258− Just line -> do
259− runTutorialD sessionId conn (Just (T.length prompt)) (T.pack line)
260− reprLoop config sessionId conn
261−
262−
263−runTutorialD :: C.SessionId -> C.Connection -> Maybe PromptLength -> T.Text -> IO ()
264−runTutorialD sessionId conn mPromptLength tutd =
265− case parseTutorialD tutd of
266− Left err ->
267− displayOpResult $ DisplayParseErrorResult mPromptLength err
268− Right parsed ->
269− catchJust (\exc -> if exc == C.RequestTimeoutException then Just exc else Nothing) (do
270− evald <- evalTutorialDInteractive sessionId conn UnsafeEvaluation True parsed
271− displayOpResult evald)
272− (\_ -> displayOpResult (DisplayErrorResult "Request timed out."))
src/bin/TutorialD/Interpreter/Base.hsdeleted−245
@@ -1,245 +0,0 @@
1−{-# LANGUAGE DeriveGeneric, CPP #-}
2−module TutorialD.Interpreter.Base (
3− module TutorialD.Interpreter.Base,
4− module Text.Megaparsec,
5−#if MIN_VERSION_megaparsec(6,0,0)
6− module Text.Megaparsec.Char,
7− module Control.Applicative
8−#else
9− module Text.Megaparsec.Text
10−#endif
11− )
12− where
13−import ProjectM36.Base
14−import ProjectM36.AtomType
15−import ProjectM36.Attribute as A
16−import ProjectM36.Relation
17−import ProjectM36.DataFrame
18−
19−#if MIN_VERSION_megaparsec(6,0,0)
20−import Text.Megaparsec.Char
21−import qualified Text.Megaparsec.Char.Lexer as Lex
22−import Text.Megaparsec
23−import Data.Void
24−import Control.Applicative hiding (many, some)
25−#else
26−import Text.Megaparsec.Text
27−import qualified Text.Megaparsec.Lexer as Lex
28−#endif
29−
30−import Data.Text hiding (count)
31−import System.Random
32−import qualified Data.Text as T
33−import qualified Data.List as L
34−import qualified Data.Text.IO as TIO
35−import System.IO
36−import ProjectM36.Relation.Show.Term
37−import GHC.Generics
38−#if __GLASGOW_HASKELL__ < 804
39−import Data.Monoid
40−#endif
41−import qualified Data.UUID as U
42−import Control.Monad.Random
43−import Data.List.NonEmpty as NE
44−import Data.Time.Clock
45−import Data.Time.Format
46−import Control.Monad (void)
47−import Data.Char
48−
49−#if !MIN_VERSION_megaparsec(7,0,0)
50−anySingle :: Parsec Void Text (Token Text)
51−anySingle = anyChar
52−#endif
53−
54−displayOpResult :: TutorialDOperatorResult -> IO ()
55−displayOpResult QuitResult = return ()
56−displayOpResult (DisplayResult out) = TIO.putStrLn out
57−displayOpResult (DisplayIOResult ioout) = ioout
58−displayOpResult (DisplayErrorResult err) = let outputf = if T.length err > 0 && T.last err /= '\n' then TIO.hPutStrLn else TIO.hPutStr in
59− outputf stderr ("ERR: " <> err)
60−displayOpResult QuietSuccessResult = return ()
61−displayOpResult (DisplayRelationResult rel) = do
62− gen <- newStdGen
63− let randomlySortedRel = evalRand (randomizeTupleOrder rel) gen
64− TIO.putStrLn (showRelation randomlySortedRel)
65−displayOpResult (DisplayParseErrorResult mPromptLength err) = do
66−#if MIN_VERSION_megaparsec(7,0,0)
67− let errorIndent = errorOffset . NE.head . bundleErrors $ err
68− errString = T.pack (parseErrorPretty . NE.head . bundleErrors $ err)
69−#else
70− let errorIndent = unPos (sourceColumn (NE.head (errorPos err)))
71− errString = T.pack (parseErrorPretty err)
72−#endif
73− pointyString len = T.justifyRight (len + fromIntegral errorIndent) '_' "^"
74− maybe (pure ()) (TIO.putStrLn . pointyString) mPromptLength
75− TIO.putStr ("ERR:" <> errString)
76−displayOpResult (DisplayDataFrameResult dFrame) = TIO.putStrLn (showDataFrame dFrame)
77−
78−#if MIN_VERSION_megaparsec(6,0,0)
79−type Parser = Parsec Void Text
80−type ParseStr = Text
81−#else
82−type ParseStr = String
83−#endif
84−
85−-- consumes only horizontal spaces
86−spaceConsumer :: Parser ()
87−spaceConsumer = Lex.space space1 (Lex.skipLineComment "--") (Lex.skipBlockComment "{-" "-}")
88−
89−opChar :: Parser Char
90−opChar = oneOf (":!#$%&*+./<=>?\\^|-~" :: String)-- remove "@" so it can be used as attribute marker without spaces
91−
92−reserved :: ParseStr -> Parser ()
93−reserved word = try (string word *> notFollowedBy opChar *> spaceConsumer)
94−
95−reservedOp :: ParseStr -> Parser ()
96−reservedOp op = try (spaceConsumer *> string op *> notFollowedBy opChar *> spaceConsumer)
97−
98−parens :: Parser a -> Parser a
99−parens = between (symbol "(") (symbol ")")
100−
101−braces :: Parser a -> Parser a
102−braces = between (symbol "{") (symbol "}")
103−
104−identifier :: Parser Text
105−identifier = do
106− istart <- letterChar <|> char '_'
107− identifierRemainder istart
108−
109−identifierRemainder :: Char -> Parser Text
110−identifierRemainder c = do
111− rest <- many (alphaNumChar <|> char '_' <|> char '#')
112− spaceConsumer
113− pure (pack (c:rest))
114−
115−symbol :: ParseStr -> Parser Text
116−#if MIN_VERSION_megaparsec(6,0,0)
117−symbol sym = Lex.symbol spaceConsumer sym
118−#else
119−symbol sym = pack <$> Lex.symbol spaceConsumer sym
120−#endif
121−
122−comma :: Parser Text
123−comma = symbol ","
124−
125−pipe :: Parser Text
126−pipe = symbol "|"
127−
128−quote :: Parser Text
129−quote = symbol "\""
130−
131−tripleQuote :: Parser Text
132−tripleQuote = symbol "\"\"\""
133−
134−arrow :: Parser Text
135−arrow = symbol "->"
136−
137−semi :: Parser Text
138−semi = symbol ";"
139−
140−nline :: Parser Text
141−nline = (T.singleton <$> newline) <|> crlf
142−
143−integer :: Parser Integer
144−#if MIN_VERSION_megaparsec(6,0,0)
145−integer = Lex.signed (pure ()) Lex.decimal <* spaceConsumer
146−#else
147−integer = Lex.signed (pure ()) Lex.integer <* spaceConsumer
148−#endif
149−
150−natural :: Parser Integer
151−#if MIN_VERSION_megaparsec(6,0,0)
152−natural = Lex.decimal <* spaceConsumer
153−#else
154−natural = Lex.integer <* spaceConsumer
155−#endif
156−
157−float :: Parser Double
158−float = Lex.float <* spaceConsumer
159−
160−capitalizedIdentifier :: Parser Text
161−capitalizedIdentifier =
162− upperChar >>= identifierRemainder
163−
164−uncapitalizedIdentifier :: Parser Text
165−uncapitalizedIdentifier =
166− lowerChar >>= identifierRemainder
167−
168−showRelationAttributes :: Attributes -> Text
169−showRelationAttributes attrs = "{" <> T.concat (L.intersperse ", " $ L.map showAttribute attrsL) <> "}"
170− where
171− showAttribute (Attribute name atomType') = name <> " " <> prettyAtomType atomType'
172− attrsL = A.toList attrs
173−
174−type PromptLength = Int
175−
176−#if MIN_VERSION_megaparsec(7,0,0)
177−type ParserError = ParseErrorBundle T.Text Void
178−#elif MIN_VERSION_megaparsec(6,0,0)
179−type ParserError = ParseError Char Void
180−#else
181−type ParserError = ParseError Char Dec
182−#endif
183−
184−data TutorialDOperatorResult = QuitResult |
185− DisplayResult StringType |
186− DisplayIOResult (IO ()) |
187− DisplayRelationResult Relation |
188− DisplayDataFrameResult DataFrame |
189− DisplayErrorResult StringType |
190− DisplayParseErrorResult (Maybe PromptLength) ParserError | -- PromptLength refers to length of prompt text
191− QuietSuccessResult
192− deriving (Generic)
193−
194−type TransactionGraphWasUpdated = Bool
195−
196−--allow for python-style triple quoting because guessing the correct amount of escapes in different contexts is annoying
197−tripleQuotedString :: Parser Text
198−tripleQuotedString = do
199− _ <- tripleQuote
200− pack <$> manyTill anySingle (try (tripleQuote >> notFollowedBy quote))
201−
202−normalQuotedString :: Parser Text
203−normalQuotedString = quote *> (T.pack <$> manyTill Lex.charLiteral quote)
204−
205−quotedString :: Parser Text
206−quotedString = try tripleQuotedString <|> normalQuotedString
207−
208−quoted :: Parser a -> Parser a
209−quoted = between quote quote
210−
211−uuidP :: Parser U.UUID
212−uuidP = do
213− uuidStart <- count 8 hexDigitChar
214− _ <- char '-' -- min 28 with no dashes, maximum 4 dashes
215− uuidMid1 <- count 4 hexDigitChar
216− _ <- char '-'
217− uuidMid2 <- count 4 hexDigitChar
218− _ <- char '-'
219− uuidMid3 <- count 4 hexDigitChar
220− _ <- char '-'
221− uuidEnd <- count 12 hexDigitChar
222− let uuidStr = L.intercalate "-" [uuidStart, uuidMid1, uuidMid2, uuidMid3, uuidEnd]
223− case U.fromString uuidStr of
224− Nothing -> fail "Invalid uuid string"
225− Just uuid -> return uuid
226−
227−utcTimeP :: Parser UTCTime
228−utcTimeP = do
229− timeStr <- quotedString
230− case parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" (T.unpack timeStr) of
231− Nothing -> fail "invalid datetime input, use \"YYYY-MM-DD HH:MM:SS\""
232− Just stamp' -> pure stamp'
233−
234−
235−colonOp :: Text -> Parser ()
236−colonOp opStr = do
237− _ <- string opStr <* (void spaceChar <|> eof) <* spaceConsumer
238− pure ()
239−
240−hex :: Parser Text
241−hex = takeWhileP (Just "hexadecimal")
242− (\c ->
243− isDigit c
244− || (c >= 'a' && c <= 'f'))
245−
src/bin/TutorialD/Interpreter/DatabaseContextExpr.hsdeleted−219
@@ -1,219 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−module TutorialD.Interpreter.DatabaseContextExpr where
3−import ProjectM36.Base
4−import TutorialD.Interpreter.Base
5−import qualified Data.Text as T
6−import TutorialD.Interpreter.RelationalExpr
7−import TutorialD.Interpreter.Types
8−import qualified Data.Map as M
9−import ProjectM36.StaticOptimizer
10−import qualified ProjectM36.Error as PM36E
11−import ProjectM36.Error
12−import qualified ProjectM36.RelationalExpression as RE
13−import ProjectM36.Key
14−import ProjectM36.FunctionalDependency
15−#if __GLASGOW_HASKELL__ < 804
16−import Data.Monoid
17−#endif
18−import Data.Functor
19−
20−--parsers which create "database expressions" which modify the database context (such as relvar assignment)
21−databaseContextExprP :: Parser DatabaseContextExpr
22−databaseContextExprP = choice [insertP,
23− deleteConstraintP,
24− deleteP,
25− updateP,
26− addConstraintP,
27− keyP,
28− funcDepP,
29− defineP,
30− undefineP,
31− assignP,
32− addNotificationP,
33− removeNotificationP,
34− addTypeConstructorP,
35− removeTypeConstructorP,
36− removeAtomFunctionP,
37− executeDatabaseContextFunctionP,
38− removeDatabaseContextFunctionP,
39− nothingP]
40−
41−nothingP :: Parser DatabaseContextExpr
42−nothingP = spaceConsumer >> pure NoOperation
43−
44−assignP :: Parser DatabaseContextExpr
45−assignP = do
46− relVarName <- try $ do
47− relVarName <- relVarNameP
48− reservedOp ":="
49− return relVarName
50− Assign relVarName <$> relExprP
51−
52−multilineSep :: Parser T.Text
53−multilineSep = newline >> pure "\n"
54−
55−multipleDatabaseContextExprP :: Parser DatabaseContextExpr
56−multipleDatabaseContextExprP = do
57− exprs <- filter (/= NoOperation) <$> sepBy1 databaseContextExprP semi
58− pure (MultipleExpr exprs)
59−
60−insertP :: Parser DatabaseContextExpr
61−insertP = do
62− reservedOp "insert"
63− relvar <- relVarNameP
64− Insert relvar <$> relExprP
65−
66−defineP :: Parser DatabaseContextExpr
67−defineP = do
68− relVarName <- try $ do
69− relVarName <- relVarNameP
70− reservedOp "::"
71− return relVarName
72− Define relVarName <$> makeAttributeExprsP
73−
74−undefineP :: Parser DatabaseContextExpr
75−undefineP = do
76− reservedOp "undefine"
77− Undefine <$> relVarNameP
78−
79−deleteP :: Parser DatabaseContextExpr
80−deleteP = do
81− reservedOp "delete"
82− Delete <$> relVarNameP <*> option TruePredicate (reservedOp "where" *> restrictionPredicateP)
83−
84−updateP :: Parser DatabaseContextExpr
85−updateP = do
86− reservedOp "update"
87− relVarName <- relVarNameP
88− predicate <- option TruePredicate (reservedOp "where" *> restrictionPredicateP <* spaceConsumer)
89− attributeAssignments <- M.fromList <$> parens (sepBy attributeAssignmentP comma)
90− return $ Update relVarName attributeAssignments predicate
91−
92−data IncDepOp = SubsetOp | EqualityOp
93−
94−addConstraintP :: Parser DatabaseContextExpr
95−addConstraintP = do
96− reservedOp "constraint" <|> reservedOp "foreign key"
97− constraintName <- identifier
98− subset <- relExprP
99− op <- (reservedOp "in" $> SubsetOp) <|> (reservedOp "equals" $> EqualityOp)
100− superset <- relExprP
101− let subsetA = incDepSet constraintName subset superset
102− subsetB = incDepSet (constraintName <> "_eqInvert") superset subset --inverted args for equality constraint
103− incDepSet nam a b = AddInclusionDependency nam (InclusionDependency a b)
104− case op of
105− SubsetOp -> pure subsetA
106− EqualityOp -> pure (MultipleExpr [subsetA, subsetB])
107−
108−deleteConstraintP :: Parser DatabaseContextExpr
109−deleteConstraintP = do
110− reserved "deleteconstraint"
111− RemoveInclusionDependency <$> identifier
112−
113−-- key <constraint name> {<uniqueness attributes>} <uniqueness relexpr>
114−keyP :: Parser DatabaseContextExpr
115−keyP = do
116− reserved "key"
117− keyName <- identifier
118− uniquenessAttrNames <- braces attributeListP
119− uniquenessExpr <- relExprP
120− let newIncDep = inclusionDependencyForKey uniquenessAttrNames uniquenessExpr
121− pure $ AddInclusionDependency keyName newIncDep
122−
123−funcDepP :: Parser DatabaseContextExpr
124−funcDepP = do
125− reserved "funcdep"
126− keyName <- identifier
127− source <- parens attributeListP
128− reserved "->"
129− dependents <- parens attributeListP
130− expr <- relExprP
131− let newIncDeps = inclusionDependenciesForFunctionalDependency funcDep
132− funcDep = FunctionalDependency source dependents expr
133− nameA = keyName <> "_A"
134− nameB = keyName <> "_B"
135− pure (MultipleExpr [AddInclusionDependency nameA (fst newIncDeps),
136− AddInclusionDependency nameB (snd newIncDeps)])
137−
138−attributeAssignmentP :: Parser (AttributeName, AtomExpr)
139−attributeAssignmentP = do
140− attrName <- identifier
141− reservedOp ":="
142− atomExpr <- atomExprP
143− pure (attrName, atomExpr)
144−
145−addNotificationP :: Parser DatabaseContextExpr
146−addNotificationP = do
147− reserved "notify"
148− notName <- identifier
149− triggerExpr <- relExprP
150− resultOldExpr <- relExprP
151− AddNotification notName triggerExpr resultOldExpr <$> relExprP
152−
153−removeNotificationP :: Parser DatabaseContextExpr
154−removeNotificationP = do
155− reserved "unnotify"
156− RemoveNotification <$> identifier
157−
158−-- | data Hair = Bald | Color Text
159−addTypeConstructorP :: Parser DatabaseContextExpr
160−addTypeConstructorP = do
161− reserved "data"
162− typeConstructorDef <- typeConstructorDefP
163− reservedOp "="
164− dataConstructorDefs <- sepBy1 dataConstructorDefP pipe
165− pure (AddTypeConstructor typeConstructorDef dataConstructorDefs)
166−
167−removeTypeConstructorP :: Parser DatabaseContextExpr
168−removeTypeConstructorP = do
169− reserved "undata"
170− RemoveTypeConstructor <$> typeConstructorNameP
171−
172−removeAtomFunctionP :: Parser DatabaseContextExpr
173−removeAtomFunctionP = do
174− reserved "removeatomfunction"
175− RemoveAtomFunction <$> quotedString
176−
177−removeDatabaseContextFunctionP :: Parser DatabaseContextExpr
178−removeDatabaseContextFunctionP = do
179− reserved "removedatabasecontextfunction"
180− RemoveDatabaseContextFunction <$> quotedString
181−
182−functionNameP :: Parser AtomFunctionName
183−functionNameP = uncapitalizedIdentifier
184−
185−executeDatabaseContextFunctionP :: Parser DatabaseContextExpr
186−executeDatabaseContextFunctionP = do
187− reserved "execute"
188− funcName <- functionNameP
189− args <- parens (sepBy atomExprP comma)
190− pure (ExecuteDatabaseContextFunction funcName args)
191−
192−databaseExprOpP :: Parser DatabaseContextExpr
193−databaseExprOpP = multipleDatabaseContextExprP
194−
195−{-
196−evalDatabaseContextExpr :: Bool -> DatabaseContext -> DatabaseContextExpr -> Either RelationalError DatabaseContext
197−evalDatabaseContextExpr useOptimizer context expr = do
198− optimizedExpr <- evalState (applyStaticDatabaseOptimization expr) (RE.freshDatabaseState context)
199− case runState (RE.evalDatabaseContextExpr (if useOptimizer then optimizedExpr else expr)) (RE.freshDatabaseState context) of
200− (Right (), (context',_, _)) -> Right context'
201− (Left err, _) -> Left err
202−-}
203−
204−interpretDatabaseContextExpr :: DatabaseContext -> TransactionId -> TransactionGraph -> T.Text -> Either RelationalError DatabaseContext
205−interpretDatabaseContextExpr context transId graph tutdstring =
206− case parse databaseExprOpP "" tutdstring of
207− Left err -> Left $ PM36E.ParseError (T.pack (show err))
208− Right parsed -> do
209− let env = RE.mkDatabaseContextEvalEnv transId graph
210− RE.dbc_context <$> RE.runDatabaseContextEvalMonad context env (optimizeAndEvalDatabaseContextExpr True parsed)
211−
212−{-
213−--no optimization
214−interpretNO :: DatabaseContext -> String -> (Maybe RelationalError, DatabaseContext)
215−interpretNO context tutdstring = case parseString tutdstring of
216− Left err -> (Just err, context)
217− Right parsed -> runState (evalContextExpr parsed) context
218−-}
219−
src/bin/TutorialD/Interpreter/DatabaseContextIOOperator.hsdeleted−50
@@ -1,50 +0,0 @@
1−--compiling the script requires the IO monad because it must load modules from the filesystem, so we create the function and generate the requisite DatabaseExpr here.
2−module TutorialD.Interpreter.DatabaseContextIOOperator where
3−import ProjectM36.Base
4−import TutorialD.Interpreter.Base
5−import TutorialD.Interpreter.Types
6−import Data.Text
7−
8−addAtomFunctionExprP :: Parser DatabaseContextIOExpr
9−addAtomFunctionExprP = dbioexprP "addatomfunction" AddAtomFunction
10−
11−addDatabaseContextFunctionExprP :: Parser DatabaseContextIOExpr
12−addDatabaseContextFunctionExprP = dbioexprP "adddatabasecontextfunction" AddDatabaseContextFunction
13−
14−createArbitraryRelationP :: Parser DatabaseContextIOExpr
15−createArbitraryRelationP = do
16− reserved "createarbitraryrelation"
17− relVarName <- identifier
18− attrExprs <- makeAttributeExprsP :: Parser [AttributeExpr]
19− min' <- fromInteger <$> integer
20− _ <- symbol "-"
21− max' <- fromInteger <$> integer
22− pure $ CreateArbitraryRelation relVarName attrExprs (min',max')
23−
24−dbioexprP :: ParseStr -> (Text -> [TypeConstructor] -> Text -> DatabaseContextIOExpr) -> Parser DatabaseContextIOExpr
25−dbioexprP res adt = do
26− reserved res
27− funcName <- quotedString
28− funcType <- atomTypeSignatureP
29− adt funcName funcType <$> quotedString
30−
31−atomTypeSignatureP :: Parser [TypeConstructor]
32−atomTypeSignatureP = sepBy typeConstructorP arrow
33−
34−dbContextIOExprP :: Parser DatabaseContextIOExpr
35−dbContextIOExprP = addAtomFunctionExprP <|>
36− addDatabaseContextFunctionExprP <|>
37− loadAtomFunctionsP <|>
38− loadDatabaseContextFunctionsP <|>
39− createArbitraryRelationP
40−
41−loadAtomFunctionsP :: Parser DatabaseContextIOExpr
42−loadAtomFunctionsP = do
43− reserved "loadatomfunctions"
44− LoadAtomFunctions <$> quotedString <*> quotedString <*> fmap unpack quotedString
45−
46−loadDatabaseContextFunctionsP :: Parser DatabaseContextIOExpr
47−loadDatabaseContextFunctionsP = do
48− reserved "loaddatabasecontextfunctions"
49− LoadDatabaseContextFunctions <$> quotedString <*> quotedString <*> fmap unpack quotedString
50−
src/bin/TutorialD/Interpreter/Import/Base.hsdeleted−32
@@ -1,32 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−module TutorialD.Interpreter.Import.Base where
3−import ProjectM36.Base
4−import ProjectM36.Error
5−import Text.URI (URI)
6−import Data.Text (Text)
7−#if __GLASGOW_HASKELL__ < 804
8−import Data.Monoid
9−#endif
10−
11−-- | import data into a relation variable
12−data RelVarDataImportOperator = RelVarDataImportOperator RelVarName FilePath (RelVarName -> TypeConstructorMapping -> Attributes -> FilePath -> IO (Either RelationalError DatabaseContextExpr))
13−
14−instance Show RelVarDataImportOperator where
15− show (RelVarDataImportOperator rv path _) = "RelVarDataImportOperator " <> show rv <> " " <> path
16−
17−type HashVerification = Maybe Text
18−
19−-- | import data into a database context
20−data DatabaseContextDataImportOperator = DatabaseContextDataImportOperator URI HashVerification (URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr))
21−
22−instance Show DatabaseContextDataImportOperator where
23− show (DatabaseContextDataImportOperator uri hash _) =
24− "DatabaseContextDataImportOperator " <> show uri <> " " <> show hash
25−
26−-- perhaps create a structure to import a whole transaction graph section in the future
27−
28−evalRelVarDataImportOperator :: RelVarDataImportOperator -> TypeConstructorMapping -> Attributes -> IO (Either RelationalError DatabaseContextExpr)
29−evalRelVarDataImportOperator (RelVarDataImportOperator relVarName path importFunc) tConsMap attrs = importFunc relVarName tConsMap attrs path
30−
31−evalDatabaseContextDataImportOperator :: DatabaseContextDataImportOperator -> IO (Either RelationalError DatabaseContextExpr)
32−evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator uri hash importFunc) = importFunc uri hash
src/bin/TutorialD/Interpreter/Import/CSV.hsdeleted−29
@@ -1,29 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−module TutorialD.Interpreter.Import.CSV where
3−import TutorialD.Interpreter.Import.Base
4−import ProjectM36.Base
5−import ProjectM36.Error
6−import ProjectM36.Relation.Parse.CSV hiding (quotedString)
7−import qualified Data.ByteString.Lazy as BS
8−import qualified Data.Text as T
9−import TutorialD.Interpreter.Base hiding (try)
10−import Control.Exception
11−
12−importCSVRelation :: RelVarName -> TypeConstructorMapping -> Attributes -> FilePath -> IO (Either RelationalError DatabaseContextExpr)
13−importCSVRelation relVarName tConsMap attrs pathIn = do
14− --TODO: handle filesystem errors
15− csvData <- try (BS.readFile pathIn) :: IO (Either IOError BS.ByteString)
16− case csvData of
17− Left err -> pure $ Left (ImportError (ImportFileError (T.pack (show err))))
18− 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))
21−
22−importCSVP :: Parser RelVarDataImportOperator
23−importCSVP = do
24− reserved ":importcsv"
25− path <- quotedString
26− spaceConsumer
27− relVarName <- identifier
28− return $ RelVarDataImportOperator relVarName (T.unpack path) importCSVRelation
29−
src/bin/TutorialD/Interpreter/Import/TutorialD.hsdeleted−86
@@ -1,86 +0,0 @@
1−module TutorialD.Interpreter.Import.TutorialD where
2−import ProjectM36.Base
3−import TutorialD.Interpreter.Import.Base
4−import TutorialD.Interpreter.Base hiding (try)
5−import TutorialD.Interpreter.DatabaseContextExpr
6−import ProjectM36.Error
7−import qualified ProjectM36.Error as PM36E
8−import qualified Data.Text as T
9−import Control.Exception
10−import qualified Data.ByteString as BS
11−import 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
19−
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−
75−tutdImportP :: Parser DatabaseContextDataImportOperator
76−tutdImportP = do
77− reserved ":importtutd"
78− uri <- quoted URI.parser
79− 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
src/bin/TutorialD/Interpreter/RODatabaseContextOperator.hsdeleted−210
@@ -1,210 +0,0 @@
1−{-# LANGUAGE GADTs #-}
2−module TutorialD.Interpreter.RODatabaseContextOperator where
3−import ProjectM36.Base
4−import ProjectM36.Relation
5−import qualified ProjectM36.DataFrame as DF
6−import ProjectM36.Error
7−import ProjectM36.Tuple
8−import ProjectM36.InclusionDependency
9−import qualified ProjectM36.Client as C
10−import TutorialD.Interpreter.Base
11−import TutorialD.Interpreter.RelationalExpr
12−import TutorialD.Interpreter.DatabaseContextExpr
13−import TutorialD.Printer
14−import Control.Monad.State
15−import qualified Data.Text as T
16−import ProjectM36.Relation.Show.Gnuplot
17−import qualified Data.Map as M
18−import Data.Maybe
19−
20−--operators which only rely on database context reading
21−data RODatabaseContextOperator where
22− ShowRelation :: RelationalExpr -> RODatabaseContextOperator
23− PlotRelation :: RelationalExpr -> RODatabaseContextOperator
24− ShowRelationType :: RelationalExpr -> RODatabaseContextOperator
25− ShowConstraints :: StringType -> RODatabaseContextOperator
26− ShowPlan :: DatabaseContextExpr -> RODatabaseContextOperator
27− ShowTypes :: RODatabaseContextOperator
28− ShowRelationVariables :: RODatabaseContextOperator
29− ShowAtomFunctions :: RODatabaseContextOperator
30− ShowDatabaseContextFunctions :: RODatabaseContextOperator
31− ShowDataFrame :: DF.DataFrameExpr -> RODatabaseContextOperator
32− Quit :: RODatabaseContextOperator
33− deriving (Show)
34−
35−typeP :: Parser RODatabaseContextOperator
36−typeP = do
37− colonOp ":type"
38− ShowRelationType <$> relExprP
39−
40−showRelP :: Parser RODatabaseContextOperator
41−showRelP = do
42− colonOp ":showexpr"
43− ShowRelation <$> relExprP
44−
45−showPlanP :: Parser RODatabaseContextOperator
46−showPlanP = do
47− colonOp ":showplan"
48− ShowPlan <$> databaseContextExprP
49−
50−showTypesP :: Parser RODatabaseContextOperator
51−showTypesP = colonOp ":showtypes" >> pure ShowTypes
52−
53−showRelationVariables :: Parser RODatabaseContextOperator
54−showRelationVariables = colonOp ":showrelvars" >> pure ShowRelationVariables
55−
56−showAtomFunctionsP :: Parser RODatabaseContextOperator
57−showAtomFunctionsP = colonOp ":showatomfunctions" >> pure ShowAtomFunctions
58−
59−showDatabaseContextFunctionsP :: Parser RODatabaseContextOperator
60−showDatabaseContextFunctionsP = colonOp ":showdatabasecontextfunctions" >> pure ShowDatabaseContextFunctions
61−
62−quitP :: Parser RODatabaseContextOperator
63−quitP = do
64− colonOp ":quit"
65− return Quit
66−
67−showConstraintsP :: Parser RODatabaseContextOperator
68−showConstraintsP = do
69− colonOp ":constraints"
70− ShowConstraints <$> option "" identifier
71−
72−plotRelExprP :: Parser RODatabaseContextOperator
73−plotRelExprP = do
74− colonOp ":plotexpr"
75− PlotRelation <$> relExprP
76−
77−roDatabaseContextOperatorP :: Parser RODatabaseContextOperator
78−roDatabaseContextOperatorP = typeP
79− <|> showRelP
80− <|> showRelationVariables
81− <|> plotRelExprP
82− <|> showConstraintsP
83− <|> showPlanP
84− <|> showTypesP
85− <|> showAtomFunctionsP
86− <|> showDatabaseContextFunctionsP
87− <|> showDataFrameP
88− <|> quitP
89−
90−--logically, these read-only operations could happen purely, but not if a remote call is required
91−evalRODatabaseContextOp :: C.SessionId -> C.Connection -> RODatabaseContextOperator -> IO TutorialDOperatorResult
92−evalRODatabaseContextOp sessionId conn (ShowRelationType expr) = do
93− res <- C.typeForRelationalExpr sessionId conn expr
94− case res of
95− Left err -> pure $ DisplayErrorResult $ T.pack (show err)
96− Right rel -> pure $ DisplayRelationResult rel
97−
98−evalRODatabaseContextOp sessionId conn (ShowRelation expr) = do
99− res <- C.executeRelationalExpr sessionId conn expr
100− case res of
101− Left err -> pure $ DisplayErrorResult $ T.pack (show err)
102− Right rel -> pure $ DisplayRelationResult rel
103−
104−evalRODatabaseContextOp sessionId conn (PlotRelation expr) = do
105− res <- C.executeRelationalExpr sessionId conn expr
106− pure $ case res of
107− Left err -> DisplayErrorResult $ T.pack (show err)
108− Right rel -> DisplayIOResult $ do
109− err <- plotRelation rel
110− when (isJust err) $ print err
111−
112−evalRODatabaseContextOp sessionId conn (ShowConstraints name) = do
113− eIncDeps <- C.inclusionDependencies sessionId conn
114− let val = case eIncDeps of
115− Left err -> Left err
116− Right incDeps -> case name of
117− "" -> inclusionDependenciesAsRelation incDeps >>= renderRelExprsInIncDeps
118− depName -> case M.lookup depName incDeps of
119− Nothing -> Left (InclusionDependencyNameNotInUseError depName)
120− Just dep ->
121− inclusionDependenciesAsRelation (M.singleton depName dep) >>= renderRelExprsInIncDeps
122− pure $ case val of
123− Left err -> DisplayErrorResult (T.pack (show err))
124− Right rel -> DisplayRelationResult rel
125−
126−evalRODatabaseContextOp sessionId conn (ShowPlan dbExpr) = do
127− plan <- C.planForDatabaseContextExpr sessionId conn dbExpr
128− pure $ case plan of
129− Left err -> DisplayErrorResult (T.pack (show err))
130− Right optDbExpr -> DisplayResult $ T.pack (show optDbExpr)
131−
132−evalRODatabaseContextOp sessionId conn ShowTypes = do
133− eRel <- C.atomTypesAsRelation sessionId conn
134− case eRel of
135− Left err -> pure $ DisplayErrorResult (T.pack (show err))
136− Right rel -> evalRODatabaseContextOp sessionId conn (ShowRelation (ExistingRelation rel))
137−
138−evalRODatabaseContextOp sessionId conn ShowRelationVariables = do
139− eRel <- C.relationVariablesAsRelation sessionId conn
140− case eRel of
141− Left err -> pure $ DisplayErrorResult (T.pack (show err))
142− Right rel -> evalRODatabaseContextOp sessionId conn (ShowRelation (ExistingRelation rel))
143−
144−evalRODatabaseContextOp sessionId conn ShowAtomFunctions = do
145− eRel <- C.atomFunctionsAsRelation sessionId conn
146− case eRel of
147− Left err -> pure $ DisplayErrorResult (T.pack (show err))
148− Right rel -> evalRODatabaseContextOp sessionId conn (ShowRelation (ExistingRelation rel))
149−
150−evalRODatabaseContextOp sessionId conn ShowDatabaseContextFunctions = do
151− eRel <- C.databaseContextFunctionsAsRelation sessionId conn
152− case eRel of
153− Left err -> pure $ DisplayErrorResult (T.pack (show err))
154− Right rel -> evalRODatabaseContextOp sessionId conn (ShowRelation (ExistingRelation rel))
155−
156−evalRODatabaseContextOp sessionId conn (ShowDataFrame dfExpr) = do
157− eDataFrame <- C.executeDataFrameExpr sessionId conn dfExpr
158− case eDataFrame of
159− Left err -> pure (DisplayErrorResult (T.pack (show err)))
160− Right dframe -> pure (DisplayDataFrameResult dframe)
161−
162−evalRODatabaseContextOp _ _ Quit = pure QuitResult
163−
164−interpretRODatabaseContextOp :: C.SessionId -> C.Connection -> T.Text -> IO TutorialDOperatorResult
165−interpretRODatabaseContextOp sessionId conn tutdstring = case parse roDatabaseContextOperatorP "" tutdstring of
166− Left err -> pure $ DisplayErrorResult (T.pack (show err))
167− Right parsed -> evalRODatabaseContextOp sessionId conn parsed
168−
169−showDataFrameP :: Parser RODatabaseContextOperator
170−showDataFrameP = do
171− colonOp ":showdataframe"
172− relExpr <- relExprP
173− reservedOp "orderby"
174− attrOrdersExpr <- attrOrdersExprP
175− mbOffset <- optional offsetP
176− mbLimit <- optional limitP
177− pure $ ShowDataFrame (DF.DataFrameExpr relExpr attrOrdersExpr mbOffset mbLimit)
178−
179−
180−offsetP :: Parser Integer
181−offsetP = do
182− reservedOp "offset"
183− natural
184−
185−limitP :: Parser Integer
186−limitP = do
187− reservedOp "limit"
188− natural
189−
190−attrOrdersExprP :: Parser [DF.AttributeOrderExpr]
191−attrOrdersExprP = braces (sepBy attrOrderExprP comma)
192−
193−attrOrderExprP :: Parser DF.AttributeOrderExpr
194−attrOrderExprP = DF.AttributeOrderExpr <$> identifier <*> orderP
195−
196−orderP :: Parser DF.Order
197−orderP = try (reservedOp "ascending" >> pure DF.AscendingOrder) <|> try (reservedOp "descending" >> pure DF.DescendingOrder) <|> pure DF.AscendingOrder
198−
199−-- render RelationalExprAtoms as TutorialD
200−renderRelExprsInIncDeps :: Relation -> Either RelationalError Relation
201−renderRelExprsInIncDeps = relMogrify tupMapper attrs
202− where
203− tupMapper tup = pure $ mkRelationTupleFromMap (M.map mapper (tupleToMap tup))
204− mapper (RelationalExprAtom expr) = TextAtom (T.pack (show (prettyRelationalExpr expr)))
205− mapper atom = atom
206− attrs = C.attributesFromList [Attribute "name" TextAtomType,
207− Attribute "sub" TextAtomType,
208− Attribute "super" TextAtomType
209− ]
210−
src/bin/TutorialD/Interpreter/RelationalExpr.hsdeleted−284
@@ -1,284 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−module TutorialD.Interpreter.RelationalExpr where
3−import Text.Megaparsec
4−#if MIN_VERSION_megaparsec(7,0,0)
5−import Control.Monad.Combinators.Expr
6−#else
7−import Text.Megaparsec.Expr
8−#endif
9−import ProjectM36.Base
10−import TutorialD.Interpreter.Base
11−import TutorialD.Interpreter.Types
12−import qualified Data.Text as T
13−import qualified Data.Set as S
14−import qualified Data.Map as M
15−import Data.List (sort)
16−import ProjectM36.MiscUtils
17−
18−--used in projection
19−attributeListP :: RelationalMarkerExpr a => Parser (AttributeNamesBase a)
20−attributeListP =
21− (reservedOp "all but" >>
22− InvertedAttributeNames . S.fromList <$> sepBy attributeNameP comma) <|>
23−
24− (reservedOp "all from" >>
25− RelationalExprAttributeNames <$> relExprP) <|>
26−
27− (reservedOp "union of" >>
28− UnionAttributeNames <$> braces attributeListP <*> braces attributeListP) <|>
29−
30− (reservedOp "intersection of" >>
31− IntersectAttributeNames <$> braces attributeListP <*> braces attributeListP) <|>
32−
33− (AttributeNames . S.fromList <$> sepBy attributeNameP comma)
34−
35−
36−makeRelationP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)
37−makeRelationP = do
38− reserved "relation"
39− attrExprs <- try (fmap Just makeAttributeExprsP) <|> pure Nothing
40− tupleExprs <- braces (sepBy tupleExprP comma) <|> pure []
41− marker <- parseMarkerP
42− pure $ MakeRelationFromExprs attrExprs (TupleExprs marker tupleExprs)
43−
44−
45−--abstract data type parser- in this context, the type constructor must not include any type arguments
46−--Either Text Int
47−adTypeConstructorP :: Parser TypeConstructor
48−adTypeConstructorP = do
49− tConsName <- typeConstructorNameP
50− tConsArgs <- many typeConstructorP
51− pure $ ADTypeConstructor tConsName tConsArgs
52−
53−tupleExprP :: RelationalMarkerExpr a => Parser (TupleExprBase a)
54−tupleExprP = do
55− reservedOp "tuple"
56− attrAssocs <- braces (sepBy tupleAtomExprP comma)
57− --detect duplicate attribute names
58− let dupAttrNames = dupes (sort (map fst attrAssocs))
59− if not (null dupAttrNames) then
60− fail ("Attribute names duplicated: " ++ show dupAttrNames)
61− else
62− pure (TupleExpr (M.fromList attrAssocs))
63−
64−tupleAtomExprP :: RelationalMarkerExpr a => Parser (AttributeName, AtomExprBase a)
65−tupleAtomExprP = do
66− attributeName <- attributeNameP
67− atomExpr <- atomExprP
68− pure (attributeName, atomExpr)
69−
70−projectP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)
71−projectP = Project <$> braces attributeListP
72−
73−renameClauseP :: Parser (T.Text, T.Text)
74−renameClauseP = do
75− oldAttr <- attributeNameP
76− reservedOp "as"
77− newAttr <- attributeNameP
78− pure (oldAttr, newAttr)
79−
80−renameP :: Parser (RelationalExprBase a -> RelationalExprBase a)
81−renameP = do
82− reservedOp "rename"
83− renameList <- braces (sepBy renameClauseP comma)
84− case renameList of
85− [] -> pure (Restrict TruePredicate) --no-op when rename list is empty
86− renames ->
87− pure $ \expr -> foldl (\acc (oldAttr, newAttr) -> Rename oldAttr newAttr acc) expr renames
88−
89−whereClauseP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)
90−whereClauseP = reservedOp "where" *> (Restrict <$> restrictionPredicateP)
91−
92−groupClauseP :: RelationalMarkerExpr a => Parser (AttributeNamesBase a, T.Text)
93−groupClauseP = do
94− attrs <- braces attributeListP
95− reservedOp "as"
96− newAttrName <- attributeNameP
97− pure (attrs, newAttrName)
98−
99−groupP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)
100−groupP = do
101− reservedOp "group"
102− (groupAttrList, groupAttrName) <- parens groupClauseP
103− pure $ Group groupAttrList groupAttrName
104−
105−--in "Time and Relational Theory" (2014), Date's Tutorial D grammar for ungroup takes one attribute, while in previous books, it take multiple arguments. Let us assume that nested ungroups are the same as multiple attributes.
106−ungroupP :: Parser (RelationalExprBase a -> RelationalExprBase a)
107−ungroupP = do
108− reservedOp "ungroup"
109− Ungroup <$> attributeNameP
110−
111−extendP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)
112−extendP = do
113− reservedOp ":"
114− extends <- braces (sepBy extendTupleExpressionP comma)
115− case extends of
116− [] -> pure (Restrict TruePredicate)
117− extends' ->
118− pure $ \expr -> foldl (flip Extend) expr extends'
119−
120−semijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)
121−semijoinP = do
122− reservedOp "semijoin" <|> reservedOp "matching"
123− pure (\exprA exprB ->
124− Project (RelationalExprAttributeNames exprA) (Join exprA exprB))
125−
126−antijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)
127−antijoinP = do
128− reservedOp "not matching" <|> reservedOp "antijoin"
129− pure (\exprA exprB ->
130− Difference exprA (
131− Project (RelationalExprAttributeNames exprA) (Join exprA exprB)))
132−
133−relOperators :: RelationalMarkerExpr a => [[Operator Parser (RelationalExprBase a)]]
134−relOperators = [
135− [Postfix projectP],
136− [Postfix renameP],
137− [Postfix whereClauseP],
138− [Postfix groupP],
139− [Postfix ungroupP],
140− [InfixL (reservedOp "join" >> return Join)],
141− [InfixL semijoinP],
142− [InfixL antijoinP],
143− [InfixL (reservedOp "union" >> return Union)],
144− [InfixL (reservedOp "minus" >> return Difference)],
145− [InfixN (reservedOp "=" >> return Equals),
146− InfixN (reservedOp "/=" >> return NotEquals)],
147− [Postfix extendP]
148− ]
149−
150−relExprP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)
151−relExprP = try withMacroExprP <|> makeExprParser relTerm relOperators
152−
153−--allow for additional characters
154−attributeNameP :: Parser AttributeName
155−attributeNameP = uncapitalizedIdentifier
156−
157−relVarNameP :: Parser RelVarName
158−relVarNameP = uncapitalizedIdentifier
159−
160−relVarP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)
161−relVarP = RelationVariable <$> relVarNameP <*> parseMarkerP
162−
163−relTerm :: RelationalMarkerExpr a => Parser (RelationalExprBase a)
164−relTerm = parens relExprP
165− <|> makeRelationP
166− <|> relVarP
167−
168−restrictionPredicateP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)
169−restrictionPredicateP = makeExprParser predicateTerm predicateOperators
170− where
171− predicateOperators = [
172− [Prefix (reservedOp "not" >> return NotPredicate)],
173− [InfixL (reservedOp "and" >> return AndPredicate)],
174− [InfixL (reservedOp "or" >> return OrPredicate)]
175− ]
176− predicateTerm = try (parens restrictionPredicateP)
177− <|> try restrictionAtomExprP
178− <|> try restrictionAttributeEqualityP
179− <|> relationalBooleanExprP
180−
181−relationalBooleanExprP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)
182−relationalBooleanExprP =
183− --we can't actually detect if the type is relational boolean, so we just pass it to the next phase
184− RelationalExprPredicate <$> (parens relExprP <|> relTerm)
185−
186−restrictionAttributeEqualityP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)
187−restrictionAttributeEqualityP = do
188− attributeName <- attributeNameP
189− reservedOp "="
190− AttributeEqualityPredicate attributeName <$> atomExprP
191−
192−restrictionAtomExprP :: RelationalMarkerExpr a=> Parser (RestrictionPredicateExprBase a) --atoms which are of type "boolean"
193−restrictionAtomExprP = do
194− _ <- char '^' -- not ideal, but allows me to continue to use a context-free grammar
195− (try (char 't') >> pure TruePredicate) <|> (try (char 'f') >> pure (NotPredicate TruePredicate)) <|> AtomExprPredicate <$> atomExprP
196−
197−multiTupleExpressionP :: RelationalMarkerExpr a => Parser [ExtendTupleExprBase a]
198−multiTupleExpressionP = sepBy extendTupleExpressionP comma
199−
200−extendTupleExpressionP :: RelationalMarkerExpr a => Parser (ExtendTupleExprBase a)
201−extendTupleExpressionP = attributeExtendTupleExpressionP
202−
203−attributeExtendTupleExpressionP :: RelationalMarkerExpr a => Parser (ExtendTupleExprBase a)
204−attributeExtendTupleExpressionP = do
205− newAttr <- attributeNameP
206− reservedOp ":="
207− AttributeExtendTupleExpr newAttr <$> atomExprP
208−
209−atomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)
210−atomExprP = consumeAtomExprP True
211−
212−consumeAtomExprP :: RelationalMarkerExpr a => Bool -> Parser (AtomExprBase a)
213−consumeAtomExprP consume = try functionAtomExprP <|>
214− try (parens (constructedAtomExprP True)) <|>
215− constructedAtomExprP consume <|>
216− attributeAtomExprP <|>
217− try nakedAtomExprP <|>
218− relationalAtomExprP
219−
220−
221−attributeAtomExprP :: Parser (AtomExprBase a)
222−attributeAtomExprP = do
223− _ <- string "@"
224− AttributeAtomExpr <$> attributeNameP
225−
226−nakedAtomExprP :: Parser (AtomExprBase a)
227−nakedAtomExprP = NakedAtomExpr <$> atomP
228−
229−constructedAtomExprP :: RelationalMarkerExpr a => Bool -> Parser (AtomExprBase a)
230−constructedAtomExprP consume = do
231− dConsName <- dataConstructorNameP
232− dConsArgs <- if consume then sepBy (consumeAtomExprP False) spaceConsumer else pure []
233− ConstructedAtomExpr dConsName dConsArgs <$> parseMarkerP
234−
235−-- used only for primitive type parsing ?
236−atomP :: Parser Atom
237−atomP = stringAtomP <|>
238− try doubleAtomP <|>
239− integerAtomP <|>
240− boolAtomP
241−
242−functionAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)
243−functionAtomExprP =
244− FunctionAtomExpr <$> uncapitalizedIdentifier <*> parens (sepBy atomExprP comma) <*> parseMarkerP
245−
246−relationalAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)
247−relationalAtomExprP = RelationAtomExpr <$> relExprP
248−
249−stringAtomP :: Parser Atom
250−stringAtomP = TextAtom <$> quotedString
251−
252−doubleAtomP :: Parser Atom
253−doubleAtomP = DoubleAtom <$> float
254−
255−integerAtomP :: Parser Atom
256−integerAtomP = IntegerAtom <$> integer
257−
258−boolAtomP :: Parser Atom
259−boolAtomP = do
260− v <- identifier
261− if v == "t" || v == "f" then
262− pure $ BoolAtom (v == "t")
263− else
264− fail "invalid boolAtom"
265−
266−
267−relationAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)
268−relationAtomExprP = RelationAtomExpr <$> makeRelationP
269−
270−withMacroExprP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)
271−withMacroExprP = do
272− reservedOp "with"
273− views <- parens (sepBy1 createMacroP comma)
274− With views <$> relExprP
275−
276−createMacroP :: RelationalMarkerExpr a => Parser (WithNameExprBase a, RelationalExprBase a)
277−createMacroP = do
278− name <- identifier
279− reservedOp "as"
280− expr <- relExprP
281− marker <- parseMarkerP
282− pure (WithNameExpr name marker, expr)
283−
284−
src/bin/TutorialD/Interpreter/SchemaOperator.hsdeleted−77
@@ -1,77 +0,0 @@
1−module TutorialD.Interpreter.SchemaOperator where
2−import Text.Megaparsec
3−import ProjectM36.Base
4−import ProjectM36.IsomorphicSchema
5−import ProjectM36.Session
6−import ProjectM36.Client
7−import TutorialD.Interpreter.RelationalExpr
8−import TutorialD.Interpreter.Base
9−
10−data SchemaOperator = ModifySchemaExpr SchemaExpr |
11− SetCurrentSchema SchemaName
12− deriving Show
13−
14−schemaOperatorP :: Parser SchemaOperator
15−schemaOperatorP = (ModifySchemaExpr <$> schemaExprP) <|>
16− setCurrentSchemaP
17−
18−setCurrentSchemaP :: Parser SchemaOperator
19−setCurrentSchemaP = do
20− reserved ":setschema"
21− SetCurrentSchema <$> identifier
22−
23−schemaExprP :: Parser SchemaExpr
24−schemaExprP = addSubschemaP <|>
25− removeSubschemaP
26−
27−addSubschemaP :: Parser SchemaExpr
28−addSubschemaP = do
29− reserved ":addschema"
30− AddSubschema <$> identifier <*> parens (sepBy schemaIsomorphP comma)
31−
32−schemaIsomorphP :: Parser SchemaIsomorph
33−schemaIsomorphP = isoRestrictP <|> isoUnionP <|> isoRenameP <|> isoPassthrough
34−
35−removeSubschemaP :: Parser SchemaExpr
36−removeSubschemaP = do
37− reserved ":removeschema"
38− RemoveSubschema <$> identifier
39−
40−isoRestrictP :: Parser SchemaIsomorph
41−isoRestrictP = do
42− reserved "isorestrict"
43− relVarIn <- qrelVarP
44− relvarsOut <- isoRestrictOutRelVarsP
45− IsoRestrict relVarIn <$> restrictionPredicateP <*> pure relvarsOut
46−
47−isoRestrictOutRelVarsP :: Parser (RelVarName, RelVarName)
48−isoRestrictOutRelVarsP = (,) <$> qrelVarP <*> qrelVarP
49−
50−qrelVarP :: Parser RelVarName
51−qrelVarP = quotedString
52−
53−isoUnionP :: Parser SchemaIsomorph
54−isoUnionP = do
55− reserved "isounion"
56− relVarsIn <- isoUnionInRelVarsP
57− relVarsOut <- qrelVarP
58− IsoUnion relVarsIn <$> restrictionPredicateP <*> pure relVarsOut
59−
60−isoRenameP :: Parser SchemaIsomorph
61−isoRenameP = do
62− reserved "isorename"
63− IsoRename <$> qrelVarP <*> qrelVarP
64−
65−isoPassthrough :: Parser SchemaIsomorph
66−isoPassthrough = do
67− reserved "isopassthrough"
68− rv <- qrelVarP
69− pure (IsoRename rv rv)
70−
71−isoUnionInRelVarsP :: Parser (RelVarName, RelVarName)
72−isoUnionInRelVarsP = (,) <$> qrelVarP <*> qrelVarP
73−
74−evalSchemaOperator :: SessionId -> Connection -> SchemaOperator -> IO (Either RelationalError ())
75−evalSchemaOperator sessionId conn (ModifySchemaExpr expr) = executeSchemaExpr sessionId conn expr
76−evalSchemaOperator sessionId conn (SetCurrentSchema sname) = setCurrentSchemaName sessionId conn sname
77−
src/bin/TutorialD/Interpreter/TransGraphRelationalOperator.hsdeleted−46
@@ -1,46 +0,0 @@
1−{-# LANGUAGE FlexibleInstances #-}
2−{-# OPTIONS_GHC -fno-warn-orphans #-}
3−module TutorialD.Interpreter.TransGraphRelationalOperator where
4−import ProjectM36.TransGraphRelationalExpression
5−import ProjectM36.TransactionGraph
6−import TutorialD.Interpreter.Types
7−import qualified ProjectM36.Client as C
8−
9−import TutorialD.Interpreter.Base
10−import TutorialD.Interpreter.RelationalExpr
11−
12−import qualified Data.Text as T
13−
14−instance RelationalMarkerExpr TransactionIdLookup where
15− parseMarkerP = string "@" *> transactionIdLookupP
16−
17−newtype TransGraphRelationalOperator = ShowTransGraphRelation TransGraphRelationalExpr
18− deriving Show
19−
20−transactionIdLookupP :: Parser TransactionIdLookup
21−transactionIdLookupP = (TransactionIdLookup <$> uuidP) <|>
22− (TransactionIdHeadNameLookup <$> identifier <*> many transactionIdHeadBacktrackP)
23−
24−transactionIdHeadBacktrackP :: Parser TransactionIdHeadBacktrack
25−transactionIdHeadBacktrackP = (string "~" *> (TransactionIdHeadParentBacktrack <$> backtrackP)) <|>
26− (string "^" *> (TransactionIdHeadBranchBacktrack <$> backtrackP)) <|>
27− (string "@" *> (TransactionStampHeadBacktrack <$> utcTimeP))
28−
29−backtrackP :: Parser Int
30−backtrackP = fromIntegral <$> integer <|> pure 1
31−
32−transGraphRelationalOpP :: Parser TransGraphRelationalOperator
33−transGraphRelationalOpP = showTransGraphRelationalOpP
34−
35−showTransGraphRelationalOpP :: Parser TransGraphRelationalOperator
36−showTransGraphRelationalOpP = do
37− reservedOp ":showtransgraphexpr"
38− ShowTransGraphRelation <$> relExprP
39−
40−evalTransGraphRelationalOp :: C.SessionId -> C.Connection -> TransGraphRelationalOperator -> IO TutorialDOperatorResult
41−evalTransGraphRelationalOp sessionId conn (ShowTransGraphRelation expr) = do
42− res <- C.executeTransGraphRelationalExpr sessionId conn expr
43− case res of
44− Left err -> pure $ DisplayErrorResult $ T.pack (show err)
45− Right rel -> pure $ DisplayRelationResult rel
46−
src/bin/TutorialD/Interpreter/Types.hsdeleted−61
@@ -1,61 +0,0 @@
1−--parse type and data constructors
2−module TutorialD.Interpreter.Types where
3−import ProjectM36.Base
4−import Text.Megaparsec
5−import TutorialD.Interpreter.Base
6−
7−class RelationalMarkerExpr a where
8− parseMarkerP :: Parser a
9−
10−instance RelationalMarkerExpr () where
11− parseMarkerP = pure ()
12−
13−typeConstructorNameP :: Parser TypeConstructorName
14−typeConstructorNameP = capitalizedIdentifier
15−
16−dataConstructorNameP :: Parser DataConstructorName
17−dataConstructorNameP = capitalizedIdentifier
18−
19−-- | Upper case names are type names while lower case names are polymorphic typeconstructor arguments.
20−-- data *Either a b* = Left a | Right b
21−typeConstructorDefP :: Parser TypeConstructorDef
22−typeConstructorDefP = ADTypeConstructorDef <$> typeConstructorNameP <*> typeVarNamesP
23−
24−typeVarNamesP :: Parser [TypeVarName]
25−typeVarNamesP = many uncapitalizedIdentifier
26−
27−-- data Either a b = *Left a* | *Right b*
28−dataConstructorDefP :: Parser DataConstructorDef
29−dataConstructorDefP = DataConstructorDef <$> typeConstructorNameP <*> many dataConstructorDefArgP
30−
31−-- data *Either a b* = Left *a* | Right *b*
32−dataConstructorDefArgP :: Parser DataConstructorDefArg
33−dataConstructorDefArgP = DataConstructorDefTypeConstructorArg <$> (monoTypeConstructorP <|> parens typeConstructorP) <|>
34− DataConstructorDefTypeVarNameArg <$> uncapitalizedIdentifier
35−
36−-- relation{a Int} in type construction (no tuples parsed)
37−relationTypeConstructorP :: Parser TypeConstructor
38−relationTypeConstructorP = do
39− reserved "relation"
40− RelationAtomTypeConstructor <$> makeAttributeExprsP
41−
42−--used in relation creation
43−makeAttributeExprsP :: RelationalMarkerExpr a => Parser [AttributeExprBase a]
44−makeAttributeExprsP = braces (sepBy attributeAndTypeNameP comma)
45−
46−attributeAndTypeNameP :: RelationalMarkerExpr a => Parser (AttributeExprBase a)
47−attributeAndTypeNameP = AttributeAndTypeNameExpr <$> identifier <*> typeConstructorP <*> parseMarkerP
48−
49−-- *Either Int Text*, *Int*
50−typeConstructorP :: Parser TypeConstructor
51−typeConstructorP = relationTypeConstructorP <|>
52− ADTypeConstructor <$> capitalizedIdentifier <*> many (monoTypeConstructorP <|> parens typeConstructorP) <|>
53− monoTypeConstructorP
54−
55−monoTypeConstructorP :: Parser TypeConstructor
56−monoTypeConstructorP = ADTypeConstructor <$> typeConstructorNameP <*> pure [] <|>
57− TypeVariable <$> uncapitalizedIdentifier
58−
59−
60−
61−
src/bin/TutorialD/Printer.hsdeleted−165
@@ -1,165 +0,0 @@
1−{-# OPTIONS_GHC -fno-warn-orphans #-}
2−{-# LANGUAGE FlexibleInstances #-}
3−{-# LANGUAGE OverloadedStrings #-}
4−{-# LANGUAGE ScopedTypeVariables #-}
5−{-# LANGUAGE TypeApplications #-}
6−module TutorialD.Printer where
7−import ProjectM36.Base
8−import ProjectM36.Attribute as A hiding (null)
9−import Data.Text.Prettyprint.Doc
10−import qualified Data.Set as S hiding (fromList)
11−import qualified Data.Vector as V
12−import qualified Data.Map.Strict as M
13−import Data.Time.Calendar
14−import Data.Time.Clock.POSIX
15−import qualified Data.ByteString.Base64 as B64
16−import qualified Data.Text.Encoding as TE
17−
18−instance Pretty Atom where
19− pretty (IntegerAtom x) = pretty x
20− pretty (IntAtom x) = "int" <> parensList [pretty x]
21− pretty (DoubleAtom x) = pretty x
22− pretty (TextAtom x) = dquotes (pretty x)
23− pretty (DayAtom x) = "fromGregorian" <> parensList [pretty a, pretty b, pretty c]
24− where
25− (a,b,c) = toGregorian x
26− pretty (DateTimeAtom time) = "dateTimeFromEpochSeconds" <> parensList [pretty @Integer (round (utcTimeToPOSIXSeconds time))]
27− pretty (ByteStringAtom bs) = "bytestring" <> parensList [dquotes (pretty (TE.decodeUtf8 (B64.encode bs)))]
28− pretty (BoolAtom x) = if x then "t" else "f"
29− pretty (RelationAtom x) = pretty x
30− pretty (RelationalExprAtom re) = pretty re
31− pretty (ConstructedAtom n _ as) = pretty n <+> prettyList as
32−
33−instance Pretty AtomExpr where
34− pretty (AttributeAtomExpr attrName) = pretty attrName
35− pretty (NakedAtomExpr atom) = pretty atom
36− pretty (FunctionAtomExpr atomFuncName' atomExprs _) = pretty atomFuncName' <> prettyAtomExprsAsArguments atomExprs
37− pretty (RelationAtomExpr relExpr) = pretty relExpr
38− pretty (ConstructedAtomExpr dName [] _) = pretty dName
39− pretty (ConstructedAtomExpr dName atomExprs _) = pretty dName <+> hsep (map prettyAtomExpr atomExprs)
40−
41−prettyAtomExpr :: AtomExpr -> Doc ann
42−prettyAtomExpr atomExpr =
43− case atomExpr of
44− AttributeAtomExpr attrName -> "@" <> pretty attrName
45− ConstructedAtomExpr dConsName [] () -> pretty dConsName
46− ConstructedAtomExpr dConsName atomExprs () -> parens (pretty dConsName <+> hsep (map prettyAtomExpr atomExprs))
47− _ -> pretty atomExpr
48−
49−prettyAtomExprsAsArguments :: [AtomExpr] -> Doc ann
50−prettyAtomExprsAsArguments = align . parensList . map addAt
51− where addAt (atomExpr :: AtomExpr) =
52− case atomExpr of
53− AttributeAtomExpr attrName -> "@" <> pretty attrName
54− _ -> pretty atomExpr
55−
56−instance Pretty TupleExpr where
57− pretty (TupleExpr map') = "tuple" <> bracesList (Prelude.map (\(attrName,atom)-> pretty attrName <+> pretty atom) (M.toList map'))
58−
59−instance Pretty RelationTuple where
60− pretty (RelationTuple attrs atoms) = "tuple" <> bracesList (zipWith (\x y-> pretty x <+> pretty y) (V.toList (attributeNames attrs)) (V.toList atoms))
61−
62−instance Pretty Relation where
63− pretty (Relation attrs tupSet) | attrs == mempty && null (asList tupSet) = "false"
64− pretty (Relation attrs tupSet) | attrs == mempty && asList tupSet == [RelationTuple mempty mempty] = "true"
65− pretty (Relation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)
66−
67−instance Pretty Attribute where
68− pretty (Attribute n aTy) = pretty n <+> pretty (show aTy) -- workaround
69−
70−instance Pretty RelationalExpr where
71− pretty (RelationVariable n _) = pretty n
72− pretty (ExistingRelation r) = pretty r
73− pretty (NotEquals a b) = pretty' a <+> "!=" <+> pretty' b
74− pretty (Equals a b) = pretty' a <+> "==" <+> pretty' b
75− pretty (Project ns r) = pretty' (ignoreProjects r) <> pretty ns
76− pretty (Extend ext r) = collectExtends r <> pretty ext <> "}"
77− pretty (MakeRelationFromExprs Nothing (TupleExprs () tupExprs)) = "relation" <> prettyBracesList tupExprs
78− pretty (MakeRelationFromExprs (Just attrExprs) (TupleExprs () tupExprs)) = "relation" <> prettyBracesList attrExprs <> prettyBracesList tupExprs
79− pretty (MakeStaticRelation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)
80− pretty (Union a b) = parens $ pretty' a <+> "union" <+> pretty' b
81− pretty (Join a b) = parens $ pretty' a <+> "join" <+> pretty' b
82− pretty (Rename n1 n2 relExpr) = parens $ pretty relExpr <+> "rename" <+> braces (pretty n1 <+> "as" <+> pretty n2)
83− pretty (Difference a b) = parens $ pretty' a <+> "minus" <+> pretty' b
84− pretty (Group attrNames attrName relExpr) = parens $ pretty relExpr <+> "group" <+> parens (pretty attrNames <+> "as" <+> pretty attrName)
85− pretty (Ungroup attrName relExpr) = parens $ pretty' relExpr <+> "ungroup" <+> pretty attrName
86− pretty (Restrict resPreExpr relExpr) = parens $ pretty' relExpr <+> "where" <+> pretty resPreExpr
87− pretty (With pairs a) = "with" <+> parensList (map (\(name,expr)-> pretty name <+> "as" <+> pretty expr) pairs) <+> pretty' a
88−
89−-- relvar:{a:=?}:{b:=?}:... in ADTs => relvar:{a:=?, b:=?, ...} in Doc ann
90−collectExtends :: RelationalExpr -> Doc ann
91−collectExtends (Extend ext r) = collectExtends r <> pretty ext <> ", "
92−collectExtends r = pretty r <> ":{"
93−
94−--relvar{a,b,c,...}{a,b,...}..{a} => relvar{a}
95−ignoreProjects :: RelationalExpr -> RelationalExpr
96−ignoreProjects (Project _ r) = ignoreProjects r
97−ignoreProjects r = r
98−
99−prettyRelationalExpr :: RelationalExpr -> Doc n
100−prettyRelationalExpr (RelationVariable n _) = pretty n
101−prettyRelationalExpr r = parens (pretty r)
102−
103−pretty' :: RelationalExpr -> Doc n
104−pretty' = prettyRelationalExpr
105−
106−instance Pretty AttributeNames where
107− pretty (AttributeNames attrNames) = prettyBracesList (S.toList attrNames)
108− pretty (InvertedAttributeNames attrNames) = braces $ "all but" <+> concatWith (surround ", ") (map pretty (S.toList attrNames))
109− pretty (RelationalExprAttributeNames relExpr) = braces $ "all from" <+> pretty relExpr
110− pretty (UnionAttributeNames aAttrNames bAttrNames) = braces ("union of" <+> pretty aAttrNames <+> pretty bAttrNames)
111− pretty (IntersectAttributeNames aAttrNames bAttrNames) = braces ("intersection of" <+> pretty aAttrNames <+> pretty bAttrNames)
112−
113−instance Pretty AttributeExpr where
114− pretty (NakedAttributeExpr attr) = pretty attr
115− pretty (AttributeAndTypeNameExpr name typeCons _) = pretty name <+> pretty typeCons
116−
117−instance Pretty TypeConstructor where
118− pretty (ADTypeConstructor tcName []) = pretty tcName
119− pretty (ADTypeConstructor tcName tConsArgs) = pretty tcName <+> hsep (map pretty tConsArgs)
120− pretty (PrimitiveTypeConstructor tcName atomType') = pretty tcName <+> pretty atomType'
121− pretty (RelationAtomTypeConstructor attrExprs) = "relation" <> prettyBracesList attrExprs
122− pretty (TypeVariable x) = pretty x
123−
124−instance Pretty AtomType where
125− pretty IntAtomType = "Int"
126− pretty IntegerAtomType = "Integer"
127− pretty DoubleAtomType = "Double"
128− pretty TextAtomType = "Text"
129− pretty DayAtomType = "Day"
130− pretty DateTimeAtomType = "DateTime"
131− pretty ByteStringAtomType = "ByteString"
132− pretty BoolAtomType = "Bool"
133− pretty (RelationAtomType attrs) = "relation " <+> prettyBracesList (A.toList attrs)
134− pretty (ConstructedAtomType tcName tvMap) = pretty tcName <+> hsep (map pretty (M.toList tvMap)) --order matters
135− pretty RelationalExprAtomType = "RelationalExpr"
136− pretty (TypeVariableType x) = pretty x
137−
138−instance Pretty ExtendTupleExpr where
139− pretty (AttributeExtendTupleExpr attrName atomExpr) = pretty attrName <> ":=" <> pretty atomExpr
140−
141−
142−instance Pretty RestrictionPredicateExpr where
143− pretty TruePredicate = "true"
144− pretty (AndPredicate a b) = pretty a <+> "and" <+> pretty b
145− pretty (OrPredicate a b) = pretty a <+> "or" <+> pretty b
146− pretty (NotPredicate a) = "not" <+> pretty a
147− pretty (RelationalExprPredicate relExpr) = pretty relExpr
148− pretty (AtomExprPredicate atomExpr) = pretty atomExpr
149− pretty (AttributeEqualityPredicate attrName atomExpr) = pretty attrName <> "=" <> pretty atomExpr
150−
151−instance Pretty WithNameExpr where
152− pretty (WithNameExpr name _) = pretty name
153−
154−bracesList :: [Doc ann] -> Doc ann
155−bracesList = group . encloseSep (flatAlt "{ " "{") (flatAlt " }" "}") ", "
156−
157−prettyBracesList :: Pretty a => [a] -> Doc ann
158−prettyBracesList = align . bracesList . map pretty
159−
160−parensList :: [Doc ann] -> Doc ann
161−parensList = group . encloseSep (flatAlt "( " "(") (flatAlt " )" ")") ", "
162−
163−prettyParensList :: Pretty a => [a] -> Doc ann
164−prettyParensList = align . parensList . map pretty
165−
src/bin/TutorialD/tutd.hsdeleted−110
@@ -1,110 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−import TutorialD.Interpreter
3−import ProjectM36.Base
4−import ProjectM36.Client
5−import ProjectM36.Server.ParseArgs
6−import ProjectM36.Server
7−import System.IO
8−import GHC.IO.Encoding
9−import Options.Applicative
10−import System.Exit
11−import Control.Monad
12−#if __GLASGOW_HASKELL__ < 804
13−import Data.Monoid
14−#endif
15−import Data.Maybe
16−import qualified Data.Text as T
17−
18−#if !defined(VERSION_project_m36)
19−# warning Failed to discover proper version from cabal_macros.h
20−# define VERSION_project_m36 "<unknown>"
21−#endif
22−
23−parseArgs :: Parser InterpreterConfig
24−parseArgs = LocalInterpreterConfig <$> parsePersistenceStrategy <*> parseHeadName <*> parseTutDExec <*> many parseGhcPkgPath <*> parseCheckFS <|>
25− RemoteInterpreterConfig <$> parseHostname "127.0.0.1" <*> parsePort defaultServerPort <*> parseDatabaseName <*> parseHeadName <*> parseTutDExec <*> parseCheckFS
26−
27−parseHeadName :: Parser HeadName
28−parseHeadName = option auto (long "head" <>
29− help "Start session at head name." <>
30− metavar "GRAPH HEAD NAME" <>
31− value "master"
32− )
33−
34−--just execute some tutd and exit
35−parseTutDExec :: Parser (Maybe TutorialDExec)
36−parseTutDExec = optional $ strOption (long "exec-tutd" <>
37− short 'e' <>
38− metavar "TUTORIALD" <>
39− help "Execute TutorialD expression and exit"
40− )
41−
42−opts :: ParserInfo InterpreterConfig
43−opts = info (parseArgs <**> helpOption) idm
44−
45−connectionInfoForConfig :: InterpreterConfig -> ConnectionInfo
46−connectionInfoForConfig (LocalInterpreterConfig pStrategy _ _ ghcPkgPaths _) = InProcessConnectionInfo pStrategy outputNotificationCallback ghcPkgPaths
47−connectionInfoForConfig (RemoteInterpreterConfig remoteHost remotePort remoteDBName _ _ _) = RemoteConnectionInfo remoteDBName remoteHost (show remotePort) outputNotificationCallback
48−
49−headNameForConfig :: InterpreterConfig -> HeadName
50−headNameForConfig (LocalInterpreterConfig _ headn _ _ _) = headn
51−headNameForConfig (RemoteInterpreterConfig _ _ _ headn _ _) = headn
52−
53−execTutDForConfig :: InterpreterConfig -> Maybe String
54−execTutDForConfig (LocalInterpreterConfig _ _ t _ _) = t
55−execTutDForConfig (RemoteInterpreterConfig _ _ _ _ t _) = t
56−
57−checkFSForConfig :: InterpreterConfig -> Bool
58−checkFSForConfig (LocalInterpreterConfig _ _ _ _ c) = c
59−checkFSForConfig (RemoteInterpreterConfig _ _ _ _ _ c) = c
60−
61−persistenceStrategyForConfig :: InterpreterConfig -> Maybe PersistenceStrategy
62−persistenceStrategyForConfig (LocalInterpreterConfig strat _ _ _ _) = Just strat
63−persistenceStrategyForConfig RemoteInterpreterConfig{} = Nothing
64−
65−errDie :: String -> IO ()
66−errDie err = hPutStrLn stderr err >> exitFailure
67−
68−#ifndef VERSION_project_m36
69−#error VERSION_project_m36 is not defined
70−#endif
71−printWelcome :: IO ()
72−printWelcome = do
73− putStrLn $ "Project:M36 TutorialD Interpreter " ++ VERSION_project_m36
74− putStrLn "Type \":help\" for more information."
75− putStrLn "A full tutorial is available at:"
76− putStrLn "https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown"
77−
78−-- | If the locale is set to ASCII, upgrade it to UTF-8 because tutd outputs UTF-8-encoded attributes. This is especially important in light docker images where the locale data may be missing.
79−setLocaleIfNecessary :: IO ()
80−setLocaleIfNecessary = do
81− l <- getLocaleEncoding
82− when (textEncodingName l == "ASCII") (setLocaleEncoding utf8)
83−
84−main :: IO ()
85−main = do
86− setLocaleIfNecessary
87− interpreterConfig <- execParser opts
88− let connInfo = connectionInfoForConfig interpreterConfig
89− fscheck <- checkFSType (checkFSForConfig interpreterConfig) (fromMaybe NoPersistence (persistenceStrategyForConfig interpreterConfig))
90− if not fscheck then
91− errDie checkFSErrorMsg
92− else do
93− dbconn <- connectProjectM36 connInfo
94− case dbconn of
95− Left err ->
96− errDie ("Failed to create database connection: " ++ show err)
97− Right conn -> do
98− let connHeadName = headNameForConfig interpreterConfig
99− eSessionId <- createSessionAtHead conn connHeadName
100− case eSessionId of
101− Left err -> errDie ("Failed to create database session at \"" ++ show connHeadName ++ "\": " ++ show err)
102− Right sessionId ->
103− case execTutDForConfig interpreterConfig of
104− Nothing -> do
105− printWelcome
106− _ <- reprLoop interpreterConfig sessionId conn
107− pure ()
108− Just tutdStr ->
109− runTutorialD sessionId conn Nothing (T.pack tutdStr)
110−
src/bin/benchmark/Basic.hsdeleted−106
@@ -1,106 +0,0 @@
1−import ProjectM36.Base
2−import Criterion.Main
3−import qualified ProjectM36.Attribute as A
4−import ProjectM36.Relation
5−import ProjectM36.Persist
6−import ProjectM36.RelationalExpression
7−import ProjectM36.Error
8−import ProjectM36.Transaction.Persist
9−import qualified Data.Text as T
10−import qualified Data.Vector as V
11−import Control.Monad.Trans.Reader
12−import qualified ProjectM36.DatabaseContext as DBC
13−import qualified Data.Set as S
14−import Data.Monoid
15−import System.IO.Temp
16−import System.FilePath
17−import System.Directory
18−
19−{-
20−* create a relation
21−* restrict a relation
22−* project a relation
23−* join two relations
24−-}
25−
26−validate :: Either RelationalError a -> a
27−validate (Left err) = error (show err)
28−validate (Right x) = x
29−
30−createRelation :: Int -> Int -> Either RelationalError Relation
31−createRelation attributeCount tupleCount = do
32− let attrs = A.attributesFromList $ map (\c-> Attribute (T.pack $ "a" ++ show c) IntAtomType) [0 .. attributeCount-1]
33− tuple tupleX = RelationTuple attrs (V.generate attributeCount (\_ -> IntAtom (fromIntegral tupleX)))
34− tuples = map tuple [0 .. tupleCount]
35− mkRelationDeferVerify attrs (RelationTupleSet tuples)
36−
37−createRelation' :: Int -> Int -> Relation
38−createRelation' x y = validate (createRelation x y)
39−
40−restrictRelationToOneTuple :: Int -> Relation -> Relation
41−restrictRelationToOneTuple match rel = validate (runReader (evalRelationalExpr restriction) exprState)
42− where
43− exprState = mkRelationalExprState DBC.empty
44− restriction = Restrict predicateMatch (ExistingRelation rel)
45− predicateMatch = AttributeEqualityPredicate "a0" (NakedAtomExpr (IntAtom match))
46−
47−restrictRelationToHalfRelation :: Int -> Relation -> Relation
48−restrictRelationToHalfRelation cutoff rel = validate (runReader (evalRelationalExpr restriction) exprState)
49− where
50− exprState = mkRelationalExprState DBC.basicDatabaseContext
51− restriction = Restrict predicateMatch (ExistingRelation rel)
52− predicateMatch = AtomExprPredicate (FunctionAtomExpr "lte" [AttributeAtomExpr "a0", NakedAtomExpr (IntAtom cutoff)] ())
53−
54−projectRelationToAttributes :: AttributeNames -> Relation -> Relation
55−projectRelationToAttributes attrNames rel = validate (runReader (evalRelationalExpr projection) exprState)
56− where
57− exprState = mkRelationalExprState DBC.empty
58− projection = Project attrNames (ExistingRelation rel)
59−
60−unionRelations :: Relation -> Relation -> Relation
61−unionRelations relA relB = validate (relA `union` relB)
62−
63−joinRelations :: Relation -> Relation -> Relation
64−joinRelations relA relB = validate (join relA relB)
65−
66−groupRelation :: AttributeNames -> Relation -> Relation
67−groupRelation attrNames rel = validate (runReader (evalRelationalExpr (Group attrNames "x" (ExistingRelation rel))) exprState)
68− where
69− exprState = mkRelationalExprState DBC.empty
70−
71−bigRelAttrNames :: Int -> Int -> AttributeNames
72−bigRelAttrNames start end = AttributeNames (S.fromList (map (\i -> "a" <> T.pack (show i)) [start .. end]))
73−
74−main :: IO ()
75−main = do
76− tmpDir <- getCanonicalTemporaryDirectory
77− createDirectoryIfMissing False (tmpDir </> "relvars")
78− defaultMain [createRel, restrictRel, projectRel, unionRel, joinRel, groupRel, writeRel tmpDir]
79− where
80− createRel = bgroup "create" $ map (\tupCount -> bench ("relation 10x" ++ show tupCount) (nf (createRelation' 10) tupCount)) [100, 1000, 10000]
81− bigrel10000 = createRelation' 10 10000
82− bigrel1000 = createRelation' 10 1000
83− bigrel100 = createRelation' 10 100
84−
85− restrictRel = bgroup "restrict" [restrictOneTupleRel, restrictHalfTuplesRel]
86− restrictOneTupleRel = bench "restrict relation 10x10000 to 10x1" (nf (restrictRelationToOneTuple 5000) bigrel10000)
87− restrictHalfTuplesRel = bench "restrict relation 10x10000 to 10x5000" (nf (restrictRelationToHalfRelation 5000) bigrel10000)
88−
89− projectRel = bgroup "project" [projectOneAttr, projectHalfAttrs]
90− projectOneAttr = bench "project 10x1000 to 1x1000" (nf (projectRelationToAttributes (bigRelAttrNames 0 0)) bigrel1000)
91− projectHalfAttrs = bench "project 10x1000 to 5x1000" (nf (projectRelationToAttributes (bigRelAttrNames 0 4)) bigrel1000)
92−
93− unionRel = bgroup "union" [unionIdenticalRelations1000, unionIdenticalRelations10000]
94− unionIdenticalRelations1000 = bench "union identical 10x1000" (nf (unionRelations bigrel1000) bigrel1000)
95− unionIdenticalRelations10000 = bench "union identical 10x10000" (nf (unionRelations bigrel10000) bigrel10000)
96−
97− joinRel = bgroup "join" [joinIdenticalRelations100]
98− joinIdenticalRelations100 = bench "join identical 10x100" (nf (joinRelations bigrel100) bigrel100)
99−
100− groupRel = bgroup "group" [group100]
101− group100 = bench "group 10x100" (nf (groupRelation (bigRelAttrNames 1 9)) bigrel100)
102−
103− writeRel tmpDir = bgroup "write" [writeRel10000 tmpDir]
104− writeRel10000 tmpDir = bench "write 10x1000" $ nfIO (writeRelVar FsyncDiskSync tmpDir ("x", bigrel10000))
105−
106−
src/bin/benchmark/Handles.hsdeleted−97

This diff is too big to show here.

src/bin/benchmark/Relation.hsdeleted−27

This diff is too big to show here.

src/lib/ProjectM36/Arbitrary.hsdeleted−127

This diff is too big to show here.

src/lib/ProjectM36/Atom.hsdeleted−46

This diff is too big to show here.

src/lib/ProjectM36/AtomFunction.hsdeleted−101

This diff is too big to show here.

src/lib/ProjectM36/AtomFunctionBody.hsdeleted−7

This diff is too big to show here.

src/lib/ProjectM36/AtomFunctionError.hsdeleted−17

This diff is too big to show here.

src/lib/ProjectM36/AtomFunctionUtils.hsdeleted−4

This diff is too big to show here.

src/lib/ProjectM36/AtomFunctions/Basic.hsdeleted−29

This diff is too big to show here.

src/lib/ProjectM36/AtomFunctions/Primitive.hsdeleted−99

This diff is too big to show here.

src/lib/ProjectM36/AtomType.hsdeleted−456

This diff is too big to show here.

src/lib/ProjectM36/Atomable.hsdeleted−286

This diff is too big to show here.

src/lib/ProjectM36/Attribute.hsdeleted−278

This diff is too big to show here.

src/lib/ProjectM36/AttributeExpr.hsdeleted−7

This diff is too big to show here.

src/lib/ProjectM36/AttributeNames.hsdeleted−11

This diff is too big to show here.

src/lib/ProjectM36/Base.hsdeleted−646

This diff is too big to show here.

src/lib/ProjectM36/Client.hsdeleted−1095

This diff is too big to show here.

src/lib/ProjectM36/Client/Simple.hsdeleted−129

This diff is too big to show here.

src/lib/ProjectM36/DataFrame.hsdeleted−183

This diff is too big to show here.

src/lib/ProjectM36/DataTypes/Basic.hsdeleted−19

This diff is too big to show here.

src/lib/ProjectM36/DataTypes/ByteString.hsdeleted−18

This diff is too big to show here.

src/lib/ProjectM36/DataTypes/DateTime.hsdeleted−14

This diff is too big to show here.

src/lib/ProjectM36/DataTypes/Day.hsdeleted−17

This diff is too big to show here.

src/lib/ProjectM36/DataTypes/Interval.hsdeleted−146

This diff is too big to show here.

src/lib/ProjectM36/DataTypes/List.hsdeleted−53

This diff is too big to show here.

src/lib/ProjectM36/DataTypes/Maybe.hsdeleted−38

This diff is too big to show here.

src/lib/ProjectM36/DataTypes/NonEmptyList.hsdeleted−53

This diff is too big to show here.

src/lib/ProjectM36/DataTypes/Primitive.hsdeleted−45

This diff is too big to show here.

src/lib/ProjectM36/DataTypes/Sorting.hsdeleted−31

This diff is too big to show here.

src/lib/ProjectM36/DatabaseContextFunction.hsdeleted−91

This diff is too big to show here.

src/lib/ProjectM36/DatabaseContextFunctionError.hsdeleted−8

This diff is too big to show here.

src/lib/ProjectM36/DatabaseContextFunctionUtils.hsdeleted−22

This diff is too big to show here.

src/lib/ProjectM36/DateExamples.hsdeleted−90

This diff is too big to show here.

src/lib/ProjectM36/DisconnectedTransaction.hsdeleted−17

This diff is too big to show here.

src/lib/ProjectM36/FSType.hsdeleted−102

This diff is too big to show here.

src/lib/ProjectM36/FileLock.hsdeleted−96

This diff is too big to show here.

src/lib/ProjectM36/FunctionalDependency.hsdeleted−20

This diff is too big to show here.

src/lib/ProjectM36/GraphRefRelationalExpr.hsdeleted−45

This diff is too big to show here.

src/lib/ProjectM36/InclusionDependency.hsdeleted−19

This diff is too big to show here.

src/lib/ProjectM36/IsomorphicSchema.hsdeleted−333

This diff is too big to show here.

src/lib/ProjectM36/Key.hsdeleted−69

This diff is too big to show here.

src/lib/ProjectM36/MerkleHash.hsdeleted−9

This diff is too big to show here.

src/lib/ProjectM36/MiscUtils.hsdeleted−15

This diff is too big to show here.

src/lib/ProjectM36/NormalizeExpr.hsdeleted−132

This diff is too big to show here.

src/lib/ProjectM36/Notifications.hsdeleted−22

This diff is too big to show here.

src/lib/ProjectM36/Relation/Parse/CSV.hsdeleted−165

This diff is too big to show here.

src/lib/ProjectM36/Relation/Show/CSV.hsdeleted−47

This diff is too big to show here.

src/lib/ProjectM36/Relation/Show/HTML.hsdeleted−63

This diff is too big to show here.

src/lib/ProjectM36/RelationalExpression.hsdeleted−1392

This diff is too big to show here.

src/lib/ProjectM36/ScriptSession.hsdeleted−275

This diff is too big to show here.

src/lib/ProjectM36/Serialise/AtomFunctionError.hsdeleted−7

This diff is too big to show here.

src/lib/ProjectM36/Serialise/Base.hsdeleted−85

This diff is too big to show here.

src/lib/ProjectM36/Serialise/DataFrame.hsdeleted−13

This diff is too big to show here.

src/lib/ProjectM36/Serialise/DatabaseContextFunctionError.hsdeleted−7

This diff is too big to show here.

src/lib/ProjectM36/Serialise/Error.hsdeleted−15

This diff is too big to show here.

src/lib/ProjectM36/Serialise/IsomorphicSchema.hsdeleted−7

This diff is too big to show here.

src/lib/ProjectM36/Serialise/MergeError.hsdeleted−1

This diff is too big to show here.

src/lib/ProjectM36/Server.hsdeleted−217

This diff is too big to show here.

src/lib/ProjectM36/Server/Config.hsdeleted−30

This diff is too big to show here.

src/lib/ProjectM36/Server/EntryPoints.hsdeleted−146

This diff is too big to show here.

src/lib/ProjectM36/Server/EntryPoints/Json.hsdeleted

No changes to the content.

src/lib/ProjectM36/Server/ParseArgs.hsdeleted−102

This diff is too big to show here.

src/lib/ProjectM36/Server/RemoteCallTypes.hsdeleted−103

This diff is too big to show here.

src/lib/ProjectM36/Session.hsdeleted−44

This diff is too big to show here.

src/lib/ProjectM36/Sessions.hsdeleted−49

This diff is too big to show here.

src/lib/ProjectM36/Shortcuts.hsdeleted−247

This diff is too big to show here.

src/lib/ProjectM36/StaticOptimizer.hsdeleted−578

This diff is too big to show here.

src/lib/ProjectM36/TransGraphRelationalExpression.hsdeleted−180

This diff is too big to show here.

src/lib/ProjectM36/Transaction.hsdeleted−54

This diff is too big to show here.

src/lib/ProjectM36/Transaction/Persist.hsdeleted−264

This diff is too big to show here.

src/lib/ProjectM36/Transaction/Type.hsdeleted−8

This diff is too big to show here.

src/lib/ProjectM36/TransactionDiffs.hsdeleted−12

This diff is too big to show here.

src/lib/ProjectM36/TransactionGraph.hsdeleted−635

This diff is too big to show here.

src/lib/ProjectM36/TransactionGraph/Persist.hsdeleted−228

This diff is too big to show here.

src/lib/ProjectM36/TransactionGraph/Types.hsdeleted−12

This diff is too big to show here.

src/lib/ProjectM36/TransactionInfo.hsdeleted−12

This diff is too big to show here.

src/lib/ProjectM36/Tupleable.hsdeleted−287

This diff is too big to show here.

src/lib/ProjectM36/Tupleable/Deriving.hsdeleted−229

This diff is too big to show here.

src/lib/ProjectM36/TypeConstructor.hsdeleted−17

This diff is too big to show here.

src/lib/ProjectM36/WCWidth.hsdeleted−425

This diff is too big to show here.

src/lib/ProjectM36/WithNameExpr.hsdeleted−86

This diff is too big to show here.

stack.ghc8.10.yamldeleted−19

This diff is too big to show here.

stack.ghc8.6.yamldeleted−62

This diff is too big to show here.

stack.ghc8.8.yaml → stack.yamlrenamed+9−30

This diff is too big to show here.

test/Client/Simple.hsdeleted−72

This diff is too big to show here.

test/DataFrame.hsdeleted−61

This diff is too big to show here.

test/IsomorphicSchema.hsdeleted−138

This diff is too big to show here.

test/MultiProcessDatabaseAccess.hsdeleted−45

This diff is too big to show here.

test/Relation/Atomable.hsdeleted−209

This diff is too big to show here.

test/Relation/Basic.hs+15−39

This diff is too big to show here.

test/Relation/Export/CSV.hs+22−87

This diff is too big to show here.

test/Relation/Import/CSV.hs+9−9

This diff is too big to show here.

test/Relation/StaticOptimizer.hs+20−157

This diff is too big to show here.

test/Relation/Tupleable.hsdeleted−380

This diff is too big to show here.

test/Server/Main.hs+66−149

This diff is too big to show here.

test/Server/WebSocket.hs+22−42

This diff is too big to show here.

test/TransactionGraph/Automerge.hsdeleted−94

This diff is too big to show here.

test/TransactionGraph/Merge.hs+57−136

This diff is too big to show here.

test/TransactionGraph/Persist.hs+16−123

This diff is too big to show here.

test/TutorialD/Interpreter.hsnew file+328

This diff is too big to show here.

test/TutorialD/Interpreter/AtomFunctionScript.hsdeleted−122

This diff is too big to show here.

test/TutorialD/Interpreter/DatabaseContextFunctionScript.hsdeleted−65

This diff is too big to show here.

test/TutorialD/Interpreter/Import/ImportTest.hsdeleted−47

This diff is too big to show here.

test/TutorialD/Interpreter/Import/TutorialD.hsnew file+22

This diff is too big to show here.

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

This diff is too big to show here.

test/TutorialD/Interpreter/TestBase.hsdeleted−57

This diff is too big to show here.

test/TutorialD/InterpreterTest.hsdeleted−732

This diff is too big to show here.

test/TutorialD/PrinterTest.hsdeleted−47

This diff is too big to show here.

test/persistent-driver/test.hsnew file+175

This diff is too big to show here.

test/scripts.hs+2−5

This diff is too big to show here.