* Explode the From GADT. Move runFrom into the ToFrom typeclass removing the need for the intermediate structure. Extract the parts of the Experimental module into submodules.
* Reorganize Experimental folder. Move Subquery into core Experimental.From module.
* Cleanup hackage documentation. Make sure stylish ran correctly. Update changelog and bump version
* Update ERaw to change the direction of NeedParens (parent now tells child context). Removed need for composite key constructor
* Get rid of AliasedValue and ValueReference; added sqlExprMetaAlias to SqlExprMeta
* Remove EList and EEmptyList; ERaw is now technically possible in each case since it is generalized to all
* Remove entity specific constructors from SqlExpr
* Remove EOrderBy, EDistinctOn; Change PreprocessedFrom a to just be an independent datatype
* Remove EOrderByRandom, calling distinctOnOrderBy with rand will choke the db but you shouldnt be using rand anyway. distinctOnOrderBy seems dangerous though
* Remove ESet
* Remove EInsert and EInsertFinal
* Make postgres tests pass
* Change aliased val to be legal value by waiting until expr materialization in select clause before adding AS <alias>
* Cleanup ToAliasRefernce; Add isReference meta to value reference even though that info isnt currently used anywhere
* Expose Experimental submodules
* Update changelog
* Create a FromRaw to replace FromSubquery and FromIdent in from clause. Modify Experimental to only use FromRaw.
* Convert all of experimental to use new From type instead of From type class. Make the data constructors second class, functions should be used. Introduce *Lateral functions, using the same type for lateral and non lateral queries was probably a mistake.
* Expose the new functions and fix the mysql test compilation error (type inference was wonky with `Union` replaced with `union_`
* Bump version and add more comments
* ValidOnClause was too restrictive, ToFrom is actually the correct amount of leniency. ValidOnClause would not catch use of on for a cross join but would prevent nested joins
* Unbreak lateral joins by introducing a completely different ValidOnClause constraint
* Fixe error introduced in merge with master
* Dont realias alias references
* Never realias an already aliased Entity or Value
* reindex value references to the latest 'source'
* Initial attempt at Lateral joins
* Fix lateral queries for Inner and Left joins. Remove for Full and Right as this is apparently illegal(who knew). Add TypeError on Full and Right joins. Update on clause to use a custom constraint instead of relying on ToFrom.
* Fix typo leading to erroneous ToFrom instance
* Implement non-recursive CTE's
* add withRecursive; cleanup whitespace
* Fix multiple recursive CTEs. Apparently the spec just wants RECURSIVE if any of the queries are recursive.
* Add test to verify that a CTE can reference a previously defined CTE
* Update with/Recursive to return an element of a from clause to allow for joins against CTEs
* Modify set operations to use a custom data type + typeclass + typefamily to allow direct use of SqlQuery a in set operation and to allow recursive cte's to unify syntax with SqlSetOperation. Added lowercase names for set operations. If we can migrate off the constructor names we may be able to simplify the implementation.
* Fixed haddock documentation issue from v3.3.4.0 and added documentation
for new features introduced by v3.4.0.0
* fixed comments that were changed while debugging haddock build
* Cleanup formatting in From per PR. Cleanup ValidOnClause, added documentation and reduced the number of instances
* Update src/Database/Esqueleto/Experimental.hs
Co-authored-by: charukiewicz <charukiewicz@protonmail.com>
Co-authored-by: Matt Parsons <parsonsmatt@gmail.com>
* It works?
* Add multiple return values back in
* Allow order by alias
* Support groupBy and count, Returning value from a fromQuery now will make it into an alias
* Eliminate Alias type, TODO: finish implementing all the functions on Value for the alias constructors
* Add entity support to subqueries
* Cleanup duplication; Cleanup warnings and finish implementing all the cases for aliased values and entities.
* Cleanup fromQuery and add comments
* Modify EValueReference to support aliased entity fields instead of having to use opaque ERaw in field access
* Implement SQL Set Operations
* Add test to show novel use of fromQuery
* Cleanup unsafe case statements
* Add type annotations to helper queries to satisfy the typechecker on older GHC
* New syntax for joins, using placeholder names with ' in them to avoid name conflict with existing join types.
New api properly enforces Maybe on outer joins and requires an on clause for all joins in their construction.
* Add some more test queries using the new syntax
* Add test to verify that delete works with the new syntax
* Add cross join and implicit cross join using comma examples to test code for new from syntax
* Comment out use of CrossJoin in common tests since postgres cant handle it with the current implementation of the CrossJoin kind
* Add typeclass machinery to support the use of the old Join data types used in the existing from clause
* Fix bug with CrossJoin and add on_ syntax sugar
* move new from syntax into Database.Esqueleto.Experimental
* Merge subqueries and unions with the new join syntax, they all seem to play nicely together
* Cleanup somehow copies of ToAlias ended up staying in Internal and a swp file made it in to the branch.
* Fix compilation errors
* Swith tuple to using a TypeOperator
* Make operator only 2 characters
* added up to 8-tuple instances for ToMaybe, ToAlias, and ToAliasReference
* Add compiler error tests for new syntax to support making better errors
* Use closed data families to allow for catching missing on statements in joins.
* Convert ToAliasReferenceT to be a closed type family matching the other classes in the Experimental module
* added Esqueleto.Experimental documentation: added introduction and several examples of old vs. new syntax
* added more usage examples to module introduction; added documentation to SqlSetOperation, From, on, from, and (:&)
* Update (^.) to only treat natural keys with more than one component as ECompositeKey. Fixes#176.
* Update article metadata test to ensure the correct response was being returned instead of just check if an exception was thrown
* Add article metadata to cleanDB before deleting all articles to fix foreign key constraint errors
* Bump version number and add changelog entry
* Fix issue with ToMaybeT for Values, Maybe was going in the wrong place compared to the rest of the library. Add test to prove that Left joining into a subquery that returns a maybe flattens the maybe properly to avoid needing to call joinV.
* Fix common test for postgres, needed to add dogCounts to the group by since postgres is strict on only agregates for non grouped columns; I really need to set up a local postgresql
* Revert ToFromT changes. Only accept functions that return a SqlExpr (Value Bool) in ToFromT
* escaped use of '@' in TypeApplications in documentation
* Add more specific type signature to `on`
per parsonsmatt review suggestion. Improves type inference significantly.
Co-Authored-By: Matt Parsons <parsonsmatt@gmail.com>
Co-authored-by: charukiewicz <c.charukiewicz@gmail.com>
Co-authored-by: Matt Parsons <parsonsmatt@gmail.com>
* Add failing test
* Refactor newIdentFor to not have an error case
* annotation for warning
* refactoring
* Expression parser
* holy shit it works
* Add a shitload of tests
* cross join
* Find a failing case
* Account for that one case
* works
* Composability test
* okay now it tests something
* Documentation updates
* Add since, changelog
* fix
* Update between so it works with SQL values
* Add support for composite keys in between clause
* Remove unused values from ERaw in construct
* Update unsafeSqlBinOp to handle composite keys and between to use >=., <=. and &&.
* Support composite keys in unsafeSqlBinOp correctly
* Updated changelog
* Update version number of between to 3.1.0
Actually, the old form of backticks works on my Haddock, but somehow
doesn't on Hackage's Haddock. This second form is still valid although
ugly, and works on my Haddock as well. From reading Haddock's
documentation and source code, I don't think there's a canonical way of
writing this markup.
* This seems to work but I don't have in-depth tests yet
* I seem to still have some oddity here and there which needs to be
nailed down
* This only implements the "full" CASE syntax, not the simplified, and
it makes ELSE mandatory, (its optional with CASE)
As Felipe points out in the PR comments, the implementation can be
simplified to "val . unValue" but the type signature on the function
still prevents anything non-sensical happening.
See: https://github.com/prowdsponsor/esqueleto/pull/69
Give a value, keyE lifts the Key for that value into the query expression.
keyE :: Esqueleto query expr backend =>
Value (Key entity) -> expr (Value (Key entity))
