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