grupo-abraxas / slothql Goto Github PK

Transformer typeclass, introduced as solution for issue #30 cannot apply/chain multiple transformations
due to diverging implicit expansion errors.

Support matching edges of any direction: --, -.

TODO: - syntax fragment breaks IDE compatibility.

Given two queries

q1 = MATCH $pattern1 RETURN $result1
q2 = MATCH $pattern2 RETURN $result2

The merged query should be

q1 ∪ q2 = MATCH $pattern1, $pattern2 RETURN $result1, $result2 

Introduce shorter syntax for common functions (over nodes/relations).

• labels
• type
• id
• count
• keys

• Create
• Delete (detach)
• Set / Remove
• Foreach

• Introduce an arrow for Scala's Function1 - Func1Arrow
  • override composition (add higher-priority Compose typeclass instance)
• Map ScalaExpr arrows to Func1Arrow
  • Id
  • SelectField
  • FMap
  • MBind
  • Split
  • SelectIn

While Split is a bundle of arrows with common source that represents a kind of product, similar coproduct representation Choose is needed.

When mapping a composed arrow with a Functor, the associativity property does not comply.

Functor.map(sel3 ∘ (sel2 ∘ sel1)).to[DBArrow] // Compiles
Functor.map((sel3 ∘ sel2) ∘ sel1).to[DBArrow] // Does not compile

The problem appears because the mapping is defined for a composition sel2 ∘ sel1, not for the underlying arrows.

Introduce graph traversal syntax for building dynamic queries.

Boilerplate reduction.

A schema should define model's representation as a sub-graph. Static = compile time.

Use pattern match if guard for constructing WHERE cypher clause.

Introduce syntax for paginating query results.

Use arrows from #38.

• High-level expressions: ScalaExpr
  • Id - identity arrow (self selection)
  • SelectField - expression representing selection of a field of an ADT (case class)
  • FMap - expression representing functor map operation
  • MBind - expression representing monadic bind / flatMap operation
  • SelectIn
    • select sequence index
    • select map key
    • (?) select Option / Either projection value
  • (?) expression for Either projections
  • (?) coproducts
  • execute expression

Static alias renamer (with fresh names generation) is required for merging queries.

Support matching directed edges without assigning aliases: ->, <-.

Typeclasses:

• AllAliases
• HasAlias
• RenameAlias (todo)
• ...

Introduce syntax for cypher lists:

• list constructor [ ..., ... ]
• in expression
• index selection
• index range selection
• + concatenation

Type functor should map arrows at type-level.

Dependent issues: #39, #43, #45.

Define Functors for mapping ScalaExpr arrows to GraphPath.

• Id ⇒ Initial
• SelectField depends on graph representation of selected field
  • Node ⇒ RelationTarget ∘ OutgoingRelation
  • Relation ⇒ OutgoingRelation
  • Property ⇒ PropSelection
• FMap ⇒ ?
• MBind ⇒ ?
• SelectIn ⇒ ?

• Arrow.Split ⇒ ?
• Arrow.Composition ⇒ ?

A problem with #30.

While transformations by different functions can be chained

object F1 extends Poly1{
    implicit def impl[A]: Case.Aux[Lit[A], Lit[A with X]] = at[Lit[A]](_.asInstanceOf[Lit[A with X]])
  }
object F2 extends Poly1{
    implicit def call[A, Func0 <: String, Params0 <: HList](
      implicit copy: Copy[Call.Aux[A, Func0, Params0], Witness.`'params`.Field[Lit[Float] :: Lit[Boolean] :: HNil] :: HNil]
    ): Case.Aux[Call.Aux[A, Func0, Params0], copy.Out] =
      at[Call.Aux[A, Func0, Params0]](copy(_, 'params ->> (Lit(1.2f) :: Lit(true) :: HNil) :: HNil))
  }

Transform(Transform(call, F2), F1)

A single polymorphic function, defining all the transformations, doesn't work because of diverging implicit expansion

object F3 extends Poly1 {
    implicit def call[A, Func0 <: String, Params0 <: HList](
      implicit copy: Copy[Call.Aux[A, Func0, Params0], Witness.`'params`.Field[Lit[Float] :: Lit[Boolean] :: HNil] :: HNil]
    ): Case.Aux[Call.Aux[A, Func0, Params0], copy.Out] =
      at[Call.Aux[A, Func0, Params0]](copy(_, 'params ->> (Lit(1.2f) :: Lit(true) :: HNil) :: HNil))
    implicit def lit[A]: Case.Aux[Lit[A], Lit[A with X]] = at[Lit[A]](_.asInstanceOf[Lit[A with X]])
  }

Transform(call, F3)
// diverging implicit expansion for type Transform[Call.Aux[String,String("foo"),shapeless.::[Lit[String],shapeless.::[Lit[String],shapeless.HNil]]],TestTransform.F3_2.type]
// starting with method noStringChildren in object TestTransform

Introduce syntax for ordering query results.

Introduce syntax for equality/inequality expressions:

• =
• <>
• <
• >
• <=
• >=
• IS NULL
• IS NOT NULL

• transform only outer CaseDef; right now the underlying CaseDefs are also modified
• most of the Expr are no longer needed

Support matching a single vertex.

Support matching relation length.

len ::= ∗ | ∗d | ∗d1.. | ∗..d2 | ∗d1..d2       where d,d1,d2 ∈ N

Introduce syntax for built-in functions calls.

In Scala 2.10, scala.reflect.ClassManifest are deprecated, and it is planned to deprecate scala.reflect.Manifest in favor of TypeTags and ClassTags in an upcoming point release. Thus, it is advisable to migrate any Manifest-based APIs to use Tags.

scala-lang

CypherFragments should include full type information about their sub-fragments.

This information is to be used for static query analysis and manipulation.

Given two queries

q1 = MATCH $pattern1 RETURN $result1
q2 = MATCH $pattern2 RETURN $result2

The merged query should be

q1 ∪ q2 = MATCH $pattern1, $pattern2 RETURN $result1, $result2 

The template is a string containing placeholders that are substituted with parameter values at runtime. While it is possible to run non-parameterized Cypher, good programming practice is to use parameters in Cypher statements. This allows for caching of statements within the Cypher engine, which is beneficial for performance.
(Neo4J developer manual)

Arrow composition must be associative:

(a ∘ b) ∘ c == a ∘ (b ∘ c)

Vertex and Edge extractors now require outer parentheses in the pattern. It should not.

Vars are used in generated code for

• setting pattern's GraphElem aliases
• defining query's where clause

Remove them if possible.

See also #27.

A polymorphic mapper is required for transforming Cypher trees at compile-time.

Functors should map high-level expressions to an intermediate level, not to cypher fragments directly.

This layer should describe the paths (arrows) within an abstract graph.
Those paths should then be mapped to cypher expressions.

This layer will also serve as a base for introducing gremlin-like syntax in the future.

• Initial vertex selection
• 'Move to' relation from node
  • Outgoing
  • Incoming
• 'Move to' node from relation
  • Source
  • Target
• Select property

TODO

Support returning errors in transaction monad.

Introduce syntax for boolean expressions:

• OR
• AND
• XOR
• NOT

TBD: I'm not really confident with Category Theory, so I'll fill the description after a couple of discussions.

• Arrows
  • Definition
  • Composition
    • syntax compose
    • syntax andThen
  • Unchaining - recursive decomposition
  • Pipes - arrows of tuples
    • Splitting - A ~> (B, C, D, E)
    • processing a single tuple element (A, B, C, D) ~> (A, E, C, D), similar to first/second
    • Joining - (A, B, C) ~> D
• Functor - map arrows
  • generic functor for composition arrow
  • generic functor for split arrow

Selector is an optic that preserves selection path at type-level.

A schema should define model's representation as a sub-graph. Dynamic = runtime.