index.xml

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Basics on A Tour of Dgraph</title>
    <link>https://dgraph.io/tour/dgraph-1.0.16/basic/</link>
    <description>Recent content in Basics on A Tour of Dgraph</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Mon, 17 Sep 2018 16:11:42 +1000</lastBuildDate><atom:link href="https://dgraph.io/tour/dgraph-1.0.16/basic/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Hello World</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/1/</link>
      <pubDate>Wed, 26 Apr 2017 22:36:18 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/1/</guid>
      <description>Note For the following queries to run, you should have loaded data in the introduction.
 Let’s have a look at a hello world query in GraphQL+-.
Every query has a name, and the result is labelled with the same name.
The search criteria func: ... matches nodes. Function eq does what you&amp;rsquo;d expect, matching nodes with a name equalling &amp;ldquo;Michael&amp;rdquo;. The result is the matched nodes and listed outgoing edges from those nodes.</description>
    </item>
    
    <item>
      <title>Graphs as results</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/2/</link>
      <pubDate>Wed, 26 Apr 2017 22:36:22 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/2/</guid>
      <description>The last query got us some data, but the result wasn’t very interesting, nor was it much to do with graphs.
In Dgraph and GraphQL+-, queries return graphs, not tables or lists of data.
A query is executed against a graph and the result is a subset of the queried graph, or some manipulation or calculation based on the queried graph.
Let’s improve the query to get Michael and his network of friends.</description>
    </item>
    
    <item>
      <title>Data types and Schema</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/3/</link>
      <pubDate>Wed, 26 Apr 2017 22:36:41 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/3/</guid>
      <description>It’s time to talk about data types and nodes
There was some magic in the last query because some of the queried edges returned a value (name and age), but some were edges to other nodes (friend and owns_pet) that themselves had further properties.
The truth is that there is a schema to tell us how to interpret an edge.
The visualization won’t be much use this time. Have a look at the JSON to find out about the schema of the example.</description>
    </item>
    
    <item>
      <title>Language Support</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/4/</link>
      <pubDate>Wed, 26 Apr 2017 22:36:45 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/4/</guid>
      <description>Dgraph supports string text and queries as UTF-8.
String valued predicates can be annotated with a language tag.
Amit&amp;rsquo;s name was stored in English &amp;quot;Amit&amp;quot;@en, Hindi &amp;quot;अमित&amp;quot;@hi and Bengali &amp;quot;অমিত&amp;quot;@bn. Michael&amp;rsquo;s was stored in English. Artyom&amp;rsquo;s was stored in English and Russian &amp;quot;Артём&amp;quot;@ru. Sang Hyun&amp;rsquo;s was stored in English and Korean &amp;quot;상현&amp;quot;@ko.
Queries can search over text in the tagged languages by specifying which language to search and which languages to return.</description>
    </item>
    
    <item>
      <title>Queries describe graphs</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/5/</link>
      <pubDate>Wed, 26 Apr 2017 22:36:45 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/5/</guid>
      <description>Dgraph query results are graphs. In fact, the result structure matches the query structure.
The braces edge_name { ... } in the query signify nested blocks where the edges inside the block are matched against nodes found by following the edge that begins the block. We continue nesting the query as we follow edges from node to node.
While not strictly required, it’s a good style to indent the query.</description>
    </item>
    
    <item>
      <title>Functions and filtering</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/6/</link>
      <pubDate>Wed, 26 Apr 2017 22:36:47 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/6/</guid>
      <description>Nodes are filtered based on functions applied to the node&amp;rsquo;s outgoing edges.
So far the queries have only applied a filter to the top level nodes, but filters can be applied to any node in the query.
Note the syntax difference between filtering at the root of a query and filtering on internal blocks.
There are many functions for filtering, some of them are
  allOfTerms(edge_name, &amp;quot;term1 ... termN&amp;quot;): matches nodes with an outgoing string edge edge_name where the string contains all listed terms.</description>
    </item>
    
    <item>
      <title>AND, OR and NOT</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/7/</link>
      <pubDate>Wed, 26 Apr 2017 22:36:51 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/7/</guid>
      <description>The logical connectives AND, OR and NOT combine multiple functions in a filter.</description>
    </item>
    
    <item>
      <title>Sorting (orderasc or orderdesc)</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/8/</link>
      <pubDate>Wed, 26 Apr 2017 23:11:34 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/8/</guid>
      <description>Results can be ordered using orderasc and orderdesc.
The visualization will look the same as without the sorting, but the JSON result is ordered.</description>
    </item>
    
    <item>
      <title>Pagination (first, offset and after)</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/9/</link>
      <pubDate>Wed, 26 Apr 2017 23:11:36 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/9/</guid>
      <description>It&amp;rsquo;s not uncommon to have thousands of results for a query.
But you might want to select only the top-k answers, paginate the results for display, or limit a large result.
In GraphQL+- this is done with first, offset and after in combination with ordering.
 first: N Return only the first N results offset: N Skip the first N results after: uid Return the results after uid  By default, query answers are ordered by uid.</description>
    </item>
    
    <item>
      <title>Count</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/10/</link>
      <pubDate>Wed, 26 Apr 2017 23:11:40 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/10/</guid>
      <description>The number of outgoing edges can be counted, using the count function.</description>
    </item>
    
    <item>
      <title>How Dgraph Search Works</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/11/</link>
      <pubDate>Mon, 01 May 2017 11:55:43 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/11/</guid>
      <description>Given what you&amp;rsquo;ve seen so far, you&amp;rsquo;ve probably already understood this, but it&amp;rsquo;s worth going over.
The graphs in Dgraph can be huge, so starting searching from all nodes isn&amp;rsquo;t efficient. Dgraph needs a place to start searching, that&amp;rsquo;s the root node.
At root, we use func: and a function to find an initial set of nodes. So far we&amp;rsquo;ve used eq and allofterms for string search, but we can also search on other values like dates, numbers, and also filters on count.</description>
    </item>
    
    <item>
      <title>Has</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/12/</link>
      <pubDate>Mon, 01 May 2017 11:55:43 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/12/</guid>
      <description>The function has(edge_name) returns nodes that have an outgoing edge of the given name.</description>
    </item>
    
    <item>
      <title>Alias</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/13/</link>
      <pubDate>Mon, 01 May 2017 11:55:43 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/13/</guid>
      <description>The output graph can set names for edges in the output with aliasing.</description>
    </item>
    
    <item>
      <title>Cascade</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/14/</link>
      <pubDate>Mon, 01 May 2017 11:55:46 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/14/</guid>
      <description>The @cascade directive removes any nodes that don&amp;rsquo;t have all matching edges in the query.
Another use is to remove nodes where a filter inside a block returns no results.
In the query below, Dgraph returns all Michael&amp;rsquo;s friends, and only the friends of friends who are over 27.
{ michael_friends(func: allofterms(name, &amp;quot;Michael&amp;quot;)) { name age friend { name@. friend @filter(ge(age, 27)) { name@. age } } } } With the @cascade directive, friends of Michael that don&amp;rsquo;t have friends who are over 27 are not included in the result.</description>
    </item>
    
    <item>
      <title>Normalize</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/15/</link>
      <pubDate>Mon, 01 May 2017 11:55:49 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/15/</guid>
      <description>The @normalize directive
  returns only edges listed with an alias, and
  flattens the result to remove nesting
  Tip Aliased names can be the same as the original edge.
 </description>
    </item>
    
    <item>
      <title>Comments</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/16/</link>
      <pubDate>Wed, 26 Apr 2017 23:11:42 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/16/</guid>
      <description>Queries can contain comments.
Anything after # on a line is a comment and ignored for query processing.
This is helpful for debugging queries and for tutorials that need to explain parts of queries in-line, which is what we&amp;rsquo;ll do for the more complex queries you&amp;rsquo;ll encounter later in the tutorial.</description>
    </item>
    
    <item>
      <title>Facets : Edge attributes</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/17/</link>
      <pubDate>Mon, 17 Sep 2018 16:11:42 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/17/</guid>
      <description>Dgraph supports facets — key value pairs on edges — as an extension to RDF triples. That is, facets add properties to edges, rather than to nodes. For example, a friend edge between two nodes may have a boolean property of close friendship. Facets can also be used as weights for edges.
More details about Facets you can find in our Docs: https://docs.dgraph.io/query-language/#facets-edge-attributes
Reading all the documentation about Facets you will have examples of:</description>
    </item>
    
    <item>
      <title>Congratulations</title>
      <link>https://dgraph.io/tour/dgraph-1.0.16/basic/18/</link>
      <pubDate>Wed, 26 Apr 2017 23:11:42 +1000</pubDate>
      
      <guid>https://dgraph.io/tour/dgraph-1.0.16/basic/18/</guid>
      <description>You’ve finished the lesson.
You can use the material in this lesson to query graphs, filter the output, and sort and paginate the results.
Check out the list of sections again, go back and review anything that wasn&amp;rsquo;t clear, or go on with the next lesson.</description>
    </item>
    
  </channel>
</rss>