====== Dgraph ======

===== References =====
  * [[https://dgraph.io|Dgraph docs]]

===== Terminology =====
Mutation - adding/removing data

Mutation formats
  * RDF (Resource Description Framework) 
  * JSON (JavaScript Object Notation)

Mutation paterns
  * blank UID reference <_:michael>
  * explicit UID reference

===== Schema =====
Infer schema
<code bash>
schema(pred: [name, age, friend, owns_pet]) {
  type
  index
}
</code>


Root level node selection
<code bash>
allofterms(name@en, "Peter Jackson")
anyofterms(name@en, "Peter Jackson")
alloftext(name@en, "the man runs")
</code>

===== Filters =====
<code bash>
@filter(has(genre)
@filter(ge(age, 27)) 
@filter(ge(age, 27) AND le(age, 45))
</code>

===== Queries =====
<code bash>
{
  michael_friends_and_pet(func: eq(name, "Michael")) {
    name
    age
    friend {
      name@.
    }
    owns_pet {
      name
    }
  }
}
</code>

Order ''orderasc'', ''orderdesc''. ''offset'' and selecting ''first'' entries
<code bash>
friend (orderasc: age) {}
friend (orderasc: name@., offset: 1, first: 2) {}
</code>

Root level filtering. People who have at least ''2'' friends and have ''20 < = age < 30''
<code bash>
lots_of_friends(func: ge(count(friend), 2)) @filter(ge(age,20) AND lt(age,30)) {}
</code>

Get nodes that have specific edge (root selector)
<code bash>
have_friends(func: has(friend)) {}
</code>

===== Misc =====
Alias
<code bash>
persons_name : name
number_of_friends : count(friend)
</code>

Query Variables (it is error to assign a variable and not use it)
<code bash>
  A as not_a_real_query(...) {
    B as some_edge @filter(...) { # can't use C or B in this filter
      C as ... { 
        # A, B and C here
      }
      # A, B and C here
    }
    # A, B and C can be used in any blocks here
  }
  # A, B and C can be used in any other query block
</code>

Value Variables (map from uid to value) can be used with ''max'', ''min'', ''avg'', ''sum'', ''math''
<code bash>
{
  q(func: allofterms(name@en, "Ang Lee")) {
    director.film {
      uid
      name@en
      num_actors as count(starring)
    }
    most_actors : max(val(num_actors))
  }
}
</code>

Expand all 
<code bash>
expand(_all_)  { expand(_all_)}
</code>
===== Directives =====

''@cascade'' directive removes any nodes that don’t have all matching edges in the query. (remove nodes that of which filters return no results)
<code bash>
michael_friends_with_pets(func: allofterms(name, "Michael")) @cascade {}
</code>

''@normalize'' returns only edges with alias and flattens result to remove nesting
<code bash>
michael_number_friends(func: allofterms(name, "Michael")) @normalize {}
</code> 

===== Example queries =====
<code bash>
{
  coactors(func:allofterms(name@en, "Jane Campion")) @cascade {
    JC_films as director.film {      # JC_films = all Jane Campion's films
      starting_movie: name@en
      starring {
        JC_actors as performance.actor {      # JC_actors = all actors in all JC films
          actor : name@en
          actor.film {
            performance.film @filter(not uid(JC_films)) {
              film_together : name@en
              starring {
                # find a coactor who has been in some JC film
                performance.actor @filter(uid(JC_actors)) {
                  coactor_name: name@en
                }
              }
            }
          }
        }
      }
    }
  }
}
</code>

Defining variables
<code bash>
{
  PJ as var(func:allofterms(name@en, "Peter Jackson")) @normalize @cascade {
    F as director.film
  }

  peterJ(func: uid(PJ)) @normalize @cascade {
    name : name@en
    actor.film {
      performance.film @filter(uid(F)) {
        film_name: name@en
      }
      performance.character {
        character: name@en
      }
    }
  }
}

</code>

<code bash>
{
  var(func: allofterms(name@en, "Taraji Henson")) {
    actor.film {
      F as performance.film {
        G as genre
      }
    }
  }

  Taraji_films_by_genre(func: uid(G)) {
    genre_name : name@en
    films : ~genre @filter(uid(F)) {
      film_name : name@en
    }
  }
}
</code>

<code bash>
{
 anotherQ(func: allofterms(name@en, "Taraji Henson")) {
    actor.film {
      performance.film {
        film_name: name@en
        genre {
          name@en
        }
      }
    }
  }
}
</code>

Returning single node with information instead of a graph
<code bash>
{
  ID as var(func: allofterms(name@en, "Steven Spielberg")) {
    director.film {
      num_actors as count(starring)
    }
    average as avg(val(num_actors))
  }
  
  avs(func: uid(ID)) @normalize {
    name : name@en
    average_actors: val(average)
    num_films: count(director.film)
  }
}
</code>
Using value variables for filtering and ordering
<code bash>
{
  ID as var(func: allofterms(name@en, "Steven")) {
    director.film {
      num_actors as count(starring)
    }
    average as avg(val(num_actors))
  }

  avs(func: uid(ID), orderdesc: val(average)) @filter(ge(val(average), 40)) @normalize {
    name : name@en
    average_actors : val(average)
    num_films : count(director.film)
  }
}
</code>

<code bash>
{
	var(func:allofterms(name@en, "Jean-Pierre Jeunet")) {
		name@en
		films as director.film {
			stars as count(starring)
			directors as count(~director.film)
			ratio as math(stars / directors)
		}
	}

	best_ratio(func: uid(films), orderdesc: val(ratio)){
		name@en
		stars_per_director : val(ratio)
		num_stars : val(stars)
	}
}
</code>

Get latest movies for each director and order by date
<code bash>
{ 
  # Get all directors
  var(func: has(director.film)) @cascade {
    director.film {
      date as initial_release_date
    }
    # Store maxDate as a variable
    maxDate as max(val(date))
    daysSince as math(since(maxDate)/(24*60*60))
  }

  # Order by maxDate
  me(func: uid(maxDate), orderdesc: val(maxDate), first: 10) {
    name@en
    days : val(daysSince)

    # For each director, sort by release date and get latest movie.
    director.film(orderdesc: initial_release_date, first: 1) {
      name@en
      initial_release_date
    }
  }
}
</code>

Group by
<code bash>
{
  var(func:allofterms(name@en, "Steven Spielberg")) {
    director.film @groupby(genre) {
      a as count(uid)
    }
  }

  byGenre(func: uid(a), orderdesc: val(a)) {
    name@en
    num_movies : val(a)
  }
}
</code>