Issue 1:
In the example below, the FILTER operation applied to paths does not return a correct result. Or am I getting it wrong?

Neo4j Version: 3.0.4

Operating System: Windows 10

API: Browser (Google Chrome) / Cypher

Steps to reproduce

Create the graph "SIL" with the Cypher script below. This represents a subset inclusion lattice with the basic sets a,b,c,d,e,f. The lattice has 63 nodes and 186 relationships (the empty set is omitted from the lattice)

Compute the complement of the :abcd sub-lattice with:

// All nodes and relationships in the lattice

MATCH n=(:abcdef)-->(l01)-->(l02)-->(l03)-->(l04)-->(l05)

// All nodes in the downset of :abcd

MATCH p=(:abcd)-->(l11)-->(l12)-->(l13)

// Get those nodes that are not in the downset of :abcd

RETURN FILTER (x IN nodes(n) WHERE NOT (x IN nodes(p)))

Expected behavior

Return all nodes and relationships that do not belong to the :abcd sub-lattice

Actual behavior

All nodes except the upper bound of the complete lattice (:abcdef) and their relationships are returned. The computation takes on the order of a minute on a Lenovo T400s.

Cypher statements to create "SIL"

// All n = 6 elements in one set

Create (abcdef:abcdef {headline:'a,b,c,d,e,f'})

// n-1 = 5 elements per set

Create (bcdef:bcdef {headline:'b,c,d,e,f'})

Create (acdef:acdef {headline:'a,c,d,e,f'})

Create (abdef:abdef {headline:'a,b,d,e,f'})

Create (abcef:abcef {headline:'a,b,c,e,f'})

Create (abcdf:abcdf {headline:'a,b,c,d,f'})

Create (abcde:abcde {headline:'a,b,c,d,e'})

// superset relationships level 6 - level 5

CREATE (abcdef) - [:superset] ->(bcdef)

CREATE (abcdef) - [:superset] ->(acdef)

CREATE (abcdef) - [:superset] ->(abdef)

CREATE (abcdef) - [:superset] ->(abcef)

CREATE (abcdef) - [:superset] ->(abcdf)

CREATE (abcdef) - [:superset] ->(abcde)

// n-2 = 4 elements per set

Create (cdef:cdef {headline:'c,d,e,f'})

Create (bdef:bdef {headline:'b,d,e,f'})

Create (bcef:bcef {headline:'b,c,e,f'})

Create (bcdf:bcdf {headline:'b,c,d,f'})

Create (bcde:bcde {headline:'b,c,d,e'})

Create (adef:adef {headline:'a,d,e,f'})

Create (acef:acef {headline:'a,c,e,f'})

Create (acdf:acdf {headline:'a,c,d,f'})

Create (acde:acde {headline:'a,c,d,e'})

Create (abef:abef {headline:'a,b,e,f'})

Create (abdf:abdf {headline:'a,b,d,f'})

Create (abde:abde {headline:'a,b,d,e'})

Create (abcf:abcf {headline:'a,b,c,f'})

Create (abce:abce {headline:'a,b,c,e'})

Create (abcd:abcd {headline:'a,b,c,d'})

// superset relationships level 5 to level 4

CREATE (bcdef) - [:superset] ->(cdef)

CREATE (bcdef) - [:superset] ->(bdef)

CREATE (bcdef) - [:superset] ->(bcef)

CREATE (bcdef) - [:superset] ->(bcdf)

CREATE (bcdef) - [:superset] ->(bcde)

CREATE (acdef) - [:superset] ->(cdef)

CREATE (acdef) - [:superset] ->(adef)

CREATE (acdef) - [:superset] ->(acef)

CREATE (acdef) - [:superset] ->(acdf)

CREATE (acdef) - [:superset] ->(acde)

CREATE (abdef) - [:superset] ->(bdef)

CREATE (abdef) - [:superset] ->(adef)

CREATE (abdef) - [:superset] ->(abef)

CREATE (abdef) - [:superset] ->(abdf)

CREATE (abdef) - [:superset] ->(abde)

CREATE (abcef) - [:superset] ->(bcef)

CREATE (abcef) - [:superset] ->(acef)

CREATE (abcef) - [:superset] ->(abef)

CREATE (abcef) - [:superset] ->(abcf)

CREATE (abcef) - [:superset] ->(abce)

CREATE (abcdf) - [:superset] ->(bcdf)

CREATE (abcdf) - [:superset] ->(acdf)

CREATE (abcdf) - [:superset] ->(abdf)

CREATE (abcdf) - [:superset] ->(abcf)

CREATE (abcdf) - [:superset] ->(abcd)

CREATE (abcde) - [:superset] ->(bcde)

CREATE (abcde) - [:superset] ->(acde)

CREATE (abcde) - [:superset] ->(abde)

CREATE (abcde) - [:superset] ->(abce)

CREATE (abcde) - [:superset] ->(abcd)

// n-3 = 3 elements per set

Create (def:def {headline:'d,e,f'})

Create (cef:cef {headline:'c,e,f'})

Create (cdf:cdf {headline:'c,d,f'})

Create (cde:cde {headline:'c,d,e'})

Create (bef:bef {headline:'b,e,f'})

Create (bdf:bdf {headline:'b,d,f'})

Create (bde:bde {headline:'b,d,e'})

Create (bcf:bcf {headline:'b,c,f'})

Create (bce:bce {headline:'b,c,e'})

Create (bcd:bcd {headline:'b,c,d'})

Create (aef:aef {headline:'a,e,f'})

Create (adf:adf {headline:'a,d,f'})

Create (ade:ade {headline:'a,d,e'})

Create (acf:acf {headline:'a,c,f'})

Create (ace:ace {headline:'a,c,e'})

Create (acd:acd {headline:'a,c,d'})

Create (abf:abf {headline:'a,b,f'})

Create (abe:abe {headline:'a,b,e'})

Create (abd:abd {headline:'a,b,d'})

Create (abc:abc {headline:'a,b,c'})

// superset relationships level 4 to level 3

Create (cdef) - [:superset] ->(def)

Create (cdef) - [:superset] ->(cef)

Create (cdef) - [:superset] ->(cdf)

Create (cdef) - [:superset] ->(cde)

Create (bdef) - [:superset] ->(def)

Create (bdef) - [:superset] ->(bef)

Create (bdef) - [:superset] ->(bdf)

Create (bdef) - [:superset] ->(bde)

Create (bcef) - [:superset] ->(cef)

Create (bcef) - [:superset] ->(bef)

Create (bcef) - [:superset] ->(bcf)

Create (bcef) - [:superset] ->(bce)

Create (bcdf) - [:superset] ->(cdf)

Create (bcdf) - [:superset] ->(bdf)

Create (bcdf) - [:superset] ->(bcf)

Create (bcdf) - [:superset] ->(bcd)

Create (bcde) - [:superset] ->(cde)

Create (bcde) - [:superset] ->(bde)

Create (bcde) - [:superset] ->(bce)

Create (bcde) - [:superset] ->(bcd)

Create (adef) - [:superset] ->(def)

Create (adef) - [:superset] ->(aef)

Create (adef) - [:superset] ->(adf)

Create (adef) - [:superset] ->(ade)

Create (acef) - [:superset] ->(cef)

Create (acef) - [:superset] ->(aef)

Create (acef) - [:superset] ->(acf)

Create (acef) - [:superset] ->(ace)

Create (acdf) - [:superset] ->(cdf)

Create (acdf) - [:superset] ->(adf)

Create (acdf) - [:superset] ->(acf)

Create (acdf) - [:superset] ->(acd)

Create (acde) - [:superset] ->(cde)

Create (acde) - [:superset] ->(ade)

Create (acde) - [:superset] ->(ace)

Create (acde) - [:superset] ->(acd)

Create (abef) - [:superset] ->(bef)

Create (abef) - [:superset] ->(aef)

Create (abef) - [:superset] ->(abf)

Create (abef) - [:superset] ->(abe)

Create (abdf) - [:superset] ->(bdf)

Create (abdf) - [:superset] ->(adf)

Create (abdf) - [:superset] ->(abf)

Create (abdf) - [:superset] ->(abd)

Create (abde) - [:superset] ->(bde)

Create (abde) - [:superset] ->(ade)

Create (abde) - [:superset] ->(abe)

Create (abde) - [:superset] ->(abd)

Create (abcf) - [:superset] ->(bcf)

Create (abcf) - [:superset] ->(acf)

Create (abcf) - [:superset] ->(abf)

Create (abcf) - [:superset] ->(abc)

Create (abce) - [:superset] ->(bce)

Create (abce) - [:superset] ->(ace)

Create (abce) - [:superset] ->(abe)

Create (abce) - [:superset] ->(abc)

Create (abcd) - [:superset] ->(bcd)

Create (abcd) - [:superset] ->(acd)

Create (abcd) - [:superset] ->(abd)

Create (abcd) - [:superset] ->(abc)

// n-4 = 2 elements per set

Create (ef:ef {headline:'e,f'})

Create (df:df {headline:'d,f'})

Create (de:de {headline:'d,e'})

Create (cf:cf {headline:'c,f'})

Create (ce:ce {headline:'c,e'})

Create (cd:cd {headline:'c,d'})

Create (bf:bf {headline:'b,f'})

Create (be:be {headline:'b,e'})

Create (bd:bd {headline:'b,d'})

Create (bc:bc {headline:'b,c'})

Create (af:af {headline:'a,f'})

Create (ae:ae {headline:'a,e'})

Create (ad:ad {headline:'a,d'})

Create (ac:ac {headline:'a,c'})

Create (ab:ab {headline:'a,b'})

// Superset relationships level 3 to level 2

Create (def) - [:superset] -> (ef)

Create (def) - [:superset] -> (df)

Create (def) - [:superset] -> (de)

Create (cef) - [:superset] -> (ef)

Create (cef) - [:superset] -> (cf)

Create (cef) - [:superset] -> (ce)

Create (cdf) - [:superset] -> (df)

Create (cdf) - [:superset] -> (cf)

Create (cdf) - [:superset] -> (cd)

Create (cde) - [:superset] -> (de)

Create (cde) - [:superset] -> (ce)

Create (cde) - [:superset] -> (cd)

Create (bef) - [:superset] -> (ef)

Create (bef) - [:superset] -> (bf)

Create (bef) - [:superset] -> (be)

Create (bdf) - [:superset] -> (df)

Create (bdf) - [:superset] -> (bf)

Create (bdf) - [:superset] -> (bd)

Create (bde) - [:superset] -> (de)

Create (bde) - [:superset] -> (be)

Create (bde) - [:superset] -> (bd)

Create (bcf) - [:superset] -> (cf)

Create (bcf) - [:superset] -> (bf)

Create (bcf) - [:superset] -> (bc)

Create (bce) - [:superset] -> (ce)

Create (bce) - [:superset] -> (be)

Create (bce) - [:superset] -> (bc)

Create (bcd) - [:superset] -> (cd)

Create (bcd) - [:superset] -> (bd)

Create (bcd) - [:superset] -> (bc)

Create (aef) - [:superset] -> (ef)

Create (aef) - [:superset] -> (af)

Create (aef) - [:superset] -> (ae)

Create (adf) - [:superset] -> (df)

Create (adf) - [:superset] -> (af)

Create (adf) - [:superset] -> (ad)

Create (ade) - [:superset] -> (de)

Create (ade) - [:superset] -> (ae)

Create (ade) - [:superset] -> (ad)

Create (acf) - [:superset] -> (cf)

Create (acf) - [:superset] -> (af)

Create (acf) - [:superset] -> (ac)

Create (ace) - [:superset] -> (ce)

Create (ace) - [:superset] -> (ae)

Create (ace) - [:superset] -> (ac)

Create (acd) - [:superset] -> (cd)

Create (acd) - [:superset] -> (ad)

Create (acd) - [:superset] -> (ac)

Create (abf) - [:superset] -> (bf)

Create (abf) - [:superset] -> (af)

Create (abf) - [:superset] -> (ab)

Create (abe) - [:superset] -> (be)

Create (abe) - [:superset] -> (ae)

Create (abe) - [:superset] -> (ab)

Create (abd) - [:superset] -> (bd)

Create (abd) - [:superset] -> (ad)

Create (abd) - [:superset] -> (ab)

Create (abc) - [:superset] -> (bc)

Create (abc) - [:superset] -> (ac)

Create (abc) - [:superset] -> (ab)

// n-(n-1) = 1 element per set

Create (a:a {headline:'a'})

Create (b:b {headline:'b'})

Create (c:c {headline:'c'})

Create (d:d {headline:'d'})

Create (e:e {headline:'e'})

Create (f:f {headline:'f'})

// Superset relationships level 3 to level 2

Create (ef) - [:superset] -> (f)

Create (ef) - [:superset] -> (e)

Create (df) - [:superset] -> (f)

Create (df) - [:superset] -> (d)

Create (de) - [:superset] -> (e)

Create (de) - [:superset] -> (d)

Create (cf) - [:superset] -> (f)

Create (cf) - [:superset] -> (c)

Create (ce) - [:superset] -> (e)

Create (ce) - [:superset] -> (c)

Create (cd) - [:superset] -> (d)

Create (cd) - [:superset] -> (c)

Create (bf) - [:superset] -> (f)

Create (bf) - [:superset] -> (b)

Create (be) - [:superset] -> (e)

Create (be) - [:superset] -> (b)

Create (bd) - [:superset] -> (d)

Create (bd) - [:superset] -> (b)

Create (bc) - [:superset] -> (c)

Create (bc) - [:superset] -> (b)

Create (af) - [:superset] -> (f)

Create (af) - [:superset] -> (a)

Create (ae) - [:superset] -> (e)

Create (ae) - [:superset] -> (a)

Create (ad) - [:superset] -> (d)

Create (ad) - [:superset] -> (a)

Create (ac) - [:superset] -> (c)

Create (ac) - [:superset] -> (a)

Create (ab) - [:superset] -> (b)

Create (ab) - [:superset] -> (a)

Issue 2:
Neo4j version: 3.5.4

Operating system: debian-9-x86

API/Driver: neo4j-admin

Steps to reproduce

Try to import 30GB(after zipped) csv data to fresh installed neo4j,

command i ran:

sudo -u neo4j /opt/bitnami/neo4j/bin/neo4j-admin import \
--nodes:Group="header_group.csv,groups.*.zip" \
--nodes:Person="header_person.csv,people.*.zip" \
--relationships:IN_GROUP="header_ingroup.csv,people.*.zip" \
--input-encoding="UTF-16LE" --ignore-duplicate-nodes --ignore-missing-nodes --delimiter="\t"

nodes import done in 30 minutes, but then the command stuck on this 'Prepare node index'stage for 2 days already:

******** DETAILS 2019-04-13 19:11:19.799+0000 ********
Nodes
[*Nodes---------------------------------------------------------------------------------------]1.53B
Memory usage: 12.45 GB
I/O throughput: 72.87 MB/s
Duration: 35m 41s 667ms
Done batches: 153631
Prepare node index
[*SORT----------------------------------------------------------------------------------------]7.33B
Memory usage: 123.34 GB
VM stop-the-world time: 2s 23ms
Duration: 2d 5h 25m 29s 892ms
Done batches: 733092
Environment information:
Free physical memory: 219.49 MB
Max VM memory: 17.78 GB
Free VM memory: 73.79 MB
VM stop-the-world time: 2s 23ms
Duration: 2d 6h 1m 11s 559ms

some sample data:

// header_group.csv
:IGNORE	QunNum:ID(Group-ID)	MastQQ:int	CreateDate:date	Title	Class	QunText

groups node:

78	100263	19	2002-08-31	BTBBS	0	btbbs.3322.org
79	100264	1	2002-08-31	1	0	1
80	100265	1	2002-08-31	1	0	1
81	100269	11	2002-08-31	★顺网论坛内务群★	3126

// header_person.csv
:IGNORE	QQNum:ID(Person-ID)	:IGNORE	:IGNORE	:IGNORE	:IGNORE	:IGNORE

// header_ingroup.csv
:IGNORE	:START_ID(Person-ID)	Nick	Age:int	Gender:int	Auth:int	:END_ID(Group-ID)

person nodes:
2	32507773	黄璘	105	1	2	100100
3	389737625	niki	26	1	3	100100
4	10095	Paul	31	0	2	100100
5	795019031	一二三四五六	2	0	1	100100
6	251000782	赵耀	33	0	1	100100

those csv files are generate from a SQL database, as you can see both Person nodes and the IN_GROUP using same set of csv data. There are some node id is duplicated, that's why i put --ignore-duplicate-nodes --ignore-missing-nodes options in there.

Please help!