Search icon CANCEL
Subscription
0
Cart icon
Your Cart (0 item)
Close icon
You have no products in your basket yet
Arrow left icon
Explore Products
Best Sellers
New Releases
Books
Videos
Audiobooks
Learning Hub
Free Learning
Arrow right icon
Arrow up icon
GO TO TOP
Learning Cypher

You're reading from   Learning Cypher Write powerful and efficient queries for Neo4j with Cypher, its official query language

Arrow left icon
Product type Paperback
Published in May 2014
Publisher
ISBN-13 9781783287758
Length 162 pages
Edition Edition
Arrow right icon
Author (1):
Arrow left icon
Onofrio Panzarino Onofrio Panzarino
Author Profile Icon Onofrio Panzarino
Onofrio Panzarino
Arrow right icon
View More author details
Toc

Index

A

  • aggregation
    • with COUNT function / Counting matching rows or non-null values
    • with RETURN clause / Counting matching rows or non-null values
    • with SUM function / Summation
    • with AVG function / Average
    • with MAX function / Maximum and minimum
    • with MIN function / Maximum and minimum
    • with standard deviation / Standard deviation
    • with START keyword / Collecting values in an array
    • with RETURN function / Grouping keys
    • with conditional expressions / Conditional expressions
  • aggregation functions
    • about / Aggregation functions
    • COUNT function / COUNT
    • SUM function / SUM
    • AVG function / AVG
    • PERCENTILEDISC function / PERCENTILEDISC and PERCENTILECONT
    • PERCENTILECONT function / PERCENTILEDISC and PERCENTILECONT
    • STDEVP function / STDEV and STDEVP
    • STDEV function / STDEV and STDEVP
    • MIN function / MIN and MAX
    • MAX function / MIN and MAX
  • ALLSHORTESTPATHS function
    • about / SHORTESTPATH and ALLSHORTESTPATHS
  • Apache Derby / Migrating the schema
  • AVG function
    • used, for average / Average
    • about / AVG

B

  • best practices/recommendations
    • parameterized queries, using / Using parameterized queries
    • parameterized queries, with REST API / Parameterized queries with the REST API
    • ExecutionEngine, reusing / Reusing ExecutionEngine
    • optimum transaction size, searching / Finding the optimum transaction size
    • unnecessary clauses, avoiding / Avoiding unnecessary clauses
    • direction of relationships, specifying / Specifying the direction of relationships and variable length paths
    • variable length paths, specifying / Specifying the direction of relationships and variable length paths
  • bibliography store example
    • about / Our example
    • Reference entities / Our example
    • Publisher entities / Our example
    • Author entities / Our example
    • E-R diagram / Our example
  • book store example
    • labels / The book store – an example
    • relationships / The book store – an example
    • properties / The book store – an example
  • Boolean operators
    • used, for filtering numeric value / Boolean operators
    • OR / Boolean operators
    • AND / Boolean operators
    • XOR / Boolean operators
    • NOT / Boolean operators

C

  • CASE WHEN expression
    • used, for expressing conditions / Conditional expressions
  • COALESCE function
    • used, for sorting null values / Dealing with null values using the COALESCE function
    • about / COALESCE
    • TIMESTAMP function / TIMESTAMP
    • ID function / ID
  • collection predicates
    • ANY / Working with collections
    • ALL / Working with collections
    • NONE / Working with collections
    • SINGLE / Working with collections
    • used, for filtering collections / Working with collections
  • collections
    • filtering / Working with collections
    • filtering, collection predicates used / Working with collections
    • working with / Working with collections
    • HEAD function / HEAD, TAIL, and LAST
    • TAIL function / HEAD, TAIL, and LAST
    • LAST function / HEAD, TAIL, and LAST
    • LENGTH function / LENGTH
    • EXTRACT function / EXTRACT
    • FILTER function / FILTER
    • REDUCE function / REDUCE
    • RANGE function / RANGE
  • comma-separated values (CSV) / Performance issues
  • comparison operator
    • used, for filtering numeric value / Value comparisons
  • comparison operators
    • about / Comparison operators
    • ordering operators / Ordering operators
    • equality operators / Equality operators
    • NULL equality operators / NULL equality operators
  • concatenation operator
    • about / The concatenation operator
  • conditional expressions
    • with CASE WHEN expression / Conditional expressions
  • configuration, embedded Neo4j database / Configuration
  • constraint
    • about / Constraints
    • creating / Constraints
    • defining / Indexes and constraints
  • COUNT function
    • used, for counting matching rows/non-null values / Counting matching rows or non-null values
    • arguments / Counting matching rows or non-null values
    • about / COUNT
  • CREATE clause
    • used, for creating nodes / Creating nodes and relationships
  • CREATE UNIQUE command
    • used, for creating unique patterns / Creating unique patterns
    • differentiating, with OPTIONAL MATCH command / Creating unique patterns
  • Cypher
    • performance issues / Performance issues
    • best practices/recommendations / Best practices and recommendations
    • operators / Operators
    • functions / Functions

D

  • data
    • deleting, with REMOVE clause / Deleting data
    • deleting, with DELETE clause / Deleting data
    • migrating / Migrating the data
    • entities, migrating / Entities
    • relationships, migrating / Relationships
  • database
    • clearing, with DELETE clause / Clearing the whole database
  • Data Description Language (DDL)
    • about / Migrating the schema
  • DELETE clause
    • used, for deleting nodes / Deleting nodes and relations
    • used, for deleting relationship / Deleting nodes and relations
    • used, for clearing whole database / Clearing the whole database
  • DESC clause
    • used, for descending sort / A descending sort
  • direction of relationships
    • specifying / Specifying the direction of relationships and variable length paths
  • DISTINCT clause
    • avoiding / Avoiding unnecessary clauses

E

  • E-R diagram
    • of bibliography store example / Our example
  • E-R diagram, features
    • entities / Our example
    • attributes / Our example
    • relations / Our example
  • embedded Neo4j database
    • about / An embedded database
    • development environment, preparing / Preparing the development environment
    • creating / Creating an embedded database
    • configuring / Configuration
  • ENDNODE function
    • about / ENDNODE and STARTNODE
  • entities
    • migrating / Entities
  • equality operators
    • about / Equality operators
  • ExecutionEngine
    • reusing / Reusing ExecutionEngine
  • existing data
    • modifying, with OPTIONAL MATCH clause / Modifying existing data
    • unique patterns, creating / Creating unique patterns
    • complex patterns, creating / Complex patterns
    • properties, setting / Setting properties and labels
    • labels, setting / Setting properties and labels
    • matched patterns, merging / Merging matched patterns
  • EXTRACT function
    • about / EXTRACT

F

  • FILTER function
    • about / FILTER
  • filtering
    • about / Filtering
    • book store example / The book store – an example
    • text value, WHERE clause used / Text search
    • numeric value, comparison operator used / Value comparisons
    • collections / Working with collections
  • FOREACH clause
    • used, with collections / Working with collections
  • functions
    • COALESCE function / COALESCE
    • used, for working with nodes / Working with nodes
    • used, for working with paths/relationships / Working with paths and relationships
    • used, for working with collections / Working with collections
    • used, for working with strings / Working with strings
    • aggregation functions / Aggregation functions
    • mathematical functions / Mathematical functions

H

  • HEAD function
    • about / HEAD, TAIL, and LAST
  • HR management tool
    • about / HR management tool – an example
    • nodes, creating with Java API / Creating nodes and relationships using the Java API
    • relationships, creating with Java API / Creating nodes and relationships using the Java API
    • database, querying / A querying database
    • Cypher, invoking from Java / Invoking Cypher from Java
    • nodes, finding by relationships / Finding nodes by relationships
    • filtering, on properties / Filtering properties
    • filtering, on relationships / Filtering relationships
    • missing information, dealing with / Dealing with missing parts
    • paths, woking with / Working with paths
    • node IDs, assigning as starting points / Node IDs as starting points
    • query parameters, providing / Query parameters
    • query parameters, passing with Java API / Passing parameters with Java

I

  • idempotent queries
    • creating / Idempotent queries
  • ID function
    • about / ID
  • index
    • about / Indexes and constraints
    • creating / Indexes and constraints
    • deleting / Indexes and constraints
    • creating, with SCAN keyword / SCAN hints
    • creating, with INDEX clause / Index hints
    • defining / Indexes and constraints
  • INDEX clause
    • used, for creating index / Index hints
  • IN operator
    • about / The IN operator
  • IN predicate
    • used, for filtering numeric value / The IN predicate

J

  • Java API
    • used, for creating nodes of HR management tool / Creating nodes and relationships using the Java API
    • used, for creating relationships of HR management tool / Creating nodes and relationships using the Java API
    • used, for profiling queries / Profiling using the Java API
  • Java Development Kit (JDK) / Finding the optimum transaction size
  • Java Virtual Machines (JVM) / Finding the optimum transaction size
  • jvmtop
    • URL / Finding the optimum transaction size

L

  • label index
    • about / Indexes and constraints
  • labels
    • adding, to nodes / Labels and properties
    • setting, for existing data / Setting properties and labels
    • adding, to node with SET clause / Adding labels to nodes
    • creating / Labels
  • LABELS function
    • about / LABELS
  • LAST function
    • about / HEAD, TAIL, and LAST
  • LEFT(source, length) function / SUBSTRING, LEFT, and RIGHT
  • LENGTH function
    • about / LENGTH
  • LIMIT keyword
    • used, for paging / Paging results – LIMIT and SKIP
  • loops
    • about / Loops
    • collections, working with / Working with collections
  • LOWER function
    • about / LOWER and UPPER
  • LTRIM function
    • about / Trimming functions

M

  • m2eclipse
    • about / Preparing the development environment
  • mathematical functions
    • about / Mathematical functions
  • mathematical operators
    • about / Mathematical operators
  • Maven
    • about / Preparing the development environment
  • MAX function
    • using / Maximum and minimum
    • about / MIN and MAX
  • MERGE clause
    • used, for merging matched patterns / Merging matched patterns
    • and SET clause, used for creating idempotent queries / Idempotent queries
  • MIN function
    • using / Maximum and minimum
    • about / MIN and MAX
  • multiple labels
    • adding, to nodes / Multiple labels
  • multiple patterns
    • creating, for nodes / Creating multiple patterns

N

  • Neo4j
    • about / Setting up a new Neo4j database
    • executing / Neo4j running modes
    • URL, for downloading / Using Neo4j Browser
  • Neo4j Browser
    • about / Using Neo4j Browser
    • using / Using Neo4j Browser
  • Neo4j database
    • creating / Setting up a new Neo4j database
    • Neo4j, executing / Neo4j running modes
    • Neo4j Server / Neo4j Server
    • embedded database / An embedded database
  • Neo4j Server
    • about / Neo4j Server
    • URL, for downloading / Neo4j Server
  • Neo4j Shell
    • used, for profiling queries / Profiling with Neo4j Shell
    • URL, for downloading / Profiling with Neo4j Shell
  • NetBeans 7.4
    • about / Preparing the development environment
  • nodes
    • about / Setting up a new Neo4j database
    • creating, with CREATE clause / Creating nodes and relationships
    • labels, adding / Labels and properties
    • properties, adding / Labels and properties
    • multiple labels, adding / Multiple labels
    • properties, creating / Properties
    • multiple patterns, creating / Creating multiple patterns
    • relationships, creating between / Creating relationships between existing nodes using read-and-write queries
    • NODES function / NODES
    • LABELS function / LABELS
  • NODES function
    • about / NODES
  • NULL equality operators
    • about / NULL equality operators
  • null values
    • sorting, COALESCE function used / Dealing with null values using the COALESCE function
  • numeric value
    • filtering, comparison operator used / Value comparisons
    • filtering, IN predicate used / The IN predicate
    • filtering, Boolean operators used / Boolean operators

O

  • operators
    • about / Operators
    • comparison operators / Comparison operators
    • mathematical operators / Mathematical operators
    • concatenation operator / The concatenation operator
    • IN operator / The IN operator
    • regular expressions / Regular expressions
  • optimum transaction size
    • searching / Finding the optimum transaction size
  • OPTIONAL MATCH clause
    • using / Dealing with null values using the COALESCE function
    • used, for modifying existing data / Modifying existing data
    • differentiating, with CREATE UNIQUE command / Creating unique patterns
  • ORDER BY clause
    • used, for sorting / Sorting
    • avoiding / Avoiding unnecessary clauses
  • ordering operators
    • about / Ordering operators

P

  • paging
    • with LIMIT keyword / Paging results – LIMIT and SKIP
    • with SKIP keyword / Paging results – LIMIT and SKIP
  • parameterized queries
    • using / Using parameterized queries
    • with REST API / Parameterized queries with the REST API
  • paths/relationships
    • TYPE function / TYPE
    • STARTNODE function / ENDNODE and STARTNODE
    • ENDNODE function / ENDNODE and STARTNODE
    • SHORTESTPATH function / SHORTESTPATH and ALLSHORTESTPATHS
    • ALLSHORTESTPATHS function / SHORTESTPATH and ALLSHORTESTPATHS
    • RELATIONSHIPS function / RELATIONSHIPS
  • percentile
    • reference link / PERCENTILEDISC and PERCENTILECONT
  • PERCENTILECONT function
    • about / PERCENTILEDISC and PERCENTILECONT
  • PERCENTILEDISC function
    • about / PERCENTILEDISC and PERCENTILECONT
  • performance issues, Cypher
    • about / Performance issues
  • phases, Cypher query
    • Read / Loops
    • Write / Loops
    • Return / Loops
  • properties
    • adding, to nodes / Labels and properties, Properties
    • setting, for existing data / Setting properties and labels
    • setting, with SET clause to nodes / Cloning a node

Q

  • queries
    • profiling / Profiling queries
    • profiling, Java API used / Profiling using the Java API
    • profiling, inside execution plan description / Inside the execution plan description
    • profiling, Neo4j Shell used / Profiling with Neo4j Shell
    • profiling, REST API used / Profiling with the REST API
    • migrating / Migrating queries
    • CRUD queries, migrating / CRUD
    • searching / Searching queries
    • grouping / Grouping queries
  • query
    • separating, WITH keyword used / Separating query parts using WITH

R

  • RANGE function
    • about / RANGE
  • Read phase
    • about / Loops
  • REDUCE function
    • about / REDUCE
  • regular expression patterns
    • using / Working with regular expressions, Escaping the text
  • regular expressions
    • used, for filtering text value / Working with regular expressions
    • reference links / Working with regular expressions
    • about / Regular expressions
  • relationships
    • about / Setting up a new Neo4j database
    • creating / Creating nodes and relationships, Creating relationships
    • full path, creating / Creating full paths
    • creating, between existing nodes / Creating relationships between existing nodes using read-and-write queries
    • defining / Relationships
    • migrating / Relationships
  • RELATIONSHIPS function
    • about / RELATIONSHIPS
  • REMOVE clause
    • used, for removing labels / Removing labels
    • used, for removing properties / Removing properties
  • REPLACE function
    • about / REPLACE
  • REST API / Using Neo4j Browser
    • parameterized queries, used with / Parameterized queries with the REST API
    • used, for profiling queries / Profiling with the REST API
  • RETURN function
    • used, for grouping keys / Grouping keys
  • Return phase
    • about / Loops
  • RIGHT(source, length) function / SUBSTRING, LEFT, and RIGHT
  • RTRIM function
    • about / Trimming functions

S

  • SCAN keyword
    • used, for creating index / SCAN hints
  • schema
    • about / Migrating the schema
    • migrating / Migrating the schema
    • labels / Labels
    • index / Indexes and constraints
    • constraint / Indexes and constraints
    • relationships / Relationships
  • SET clause
    • using / Setting properties and labels
    • used, for setting properties to nodes / Cloning a node
    • used, for adding labels to nodes / Adding labels to nodes
  • SHORTESTPATH function
    • about / SHORTESTPATH and ALLSHORTESTPATHS
  • SKIP keyword
    • used, for paging / Paging results – LIMIT and SKIP
  • sorting
    • ORDER BY clause used / Sorting
    • descending sort, with DESC clause / A descending sort
    • null values, COALESCE function used / Dealing with null values using the COALESCE function
  • SQL database
    • bibliography store example / Our example
  • standard deviation
    • using / Standard deviation
  • START keyword
    • used, for collecting values in array / Collecting values in an array
  • STARTNODE function
    • about / ENDNODE and STARTNODE
  • STDEV function
    • about / STDEV and STDEVP
  • STDEVP function
    • about / STDEV and STDEVP
  • STR function
    • about / STR
  • strings
    • SUBSTRING function / SUBSTRING, LEFT, and RIGHT
    • LEFTfunction / SUBSTRING, LEFT, and RIGHT
    • RIGHT function / SUBSTRING, LEFT, and RIGHT
    • STR function / STR
    • REPLACE function / REPLACE
    • trimming functions / Trimming functions
    • LOWER function / LOWER and UPPER
    • UPPER function / LOWER and UPPER
  • SUBSTRING(source, index, length) function / SUBSTRING, LEFT, and RIGHT
  • SUM function
    • used, for summation / Summation
    • about / SUM

T

  • TAIL function
    • about / HEAD, TAIL, and LAST
  • text value
    • filtering, WHERE clause used / Text search
    • filtering, regular expressions used / Working with regular expressions
    • escaping / Escaping the text
  • TIMESTAMP function
    • about / TIMESTAMP
  • TRIM function
    • about / Trimming functions
  • trimming functions
    • LTRIM function / Trimming functions
    • RTRIM function / Trimming functions
    • TRIM function / Trimming functions
  • TYPE function
    • about / TYPE

U

  • UNION ALL statement
    • about / The UNION statement
    • versus UNION statement / The UNION statement
  • UNION statement
    • using / The UNION statement
    • versus UNION ALL statement / The UNION statement
  • UPPER function
    • about / LOWER and UPPER

V

  • variable length paths
    • specifying / Specifying the direction of relationships and variable length paths

W

  • WHERE clause
    • used, for filtering text value / Text search
  • WITH keyword
    • used, for separating query / Separating query parts using WITH
  • Write phase
    • about / Loops
lock icon The rest of the chapter is locked
arrow left Previous Section
Register for a free Packt account to unlock a world of extra content!
A free Packt account unlocks extra newsletters, articles, discounted offers, and much more. Start advancing your knowledge today.
Unlock this book and the full library FREE for 7 days
Get unlimited access to 7000+ expert-authored eBooks and videos courses covering every tech area you can think of
Renews at €18.99/month. Cancel anytime
Banner background image