Datasets:

markhneedham

/

blog

like 0

2013-12-28 21:46:42

RxJava: From Future to Observable

I first came across https://rx.codeplex.com/[Reactive Extensions] about 4 years ago on http://weblogs.asp.net/podwysocki/[Matthew Podwysocki's blog] but then haven't heard much about it until I saw Matthew give a talk at http://codemesh.io/[Code Mesh] a few weeks ago. It seems to have grown in popularity recently and I noticed that's there's now a Java version called https://github.com/Netflix/RxJava[RxJava] http://techblog.netflix.com/2013/02/rxjava-netflix-api.html[written by Netflix]. I thought I'd give it a try by changing http://www.markhneedham.com/blog/2013/12/23/neo4j-cypher-using-merge-with-schema-indexesconstraints/[some code I wrote while exploring cypher's MERGE function] to expose an Observable instead of Futures. To recap, we have 50 threads and we do 100 iterations where we create random (user, event) pairs. We create a maximum of 10 users and 50 events and the goal is to concurrently send requests for the same pairs. In the example of my other post I was throwing away the result of each query whereas here I returned the result back so I had something to subscribe to. The outline of the code looks like this: [source,java] ---- public class MergeTimeRx { public static void main( final String[] args ) throws InterruptedException, IOException { String pathToDb = "/tmp/foo"; FileUtils.deleteRecursively( new File( pathToDb ) ); GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase( pathToDb ); final ExecutionEngine engine = new ExecutionEngine( db ); int numberOfThreads = 50; int numberOfUsers = 10; int numberOfEvents = 50; int iterations = 100; Observable<ExecutionResult> events = processEvents( engine, numberOfUsers, numberOfEvents, numberOfThreads, iterations ); events.subscribe( new Action1<ExecutionResult>() { @Override public void call( ExecutionResult result ) { for ( Map<String, Object> row : result ) { } } } ); .... } } ---- The nice thing about using RxJava is that there's no mention of how we got our collection of +++<cite>+++ExecutionResult+++</cite>+++s, it's not important. We just have a stream of them and by calling the +++<cite>+++subscribe+++</cite>+++ function on the +++<cite>+++Observable+++</cite>+++ we'll be informed whenever another one is made available. Most of the examples I found show how to generate events from a single thread but I wanted to use a thread pool so that I could fire off lots of requests at the same time. The +++<cite>+++processEvents+++</cite>+++ method ended up looking like this: [source,java] ---- private static Observable<ExecutionResult> processEvents( final ExecutionEngine engine, final int numberOfUsers, final int numberOfEvents, final int numberOfThreads, final int iterations ) { final Random random = new Random(); final List<Integer> userIds = generateIds( numberOfUsers ); final List<Integer> eventIds = generateIds( numberOfEvents ); return Observable.create( new Observable.OnSubscribeFunc<ExecutionResult>() { @Override public Subscription onSubscribe( final Observer<? super ExecutionResult> observer ) { final ExecutorService executor = Executors.newFixedThreadPool( numberOfThreads ); List<Future<ExecutionResult>> jobs = new ArrayList<>(); for ( int i = 0; i < iterations; i++ ) { Future<ExecutionResult> job = executor.submit( new Callable<ExecutionResult>() { @Override public ExecutionResult call() { Integer userId = userIds.get( random.nextInt( numberOfUsers ) ); Integer eventId = eventIds.get( random.nextInt( numberOfEvents ) ); return engine.execute( "MERGE (u:User {id: {userId}})\n" + "MERGE (e:Event {id: {eventId}})\n" + "MERGE (u)-[:HAS_EVENT]->(e)\n" + "RETURN u, e", MapUtil.map( "userId", userId, "eventId", eventId ) ); } } ); jobs.add( job ); } for ( Future<ExecutionResult> future : jobs ) { try { observer.onNext( future.get() ); } catch ( InterruptedException | ExecutionException ignored ) { } } observer.onCompleted(); executor.shutdown(); return Subscriptions.empty(); } } ); } ---- I'm not sure if that's the correct way of using +++<cite>+++Observable+++</cite>+++s so please let me know in the comments if I've got it wrong. I wasn't sure what the proper way of handling errors was. I initially had a call to +++<cite>+++observer#onError+++</cite>+++ in the catch block but that means that no further events are produced which wasn't what I wanted. The code is https://gist.github.com/mneedham/8164614[available as a gist] if you want to play around with it. I added the following dependency to get the RxJava library: ~~~xml +++<dependency>++++++<groupId>+++com.netflix.rxjava+++</groupId>+++ +++<artifactId>+++rxjava-core+++</artifactId>+++ +++<version>+++0.15.1+++</version>++++++</dependency>+++ ~~~

rxjava-from-future-to-observable

https://markhneedham.com/blog/2013/12/28/rxjava-from-future-to-observable

2013-12-10 23:46:46

Neo4j: Cypher - Getting the hang of MERGE

I've been trying to get the hang of cypher's http://docs.neo4j.org/chunked/milestone/query-merge.html[MERGE function] and started out by writing a small file to import some people with random properties using the https://github.com/DiUS/java-faker[java-faker] library. [source,java] ---- public class Merge { private static Label PERSON = DynamicLabel.label("Person"); public static void main(String[] args) throws IOException { File dbFile = new File("/tmp/test-db"); FileUtils.deleteRecursively(dbFile); Faker faker = new Faker(); Random random = new Random(); GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase(dbFile.getPath()); Transaction tx = db.beginTx(); for (int i = 0; i < 100000; i++) { Node person = db.createNode(PERSON); person.setProperty("name", faker.name()); person.setProperty("firstName", faker.firstName()); person.setProperty("lastName", faker.lastName()); person.setProperty("country", faker.country()); person.setProperty("age", random.nextInt(50)); } tx.success(); tx.close(); } } ---- We can write the following query to get back a sample of the people that have been imported: [source,cypher] ---- $ MATCH (p:Person) RETURN p LIMIT 5; ==> +------------------------------------------------------------------------------------------------------------------+ ==> | p | ==> +------------------------------------------------------------------------------------------------------------------+ ==> | Node[1344]{name:"Benton Swaniawski",firstName:"Rossie",lastName:"Ankunding",country:"Guadeloupe",age:30} | ==> | Node[1345]{name:"Dagmar Bartell",firstName:"Ashlynn",lastName:"Watsica",country:"French Guiana",age:35} | ==> | Node[1346]{name:"Ms. Missouri Gaylord",firstName:"Muriel",lastName:"Streich",country:"Chile",age:43} | ==> | Node[1347]{name:"Melvina Heathcote",firstName:"Geovanni",lastName:"Marks",country:"United Arab Emirates",age:33} | ==> | Node[1348]{name:"Brendan Schaefer",firstName:"Dayne",lastName:"Haley",country:"Tokelau",age:24} | ==> +------------------------------------------------------------------------------------------------------------------+ ---- We can use the MERGE function to ensure that a node with specific properties exists so we might write something like the following: [source,cypher] ---- MERGE (p:Person {name: "Benton Swaniawski", firstName:"Rossie", lastName:"Ankunding", country:"Guadeloupe", age:30}) RETURN p ---- If we have a look at the +++<cite>+++PROFILE+++</cite>+++ output of the query we'd see something like the following: [source,bash] ---- UpdateGraph(commands=[" MergeNodeAction( p, Map(firstName(1) -> Literal(Rossie), country(3) -> Literal(Guadeloupe), name(0) -> Literal(Benton Swaniawski), lastName(2) -> Literal(Ankunding), age(4) -> Literal(30)), List(Person(0)), ArrayBuffer(Property(p,lastName(2)) == Literal(Ankunding), Property(p,name(0)) == Literal(Benton Swaniawski), Property(p,age(4)) == Literal(30), Property(p,country(3)) == Literal(Guadeloupe), Property(p,firstName(1)) == Literal(Rossie)), List(LabelAction(p,LabelSetOp,List(Person(0))), PropertySetAction(Property(p,name),Literal(Benton Swaniawski)), PropertySetAction(Property(p,country),Literal(Guadeloupe)), PropertySetAction(Property(p,age),Literal(30)), PropertySetAction(Property(p,lastName),Literal(Ankunding)), PropertySetAction(Property(p,firstName), Literal(Rossie))), List(), Some(PlainMergeNodeProducer(<function2>)))"], _rows=1, _db_hits=100219) ---- The bit that stands out is that there were 100,219 db_hits which slows down the query considerably. If we want to use +++<cite>+++MERGE+++</cite>+++ then we need to make sure that we have an index or constraint on one of the properties e.g. [source,bash] ---- $ CREATE INDEX ON :Person(name); ==> +-------------------+ ==> | No data returned. | ==> +-------------------+ ==> Indexes added: 1 ---- If we look at the profile of that we'll see that the number of db_hits has reduced as it's now using the index to do part of the lookup that the MERGE requires: [source,bash] ---- UpdateGraph(commands=[" MergeNodeAction( p, Map(firstName(1) -> Literal(Rossie), country(3) -> Literal(Guadeloupe), name(0) -> Literal(Benton Swaniawski), ... Some(PlainMergeNodeProducer(<function2>)))"], _rows=1, _db_hits=4) ---- We can go one step further by only including the property that's acting as our 'key' (i.e. name) in the first part of the statement and setting the other properties only if necessary: [source,cypher] ---- MERGE (p:Person {name: "Benton Swaniawski"}) ON CREATE SET p.firstName="Rossie", p.lastName="Ankunding", p.country="Guadeloupe", p.age=30 RETURN p ---- If we profile that query we can see that things have improved: [source,bash] ---- UpdateGraph(commands=["MergeNodeAction( p, Map(name(0) -> Literal(Benton Swaniawski)), List(Person(0)),ArrayBuffer(), List(LabelAction(p,LabelSetOp,List(Person(0))), PropertySetAction(Property(p,name),Literal(Benton Swaniawski)), PropertySetAction(Property(p,firstName),Literal(Rossie)), PropertySetAction(Property(p,lastName),Literal(Ankunding)), PropertySetAction(Property(p,country),Literal(Guadeloupe)), PropertySetAction(Property(p,age),Literal(30))), List(), Some(PlainMergeNodeProducer(<function2>)))"], _rows=1, _db_hits=0) ---- In some cases we might want to update a property every time that 'key' gets matched in a MERGE statement which we could do like so: [source,cypher] ---- MERGE (p:Person {name: "Benton Swaniawski"}) ON MATCH SET p.times = COALESCE(p.times, 0) + 1 RETURN p ---- You can also use +++<cite>+++MERGE+++</cite>+++ to http://docs.neo4j.org/chunked/milestone/query-merge.html#merge-merge-on-a-relationship[create relationships] but for now I just wanted to explore how it should be used in the context of nodes which I think I've now figured out. Always happy to take tips on how to do things better though!

neo4j-cypher-getting-the-hang-of-merge

https://markhneedham.com/blog/2013/12/10/neo4j-cypher-getting-the-hang-of-merge

2013-12-23 13:30:38

Neo4j: Cypher - Using MERGE with schema indexes/constraints

A couple of weeks about I wrote about http://www.markhneedham.com/blog/2013/12/10/neo4j-cypher-getting-the-hang-of-merge/[cypher's MERGE function] and over the last few days I've been exploring how it works when used with http://docs.neo4j.org/chunked/milestone/query-schema-index.html[schema indexes] and http://docs.neo4j.org/chunked/milestone/query-constraints.html#constraints-create-uniqueness-constraint[unique constraints]. A common use case with Neo4j is to model users and events where an event could be a tweet, Facebook post or Pinterest pin. The model might look like this: image::{{<siteurl>}}/uploads/2013/12/2013-12-22_20-14-04.png[2013 12 22 20 14 04,600] We'd have a stream of (user, event) pairs and a cypher statement like the following to get the data into Neo4j: [source,cypher] ---- MERGE (u:User {id: {userId}}) MERGE (e:Event {id: {eventId}}) MERGE (u)-[:CREATED_EVENT]->(m) RETURN u, e ---- We'd like to ensure that we don't get duplicate users or events and http://docs.neo4j.org/chunked/stable/query-merge.html[MERGE provides the semantics to do this:</p>] ____ MERGE ensures that a pattern exists in the graph. Either the pattern already exists, or it needs to be created. ____ I wanted to see what would happen if I wrote a script that tried to create the same (user, event) pairs concurrently and ended up with the following: ~~~java import org.neo4j.cypher.javacompat.ExecutionEngine; import org.neo4j.cypher.javacompat.ExecutionResult; import org.neo4j.graphdb.GraphDatabaseService; import org.neo4j.graphdb.factory.GraphDatabaseFactory; import org.neo4j.helpers.collection.MapUtil; import org.neo4j.kernel.impl.util.FileUtils; \... public class MergeTime { public static void main(String[] args) throws Exception { String pathToDb = "/tmp/foo"; FileUtils.deleteRecursively(new File(pathToDb)); GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase( pathToDb ); final ExecutionEngine engine = new ExecutionEngine( db ); ExecutorService executor = Executors.newFixedThreadPool( 50 ); final Random random = new Random(); final int numberOfUsers = 10; final int numberOfEvents = 50; int iterations = 100; final List+++<Integer>+++userIds = generateIds( numberOfUsers ); final List+++<Integer>+++eventIds = generateIds( numberOfEvents ); List+++<Future>+++merges = new ArrayList<>( ); for ( int i = 0; i < iterations; i++ ) { Integer userId = userIds.get(random.nextInt(numberOfUsers)); Integer eventId = eventIds.get(random.nextInt(numberOfEvents)); merges.add(executor.submit(mergeAway( engine, userId, eventId) )); } for ( Future merge : merges ) { merge.get(); } executor.shutdown(); ExecutionResult userResult = engine.execute("MATCH (u:User) RETURN u.id as userId, COUNT(u) AS count ORDER BY userId"); System.out.println(userResult.dumpToString()); } private static Runnable mergeAway(final ExecutionEngine engine, final Integer userId, final Integer eventId) { return new Runnable() { @Override public void run() { try { ExecutionResult result = engine.execute( "MERGE (u:User {id: \{userId}})\n" + "MERGE (e:Event {id: \{eventId}})\n" + "MERGE (u)-[:CREATED_EVENT]\->(m)\n" + "RETURN u, e", MapUtil.map( "userId", userId, "eventId", eventId) ); // throw away for ( Map<String, Object> row : result ) { } } catch ( Exception e ) { e.printStackTrace(); } } }; } private static List+++<Integer>+++generateIds( int amount ) { List+++<Integer>+++ids = new ArrayList<>(); for ( int i = 1; i \<= amount; i++ ) { ids.add( i ); } return ids; } } ~~~ We create a maximum of 10 users and 50 events and then do 100 iterations of random (user, event) pairs with 50 concurrent threads. Afterwards we execute a query which checks how many users of each id have been created and get the following output: ~~~bash +----------------+ | userId | count | +----------------+ | 1 | 6 | | 2 | 3 | | 3 | 4 | | 4 | 8 | | 5 | 9 | | 6 | 7 | | 7 | 5 | | 8 | 3 | | 9 | 3 | | 10 | 2 | +----------------+ 10 rows ~~~ Next I added in a schema index on users and events to see if that would make any difference, https://groups.google.com/forum/#!topic/neo4j/ikRyqcQSBaA[something Javad Karabi recently asked on the user group]. ~~~cypher CREATE INDEX ON :User(id) CREATE INDEX ON :Event(id) ~~~ We wouldn't expect this to make a difference as schema indexes don't ensure uniqueness but I ran it anyway t and got the following output: ~~~bash +----------------+ | userId | count | +----------------+ | 1 | 2 | | 2 | 9 | | 3 | 7 | | 4 | 2 | | 5 | 3 | | 6 | 7 | | 7 | 7 | | 8 | 6 | | 9 | 5 | | 10 | 3 | +----------------+ 10 rows ~~~ If we want to ensure uniqueness of users and events we need to add a unique constraint on the id of both of these labels: ~~~cypher CREATE CONSTRAINT ON (user:User) ASSERT user.id IS UNIQUE CREATE CONSTRAINT ON (event:Event) ASSERT event.id IS UNIQUE ~~~ Now if we run the test we'll only end up with one of each user: ~~~bash +----------------+ | userId | count | +----------------+ | 1 | 1 | | 2 | 1 | | 3 | 1 | | 4 | 1 | | 5 | 1 | | 6 | 1 | | 7 | 1 | | 8 | 1 | | 9 | 1 | | 10 | 1 | +----------------+ 10 rows ~~~ We'd see the same type of result if we ran a similar query checking for the uniqueness of events. As far as I can tell this duplication of nodes that we merge on only happens if you try and create the same node twice concurrently. Once the node has been created we can use MERGE with a non-unique index and a duplicate node won't get created. All the code from this post is https://gist.github.com/mneedham/8096822[available as a gist] if you want to play around with it.+++</Integer>++++++</Integer>++++++</Future>++++++</Integer>++++++</Integer>+++

neo4j-cypher-using-merge-with-schema-indexesconstraints

https://markhneedham.com/blog/2013/12/23/neo4j-cypher-using-merge-with-schema-indexesconstraints

2014-03-03 16:34:18

Neo4j 2.1.0-M01: LOAD CSV with Rik Van Bruggen's Tube Graph

Last week we released http://blog.neo4j.org/2014/02/neo4j-210-milestone-1-release-import-and-dense-nodes.html[the first milestone of Neo4j 2.1.0] and one its features is a new function in cypher - http://docs.neo4j.org/chunked/milestone/import-importing-data-from-a-single-csv-file.html[LOAD CSV] - which aims to make it easier to get data into Neo4j. I thought I'd give it a try to import the London tube graph - something that my colleague Rik http://blog.bruggen.com/2013/11/meet-this-tubular-graph.html[wrote about a few months ago]. I'm using the same data set as Rik but I had to tweak it a bit as there were naming differences when describing the connection from Kennington to Waterloo and Kennington to Oval. My https://github.com/mneedham/tube/blob/master/runtimes.csv[updated version of the dataset is on github]. With the help of Alistair we now have a variation on the original which takes into account the various platforms at stations and the waiting time of a train on the platform. This will also enable us to add in things like getting from the ticket hall to the various platforms more easily. The model looks like this: image::{{<siteurl>}}/uploads/2014/03/2014-03-03_16-15-58.png[2014 03 03 16 15 58,600] Now we need to create a graph and the first step is to put an index on station name as we'll be looking that up quite frequently in the queries that follow: [source,cypher] ---- CREATE INDEX on :Station(stationName) ---- Now that's in place we can make use of LOAD CSV. The data is very de-normalised which works out quite nicely for us and we end up with the following script: [source,cypher] ---- LOAD CSV FROM "file:/Users/markhneedham/code/tube/runtimes.csv" AS csvLine WITH csvLine[0] AS lineName, csvLine[1] AS direction, csvLine[2] AS startStationName, csvLine[3] AS destinationStationName, toFloat(csvLine[4]) AS distance, toFloat(csvLine[5]) AS runningTime MERGE (start:Station { stationName: startStationName}) MERGE (destination:Station { stationName: destinationStationName}) MERGE (line:Line { lineName: lineName}) MERGE (line) - [:DIRECTION] -> (dir:Direction { direction: direction}) CREATE (inPlatform:InPlatform {name: "In: " + destinationStationName + " " + lineName + " " + direction}) CREATE (outPlatform:OutPlatform {name: "Out: " + startStationName + " " + lineName + " " + direction}) CREATE (inPlatform) - [:AT] -> (destination) CREATE (outPlatform) - [:AT] -> (start) CREATE (inPlatform) - [:ON] -> (dir) CREATE (outPlatform) - [:ON] -> (dir) CREATE (outPlatform) - [r:TRAIN {distance: distance, runningTime: runningTime}] -> (inPlatform) ---- This file doesn't contain any headers so we'll simulate them by using a WITH clause so that we don't have index lookups all over the place. In this case we're pointing to a file on the local file system but we could choose to point to a CSV file on the web if we wanted to. Since stations, lines and directions appear frequently we'll use MERGE to ensure they don't get duplicated. After that we have a post processing step to connect the 'in' and 'out' platforms shown in the diagram. [source,cypher] ---- MATCH (station:Station) <-[:AT]- (platformIn:InPlatform), (station:Station) <-[:AT]- (platformOut:OutPlatform), (direction:Direction) <-[:ON]- (platformIn:InPlatform), (direction:Direction) <-[:ON]- (platformOut:OutPlatform) CREATE (platformIn) -[:WAIT {runningTime: 0.5}]-> (platformOut) ---- After running a few queries on the graph I realised that it wasn't possible to combine some journies through Kennington and Euston so I had to add some relationships in there as well: [source,cypher] ---- // link the Euston stations MATCH (euston:Station {stationName: "EUSTON"})<-[:AT]-(eustonIn:InPlatform) MATCH (eustonCx:Station {stationName: "EUSTON (CX)"})<-[:AT]-(eustonCxIn:InPlatform) MATCH (eustonCity:Station {stationName: "EUSTON (CITY)"})<-[:AT]-(eustonCityIn:InPlatform) CREATE UNIQUE (eustonIn)-[:WAIT {runningTime: 0.0}]->(eustonCxIn) CREATE UNIQUE (eustonIn)-[:WAIT {runningTime: 0.0}]->(eustonCityIn) CREATE UNIQUE (eustonCxIn)-[:WAIT {runningTime: 0.0}]->(eustonCityIn) // link the Kennington stations MATCH (kenningtonCx:Station {stationName: "KENNINGTON (CX)"})<-[:AT]-(kenningtonCxIn:InPlatform) MATCH (kenningtonCity:Station {stationName: "KENNINGTON (CITY)"})<-[:AT]-(kenningtonCityIn:InPlatform) CREATE UNIQUE (kenningtonCxIn)-[:WAIT {runningTime: 0.0}]->(kenningtonCityIn) ---- I've been https://github.com/mneedham/tube/blob/master/src/main/java/tube/TubeImporter.java[playing around with the A* algorithm] to find the quickest route between stations based on the distances between stations. The next step is to put a timetable graph alongside this so we can do quickest routes at certain parts of the day and the next step after that will be to take delays into account. If you've got some data you want to get into the graph give LOAD CSV a try and https://groups.google.com/forum/#!topic/neo4j/wePBQ6YUGtw[let us know how you get on], the cypher team are keen to get feedback on this.

neo4j-2-1-0-m01-load-csv-with-rik-van-bruggens-tube-graph

https://markhneedham.com/blog/2014/03/03/neo4j-2-1-0-m01-load-csv-with-rik-van-bruggens-tube-graph

2014-03-30 14:48:41

Soulver: For all your random calculations

I often find myself doing random calculations and I used to do so part manually and part using http://www.alfredapp.com/[Alfred]'s calculator until https://twitter.com/apcj[Alistair] pointed me at http://www.acqualia.com/soulver/[Soulver], a desktop/iPhone/iPad app, which is even better. I thought I'd write some examples of calculations I use it for, partly so I'll remember the syntax in future! _Calculating how much memory Neo4j memory mapping will take up_ [source,text] ---- 800 mb + 2660mb + 6600mb + 9500mb + 40mb in GB = 19.6 GB ---- _How long would it take to cover 20,000 km at 100 km / day?_ [source,text] ---- 20,000 km / 100 km/day in months = 6.57097681677241832481 months ---- _How long did an import of some data using the Neo4j shell take?_ [source,text] ---- 4550855 ms in minutes = 75.84758333333333333333 minutes ---- _Bit shift 1 by 32 places_ [source,text] ---- 1 << 32 = 4,294,967,296 ---- _Translating into easier to digest units_ [source,text] ---- 32381KB / second in MB per minute = 1,942.86 MB/minute 500,000 / 3 years in per hour = 19.01324310408685857874 per hour^2 ---- _How long would it take to process a chunk of data?_ [source,text] ---- 100 GB / (32381KB / second in MB per minute) = 51.47051254336390681778 minutes ---- _Hexadecimal to base 10_ [source,text] ---- 0x1111 = 4,369 1 + 16 + 16^2 + 16^3 = 4,369 ---- I'm sure there's much more that you can do that I haven't figured out yet but even for these simple examples it saves me a bunch of time.

soulver-for-all-your-random-calculations

https://markhneedham.com/blog/2014/03/30/soulver-for-all-your-random-calculations

2014-03-24 23:44:29

Remote profiling Neo4j using yourkit

http://www.yourkit.com/[yourkit] is my favourite JVM profiling tool and whilst it's really easy to profile a local JVM process, sometimes I need to profile a process on a remote machine. In that case we need to first have the remote JVM started up with a http://www.yourkit.com/docs/80/help/agent.jsp[yourkit agent] parameter passed as one of the args to the Java program. Since I'm mostly working with Neo4j this means we need to add the following to +++<cite>+++conf/neo4j-wrapper.conf+++</cite>+++: [source,text] ---- wrapper.java.additional=-agentpath:/Users/markhneedham/Downloads/YourKit_Java_Profiler_2013_build_13074.app/bin/mac/libyjpagent.jnilib=port=8888 ---- If we run lsof with the Neo4j process ID we'll see that there's now a socket listening on port 8888: [source,text] ---- java 4388 markhneedham 20u IPv6 0x901df453b4e9a125 0t0 TCP *:8888 (LISTEN) ... ---- We can connect to that via the 'Monitor Remote Applications' section of yourkit: image::{{<siteurl>}}/uploads/2014/03/2014-03-24_23-39-59.png[2014 03 24 23 39 59,600] In this case I'm demonstrating how to connect to it on my laptop and am using localhost but usually we'd specify the remote machine's host name instead. We also need to ensure that port 8888 is open on any firewalls we have in front of the machine. The file we refer to in the 'agentpath' flag is a bit different depending on the operating system we're using. All the http://www.yourkit.com/docs/80/help/agent.jsp[details are on the yourkit website].

remote-profiling-neo4j-using-yourkit

https://markhneedham.com/blog/2014/03/24/remote-profiling-neo4j-using-yourkit

2014-03-23 21:18:36

Functional Programming in Java - Venkat Subramaniam: Book Review

I picked up Venkat Subramaniam's 'http://pragprog.com/book/vsjava8/functional-programming-in-java[Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions]' to learn a little bit more about Java 8 having struggled to find any online tutorials which did that. A big chunk of the book focuses on lambdas, http://www.markhneedham.com/blog/2009/01/19/f-vs-c-vs-java-functional-collection-parameters/[functional collection parameters] and lazy evaluation which will be familiar to users of C#, Clojure, Scala, Haskell, Ruby, Python, F# or libraries like https://code.google.com/p/totallylazy/[totallylazy] and https://code.google.com/p/guava-libraries/[Guava]. Although I was able to race through the book quite quickly it was still interesting to see how Java 8 is going to reduce the amount of code we need to write to do simple operations on collections. I wrote up my thoughts on http://www.markhneedham.com/blog/2014/02/26/java-8-lambda-expressions-vs-auto-closeable/[lambda expressions instead of auto closeable], using http://www.markhneedham.com/blog/2014/02/23/java-8-group-by-with-collections/[group by on collections] and http://www.markhneedham.com/blog/2014/02/23/java-8-sorting-values-in-collections/[sorting values in collections] in previous blog posts. I noticed a couple of subtle differences in the method names added to collection e.g. skip/limit are there instead of take/drop for grabbing a subset of said collection. There are also methods such as 'mapToInt' and 'mapToDouble' where in other languages you'd just have a single 'map' and it would handle everything. Over the last couple of years I've used totallylazy on Java projects to deal with collections and while I like the style of code it encourages you end up with a lot of code due to all the anonymous classes you have to create. In Java 8 lambdas are a first class concept which should make using totallylazy even better. In a previous blog post I showed how you'd go about sorted a collection of people by age. In Java 8 it would look like this: [source,java] ---- List<Person> people = Arrays.asList(new Person("Paul", 24), new Person("Mark", 30), new Person("Will", 28)); people.stream().sorted(comparing(p -> p.getAge())).forEach(System.out::println) ---- I find the 'comparing' function that we have to use a bit unintuitive and this is what we'd have using totallylazy pre Java 8: [source,java] ---- Sequence<Person> people = sequence(new Person("Paul", 24), new Person("Mark", 30), new Person("Will", 28)); people.sortBy(new Callable1<Person, Integer>() { @Override public Integer call(Person person) throws Exception { return person.getAge(); } }); ---- Using Java 8 lambdas the code is much simplified: [source,java] ---- Sequence<Person> people = sequence(new Person("Paul", 24), new Person("Mark", 30), new Person("Will", 28)); System.out.println(people.sortBy(Person::getAge)); ---- If we use 'forEach' to print out each person individually we end up with the following: [source,java] ---- Sequence<Person> people = sequence(new Person("Paul", 24), new Person("Mark", 30), new Person("Will", 28)); people.sortBy(Person::getAge).forEach((Consumer<? super Person>) System.out::println); ---- The compiler can't work out whether we want to use the forEach method from totallylazy or from Iterable so we end up having to cast which is a bit nasty. I haven't yet tried converting the totallylazy code I've written but my thinking is that the real win of Java 8 will be making it easier to use libraries like totallylazy and Guava. Overall the book describes Java 8's features very well but if you've used any of the languages I mentioned at the top it will all be very familiar - finally Java has caught up with the rest!

functional-programming-in-java-venkat-subramaniam-book-review

https://markhneedham.com/blog/2014/03/23/functional-programming-in-java-venkat-subramaniam-book-review

2014-04-19 06:33:39

Neo4j: Cypher - Creating relationships between a collection of nodes / Invalid input '[':

When working with graphs we'll frequently find ourselves wanting to create relationships between collections of nodes. A common example of this would be creating a linked list of days so that we can quickly traverse across http://blog.neo4j.org/2012/02/modeling-multilevel-index-in-neoj4.html[a time tree]. Let's say we start with just 3 days: [source,cypher] ---- MERGE (day1:Day {day:1 }) MERGE (day2:Day {day:2 }) MERGE (day3:Day {day:3 }) RETURN day1, day2, day3 ---- And we want to create a 'NEXT' relationship between adjacent days: [source,cypher] ---- (day1)-[:NEXT]->(day2)-[:NEXT]->(day3) ---- The most obvious way to do this would be to collect the days into an ordered collection and iterate over them using +++<cite>+++http://docs.neo4j.org/chunked/stable/query-foreach.html[FOREACH]+++</cite>+++, creating a relationship between adjacent nodes: [source,cypher] ---- MATCH (day:Day) WITH day ORDER BY day.day WITH COLLECT(day) AS days FOREACH(i in RANGE(0, length(days)-2) | CREATE UNIQUE (days[i])-[:NEXT]->(days[i+1])) ---- Unfortunately this isn't valid syntax: [source,text] ---- Invalid input '[': expected an identifier character, node labels, a property map, whitespace, ')' or a relationship pattern (line 6, column 32) " CREATE UNIQUE (days[i])-[:NEXT]->(days[i+1]))" ^ ---- It doesn't seem to like us using array indices where we specify the node identifier. However, we can work around that by putting +++<cite>+++days[i]+++</cite>+++ and +++<cite>+++days[i+1]+++</cite>+++ into single item arrays and using nested +++<cite>+++FOREACH+++</cite>+++ loops on those, something http://www.markhneedham.com/blog/2013/11/29/neo4j-modelling-series-of-events/[Michael Hunger showed me last year] and I forgot all about! [source,cypher] ---- MATCH (day:Day) WITH day ORDER BY day.day WITH COLLECT(day) AS days FOREACH(i in RANGE(0, length(days)-2) | FOREACH(day1 in [days[i]] | FOREACH(day2 in [days[i+1]] | CREATE UNIQUE (day1)-[:NEXT]->(day2)))) ---- Now if we do a query to get back all the days we'll see they're connected: image::{{<siteurl>}}/uploads/2014/04/2014-04-19_07-32-37.png[2014 04 19 07 32 37,366]

neo4j-cypher-creating-relationships-between-a-collection-of-nodes-invalid-input

https://markhneedham.com/blog/2014/04/19/neo4j-cypher-creating-relationships-between-a-collection-of-nodes-invalid-input

2014-04-19 21:15:21

Neo4j: Cypher - Creating a time tree down to the day

neo4j-cypher-creating-a-time-tree-down-to-the-day

https://markhneedham.com/blog/2014/04/19/neo4j-cypher-creating-a-time-tree-down-to-the-day

2014-04-19 19:51:58

Neo4j 2.0.1: Cypher - Concatenating an empty collection / Type mismatch: expected Integer, Collection<Integer> or Collection<Collection<Integer>> but was Collection<Any>

Last weekend I was playing around with some collections using Neo4j's Cypher query language and I wanted to concatenate two collections. This was easy enough when both collections contained values\... [source,cypher] ---- $ RETURN [1,2,3,4] + [5,6,7]; ==> +---------------------+ ==> | [1,2,3,4] + [5,6,7] | ==> +---------------------+ ==> | [1,2,3,4,5,6,7] | ==> +---------------------+ ==> 1 row ---- \...but I ended up with the following exception when I tried to concatenate with an empty collection: [source,cypher] ---- $ RETURN [1,2,3,4] + []; ==> SyntaxException: Type mismatch: expected Integer, Collection<Integer> or Collection<Collection<Integer>> but was Collection<Any> (line 1, column 20) ==> "RETURN [1,2,3,4] + []" ==> ^ ---- I figured there was probably some strange type coercion going on for the empty collection and came up with the following work around using the +++<cite>+++http://docs.neo4j.org/chunked/stable/query-functions-collection.html#functions-range[RANGE]+++</cite>+++ function: [source,cypher] ---- $ RETURN [1,2,3,4] + RANGE(0,-1); ==> +-------------------------+ ==> | [1,2,3,4] + RANGE(0,-1) | ==> +-------------------------+ ==> | [1,2,3,4] | ==> +-------------------------+ ==> 1 row ---- While writing this up I decided to check if it behaved the same way in the http://blog.neo4j.org/2014/04/neo4j-202-maintenance-release.html[recently released 2.0.2] and was pleasantly surprised to see that the work around is no longer necessary: [source,cypher] ---- $ RETURN [1,2,3,4] + []; ==> +----------------+ ==> | [1,2,3,4] + [] | ==> +----------------+ ==> | [1,2,3,4] | ==> +----------------+ ==> 1 row ---- So if you're seeing the same issue get yourself upgraded!

neo4j-2-0-1-cypher-concatenating-an-empty-collection-type-mismatch-expected-integer-collection-or-collection-but-was-collection

https://markhneedham.com/blog/2014/04/19/neo4j-2-0-1-cypher-concatenating-an-empty-collection-type-mismatch-expected-integer-collection-or-collection-but-was-collection

2014-04-26 07:50:46

Clojure: clj-time - Formatting a date / timestamp with day suffixes e.g. 1st, 2nd, 3rd

I've been using the https://github.com/clj-time/clj-time[clj-time] library recently - a Clojure wrapper around http://joda-time.sourceforge.net/[Joda Time] - and one thing I wanted to do is format a date with day suffixes e.g. 1st, 2nd, 3rd. I started with the following timestamp: [source,text] ---- 1309368600000 ---- The first step was to convert that into a DateTime object like so: [source,lisp] ---- user> (require '[clj-time.coerce :as c]) user> (c/from-long 1309368600000) #<DateTime 2011-06-29T17:30:00.000Z> ---- I wanted to output that date in the following format: [source,text] ---- 29th June 2011 ---- We can get quite close by using a https://github.com/clj-time/clj-time#clj-timeformat[custom time formatter]: [source,lisp] ---- user> (require '[clj-time.format :as f]) nil user> (f/unparse (f/formatter "d MMMM yyyy") (c/from-long 1309368600000)) "29 June 2011" ---- Unfortunately I couldn't find anywhere in the documentation explaining how to get the elusive 'th' or 'st' to print. I was hoping for something similar to PHP date formatting: image::{{<siteurl>}}/uploads/2014/04/2014-04-26_08-38-39.png[2014 04 26 08 38 39,600] Eventually I came across a Stack Overflow post about Joda Time suggesting that http://stackoverflow.com/questions/12950392/jodatime-format-date-with-1st-2nd-3rd-etc-day[you can't actually format a day in the way I was hoping to]. So I now have the following function to do it for me: [source,lisp] ---- (defn day-suffix [day] (let [stripped-day (if (< day 20) day (mod day 10))] (cond (= stripped-day 1) "st" (= stripped-day 2) "nd" (= stripped-day 3) "rd" :else "th"))) ---- and the code to get the date in my favoured format looks like this: [source,lisp] ---- user> (def my-time (c/from-long 1309368600000)) #'user/my-time user> (def day (read-string (f/unparse (f/formatter "d") my-time))) #'user/day user> (str day (day-suffix day) " " (f/unparse (f/formatter "MMMM yyyy") my-time)) "29th June 2011" ---- I'm assuming there's a better way but what is it?!

clojure-clj-time-formatting-a-date-timestamp-with-day-suffixes-e-g-1st-2nd-3rd

https://markhneedham.com/blog/2014/04/26/clojure-clj-time-formatting-a-date-timestamp-with-day-suffixes-e-g-1st-2nd-3rd

2014-04-07 00:04:28

install4j and AppleScript: Creating a Mac OS X Application Bundle for a Java application

We have a few internal applications at Neo which can be launched using 'java -jar +++<path-to-jar>+++' and I always forget where the jars are so I thought I'd wrap a Mac OS X application bundle around it to make life easier.</p> My favourite installation pattern is the one where when you double click the dmg it shows you a window where you can drag the application into the 'Applications' folder, like this: image::{{<siteurl>}}/uploads/2014/04/2014-04-07_00-38-41.png[2014 04 07 00 38 41,551] I'm not a fan of the installation wizards and the installation process here is so simple that a wizard seems overkill. I started out learning about https://developer.apple.com/library/mac/documentation/corefoundation/conceptual/cfbundles/BundleTypes/BundleTypes.html[the structure of an application bundle] which is well described in the Apple Bundle Programming guide. I then worked my way through a video which walks you through https://www.youtube.com/watch?v=Unl8dgqFv6o[bundling a JAR file in a Mac application]. I figured that bundling a JAR was probably a solved problem and had a look at http://docs.oracle.com/javase/7/docs/technotes/guides/jweb/packagingAppsForMac.html[App Bundler], http://informagen.com/JarBundler/[JAR Bundler] and http://s.sudre.free.fr/Software/Iceberg.html[Iceberg] before settling on http://www.ej-technologies.com/products/install4j/overview.html[Install4j] which we used for http://blog.neo4j.org/2013/09/installer-check-desktop-launcher-check.html[Neo4j desktop]. I started out by creating an installer using Install4j and then manually copying the launcher it created into an Application bundle template but it was incredibly fiddly and I ended up with a variety of indecipherable messages in the system error log. Eventually I realised that I didn't need to create an installer and that what I actually wanted was a http://resources.ej-technologies.com/install4j/help/doc/indexRedirect.html?http&&&resources.ej-technologies.com/install4j/help/doc/steps/media/mediaFileTypes.html[Mac OS X single bundle archive media file]. After I'd got install4j creating that for me I just needed to figure out how to create the background image telling the user to drag the application into their 'Applications' folder. Luckily I http://stackoverflow.com/questions/96882/how-do-i-create-a-nice-looking-dmg-for-mac-os-x-using-command-line-tools[came across this StackOverflow post] which provided some AppleScript to do just that and with a bit of tweaking I ended up with the following shell script which seems to do the job: ~~~bash #!/bin/bash rm target/DBench_macos_1_0_0.tgz /Applications/install4j\ 5/bin/install4jc TestBench.install4j title="DemoBench" backgroundPictureName="graphs.png" applicationName="DemoBench" finalDMGName="DemoBench.dmg" rm -rf target/dmg && mkdir -p target/dmg tar -C target/dmg -xvf target/DBench_macos_1_0_0.tgz cp -r src/packaging/.background target/dmg ln -s /Applications target/dmg cd target rm "$\{finalDMGName}" umount -f /Volumes/"$\{title}" hdiutil create -volname $\{title} -size 100m -srcfolder dmg/ -ov -format UDRW pack.temp.dmg device=$(hdiutil attach -readwrite -noverify -noautoopen "pack.temp.dmg" | egrep '{caret}/dev/' | sed 1q | awk '{print $1}') sleep 5 echo ' tell application "Finder" tell disk "'$\{title}'" open set current view of container window to icon view set toolbar visible of container window to false set statusbar visible of container window to false set the bounds of container window to {400, 100, 885, 430} set theViewOptions to the icon view options of container window set arrangement of theViewOptions to not arranged set icon size of theViewOptions to 72 set background picture of theViewOptions to file ".background:'$\{backgroundPictureName}'" set position of item "'$\{applicationName}'" of container window to {100, 100} set position of item "Applications" of container window to {375, 100} update without registering applications delay 5 eject end tell end tell ' | osascript hdiutil detach $\{device} hdiutil convert "pack.temp.dmg" -format UDZO -imagekey zlib-level=9 -o "$\{finalDMGName}" rm -f pack.temp.dmg cd .. ~~~ To summarise, this script creates a symlink to 'Applications', puts a background image in a directory titled '.background', sets that as the background of the window and positions the symlink and application appropriately. Et voila: image::{{<siteurl>}}/uploads/2014/04/2014-04-07_00-59-56.png[2014 04 07 00 59 56,485] The Firefox guys wrote http://limi.net/articles/improving-the-mac-installer-for-firefox/[a couple] http://limi.net/articles/firefox-mac-installation-experience-revisited[of blog posts] detailing their experiences writing an installer which were quite an interesting read as well.+++</path-to-jar>+++

install4j-and-applescript-creating-a-mac-os-x-application-bundle-for-a-java-application

https://markhneedham.com/blog/2014/04/07/install4j-and-applescript-creating-a-mac-os-x-application-bundle-for-a-java-application

2014-04-30 01:24:33

Jersey/Jax RS: Streaming JSON

About a year ago I wrote a blog post showing how to http://www.markhneedham.com/blog/2013/07/08/jax-rs-streaming-a-response-using-streamingoutput/[stream a HTTP response using Jersey/Jax RS] and I recently wanted to do the same thing but this time using JSON. A common pattern is to take our Java object and get a JSON string representation of that but that isn't the most efficient use of memory because we now have the Java object and a string representation. This is particularly problematic if we need to return a lot of the data in a response. By writing a little bit more code we can get our response to stream to the client as soon as some of it is ready rather than building the whole result and sending it all in one go: [source,java] ---- @Path("/resource") public class MadeUpResource { private final ObjectMapper objectMapper; public MadeUpResource() { objectMapper = new ObjectMapper(); } @GET @Produces(MediaType.APPLICATION_JSON) public Response loadHierarchy(@PathParam( "pkPerson" ) String pkPerson) { final Map<Integer, String> people = new HashMap<>(); people.put(1, "Michael"); people.put(2, "Mark"); StreamingOutput stream = new StreamingOutput() { @Override public void write(OutputStream os) throws IOException, WebApplicationException { JsonGenerator jg = objectMapper.getJsonFactory().createJsonGenerator( os, JsonEncoding.UTF8 ); jg.writeStartArray(); for ( Map.Entry<Integer, String> person : people.entrySet() ) { jg.writeStartObject(); jg.writeFieldName( "id" ); jg.writeString( person.getKey().toString() ); jg.writeFieldName( "name" ); jg.writeString( person.getValue() ); jg.writeEndObject(); } jg.writeEndArray(); jg.flush(); jg.close(); } }; return Response.ok().entity( stream ).type( MediaType.APPLICATION_JSON ).build() ; } } ---- If we run that this is the output we'd see: [source,text] ---- [{"id":"1","name":"Michael"},{"id":"2","name":"Mark"}] ---- It's a simple example but hopefully it's easy to see how we could translate that if we wanted to stream more complex data.

jerseyjax-rs-streaming-json

https://markhneedham.com/blog/2014/04/30/jerseyjax-rs-streaming-json

2014-04-30 00:20:46

Clojure: Paging meetup data using lazy sequences

I've been playing around with the http://www.meetup.com/meetup_api/[meetup API] to do some analysis on the http://www.meetup.com/graphdb-london/[Neo4j London meetup] and one thing I wanted to do was download all the members of the group. A feature of the meetup API is that each end point will only allow you to return a maximum of 200 records so I needed to make use of offsets and paging to retrieve everybody. It seemed like a good chance to use some lazy sequences to keep track of the offsets and then stop making calls to the API once I wasn't retrieving any more results. I wrote the following functions to take care of that bit: [source,lisp] ---- (defn unchunk [s] (when (seq s) (lazy-seq (cons (first s) (unchunk (next s)))))) (defn offsets [] (unchunk (range))) (defn get-all [api-fn] (flatten (take-while seq (map #(api-fn {:perpage 200 :offset % :orderby "name"}) (offsets))))) ---- I previously wrote about the http://www.markhneedham.com/blog/2014/04/06/clojure-not-so-lazy-sequences-a-k-a-chunking-behaviour/[chunking behaviour of lazy collections] which meant that I ended up with a minimum of 32 calls to each URI which wasn't what I had in mind! To get all the members in the group I wrote the following function which is passed to +++<cite>+++get-all+++</cite>+++: [source,lisp] ---- (:require [clj-http.client :as client]) (defn members [{perpage :perpage offset :offset orderby :orderby}] (->> (client/get (str "https://api.meetup.com/2/members?page=" perpage "&offset=" offset "&orderby=" orderby "&group_urlname=" MEETUP_NAME "&key=" MEETUP_KEY) {:as :json}) :body :results)) ---- So to get all the members we'd do this: [source,lisp] ---- (defn all-members [] (get-all members)) ---- I'm told that using lazy collections when side effects are involved is a bad idea - presumably because the calls to the API might never end - but since I only run it manually I can just kill the process if anything goes wrong. I'd be interested in how others would go about solving this problem - https://github.com/clojure/core.async[core.async] was suggested but that seems to result in much more / more complicated code than this version. The https://github.com/mneedham/neo4j-meetup/blob/master/src/neo4j_meetup/core.clj#L58[code is on github] if you want to take a look.

clojure-paging-meetup-data-using-lazy-sequences

https://markhneedham.com/blog/2014/04/30/clojure-paging-meetup-data-using-lazy-sequences

2014-04-06 22:07:47

Clojure: Not so lazy sequences a.k.a chunking behaviour

I've been playing with Clojure over the weekend and got caught out by the behaviour of lazy sequences due to chunking - something which was https://twitter.com/stilkov/status/452411800349605888[obvious] https://twitter.com/philandstuff/status/452412009074941952[to] https://twitter.com/Developerdave/status/452430573836193792[experienced] https://twitter.com/puredanger/status/452430894700048384[Clojurians] although not me. I had something similar to the following bit of code which I expected to only evaluate the first item of the infinite sequence that the range function generates: [source,lisp] ---- > (take 1 (map (fn [x] (println (str "printing..." x))) (range))) (printing...0 printing...1 printing...2 printing...3 printing...4 printing...5 printing...6 printing...7 printing...8 printing...9 printing...10 printing...11 printing...12 printing...13 printing...14 printing...15 printing...16 printing...17 printing...18 printing...19 printing...20 printing...21 printing...22 printing...23 printing...24 printing...25 printing...26 printing...27 printing...28 printing...29 printing...30 printing...31 nil) ---- The reason this was annoying is because I wanted to shortcut the lazy sequence using +++<cite>+++http://clojuredocs.org/clojure_core/clojure.core/take-while[take-while]+++</cite>+++, much like the poster of http://stackoverflow.com/questions/3407876/how-do-i-avoid-clojures-chunking-behavior-for-lazy-seqs-that-i-want-to-short-ci[this StackOverflow question]. As I understand it when we have a lazy sequence the granularity of that laziness is 32 items at a time a.k.a one chunk, something that Michael Fogus http://blog.fogus.me/2010/01/22/de-chunkifying-sequences-in-clojure/[wrote about 4 years ago]. This was a bit surprising to me but it sounds like it makes sense for the majority of cases. However, if we want to work around that behaviour we can wrap the lazy sequence in the following +++<cite>+++unchunk+++</cite>+++ function provided by Stuart Sierra: [source,lisp] ---- (defn unchunk [s] (when (seq s) (lazy-seq (cons (first s) (unchunk (next s)))))) ---- Now if we repeat our initial code we'll see it only prints once: [source,lisp] ---- > (take 1 (map (fn [x] (println (str "printing..." x))) (unchunk (range)))) (printing...0 nil) ----

clojure-not-so-lazy-sequences-a-k-a-chunking-behaviour

https://markhneedham.com/blog/2014/04/06/clojure-not-so-lazy-sequences-a-k-a-chunking-behaviour

2014-04-23 22:02:19

Neo4j: Cypher - Flatten a collection

Every now and then in Cypher land we'll end up with a collection of arrays, often created via the http://docs.neo4j.org/chunked/stable/query-aggregation.html#aggregation-collect[COLLECT] function, that we want to squash down into one array. For example let's say we have the following array of arrays\... [source,cypher] ---- $ RETURN [[1,2,3], [4,5,6], [7,8,9]] AS result; ==> +---------------------------+ ==> | result | ==> +---------------------------+ ==> | [[1,2,3],[4,5,6],[7,8,9]] | ==> +---------------------------+ ==> 1 row ---- \...and we want to return the array +++<cite>+++[1,2,3,4,5,6,7,8,9]+++</cite>+++. Many programming languages have a 'flatten' function and although cypher doesn't we can make our own by using the +++<cite>+++http://docs.neo4j.org/chunked/stable/query-functions-collection.html#functions-reduce[REDUCE]+++</cite>+++ function: [source,cypher] ---- $ WITH [[1,2,3], [4,5,6], [7,8,9]] AS result RETURN REDUCE(output = [], r IN result | output + r) AS flat; ==> +---------------------+ ==> | flat | ==> +---------------------+ ==> | [1,2,3,4,5,6,7,8,9] | ==> +---------------------+ ==> 1 row ---- Here we're passing the array 'output' over the collection and adding the individual arrays (+++<cite>+++[1,2,3]+++</cite>+++, +++<cite>+++[4,5,6]+++</cite>+++ and +++<cite>+++[7,8,9]+++</cite>+++) to that array as we iterate over the collection. If we're working with numbers in Neo4j 2.0.1 we'll get this type exception with this version of the code: [source,text] ---- ==> SyntaxException: Type mismatch: expected Any, Collection<Any> or Collection<Collection<Any>> but was Integer (line 1, column 148) ---- We can easily work around that by coercing the type of 'output' like so: [source,cypher] ---- WITH [[1,2,3], [4,5,6], [7,8,9]] AS result RETURN REDUCE(output = range(0,-1), r IN result | output + r); ---- Of course this is quite a simple example but we can handle more complicated scenarios as well by using nested calls to REDUCE. For example let's say we wanted to completely flatten this array: [source,cypher] ---- $ RETURN [[1,2,3], [4], [5, [6, 7]], [8,9]] AS result; ==> +-------------------------------+ ==> | result | ==> +-------------------------------+ ==> | [[1,2,3],[4],[5,[6,7]],[8,9]] | ==> +-------------------------------+ ==> 1 row ---- We could write the following cypher code: [source,cypher] ---- $ WITH [[1,2,3], [4], [5, [6, 7]], [8,9]] AS result RETURN REDUCE(output = [], r IN result | output + REDUCE(innerOutput = [], innerR in r | innerOutput + innerR)) AS flat; ==> +---------------------+ ==> | flat | ==> +---------------------+ ==> | [1,2,3,4,5,6,7,8,9] | ==> +---------------------+ ==> 1 row ---- Here we have an outer REDUCE function which iterates over +++<cite>+++[1,2,3]+++</cite>+++, +++<cite>+++[4]+++</cite>+++, +++<cite>+++[5, [6,7]]+++</cite>+++ and +++<cite>+++[8,9]+++</cite>+++ and then an inner REDUCE function which iterates over those individual arrays. If we had more nesting then we could just introduce another level of nesting!

neo4j-cypher-flatten-a-collection

https://markhneedham.com/blog/2014/04/23/neo4j-cypher-flatten-a-collection

2014-04-13 17:40:05

Neo4j 2.0.0: Query not prepared correctly / Type mismatch: expected Map

I was playing around with Neo4j's Cypher last weekend and found myself accidentally running some queries against an earlier version of the Neo4j 2.0 series (2.0.0). My first query started with a map and I wanted to create a person from an identifier inside the map: [source,cypher] ---- WITH {person: {id: 1}} AS params MERGE (p:Person {id: params.person.id}) RETURN p ---- When I ran the query I got this error: [source,text] ---- ==> SyntaxException: Type mismatch: expected Map but was Boolean, Number, String or Collection<Any> (line 1, column 62) ==> "WITH {person: {id: 1}} AS params MERGE (p:Person {id: params.person.id}) RETURN p" ---- If we try the same query in 2.0.1 it works as we'd expect: [source,text] ---- ==> +---------------+ ==> | p | ==> +---------------+ ==> | Node[1]{id:} | ==> +---------------+ ==> 1 row ==> Nodes created: 1 ==> Properties set: 1 ==> Labels added: 1 ==> 47 ms ---- My next query was the following which links topics of interest to a person: [source,cypher] ---- WITH {topics: [{name: "Java"}, {name: "Neo4j"}]} AS params MERGE (p:Person {id: 2}) FOREACH(t IN params.topics | MERGE (topic:Topic {name: t.name}) MERGE (p)-[:INTERESTED_IN]->(topic) ) RETURN p ---- In 2.0.0 that query fails like so: [source,text] ---- ==> InternalException: Query not prepared correctly! ---- but if we try it in 2.0.1 we'll see that it works as well: [source,text] ---- ==> +---------------+ ==> | p | ==> +---------------+ ==> | Node[4]{id:2} | ==> +---------------+ ==> 1 row ==> Nodes created: 1 ==> Relationships created: 2 ==> Properties set: 1 ==> Labels added: 1 ==> 53 ms ---- So if you're seeing either of those errors then http://www.neo4j.org/download[get yourself upgraded] to 2.0.1 as well!

neo4j-2-0-0-query-not-prepared-correctly-type-mismatch-expected-map

https://markhneedham.com/blog/2014/04/13/neo4j-2-0-0-query-not-prepared-correctly-type-mismatch-expected-map

2014-05-20 23:14:07

Neo4j 2.1: Creating adjacency matrices

About 9 months ago I wrote a blog post showing how to http://www.markhneedham.com/blog/2013/08/11/neo4j-extracting-a-subgraph-as-an-adjacency-matrix-and-calculating-eigenvector-centrality-with-jblas/[export an adjacency matrix^] from a Neo4j 1.9 database using the cypher query language and I thought it deserves an update to use 2.0 syntax. I've been spending some of my free time working on https://github.com/mneedham/neo4j-meetup[an application that runs on top of meetup.com's API^] and one of the queries I wanted to write was to find the common members between 2 meetup groups. The first part of this query is a cartesian product of the groups we want to consider which will give us the combinations of pairs of groups: [source,cypher] ---- MATCH (g1:Group), (g2:Group) RETURN g1.name, g2.name LIMIT 10 ---- .Results [source,bash] ---- +-------------------------------------------------------------------------------------+ | g1.name | g2.name | +-------------------------------------------------------------------------------------+ | "London ElasticSearch User Group" | "London ElasticSearch User Group" | | "London ElasticSearch User Group" | "Big Data / Data Science / Data Analytics Jobs" | | "London ElasticSearch User Group" | "eXist User Group London" | | "London ElasticSearch User Group" | "Couchbase London" | | "London ElasticSearch User Group" | "Big Data Developers in London" | | "London ElasticSearch User Group" | "HBase London Meetup" | | "London ElasticSearch User Group" | "Marklogic Financial Services Community" | | "London ElasticSearch User Group" | "GridGain London" | | "London ElasticSearch User Group" | "MEAN Stack" | | "London ElasticSearch User Group" | "Hazelcast User Group London (HUGL)" | ... +-------------------------------------------------------------------------------------+ ---- Our next step is to write a pattern which checks for common members between each pair of groups. We end up with the following: [source,cypher] ---- MATCH (g1:Group), (g2:Group) OPTIONAL MATCH (g1)<-[:MEMBER_OF]-()-[:MEMBER_OF]->(g2) RETURN g1.name, g2.name, COUNT(*) AS overlap ---- .Results [source,bash] ---- +----------------------------------------------------------------------------------------------+ | g1.name | g2.name | overlap | +----------------------------------------------------------------------------------------------+ | "eXist User Group London" | "Women in Data" | 1 | | "Hive London" | "Big Data Developers in London" | 47 | | "Neo4j - London User Group" | "London ElasticSearch User Group" | 80 | | "MEAN Stack" | "The London Distributed Graph Database Meetup Group" | 1 | | "HBase London Meetup" | "Big Data London" | 92 | | "London MongoDB User Group" | "Big Data Developers in London" | 63 | | "Big Data London" | "Hive London" | 195 | | "HBase London Meetup" | "Cassandra London" | 58 | | "Big Data London" | "Neo4j - London User Group" | 330 | | "Cassandra London" | "Oracle Big Data 4 the Enterprise" | 50 | ... +----------------------------------------------------------------------------------------------+ ---- The next step is to sort the rows so that we can create an array of values for each group in our next step. We therefore sort by group1 and then by group2: [source,cypher] ---- MATCH (g1:Group), (g2:Group) OPTIONAL MATCH (g1)<-[:MEMBER_OF]-()-[:MEMBER_OF]->(g2) RETURN g1.name, g2.name, COUNT(*) AS overlap ORDER BY g1.name, g2.name ---- .Results [source,bash] ---- +-------------------------------------------------------------------------------------------------------------+ | g1.name | g2.name | overlap | +-------------------------------------------------------------------------------------------------------------+ | "Big Data / Data Science / Data Analytics Jobs" | "Big Data / Data Science / Data Analytics Jobs" | 1 | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data Developers in London" | 17 | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data Jobs in London" | 20 | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data London" | 37 | | "Big Data / Data Science / Data Analytics Jobs" | "Cassandra London" | 16 | | "Big Data / Data Science / Data Analytics Jobs" | "Couchbase London" | 3 | | "Big Data / Data Science / Data Analytics Jobs" | "Data Science London" | 49 | | "Big Data / Data Science / Data Analytics Jobs" | "DeNormalised London" | 3 | | "Big Data / Data Science / Data Analytics Jobs" | "Enterprise Search London Meetup" | 2 | | "Big Data / Data Science / Data Analytics Jobs" | "GridGain London" | 1 | ... +-------------------------------------------------------------------------------------------------------------+ ---- One strange thing we see here is that there is an overlap of 1 between 'Big Data / Data Science / Data Analytics Jobs' and itself which is 'wrong' as the query doesn't actually return any overlapping members. However, since we used 'OPTIONAL MATCH' we would still have got 1 row back for that pair of groups with a 'null' value. Let's fix that: [source,cypher] ---- MATCH (g1:Group), (g2:Group) OPTIONAL MATCH path = (g1)<-[:MEMBER_OF]-()-[:MEMBER_OF]->(g2) WITH g1, g2, CASE WHEN path is null THEN 0 ELSE COUNT(path) END AS overlap RETURN g1.name, g2.name, overlap ORDER BY g1.name, g2.name LIMIT 10 ---- .Results [source,bash] ---- +-------------------------------------------------------------------------------------------------------------+ | g1.name | g2.name | overlap | +-------------------------------------------------------------------------------------------------------------+ | "Big Data / Data Science / Data Analytics Jobs" | "Big Data / Data Science / Data Analytics Jobs" | 0 | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data Developers in London" | 17 | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data Jobs in London" | 20 | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data London" | 37 | | "Big Data / Data Science / Data Analytics Jobs" | "Cassandra London" | 16 | | "Big Data / Data Science / Data Analytics Jobs" | "Couchbase London" | 3 | | "Big Data / Data Science / Data Analytics Jobs" | "Data Science London" | 49 | | "Big Data / Data Science / Data Analytics Jobs" | "DeNormalised London" | 3 | | "Big Data / Data Science / Data Analytics Jobs" | "Enterprise Search London Meetup" | 2 | | "Big Data / Data Science / Data Analytics Jobs" | "GridGain London" | 0 | ... +-------------------------------------------------------------------------------------------------------------+ ---- We'll see that there is no overlap with 'GridGain London' either which we didn't know before. We've been able to do this by using http://docs.neo4j.org/chunked/milestone/syntax-simple-case.html[CASE^] and checking whether or not the OPTIONAL MATCH came up with a path or not. Our next step is to group the data returned so that we have one row for each meetup group which contains an array showing the overlap with all the other groups: [source,cypher] ---- MATCH (g1:Group), (g2:Group) OPTIONAL MATCH path = (g1)<-[:MEMBER_OF]-()-[:MEMBER_OF]->(g2) WITH g1, g2, CASE WHEN path is null THEN 0 ELSE COUNT(path) END AS overlap ORDER BY g1.name, g2.name RETURN g1.name, COLLECT(overlap) ORDER BY g1.name ---- .Results [source,bash] ---- +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | g1.name | COLLECT(overlap) | +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | "Big Data / Data Science / Data Analytics Jobs" | [0,17,20,37,16,3,49,3,2,0,6,4,28,2,11,0,3,4,5,13,4,1,4,0,2,0,20,1,5,5,0,5,4,4,1] | | "Big Data Developers in London" | [17,0,48,231,67,18,228,18,17,0,38,10,150,12,47,4,24,18,31,63,36,11,20,7,7,1,88,2,38,10,0,33,11,26,3] | | "Big Data Jobs in London" | [20,48,0,189,70,16,168,19,7,0,21,10,128,9,51,4,24,14,23,69,13,5,20,5,7,2,69,1,34,12,0,10,10,19,4] | | "Big Data London" | [37,231,189,0,417,49,1128,94,89,0,92,31,738,39,195,20,116,93,124,328,98,44,81,20,36,10,330,2,122,79,2,74,45,107,11] | | "Cassandra London" | [16,67,70,417,0,36,276,63,40,1,58,13,292,34,104,9,72,55,71,195,58,23,64,9,10,2,174,4,50,65,2,21,23,19,4] | | "Couchbase London" | [3,18,16,49,36,0,42,8,6,1,19,6,56,7,20,2,16,11,24,51,21,10,22,12,7,1,43,2,12,9,1,6,5,9,2] | | "Data Science London" | [49,228,168,1128,276,42,0,93,83,2,71,32,611,24,174,17,63,83,120,268,82,36,60,21,22,3,363,3,88,65,0,98,45,141,9] | | "DeNormalised London" | [3,18,19,94,63,8,93,0,5,1,17,5,75,6,39,3,20,34,16,53,16,7,27,1,6,2,55,1,20,17,0,3,17,7,3] | | "Enterprise Search London Meetup" | [2,17,7,89,40,6,83,5,0,0,9,0,64,4,22,2,6,8,75,44,12,5,11,3,17,2,48,0,9,19,0,7,9,6,0] | | "GridGain London" | [0,0,0,0,1,1,2,1,0,0,0,1,1,3,1,0,0,0,0,1,1,0,0,0,0,0,2,0,0,0,0,0,0,0,0] | | "HBase London Meetup" | [6,38,21,92,58,19,71,17,9,0,0,3,94,15,37,3,17,9,30,38,22,6,12,5,5,1,51,2,24,9,0,9,10,4,4] | | "HPC & GPU Supercomputing Group of London" | [4,10,10,31,13,6,32,5,0,1,3,0,25,4,6,1,6,4,4,8,2,1,4,0,0,0,16,0,3,4,0,2,3,1,1] | | "Hadoop Users Group UK" | [28,150,128,738,292,56,611,75,64,1,94,25,0,29,214,9,81,67,113,272,75,28,72,13,28,4,259,3,101,60,4,38,39,48,11] | | "Hazelcast User Group London (HUGL)" | [2,12,9,39,34,7,24,6,4,3,15,4,29,0,6,1,6,5,5,20,14,2,10,2,1,1,27,0,3,2,1,5,2,0,1] | | "Hive London" | [11,47,51,195,104,20,174,39,22,1,37,6,214,6,0,2,22,31,40,75,23,13,26,4,9,1,80,2,39,27,1,12,18,13,1] | | "London Actionable Behavioral Analytics for Web and Mobile" | [0,4,4,20,9,2,17,3,2,0,3,1,9,1,2,0,1,0,2,8,4,1,1,1,0,1,7,0,2,0,0,8,1,2,1] | | "London Cloud Computing / NoSQL" | [3,24,24,116,72,16,63,20,6,0,17,6,81,6,22,1,0,11,15,52,21,7,27,3,7,1,39,0,15,21,4,2,2,9,5] | | "London Data Bar" | [4,18,14,93,55,11,83,34,8,0,9,4,67,5,31,0,11,0,13,58,12,4,22,3,1,0,44,4,19,7,0,5,8,8,0] | | "London ElasticSearch User Group" | [5,31,23,124,71,24,120,16,75,0,30,4,113,5,40,2,15,13,0,80,22,9,32,9,6,0,80,1,20,33,1,6,9,11,2] | | "London MongoDB User Group" | [13,63,69,328,195,51,268,53,44,1,38,8,272,20,75,8,52,58,80,0,56,32,64,62,21,4,211,5,52,71,3,17,22,22,5] | | "London NoSQL" | [4,36,13,98,58,21,82,16,12,1,22,2,75,14,23,4,21,12,22,56,0,16,24,20,8,2,69,1,12,13,0,18,8,6,3] | | "London PostgreSQL Meetup Group" | [1,11,5,44,23,10,36,7,5,0,6,1,28,2,13,1,7,4,9,32,16,0,12,2,5,1,29,1,10,10,0,3,2,7,0] | | "London Riak Meetup" | [4,20,20,81,64,22,60,27,11,0,12,4,72,10,26,1,27,22,32,64,24,12,0,5,7,1,63,2,9,24,1,9,12,4,3] | | "MEAN Stack" | [0,7,5,20,9,12,21,1,3,0,5,0,13,2,4,1,3,3,9,62,20,2,5,0,1,0,27,1,1,4,1,6,1,3,1] | | "MarkLogic User Group London" | [2,7,7,36,10,7,22,6,17,0,5,0,28,1,9,0,7,1,6,21,8,5,7,1,0,16,22,1,8,6,0,0,5,5,13] | | "Marklogic Financial Services Community" | [0,1,2,10,2,1,3,2,2,0,1,0,4,1,1,1,1,0,0,4,2,1,1,0,16,0,6,0,1,1,0,1,1,1,4] | | "Neo4j - London User Group" | [20,88,69,330,174,43,363,55,48,2,51,16,259,27,80,7,39,44,80,211,69,29,63,27,22,6,0,5,40,43,3,36,44,58,11] | | "OpenCredo Tech Workshops" | [1,2,1,2,4,2,3,1,0,0,2,0,3,0,2,0,0,4,1,5,1,1,2,1,1,0,5,0,2,1,0,0,1,1,0] | | "Oracle Big Data 4 the Enterprise" | [5,38,34,122,50,12,88,20,9,0,24,3,101,3,39,2,15,19,20,52,12,10,9,1,8,1,40,2,0,10,0,2,7,9,4] | | "Redis London" | [5,10,12,79,65,9,65,17,19,0,9,4,60,2,27,0,21,7,33,71,13,10,24,4,6,1,43,1,10,0,0,2,7,2,1] | | "The Apache Jmeter London Group" | [0,0,0,2,2,1,0,0,0,0,0,0,4,1,1,0,4,0,1,3,0,0,1,1,0,0,3,0,0,0,0,1,0,0,0] | | "The Data Scientist - UK" | [5,33,10,74,21,6,98,3,7,0,9,2,38,5,12,8,2,5,6,17,18,3,9,6,0,1,36,0,2,2,1,0,2,12,1] | | "The London Distributed Graph Database Meetup Group" | [4,11,10,45,23,5,45,17,9,0,10,3,39,2,18,1,2,8,9,22,8,2,12,1,5,1,44,1,7,7,0,2,0,9,1] | | "Women in Data" | [4,26,19,107,19,9,141,7,6,0,4,1,48,0,13,2,9,8,11,22,6,7,4,3,5,1,58,1,9,2,0,12,9,0,1] | | "eXist User Group London" | [1,3,4,11,4,2,9,3,0,0,4,1,11,1,1,1,5,0,2,5,3,0,3,1,13,4,11,0,4,1,0,1,1,1,0] | +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ---- This query is reasonably easy to follow and our next step would be to plug the output of this query into a visualisation tool of some sort. Sometimes we can't create the cartesian product as easily as we were able to here - all we needed to do was call MATCH with the same label twice. We can create cartesian products in other scenarios as well. For example let's say we only want to compare the first 5 meetup groups ordered by name. First we'll get the top 5 groups: [source,cypher] ---- MATCH (g:Group) RETURN g.name ORDER BY g.name LIMIT 5 ---- .Results [source,bash] ---- +-------------------------------------------------+ | g.name | +-------------------------------------------------+ | "Big Data / Data Science / Data Analytics Jobs" | | "Big Data Developers in London" | | "Big Data Jobs in London" | | "Big Data London" | | "Cassandra London" | +-------------------------------------------------+ ---- Now let's get all the pairs of those groups: [source,cypher] ---- MATCH (g:Group) WITH g ORDER BY g.name LIMIT 5 WITH COLLECT(g) AS groups UNWIND groups AS g1 UNWIND groups AS g2 RETURN g1.name, g2.name ORDER BY g1.name, g2.name ---- .Results [source,bash] ---- +---------------------------------------------------------------------------------------------------+ | g1.name | g2.name | +---------------------------------------------------------------------------------------------------+ | "Big Data / Data Science / Data Analytics Jobs" | "Big Data / Data Science / Data Analytics Jobs" | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data Developers in London" | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data Jobs in London" | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data London" | | "Big Data / Data Science / Data Analytics Jobs" | "Cassandra London" | | "Big Data Developers in London" | "Big Data / Data Science / Data Analytics Jobs" | | "Big Data Developers in London" | "Big Data Developers in London" | | "Big Data Developers in London" | "Big Data Jobs in London" | | "Big Data Developers in London" | "Big Data London" | | "Big Data Developers in London" | "Cassandra London" | | "Big Data Jobs in London" | "Big Data / Data Science / Data Analytics Jobs" | | "Big Data Jobs in London" | "Big Data Developers in London" | | "Big Data Jobs in London" | "Big Data Jobs in London" | | "Big Data Jobs in London" | "Big Data London" | | "Big Data Jobs in London" | "Cassandra London" | | "Big Data London" | "Big Data / Data Science / Data Analytics Jobs" | | "Big Data London" | "Big Data Developers in London" | | "Big Data London" | "Big Data Jobs in London" | | "Big Data London" | "Big Data London" | | "Big Data London" | "Cassandra London" | | "Cassandra London" | "Big Data / Data Science / Data Analytics Jobs" | | "Cassandra London" | "Big Data Developers in London" | | "Cassandra London" | "Big Data Jobs in London" | | "Cassandra London" | "Big Data London" | | "Cassandra London" | "Cassandra London" | +---------------------------------------------------------------------------------------------------+ ---- Here we're making use of my current favourite function in cypher - http://docs.neo4j.org/chunked/milestone/query-unwind.html[UNWIND^] - which allows you to take a collection of things and expand them out to have an individual row each. It's currently only available in the latest RC of Neo4j 2.1 so we'll have to wait a little bit longer before using it in production! We complete the query like so: [source,cypher] ---- MATCH (g:Group) WITH g ORDER BY g.name LIMIT 5 WITH COLLECT(g) AS groups UNWIND groups AS g1 UNWIND groups AS g2 OPTIONAL MATCH path = (g1)<-[:MEMBER_OF]-()-[:MEMBER_OF]->(g2) WITH g1, g2, CASE WHEN path is null THEN 0 ELSE COUNT(path) END AS overlap ORDER BY g1.name, g2.name RETURN g1.name, COLLECT(overlap) ORDER BY g1.name ---- .Results [source,cypher] ---- +----------------------------------------------------------------------+ | g1.name | COLLECT(overlap) | +----------------------------------------------------------------------+ | "Big Data / Data Science / Data Analytics Jobs" | [0,17,20,37,16] | | "Big Data Developers in London" | [17,0,48,231,67] | | "Big Data Jobs in London" | [20,48,0,189,70] | | "Big Data London" | [37,231,189,0,417] | | "Cassandra London" | [16,67,70,417,0] | +----------------------------------------------------------------------+ ---- And we're done!

neo4j-2-0-creating-adjacency-matrices

https://markhneedham.com/blog/2014/05/20/neo4j-2-0-creating-adjacency-matrices

2014-05-31 21:32:24

Neo4j/R: Analysing London NoSQL meetup membership

In my spare time I've been working on https://github.com/mneedham/neo4j-meetup[a Neo4j application that runs on tops of meetup.com's API] and Nicole recently showed me how I could wire up some of the queries to http://nicolewhite.github.io/2014/05/30/demo-of-rneo4j-part1.html[use her Rneo4j library]: +++ <blockquote class="twitter-tweet"><p lang="und" dir="ltr"><a href="https://twitter.com/markhneedham?ref_src=twsrc%5Etfw">@markhneedham</a> <a href="http://t.co/8014jckEUl">pic.twitter.com/8014jckEUl</a></p>&mdash; Nicole White (@_nicolemargaret) <a href="https://twitter.com/_nicolemargaret/status/472761625246957569?ref_src=twsrc%5Etfw">May 31, 2014</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script> +++ The query used in that visualisation shows the number of members that overlap between each pair of groups but a more interesting query is the one which shows the % overlap between groups based on the unique members across the groups. The query is a bit more complicated than the original: [source,cypher] ---- MATCH (group1:Group), (group2:Group) OPTIONAL MATCH (group1)<-[:MEMBER_OF]-()-[:MEMBER_OF]->(group2) WITH group1, group2, COUNT(*) as commonMembers MATCH (group1)<-[:MEMBER_OF]-(group1Member) WITH group1, group2, commonMembers, COLLECT(id(group1Member)) AS group1Members MATCH (group2)<-[:MEMBER_OF]-(group2Member) WITH group1, group2, commonMembers, group1Members, COLLECT(id(group2Member)) AS group2Members WITH group1, group2, commonMembers, group1Members, group2Members UNWIND(group1Members + group2Members) AS combinedMember WITH DISTINCT group1, group2, commonMembers, combinedMember WITH group1, group2, commonMembers, COUNT(combinedMember) AS combinedMembers RETURN group1.name, group2.name, toInt(round(100.0 * commonMembers / combinedMembers)) AS percentage ORDER BY group1.name, group1.name ---- The next step is to wire that up to use Rneo4j and ggplot2. First we'll get the libraries installed and loaded: [source,r] ---- install.packages("devtools") devtools::install_github("nicolewhite/Rneo4j") install.packages("ggplot2") library(Rneo4j) library(ggplot2) ---- And now we'll execute the query and create a chart from the results: [source,r] ---- graph = startGraph("http://localhost:7474/db/data/") query = "MATCH (group1:Group), (group2:Group) WHERE group1 <> group2 OPTIONAL MATCH p = (group1)<-[:MEMBER_OF]-()-[:MEMBER_OF]->(group2) WITH group1, group2, COLLECT(p) AS paths RETURN group1.name, group2.name, LENGTH(paths) as commonMembers ORDER BY group1.name, group2.name" group_overlap = cypher(graph, query) ggplot(group_overlap, aes(x=group1.name, y=group2.name, fill=commonMembers)) + geom_bin2d() + geom_text(aes(label = commonMembers)) + labs(x= "Group", y="Group", title="Member Group Member Overlap") + scale_fill_gradient(low="white", high="red") + theme(axis.text = element_text(size = 12, color = "black"), axis.title = element_text(size = 14, color = "black"), plot.title = element_text(size = 16, color = "black"), axis.text.x = element_text(angle = 45, vjust = 1, hjust = 1)) // as percentage query = "MATCH (group1:Group), (group2:Group) WHERE group1 <> group2 OPTIONAL MATCH path = (group1)<-[:MEMBER_OF]-()-[:MEMBER_OF]->(group2) WITH group1, group2, COLLECT(path) AS paths WITH group1, group2, LENGTH(paths) as commonMembers MATCH (group1)<-[:MEMBER_OF]-(group1Member) WITH group1, group2, commonMembers, COLLECT(id(group1Member)) AS group1Members MATCH (group2)<-[:MEMBER_OF]-(group2Member) WITH group1, group2, commonMembers, group1Members, COLLECT(id(group2Member)) AS group2Members WITH group1, group2, commonMembers, group1Members, group2Members UNWIND(group1Members + group2Members) AS combinedMember WITH DISTINCT group1, group2, commonMembers, combinedMember WITH group1, group2, commonMembers, COUNT(combinedMember) AS combinedMembers RETURN group1.name, group2.name, toInt(round(100.0 * commonMembers / combinedMembers)) AS percentage ORDER BY group1.name, group1.name" group_overlap = cypher(graph, query) ggplot(group_overlap, aes(x=group1.name, y=group2.name, fill=percentage)) + geom_bin2d() + geom_text(aes(label = percentage)) + labs(x= "Group", y="Group", title="Member Group Member Overlap") + scale_fill_gradient(low="white", high="red") + theme(axis.text = element_text(size = 12, color = "black"), axis.title = element_text(size = 14, color = "black"), plot.title = element_text(size = 16, color = "black"), axis.text.x = element_text(angle = 45, vjust = 1, hjust = 1)) ---- image::{{<siteurl>}}/uploads/2014/05/2014-05-31_21-54-42.png[2014 05 31 21 54 42,600] A first glance at the visualisation suggests that the Hadoop, Data Science and Big Data groups have the most overlap which seems to make sense as they do cover quite similar topics. Thanks to Nicole for the library and the idea of the visualisation. Now we need to do some more analysis on the data to see if there are any more interesting insights.

neo4jr-analysing-london-nosql-meetup-membership

https://markhneedham.com/blog/2014/05/31/neo4jr-analysing-london-nosql-meetup-membership

2014-05-31 12:44:10

Neo4j: Cypher - Neo.ClientError.Statement.ParameterMissing and neo4j-shell

Every now and then I get sent Neo4j cypher queries to look at and more often than not they're http://docs.neo4j.org/chunked/stable/cypher-parameters.html[parameterised] which means you can't easily run them in the http://neo4j.com/blog/neo4j-2-0-0-m06-introducing-neo4js-browser/[Neo4j browser]. For example let's say we have a database which has a user called 'Mark': [source,cypher] ---- CREATE (u:User {name: "Mark"}) ---- Now we write a query to find 'Mark' with the name parameterised so we can easily search for a different user in future: [source,cypher] ---- MATCH (u:User {name: {name}}) RETURN u ---- If we run that query in the Neo4j browser we'll get this error: [source,bash] ---- Expected a parameter named name Neo.ClientError.Statement.ParameterMissing ---- If we try that in neo4j-shell we'll get the same exception to start with: [source,cypher] ---- $ MATCH (u:User {name: {name}}) RETURN u; ParameterNotFoundException: Expected a parameter named name ---- However, as https://twitter.com/mesirii[Michael] pointed out to me, the neat thing about neo4j-shell is that we can define parameters by using the +++<cite>+++export+++</cite>+++ command: [source,cypher] ---- $ export name="Mark" $ MATCH (u:User {name: {name}}) RETURN u; +-------------------------+ | u | +-------------------------+ | Node[1923]{name:"Mark"} | +-------------------------+ 1 row ---- +++<cite>+++export+++</cite>+++ is a bit sensitive to spaces so it's best to keep them to a minimum. e.g. the following tries to create the variable 'name ' which is invalid: [source,bash] ---- $ export name = "Mark" name is no valid variable name. May only contain alphanumeric characters and underscores. ---- The variables we create in the shell don't have to only be primitives. We can create maps too: [source,bash] ---- $ export params={ name: "Mark" } $ MATCH (u:User {name: {params}.name}) RETURN u; +-------------------------+ | u | +-------------------------+ | Node[1923]{name:"Mark"} | +-------------------------+ 1 row ---- A simple tip but one that saves me from having to rewrite queries all the time!

neo4j-cypher-neo-clienterror-statement-parametermissing-and-neo4j-shell

https://markhneedham.com/blog/2014/05/31/neo4j-cypher-neo-clienterror-statement-parametermissing-and-neo4j-shell

2014-05-31 14:19:25

Neo4j: Cypher - UNWIND vs FOREACH

I've written a http://www.markhneedham.com/blog/2014/05/20/neo4j-2-0-creating-adjacency-matrices/[couple of^] http://www.markhneedham.com/blog/2014/05/25/neo4j-2-1-passing-around-node-ids-vs-unwind/[posts^] about the new http://docs.neo4j.org/chunked/milestone/query-unwind.html[UNWIND^] clause in Neo4j's cypher query language but I forgot about my favourite use of UNWIND, which is to get rid of some uses of http://docs.neo4j.org/chunked/stable/query-foreach.html[FOREACH^] from our queries. Let's say we've http://www.markhneedham.com/blog/2014/04/19/neo4j-cypher-creating-a-time-tree-down-to-the-day/[created a timetree up front^] and now have a series of events coming in that we want to create in the database and attach to the appropriate part of the timetree. Before UNWIND existed we might try to write the following query using FOREACH: [source,cypher] ---- WITH [{name: "Event 1", timetree: {day: 1, month: 1, year: 2014}}, {name: "Event 2", timetree: {day: 2, month: 1, year: 2014}}] AS events FOREACH (event IN events | CREATE (e:Event {name: event.name}) MATCH (year:Year {year: event.timetree.year }), (year)-[:HAS_MONTH]->(month {month: event.timetree.month }), (month)-[:HAS_DAY]->(day {day: event.timetree.day }) CREATE (e)-[:HAPPENED_ON]->(day)) ---- Unfortunately we can't use MATCH inside a FOREACH statement so we'll get the following error: [source,cypher] ---- Invalid use of MATCH inside FOREACH (line 5, column 3) " MATCH (year:Year {year: event.timetree.year }), " ^ Neo.ClientError.Statement.InvalidSyntax ---- We can work around this by using MERGE instead in the knowledge that it's never going to create anything because the timetree already exists: [source,cypher] ---- WITH [{name: "Event 1", timetree: {day: 1, month: 1, year: 2014}}, {name: "Event 2", timetree: {day: 2, month: 1, year: 2014}}] AS events FOREACH (event IN events | CREATE (e:Event {name: event.name}) MERGE (year:Year {year: event.timetree.year }) MERGE (year)-[:HAS_MONTH]->(month {month: event.timetree.month }) MERGE (month)-[:HAS_DAY]->(day {day: event.timetree.day }) CREATE (e)-[:HAPPENED_ON]->(day)) ---- If we replace the FOREACH with UNWIND we'd get the following: [source,cypher] ---- WITH [{name: "Event 1", timetree: {day: 1, month: 1, year: 2014}}, {name: "Event 2", timetree: {day: 2, month: 1, year: 2014}}] AS events UNWIND events AS event CREATE (e:Event {name: event.name}) WITH e, event.timetree AS timetree MATCH (year:Year {year: timetree.year }), (year)-[:HAS_MONTH]->(month {month: timetree.month }), (month)-[:HAS_DAY]->(day {day: timetree.day }) CREATE (e)-[:HAPPENED_ON]->(day) ---- Although the lines of code has slightly increased the query is now correct and we won't accidentally correct new parts of our time tree. We could also pass on the event that we created to the next part of the query which wouldn't be the case when using FOREACH.

neo4j-cypher-unwind-vs-foreach

https://markhneedham.com/blog/2014/05/31/neo4j-cypher-unwind-vs-foreach

2014-05-31 19:50:26

Thoughts on meetups

I recently came across an http://blog.factual.com/clojure-office-hours[interesting blog post by Zach Tellman] in which he explains a new approach that he's been trialling at http://www.meetup.com/The-Bay-Area-Clojure-User-Group/events/181057342/[The Bay Area Clojure User Group]. Zach explains that a lecture based approach isn't necessarily the most effective way for people to learn and that half of the people attending the meetup are likely to be novices and would struggle to follow more advanced content. He then goes on to explain an alternative approach: ____ We've been experimenting with a Clojure meetup modelled on a different academic tradition: *office hours*. At a university, students who have questions about the lecture content or coursework can visit the professor and have a one-on-one conversation. \... At the beginning of every meetup, we give everyone a name tag, and provide a whiteboard with two columns, "`teachers`" and "`students`". Attendees are encouraged to put their name and interests in both columns. From there, everyone can [\...] go in search of someone from the opposite column who shares their interests. ____ While running Neo4j meetups we've had similar observations and my colleagues https://twitter.com/darthvader42[Stefan] and https://twitter.com/neo4jfr[Cedric] http://www.meetup.com/graphdb-france/events/163480742/[actually ran a meetup in Paris a few months ago] which sounds very similar to Zach's 'office hours' style one. However, we've also been experimenting with the idea that *one size doesn't need to fit all* by running different styles of meetups aimed at different people. For example, we have: * http://www.meetup.com/graphdb-london/events/184326312/[An introductory meetup] which aims to get people to the point where they can follow talks about more advanced topics. * A http://www.meetup.com/graphdb-london/events/181678522/[more hands on session] for people who want to learn how to write queries in cypher, Neo4j's query language. * An http://www.meetup.com/graphdb-london/events/181676642/[advanced session] for people who want to learn how to model a problem as a graph and import data into a graph. I'm also thinking of running something similar to the http://londonclojurians.org/[Clojure Dojo] but focused on data and graphs where groups of people could work together and build an app. I noticed that Nick Manning has been doing http://www.meetup.com/nycneo4j/events/152795422/[a] http://www.meetup.com/nycneo4j/events/149762532/[similar] http://www.meetup.com/nycneo4j/events/158975752/[thing] with the http://www.meetup.com/nycneo4j/[New York City Neo4j meetup] as well, which is cool. I'd be interested in hearing about different / better approaches that other people have come across so if you know of any let me know in the comments.

thoughts-on-meetups

https://markhneedham.com/blog/2014/05/31/thoughts-on-meetups

2014-05-31 00:03:48

Clojure: Destructuring group-by's output

One of my favourite features of Clojure is that it allows you to destructure a data structure into values that are a bit easier to work with. I often find myself referring to http://blog.jayfields.com/2010/07/clojure-destructuring.html[Jay Fields' article] which contains several examples showing the syntax and is a good starting point. One recent use of destructuring I had was where I was working with a vector containing events like this: [source,lisp] ---- user> (def events [{:name "e1" :timestamp 123} {:name "e2" :timestamp 456} {:name "e3" :timestamp 789}]) ---- I wanted to split the events in two - those containing events with a timestamp greater than 123 and those less than or equal to 123. After remembering that the function I wanted was +++<cite>+++http://clojuredocs.org/clojure_core/1.2.0/clojure.core/group-by[group-by]+++</cite>+++ and not +++<cite>+++http://clojuredocs.org/clojure_core/1.2.0/clojure.core/partition-by[partition-by]+++</cite>+++ (I always make that mistake!) I had the following: [source,lisp] ---- user> (group-by #(> (->> % :timestamp) 123) events) {false [{:name "e1", :timestamp 123}], true [{:name "e2", :timestamp 456} {:name "e3", :timestamp 789}]} ---- I wanted to get 2 vectors that I could pass to the web page and this is fairly easy with destructuring: [source,lisp] ---- user> (let [{upcoming true past false} (group-by #(> (->> % :timestamp) 123) events)] (println upcoming) (println past)) [{:name e2, :timestamp 456} {:name e3, :timestamp 789}] [{:name e1, :timestamp 123}] nil ---- Simple!

clojure-destructuring-group-bys-output

https://markhneedham.com/blog/2014/05/31/clojure-destructuring-group-bys-output

2014-05-31 22:55:33

Neo4j Meetup Coding Dojo Style

A few weeks ago we ran a +++<cite>+++http://www.meetup.com/graphdb-london/events/179211972/[build your first Neo4j app]+++</cite>+++ meetup in the Neo4j London office during which we worked with the meta data around http://britishlibrary.typepad.co.uk/digital-scholarship/2013/12/a-million-first-steps.html[1 million images recently released into the public domain by the British Library]. Feedback from previous meetups had indicated that attendees wanted to practice modelling a domain from scratch and understand the options for importing said model into the database. This data set seemed perfect for this purpose. We started off by scanning the data set and coming up with some potential questions we could ask of it and then the group split in two and came up with a graph model: image::{{<siteurl>}}/uploads/2014/05/neo4j_dojo.png[Neo4j dojo,600] Having spent 15 minutes working on that, one person from each group explained the process they'd gone through to all attendees. Each group took a similar approach whereby they scanned a subset of the data, sketched out all the properties and then discussed whether or not something should be a node, relationship or property in a graph model. We then spent a bit of time tweaking the model so we had one everyone was happy with. We split into three groups to work on input. One group imported some of the data by generating cypher statements from Java, one imported data using http://book.py2neo.org/en/latest/[py2neo] and the last group imported data using the http://docs.neo4j.org/chunked/milestone/batchinsert.html[batch inserter]. You can have a look at the https://github.com/mneedham/neo4j-bl[github repository] to see what we got up and specifically the +++<cite>+++https://github.com/mneedham/neo4j-bl/tree/solution[solution]+++</cite>+++ branch to see the batch inserter code and the +++<cite>+++https://github.com/mneedham/neo4j-bl/tree/cypher-import[cypher-import]+++</cite>+++ branch for the cypher based approach. The approach we used throughout the session is quite similar to a http://www.markhneedham.com/blog/2011/03/29/thoughtworks-university-coding-dojo-style/[Kake coding dojo] - something I first tried out when I was a trainer at ThoughtWorks University. Although there were a few setup based things that could have been a bit slicker I think this format worked reasonably well and we'll use something similar at the http://www.meetup.com/graphdb-london/events/181676642/[next version in a couple of weeks time]. Feel free to come along if it sounds interesting!

neo4j-meetup-coding-dojo-style

https://markhneedham.com/blog/2014/05/31/neo4j-meetup-coding-dojo-style

2014-05-24 00:12:56

Clojure: Create a directory

I spent much longer than I should have done trying to work out how to create a directory in Clojure as part of an import script I'm working out so for my future self this is how you do it: [source,lisp] ---- (.mkdir (java.io.File. "/path/to/dir/to/create")) ---- I'm creating a directory which contains today's date so I'd want something like 'members-2014-05-24' if I was running it today. The https://github.com/clj-time/clj-time[clj-time] library is very good for working with dates. To create a folder containing today's date this is what we'd have: [source,lisp] ---- (ns neo4j-meetup.core (:require [clj-time.format :as f])) (def format-as-year-month-day (f/formatter "yyyy-MM-dd")) (defn create-directory-for-today [] (let [date (f/unparse format-as-year-month-day (t/now))] (.mkdir (java.io.File. (str "data/members-" date))))) ---- Initial code shamelessly stolen from https://gist.github.com/halfelf[Shu Wang's gist] so thanks to him as well!

clojure-create-a-directory

https://markhneedham.com/blog/2014/05/24/clojure-create-a-directory

2014-05-25 22:17:35

Neo4j: Cypher - Rounding a float value to decimal places

About 6 months ago http://www.jacqui.tk/[Jacqui Read] created a github issue explaining how she wanted to https://github.com/neo4j/neo4j/issues/1580[round a float value to a number of decimal places] but was unable to do so due to the +++<cite>+++http://docs.neo4j.org/chunked/stable/query-functions-mathematical.html#functions-round[round]+++</cite>+++ function not taking the appropriate parameter. I found myself wanting to do the same thing last week where I initially had the following value: [source,cypher] ---- RETURN toFloat("12.336666") AS value ---- I wanted to round that to 2 decimal places and https://twitter.com/wefreema[Wes] suggested multiplying the value before using ROUND and then dividing afterwards to achieve that. For two decimal places we need to multiply and divide by 100: [source,cypher] ---- WITH toFloat("12.336666") AS value RETURN round(100 * value) / 100 AS value ---- [source,bash] ---- 12.34 ---- https://twitter.com/mesirii[Michael] suggested abstracting the number of decimal places like so: [source,cypher] ---- WITH 2 as precision WITH toFloat("12.336666") AS value, 10^precision AS factor RETURN round(factor * value)/factor AS value ---- If we want to round to 4 decimal places we can easily change that: [source,cypher] ---- WITH 4 as precision WITH toFloat("12.336666") AS value, 10^precision AS factor RETURN round(factor * value)/factor AS value ---- [source,bash] ---- 12.3367 ---- The code is http://gist.neo4j.org/?0e68a1c6922c04b53af0[available as a graph gist] too if you want to play around with it. And you may as well check out the https://github.com/neo4j-contrib/graphgist/wiki[other gists] while you're at it - enjoy!

neo4j-cypher-rounding-a-float-value-to-decimal-places

https://markhneedham.com/blog/2014/05/25/neo4j-cypher-rounding-a-float-value-to-decimal-places

2014-05-25 10:48:39

Neo4j 2.1: Passing around node ids vs UNWIND

When Neo4j 2.1 is released we'll have the http://docs.neo4j.org/chunked/milestone/query-unwind.html[UNWIND] clause which makes working with collections of things easier. In my blog post about http://www.markhneedham.com/blog/2014/05/20/neo4j-2-0-creating-adjacency-matrices/[creating adjacency matrices] we wanted to show how many people were members of the first 5 meetup groups ordered alphabetically and then check how many were members of each of the other groups. Without the UNWIND clause we'd have to do this: [source,cypher] ---- MATCH (g:Group) WITH g ORDER BY g.name LIMIT 5 WITH COLLECT(id(g)) AS groups MATCH (g1) WHERE id(g1) IN groups MATCH (g2) WHERE id(g2) IN groups OPTIONAL MATCH path = (g1)<-[:MEMBER_OF]-()-[:MEMBER_OF]->(g2) RETURN g1.name, g2.name, CASE WHEN path is null THEN 0 ELSE COUNT(path) END AS overlap ---- Here we get the first 5 groups, put their IDs into a collection and then create a cartesian product of groups by doing back to back MATCH's with a node id lookup. If instead of passing around node ids in 'groups' we pass around nodes and then used those in the MATCH step we'd end up doing a full node scan which becomes very slow as the store grows. e.g. this version would be very slow [source,cypher] ---- MATCH (g:Group) WITH g ORDER BY g.name LIMIT 5 WITH COLLECT(g) AS groups MATCH (g1) WHERE g1 IN groups MATCH (g2) WHERE g2 IN groups OPTIONAL MATCH path = (g1)<-[:MEMBER_OF]-()-[:MEMBER_OF]->(g2) RETURN g1.name, g2.name, CASE WHEN path is null THEN 0 ELSE COUNT(path) END AS overlap ---- This is the output from the original query: [source,bash] ---- +-------------------------------------------------------------------------------------------------------------+ | g1.name | g2.name | overlap | +-------------------------------------------------------------------------------------------------------------+ | "Big Data Developers in London" | "Big Data / Data Science / Data Analytics Jobs" | 17 | | "Big Data Jobs in London" | "Big Data London" | 190 | | "Big Data London" | "Big Data Developers in London" | 244 | | "Cassandra London" | "Big Data / Data Science / Data Analytics Jobs" | 16 | | "Big Data Jobs in London" | "Big Data Developers in London" | 52 | | "Cassandra London" | "Cassandra London" | 0 | | "Big Data London" | "Big Data / Data Science / Data Analytics Jobs" | 36 | | "Big Data London" | "Cassandra London" | 422 | | "Big Data Jobs in London" | "Big Data Jobs in London" | 0 | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data / Data Science / Data Analytics Jobs" | 0 | | "Big Data Jobs in London" | "Cassandra London" | 74 | | "Big Data Developers in London" | "Big Data London" | 244 | | "Cassandra London" | "Big Data Jobs in London" | 74 | | "Cassandra London" | "Big Data London" | 422 | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data London" | 36 | | "Big Data Jobs in London" | "Big Data / Data Science / Data Analytics Jobs" | 20 | | "Big Data Developers in London" | "Big Data Jobs in London" | 52 | | "Cassandra London" | "Big Data Developers in London" | 69 | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data Jobs in London" | 20 | | "Big Data Developers in London" | "Big Data Developers in London" | 0 | | "Big Data Developers in London" | "Cassandra London" | 69 | | "Big Data / Data Science / Data Analytics Jobs" | "Big Data Developers in London" | 17 | | "Big Data London" | "Big Data Jobs in London" | 190 | | "Big Data / Data Science / Data Analytics Jobs" | "Cassandra London" | 16 | | "Big Data London" | "Big Data London" | 0 | +-------------------------------------------------------------------------------------------------------------+ 25 rows ---- If we use UNWIND we don't need to pass around node ids anymore, instead we can collect up the nodes into a collection and then explode them out into a cartesian product: [source,cypher] ---- MATCH (g:Group) WITH g ORDER BY g.name LIMIT 5 WITH COLLECT(g) AS groups UNWIND groups AS g1 UNWIND groups AS g2 OPTIONAL MATCH path = (g1)<-[:MEMBER_OF]-()-[:MEMBER_OF]->(g2) RETURN g1.name, g2.name, CASE WHEN path is null THEN 0 ELSE COUNT(path) END AS overlap ---- There's not significantly less code but I think the intent of the query is a bit clearer using UNWIND. I'm looking forward to seeing the innovative uses of UNWIND people come up with once 2.1 is GA.

neo4j-2-1-passing-around-node-ids-vs-unwind

https://markhneedham.com/blog/2014/05/25/neo4j-2-1-passing-around-node-ids-vs-unwind

2014-02-05 12:21:30

Jython/Neo4j: java.lang.ExceptionInInitializerError: java.lang.ExceptionInInitializerError

I've been playing around with calling Neo4j's Java API from Python via http://www.jython.org/[Jython] and immediately ran into the following exception when trying to create an embedded instance: [source,bash] ---- $ jython -Dpython.path /path/to/neo4j.jar Jython 2.5.3 (2.5:c56500f08d34+, Aug 13 2012, 14:48:36) [Java HotSpot(TM) 64-Bit Server VM (Oracle Corporation)] on java1.7.0_45 Type "help", "copyright", "credits" or "license" for more information. >>> import org.neo4j.graphdb.factory >>> org.neo4j.graphdb.factory.GraphDatabaseFactory().newEmbeddedDatabase("/tmp/foo") Traceback (most recent call last): File "<stdin>", line 1, in <module> at org.neo4j.graphdb.factory.GraphDatabaseFactory$1.newDatabase(GraphDatabaseFactory.java:83) at org.neo4j.graphdb.factory.GraphDatabaseBuilder.newGraphDatabase(GraphDatabaseBuilder.java:198) at org.neo4j.graphdb.factory.GraphDatabaseFactory.newEmbeddedDatabase(GraphDatabaseFactory.java:69) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:606) java.lang.ExceptionInInitializerError: java.lang.ExceptionInInitializerError ---- I eventually ended up at +++<cite>+++GraphDatabaseSettings+++</cite>+++ so I tried to import that: [source,bash] ---- >>> import org.neo4j.graphdb.factory.GraphDatabaseSettings Traceback (most recent call last): File "<stdin>", line 1, in <module> java.lang.ExceptionInInitializerError at java.lang.Class.forName0(Native Method) at java.lang.Class.forName(Class.java:270) at org.python.core.Py.loadAndInitClass(Py.java:909) at org.python.core.Py.findClassInternal(Py.java:844) at org.python.core.Py.findClassEx(Py.java:895) at org.python.core.packagecache.SysPackageManager.findClass(SysPackageManager.java:133) at org.python.core.packagecache.PackageManager.findClass(PackageManager.java:28) at org.python.core.packagecache.SysPackageManager.findClass(SysPackageManager.java:122) at org.python.core.PyJavaPackage.__findattr_ex__(PyJavaPackage.java:137) at org.python.core.PyObject.__findattr__(PyObject.java:863) at org.python.core.PyObject.impAttr(PyObject.java:1001) at org.python.core.imp.import_next(imp.java:720) at org.python.core.imp.import_logic(imp.java:782) at org.python.core.imp.import_module_level(imp.java:842) at org.python.core.imp.importName(imp.java:917) at org.python.core.ImportFunction.__call__(__builtin__.java:1220) at org.python.core.PyObject.__call__(PyObject.java:357) at org.python.core.__builtin__.__import__(__builtin__.java:1173) at org.python.core.imp.importOne(imp.java:936) at org.python.pycode._pyx5.f$0(<stdin>:1) at org.python.pycode._pyx5.call_function(<stdin>) at org.python.core.PyTableCode.call(PyTableCode.java:165) at org.python.core.PyCode.call(PyCode.java:18) at org.python.core.Py.runCode(Py.java:1275) at org.python.core.Py.exec(Py.java:1319) at org.python.util.PythonInterpreter.exec(PythonInterpreter.java:215) at org.python.util.InteractiveInterpreter.runcode(InteractiveInterpreter.java:89) at org.python.util.InteractiveInterpreter.runsource(InteractiveInterpreter.java:70) at org.python.util.InteractiveInterpreter.runsource(InteractiveInterpreter.java:46) at org.python.util.InteractiveConsole.push(InteractiveConsole.java:110) at org.python.util.InteractiveConsole.interact(InteractiveConsole.java:90) at org.python.util.jython.run(jython.java:317) at org.python.util.jython.main(jython.java:129) Caused by: java.lang.ArrayIndexOutOfBoundsException: 0 at org.neo4j.graphdb.factory.GraphDatabaseSettings.<clinit>(GraphDatabaseSettings.java:69) ... 33 more java.lang.ExceptionInInitializerError: java.lang.ExceptionInInitializerError ---- This bit of code is used to work out the default cache type. It does by first reading the available cache types from a file on the class path and then picking the first one on the list. I could see that the file it was trying to read was in the JAR and I thought passing the JAR to 'python.path' would put it on the classpath. Alistair suggested checking that assumption by checking what was actually on the classpath: [source,bash] ---- >>> import java.lang >>> java.lang.System.getProperty("java.class.path") u'/usr/local/Cellar/jython/2.5.3/libexec/jython.jar:' ---- As you can see our JAR is missing from the list which explains the problem with reading the file. If we launch the jython REPL with our JAR passed explicitly to the Java classpath then it works: [source,bash] ---- $ jython -J-cp /path/to/neo4j.jar Jython 2.5.3 (2.5:c56500f08d34+, Aug 13 2012, 14:48:36) [Java HotSpot(TM) 64-Bit Server VM (Oracle Corporation)] on java1.7.0_45 Type "help", "copyright", "credits" or "license" for more information. >>> import java.lang >>> java.lang.System.getProperty("java.class.path") u'/usr/local/Cellar/jython/2.5.3/libexec/jython.jar:/path/to/neo4j.jar:' ---- We can now create an embedded database with no problems: [source,bash] ---- >>> import org.neo4j.graphdb.factory >>> org.neo4j.graphdb.factory.GraphDatabaseFactory().newEmbeddedDatabase("/tmp/foo") EmbeddedGraphDatabase [/tmp/foo] ----

jythonneo4j-java-lang-exceptionininitializererror-java-lang-exceptionininitializererror

https://markhneedham.com/blog/2014/02/05/jythonneo4j-java-lang-exceptionininitializererror-java-lang-exceptionininitializererror

2014-02-20 23:16:34

Automating Skype's 'This message has been removed'

One of the stranger features of Skype is that that it allows you to delete the contents of a message that you've already sent to someone - something I haven't seen on any other messaging system I've used. For example if I wrote a message in Skype and wanted to edit it I would press the 'up' arrow: image::{{<siteurl>}}/uploads/2014/02/2014-02-20_23-02-28.png[2014 02 20 23 02 28,564] Once I've deleted the message I'd see this in the space where the message used to be: image::{{<siteurl>}}/uploads/2014/02/2014-02-20_23-00-41.png[2014 02 20 23 00 41,600] I almost certainly am too obsessed with this but I find it quite amusing when I see people posting and retracting messages so I wanted to see if it could be automated. https://twitter.com/apcj[Alistair] showed me http://support.apple.com/kb/ht2488[Automator], a built in tool on the Mac for automating work flows. Automator allows you to execute Applescript so we wrote the following code which selects the current chat in Skype, writes a message and then deletes it one character at a time: [source,bash] ---- on run {input, parameters} tell application "Skype" activate end tell tell application "System Events" set message to "now you see me, now you don't" keystroke message keystroke return keystroke (ASCII character 30) --up arrow repeat length of message times keystroke (ASCII character 8) --backspace end repeat keystroke return end tell return input end run ---- We wired up the Applescript via the Utilities > Run Applescript menu option in Automator: image::{{<siteurl>}}/uploads/2014/02/2014-02-20_23-12-38.png[2014 02 20 23 12 38,380] We can then go further and wire that up to a keyboard shortcut if we want by saving the workflow as a service in Automator but for my messing around purposes clicking the 'Run' button from Automator didn't seem too much of a hardship!

automating-skypes-this-message-has-been-removed

https://markhneedham.com/blog/2014/02/20/automating-skypes-this-message-has-been-removed

2014-02-20 18:22:43

Neo4j: Cypher - Set Based Operations

I was recently reminded of a Neo4j cypher query that I wrote a couple of years ago to find the colleagues that I hadn't worked with in the ThoughtWorks London office. The model looked like this: image::{{<siteurl>}}/uploads/2014/02/2014-02-18_17-04-01.png[2014 02 18 17 04 01,344] And I created the following fake data set of the aforementioned model: [source,java] ---- public class SetBasedOperations { private static final Label PERSON = DynamicLabel.label( "Person" ); private static final Label OFFICE = DynamicLabel.label( "Office" ); private static final DynamicRelationshipType COLLEAGUES = DynamicRelationshipType.withName( "COLLEAGUES" ); private static final DynamicRelationshipType MEMBER_OF = DynamicRelationshipType.withName( "MEMBER_OF" ); public static void main( String[] args ) throws IOException { Random random = new Random(); String path = "/tmp/set-based-operations"; FileUtils.deleteRecursively( new File( path ) ); GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase( path ); Transaction tx = db.beginTx(); try { Node me = db.createNode( PERSON ); me.setProperty( "name", "me" ); Node londonOffice = db.createNode( OFFICE ); londonOffice.setProperty( "name", "London Office" ); me.createRelationshipTo( londonOffice, MEMBER_OF ); for ( int i = 0; i < 1000; i++ ) { Node colleague = db.createNode( PERSON ); colleague.setProperty( "name", "person" + i ); colleague.createRelationshipTo( londonOffice, MEMBER_OF ); if(random.nextInt( 10 ) >= 8) { me.createRelationshipTo( colleague, COLLEAGUES ); } tx.success(); } } finally { tx.finish(); } db.shutdown(); CommunityNeoServer server = CommunityServerBuilder .server() .usingDatabaseDir( path ) .onPort( 9001 ) .persistent() .build(); server.start(); } } ---- I've created a node representing me and 1,000 people who work in the London office. Out of those 1,000 people I made it so that ~150 of them have worked with me. If I want to write a cypher query to find the exact number of people who haven't worked with me I might start with the following: [source,cypher] ---- MATCH (p:Person {name: "me"})-[:MEMBER_OF]->(office {name: "London Office"})<-[:MEMBER_OF]-(colleague) WHERE NOT (p-[:COLLEAGUES]->(colleague)) RETURN COUNT(colleague) ---- We start by finding me, then find the London office which I was a member of, and then find the other people who are members of that office. On the second line we remove people that I've previously worked with and then return a count of the people who are left. When I ran this through https://github.com/mneedham/cypher-query-tuning[my Cypher query tuning tool] the average time to evaluate this query was 7.46 seconds. That is obviously a bit too slow if we want to run the query on a web page and as far as I can tell the reason for that is that for each potential colleague we are searching through my 'COLLEAGUES' relationships and checking whether they exist. We're doing that 1,000 times which is a bit inefficient. I chatted to https://twitter.com/dmontag[David] about this, and he suggested that a more efficient query would be to work out all my colleagues up front once and then do the filtering from that set of people instead. The re-worked query looks like this: ~~~cypher MATCH (p:Person {name: "me"})-[:COLLEAGUES]\->(colleague) WITH p, COLLECT(colleague) as marksColleagues MATCH (colleague)-[:MEMBER_OF]\->(office {name: "London Office"})\<-[:MEMBER_OF]-(p) WHERE NOT (colleague IN marksColleagues) RETURN COUNT(colleague) ~~~ When we run that through the query tuner the average time reduces to 150 milliseconds which is much better. This type of query seems to be more about set operations than graph ones because *we're looking for what isn't there rather than what is*. When that's the case getting the set of things that we want to compare against up front is more profitable.

neo4j-cypher-set-based-operations

https://markhneedham.com/blog/2014/02/20/neo4j-cypher-set-based-operations

2014-02-28 22:57:59

Neo4j: Cypher - Finding directors who acted in their own movie

I've been doing quite a few Intro to Neo4j sessions recently and since it contains a lot of problems for the attendees to work on I get to see how first time users of Cypher actually use it. A couple of hours in we want to write a query to find directors who acted in their own film based on the following model. image::{{<siteurl>}}/uploads/2014/02/2014-02-28_22-40-02.png[2014 02 28 22 40 02,600] A common answer is the following: [source,cypher] ---- MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d) WHERE a.name = d.name RETURN a ---- We're matching an actor 'a', finding the movie they acted in and then finding the director of that movie. We now have pairs of actors and directors which we filter down by comparing their 'name' property. I haven't written SQL for a while but if my memory serves me correctly comparing properties or attributes in this way is quite a common way to test for equality. In a graph we don't need to compare properties - what we actually want to check is if 'a' and 'd' are the same node: [source,cypher] ---- MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d) WHERE a = d RETURN a ---- We've simplifed the query a bit but we can actually go one better by binding the director to the same identifier as the actor like so: [source,cypher] ---- MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(a) RETURN a ---- So now we're matching an actor 'a', finding the movie they acted in and then finding the director if they happen to be the same person as 'a'. The code is now much simpler and more revealing of its intent too.

neo4j-cypher-finding-directors-who-acted-in-their-own-movie

https://markhneedham.com/blog/2014/02/28/neo4j-cypher-finding-directors-who-acted-in-their-own-movie

2014-02-17 14:11:07

Neo4j: Creating nodes and relationships from a list of maps

Last week https://twitter.com/apcj[Alistair] and I were porting some Neo4j cypher queries from 1.8 to 2.0 and one of the queries we had to change was an interesting one that created a bunch of relationships from a list/array of maps. In the query we had a user 'Mark' and wanted to create 'FRIENDS_WITH' relationships to Peter and Michael. image::{{<siteurl>}}/uploads/2014/02/2014-02-17_13-39-08.png[2014 02 17 13 39 08,600] The application passed in a list of maps representing Peter and Michael as a parameter but if we remove the parameters the query looked like this: [source,cypher] ---- MERGE (me:User {userId: 1} ) SET me.name = "Mark" FOREACH (f IN [{userId: 2, name: "Michael"}, {userId: 3, name: "Peter"}] | MERGE (u:User {userId: f.userId}) SET u = f MERGE (me)-[:FRIENDS_WITH]->(u)) ---- We first ensure that a user with 'id' of 1 exists in the database and then make sure their name is set to 'Mark'. After we've done that we iterate over a list of maps containing Mark's friends and ensure there is a 'FRIENDS_WITH' relationship from Mark to them. The parameterised version of that query looks like this: [source,cypher] ---- MERGE (me:User { userId: {userId} }) SET me.name = {name} FOREACH(f IN {friends} | MERGE (u:User {userId: f.userId }) SET u = f MERGE (me)-[:FRIENDS_WITH]->(u)) ---- We can then execute that query using Jersey: [source,java] ---- public class ListsOfMapsCypher { public static void main( String[] args ) { ObjectNode request = JsonNodeFactory.instance.objectNode(); request.put("query", "MERGE (me:User { userId: {userId} }) " + "SET me.name = {name} " + "FOREACH(f IN {friends} | " + "MERGE (u:User {userId: f.userId }) " + "SET u = f " + "MERGE (me)-[:FRIENDS_WITH]->(u)) "); ObjectNode params = JsonNodeFactory.instance.objectNode(); params.put("userId", 1); params.put("name", "Mark"); ArrayNode friends = JsonNodeFactory.instance.arrayNode(); ObjectNode friend1 = JsonNodeFactory.instance.objectNode(); friend1.put( "userId", 2 ); friend1.put( "name", "Michael" ); friends.add( friend1 ); ObjectNode friend2 = JsonNodeFactory.instance.objectNode(); friend2.put( "userId", 3 ); friend2.put( "name", "Peter" ); friends.add( friend2 ); params.put("friends", friends ); request.put("params", params ); ClientResponse clientResponse = client() .resource( "http://localhost:7474/db/data/cypher" ) .accept( MediaType.APPLICATION_JSON ) .entity( request, MediaType.APPLICATION_JSON_TYPE ) .post( ClientResponse.class ); System.out.println(clientResponse.getEntity( String.class )); } private static Client client() { DefaultClientConfig defaultClientConfig = new DefaultClientConfig(); defaultClientConfig.getClasses().add(JacksonJsonProvider.class); return Client.create(defaultClientConfig); } } ---- We can then write a query to check Mark and his friends were persisted: image::{{<siteurl>}}/uploads/2014/02/2014-02-17_14-10-12.png[2014 02 17 14 10 12,600] And that's it!

neo4j-creating-nodes-and-relationships-from-a-list-of-maps

https://markhneedham.com/blog/2014/02/17/neo4j-creating-nodes-and-relationships-from-a-list-of-maps

2014-02-26 00:12:01

Jersey: Ignoring SSL certificate - javax.net.ssl.SSLHandshakeException: java.security.cert.CertificateException

Last week https://twitter.com/apcj[Alistair] and I were working on an internal application and we needed to make a HTTPS request directly to an AWS machine using a certificate signed to a different host. We use http://mvnrepository.com/artifact/com.sun.jersey/jersey-client[jersey-client] so our code looked something like this: [source,java] ---- Client client = Client.create(); client.resource("https://some-aws-host.compute-1.amazonaws.com").post(); // and so on ---- When we ran this we predictably ran into trouble: [source,text] ---- com.sun.jersey.api.client.ClientHandlerException: javax.net.ssl.SSLHandshakeException: java.security.cert.CertificateException: No subject alternative DNS name matching some-aws-host.compute-1.amazonaws.com found. at com.sun.jersey.client.urlconnection.URLConnectionClientHandler.handle(URLConnectionClientHandler.java:149) at com.sun.jersey.api.client.Client.handle(Client.java:648) at com.sun.jersey.api.client.WebResource.handle(WebResource.java:670) at com.sun.jersey.api.client.WebResource.post(WebResource.java:241) at com.neotechnology.testlab.manager.bootstrap.ManagerAdmin.takeBackup(ManagerAdmin.java:33) at com.neotechnology.testlab.manager.bootstrap.ManagerAdminTest.foo(ManagerAdminTest.java:11) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:45) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:42) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20) at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:68) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:47) at org.junit.runners.ParentRunner$3.run(ParentRunner.java:231) at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:50) at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:222) at org.junit.runners.ParentRunner.run(ParentRunner.java:300) at org.junit.runner.JUnitCore.run(JUnitCore.java:157) at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:74) at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:202) at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:65) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at com.intellij.rt.execution.application.AppMain.main(AppMain.java:120) Caused by: javax.net.ssl.SSLHandshakeException: java.security.cert.CertificateException: No subject alternative DNS name matching some-aws-host.compute-1.amazonaws.com found. at sun.security.ssl.Alerts.getSSLException(Alerts.java:192) at sun.security.ssl.SSLSocketImpl.fatal(SSLSocketImpl.java:1884) at sun.security.ssl.Handshaker.fatalSE(Handshaker.java:276) at sun.security.ssl.Handshaker.fatalSE(Handshaker.java:270) at sun.security.ssl.ClientHandshaker.serverCertificate(ClientHandshaker.java:1341) at sun.security.ssl.ClientHandshaker.processMessage(ClientHandshaker.java:153) at sun.security.ssl.Handshaker.processLoop(Handshaker.java:868) at sun.security.ssl.Handshaker.process_record(Handshaker.java:804) at sun.security.ssl.SSLSocketImpl.readRecord(SSLSocketImpl.java:1016) at sun.security.ssl.SSLSocketImpl.performInitialHandshake(SSLSocketImpl.java:1312) at sun.security.ssl.SSLSocketImpl.startHandshake(SSLSocketImpl.java:1339) at sun.security.ssl.SSLSocketImpl.startHandshake(SSLSocketImpl.java:1323) at sun.net.www.protocol.https.HttpsClient.afterConnect(HttpsClient.java:563) at sun.net.www.protocol.https.AbstractDelegateHttpsURLConnection.connect(AbstractDelegateHttpsURLConnection.java:185) at sun.net.www.protocol.http.HttpURLConnection.getInputStream(HttpURLConnection.java:1300) at java.net.HttpURLConnection.getResponseCode(HttpURLConnection.java:468) at sun.net.www.protocol.https.HttpsURLConnectionImpl.getResponseCode(HttpsURLConnectionImpl.java:338) at com.sun.jersey.client.urlconnection.URLConnectionClientHandler._invoke(URLConnectionClientHandler.java:240) at com.sun.jersey.client.urlconnection.URLConnectionClientHandler.handle(URLConnectionClientHandler.java:147) ... 31 more Caused by: java.security.cert.CertificateException: No subject alternative DNS name matching some-aws-host.compute-1.amazonaws.com found. at sun.security.util.HostnameChecker.matchDNS(HostnameChecker.java:191) at sun.security.util.HostnameChecker.match(HostnameChecker.java:93) at sun.security.ssl.X509TrustManagerImpl.checkIdentity(X509TrustManagerImpl.java:347) at sun.security.ssl.X509TrustManagerImpl.checkTrusted(X509TrustManagerImpl.java:203) at sun.security.ssl.X509TrustManagerImpl.checkServerTrusted(X509TrustManagerImpl.java:126) at sun.security.ssl.ClientHandshaker.serverCertificate(ClientHandshaker.java:1323) ... 45 more ---- We figured that we needed to get our client to ignore the certificate and came across http://stackoverflow.com/questions/6047996/ignore-self-signed-ssl-cert-using-jersey-client[this Stack Overflow thread] which had some suggestions on how to do this. None of the suggestions worked on their own but we ended up with a combination of a couple of the suggestions which did the trick: [source,java] ---- public Client hostIgnoringClient() { try { SSLContext sslcontext = SSLContext.getInstance( "TLS" ); sslcontext.init( null, null, null ); DefaultClientConfig config = new DefaultClientConfig(); Map<String, Object> properties = config.getProperties(); HTTPSProperties httpsProperties = new HTTPSProperties( new HostnameVerifier() { @Override public boolean verify( String s, SSLSession sslSession ) { return true; } }, sslcontext ); properties.put( HTTPSProperties.PROPERTY_HTTPS_PROPERTIES, httpsProperties ); config.getClasses().add( JacksonJsonProvider.class ); return Client.create( config ); } catch ( KeyManagementException | NoSuchAlgorithmException e ) { throw new RuntimeException( e ); } } ---- You're welcome Future Mark.

jersey-ignoring-ssl-certificate-javax-net-ssl-sslhandshakeexception-java-security-cert-certificateexception

https://markhneedham.com/blog/2014/02/26/jersey-ignoring-ssl-certificate-javax-net-ssl-sslhandshakeexception-java-security-cert-certificateexception

2014-02-26 07:32:14

Java 8: Lambda Expressions vs Auto Closeable

If you used earlier versions of Neo4j via its Java API with Java 6 you probably have code similar to the following to ensure write operations happen within a transaction: [source,java] ---- public class StylesOfTx { public static void main( String[] args ) throws IOException { String path = "/tmp/tx-style-test"; FileUtils.deleteRecursively(new File(path)); GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase( path ); Transaction tx = db.beginTx(); try { db.createNode(); tx.success(); } finally { tx.close(); } } } ---- In Neo4j 2.0 Transaction started extending http://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html[AutoCloseable] which meant that you could use 'try with resources' and the 'close' method would be automatically called when the block finished: [source,java] ---- public class StylesOfTx { public static void main( String[] args ) throws IOException { String path = "/tmp/tx-style-test"; FileUtils.deleteRecursively(new File(path)); GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase( path ); try ( Transaction tx = db.beginTx() ) { Node node = db.createNode(); tx.success(); } } } ---- This works quite well although it's still possible to have transactions hanging around in an application when people don't use this syntax - the old style is still permissible. In http://pragprog.com/book/vsjava8/functional-programming-in-java[Venkat Subramaniam's Java 8 book] he suggests an alternative approach where we use a lambda based approach: [source,java] ---- public class StylesOfTx { public static void main( String[] args ) throws IOException { String path = "/tmp/tx-style-test"; FileUtils.deleteRecursively(new File(path)); GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase( path ); Db.withinTransaction(db, neo4jDb -> { Node node = neo4jDb.createNode(); }); } static class Db { public static void withinTransaction(GraphDatabaseService db, Consumer<GraphDatabaseService> fn) { try ( Transaction tx = db.beginTx() ) { fn.accept(db); tx.success(); } } } } ---- The 'withinTransaction' function would actually go on GraphDatabaseService or similar rather than being on that Db class but it was easier to put it on there for this example. A disadvantage of this style is that you don't have explicit control over the transaction for handling the failure case - it's assumed that if 'tx.success()' isn't called then the transaction failed and it's rolled back. I'm not sure what % of use cases actually need such fine grained control though. Brian Hurt refers to this as the 'http://www.markhneedham.com/blog/2009/04/04/functional-c-the-hole-in-the-middle-pattern/[hole in the middle pattern]' and I imagine we'll start seeing more code of this ilk once Java 8 is released and becomes more widely used.

java-8-lambda-expressions-vs-auto-closeable

https://markhneedham.com/blog/2014/02/26/java-8-lambda-expressions-vs-auto-closeable

2014-02-23 14:43:47

Java 8: Sorting values in collections

Having realised that Java 8 is http://openjdk.java.net/projects/jdk8/[due for its GA release within the next few weeks] I thought it was about time I had a look at it and over the last week have been reading http://pragprog.com/book/vsjava8/functional-programming-in-java[Venkat Subramaniam's book]. I'm up to chapter 3 which covers sorting a collection of people. The Person class is defined roughly like so: [source,java] ---- static class Person { private String name; private int age; Person(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return String.format("Person{name='%s', age=%d}", name, age); } } ---- In the first example we take a list of people and then sort them in ascending age order: [source,java] ---- List<Person> people = Arrays.asList(new Person("Paul", 24), new Person("Mark", 30), new Person("Will", 28)); people.stream().sorted((p1, p2) -> p1.age - p2.age).forEach(System.out::println); ---- [source,text] ---- Person{name='Paul', age=24} Person{name='Will', age=28} Person{name='Mark', age=30} ---- If we were to write a function to do the same thing in Java 7 it'd look like this: [source,java] ---- Collections.sort(people, new Comparator<Person>() { @Override public int compare(Person o1, Person o2) { return o1.age - o2.age; } }); for (Person person : people) { System.out.println(person); } ---- Java 8 has reduced the amount of code we have to write although it's still more complicated than what we could do in Ruby: [source,ruby] ---- > people = [ {:name => "Paul", :age => 24}, {:name => "Mark", :age => 30}, {:name => "Will", :age => 28}] > people.sort_by { |p| p[:age] } => [{:name=>"Paul", :age=>24}, {:name=>"Will", :age=>28}, {:name=>"Mark", :age=>30}] ---- A few pages later Venkat shows how you can get close to this by using the +++<cite>+++http://download.java.net/jdk8/docs/api/java/util/Comparator.html#comparing-java.util.function.Function-[Comparator#comparing]+++</cite>+++ function: [source,java] ---- Function<Person, Integer> byAge = p -> p.age ; people.stream().sorted(comparing(byAge)).forEach(System.out::println); ---- I thought I could make this simpler by inlining the 'byAge' lambda like this: [source,java] ---- people.stream().sorted(comparing(p -> p.age)).forEach(System.out::println); ---- This seems to compile and run correctly although IntelliJ 13.0 suggests there is a 'http://youtrack.jetbrains.com/issue/IDEA-101788[cyclic inference]' problem. IntelliJ is happy if we explicitly cast the lambda like this: [source,java] ---- people.stream().sorted(comparing((Function<Person, Integer>) p -> p.age)).forEach(System.out::println); ---- IntelliJ also seems happy if we explicitly type 'p' in the lambda, so I think I'll go with that for the moment: [source,java] ---- people.stream().sorted(comparing((Person p) -> p.age)).forEach(System.out::println); ----

java-8-sorting-values-in-collections

https://markhneedham.com/blog/2014/02/23/java-8-sorting-values-in-collections

2014-02-23 19:16:27

Java 8: Group by with collections

In my continued reading of Venkat Subramaniam's 'http://pragprog.com/book/vsjava8/functional-programming-in-java[Functional Programming in Java]' I've reached the part of the book where the +++<cite>+++http://download.java.net/jdk8/docs/api/java/util/stream/Stream.html#collect-java.util.stream.Collector-[Stream#collect]+++</cite>+++ function is introduced. We want to take a collection of people, group them by age and return a map of (age \-> people's names) for which this comes in handy. To refresh, this is what the Person class looks like: [source,java] ---- static class Person { private String name; private int age; Person(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return String.format("Person{name='%s', age=%d}", name, age); } } ---- And we can write the following code in Java 8 to get a map of people's names grouped by age: [source,java] ---- Stream<Person> people = Stream.of(new Person("Paul", 24), new Person("Mark", 30), new Person("Will", 28)); Map<Integer, List<String>> peopleByAge = people .collect(groupingBy(p -> p.age, mapping((Person p) -> p.name, toList()))); System.out.println(peopleByAge); ---- [source,text] ---- {24=[Paul], 28=[Will], 30=[Mark]} ---- We're running the 'collect' function over the collection, grouping by the 'age' property as we go and grouping the names of people rather than the people themselves. This is a little bit different to what you'd do in Ruby where there's a 'group_by' function which you can call on a collection: ~~~ruby > people = [ {:name \=> "Paul", :age \=> 24}, {:name \=> "Mark", :age \=> 30}, {:name \=> "Will", :age \=> 28}] > people.group_by { |p| p[:age] } \=> {24\=>[{:name\=>"Paul", :age\=>24}], 30\=>[{:name\=>"Mark", :age\=>30}], 28\=>[{:name\=>"Will", :age\=>28}]} ~~~ This gives us back lists of people grouped by age but we need to apply an additional 'map' operation to change that to be a list of names instead: ~~~ruby > people.group_by { |p| p[:age] }.map { |k,v| [k, v.map { |person| person[:name] } ] } \=> [[24, ["Paul"]], [30, ["Mark"]], [28, ["Will"]]] ~~~ At this stage we've got an array of (age, names) pairs but luckily Ruby 2.1.0 has a function 'to_h' which we can call to get back to a hash again: ~~~ruby > people.group_by { |p| p[:age] }.map { |k,v| [k, v.map { |person| person[:name] } ] }.to_h \=> {24\=>["Paul"], 30\=>["Mark"], 28\=>["Will"]} ~~~ If we want to follow the Java approach of grouping by a property while running a reduce over the collection we'd have something like the following: ~~~ruby > people.reduce({}) { |acc, item| acc[item[:age]] ||=[]; acc[item[:age]] << item[:name]; acc } \=> {24\=>["Paul"], 30\=>["Mark"], 28\=>["Will"]} ~~~ If we're using Clojure then we might end up with something like this instead: ~~~lisp (def people [{:name "Paul", :age 24} {:name "Mark", :age 30} {:name "Will", :age 28}]) > (reduce (fn [acc [k v]] (assoc-in acc [k] (map :name v))) {} (group-by :age people)) {28 ("Will"), 30 ("Mark"), 24 ("Paul")} ~~~ I thought the Java version looked a bit weird to begin with but it's actually not too bad having worked through the problem in a couple of other languages. It'd be good to know whether there's a better way of doing this the Ruby/Clojure way though!

java-8-group-by-with-collections

https://markhneedham.com/blog/2014/02/23/java-8-group-by-with-collections

2014-02-13 00:10:37

Neo4j: Value in relationships, but value in nodes too!

I've recently spent a bit of time working with people on their graph commons and a common pattern I've come across is that although the models have lots of relationships there are often missing nodes. == Emails We'll start with a model which represents the emails that people send between each other. A first cut might look like this: image::{{<siteurl>}}/uploads/2014/02/2014-02-12_08-30-59.png[2014 02 12 08 30 59,600] The problem with this approach is that we haven't modelled the concept of *an email* - that's been implicitly modelled via a relationship. This means that if we want to indicate who was cc'd or bcc'd on the email we can't do it. We might also want to track the replies on a thread but again we can't do it. A richer model that treated an email as a first class citizen would allow us to do both these things and would look like this: image::{{<siteurl>}}/uploads/2014/02/2014-02-12_23-16-02.png[2014 02 12 23 16 02,600] We could then write queries to get the chain of emails in a thread or find all the emails that a person was cc'd in - two queries that would be much more difficult to write if we don't have the concept of an email. == Footballers and football matches Our http://www.markhneedham.com/blog/2013/10/22/neo4j-modelling-hyper-edges-in-a-property-graph/[second example come from my football dataset] and involves modelling the matches that players participated in. My first attempt looked like this: image::{{<siteurl>}}/uploads/2014/02/2014-02-12_23-30-35.png[2014 02 12 23 30 35,600] This works reasonably well but I wanted to be able to model which team a player had represented in a match which was quite difficult with this model. One approach would be to add a 'team' property to the 'PLAYED_IN' relationship but then we'd need to do some work at query time to work out which team node that property value referred to. Instead I realised that I was missing the concept of a *player's performance in a match* which would make some queries much easier to write. The new model looks like this: image::{{<siteurl>}}/uploads/2014/02/2014-02-12_23-37-28.png[2014 02 12 23 37 28,600] == The tube The final example is modelling the London tube although this could apply to any transport system. Our initial model of part of the Northern Line might look like this: image::{{<siteurl>}}/uploads/2014/02/2014-02-12_23-59-46.png[2014 02 12 23 59 46,600] This model works really well and my colleague Rik has http://blog.bruggen.com/2013/11/meet-this-tubular-graph.html[written a blog post showing the queries you could write against it]. However, it's missing the concept of a platform which means if we want to create a routing application which takes into account the amount of time it takes to move between different If we introduce a node to represent the different platforms in a station we can introduce that type of information: image::{{<siteurl>}}/uploads/2014/02/2014-02-13_00-04-06.png[2014 02 13 00 04 06,600] In each of these examples we've effectively normalised our model by introducing an extra concept which means it looks more complicated. The benefit of this approach across all three examples is that it allows us to answer more complicated questions of our data which in my experience are the really interesting questions. As always, let me know what you think in the comments.

neo4j-value-in-relationships-but-value-in-nodes-too

https://markhneedham.com/blog/2014/02/13/neo4j-value-in-relationships-but-value-in-nodes-too

2014-11-27 12:28:14

Docker/Neo4j: Port forwarding on Mac OS X not working

Prompted by http://ognjenbubalo.blogspot.co.uk/2014/11/creating-graph-of-software-technologies.html[Ognjen Bubalo's excellent blog post] I thought it was about time I tried running Neo4j on a docker container on my Mac Book Pro to make it easier to play around with different data sets. I got the container up and running by following Ognien's instructions and had the following ports forwarded to my host machine: [source,bash] ---- $ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES c62f8601e557 tpires/neo4j:latest "/bin/bash -c /launc About an hour ago Up About an hour 0.0.0.0:49153->1337/tcp, 0.0.0.0:49154->7474/tcp neo4j ---- This should allow me to access Neo4j on port 49154 but when I tried to access that host:port pair I got a connection refused message: [source,bash] ---- $ curl -v http://localhost:49154 * Adding handle: conn: 0x7ff369803a00 * Adding handle: send: 0 * Adding handle: recv: 0 * Curl_addHandleToPipeline: length: 1 * - Conn 0 (0x7ff369803a00) send_pipe: 1, recv_pipe: 0 * About to connect() to localhost port 49154 (#0) * Trying ::1... * Trying 127.0.0.1... * Trying fe80::1... * Failed connect to localhost:49154; Connection refused * Closing connection 0 curl: (7) Failed connect to localhost:49154; Connection refused ---- My first thought was the maybe Neo4j hadn't started up correctly inside the container so I checked the logs: [source,bash] ---- $ docker logs --tail=10 c62f8601e557 10:59:12.994 [main] INFO o.e.j.server.handler.ContextHandler - Started o.e.j.w.WebAppContext@2edfbe28{/webadmin,jar:file:/usr/share/neo4j/system/lib/neo4j-server-2.1.5-static-web.jar!/webadmin-html,AVAILABLE} 10:59:13.449 [main] INFO o.e.j.server.handler.ContextHandler - Started o.e.j.s.ServletContextHandler@192efb4e{/db/manage,null,AVAILABLE} 10:59:13.699 [main] INFO o.e.j.server.handler.ContextHandler - Started o.e.j.s.ServletContextHandler@7e94c035{/db/data,null,AVAILABLE} 10:59:13.714 [main] INFO o.e.j.w.StandardDescriptorProcessor - NO JSP Support for /browser, did not find org.apache.jasper.servlet.JspServlet 10:59:13.715 [main] INFO o.e.j.server.handler.ContextHandler - Started o.e.j.w.WebAppContext@3e84ae71{/browser,jar:file:/usr/share/neo4j/system/lib/neo4j-browser-2.1.5.jar!/browser,AVAILABLE} 10:59:13.807 [main] INFO o.e.j.server.handler.ContextHandler - Started o.e.j.s.ServletContextHandler@4b6690b1{/,null,AVAILABLE} 10:59:13.819 [main] INFO o.e.jetty.server.ServerConnector - Started ServerConnector@495350f0{HTTP/1.1}{c62f8601e557:7474} 10:59:13.900 [main] INFO o.e.jetty.server.ServerConnector - Started ServerConnector@23ad0c5a{SSL-HTTP/1.1}{c62f8601e557:7473} 2014-11-27 10:59:13.901+0000 INFO [API] Server started on: http://c62f8601e557:7474/ 2014-11-27 10:59:13.902+0000 INFO [API] Remote interface ready and available at [http://c62f8601e557:7474/] ---- Nope! It's up and running perfectly fine which suggested the problemw was with port forwarding. I eventually found my way to Chris Jones' 'http://viget.com/extend/how-to-use-docker-on-os-x-the-missing-guide[How to use Docker on OS X: The Missing Guide]' which explained the problem: ____ The Problem: Docker forwards ports from the container to the host, which is boot2docker, not OS X. The Solution: Use the VM's IP address. ____ So to access Neo4j on my machine I need to use the VM's IP address rather than localhost. We can get the VM's IP address like so: [source,bash] ---- $ boot2docker ip The VM's Host only interface IP address is: 192.168.59.103 ---- Let's strip out that surrounding text though: [source,bash] ---- $ boot2docker ip 2> /dev/null 192.168.59.103 ---- Now if we cURL using that IP instead: [source,bash] ---- $ curl -v http://192.168.59.103:49154 * About to connect() to 192.168.59.103 port 49154 (#0) * Trying 192.168.59.103... * Adding handle: conn: 0x7fd794003a00 * Adding handle: send: 0 * Adding handle: recv: 0 * Curl_addHandleToPipeline: length: 1 * - Conn 0 (0x7fd794003a00) send_pipe: 1, recv_pipe: 0 * Connected to 192.168.59.103 (192.168.59.103) port 49154 (#0) > GET / HTTP/1.1 > User-Agent: curl/7.30.0 > Host: 192.168.59.103:49154 > Accept: */* > < HTTP/1.1 200 OK < Content-Type: application/json; charset=UTF-8 < Access-Control-Allow-Origin: * < Content-Length: 112 * Server Jetty(9.0.5.v20130815) is not blacklisted < Server: Jetty(9.0.5.v20130815) < { "management" : "http://192.168.59.103:49154/db/manage/", "data" : "http://192.168.59.103:49154/db/data/" * Connection #0 to host 192.168.59.103 left intact ---- Happy days! Chris has solutions to lots of other common problems people come across when using Docker with Mac OS X so it's worth http://viget.com/extend/how-to-use-docker-on-os-x-the-missing-guide[having a flick through his post].

dockerneo4j-port-forwarding-on-mac-os-x-not-working

https://markhneedham.com/blog/2014/11/27/dockerneo4j-port-forwarding-on-mac-os-x-not-working

2014-11-11 00:17:32

R: dplyr - Sum for group_by multiple columns

Over the weekend I was playing around with dplyr and had the following data frame grouped by both columns: [source,r] ---- > library(dplyr) > data = data.frame( letter = sample(LETTERS, 50000, replace = TRUE), number = sample (1:10, 50000, replace = TRUE) ) > data %>% count(letter, number) %>% head(20) Source: local data frame [20 x 3] Groups: letter letter number n 1 A 1 184 2 A 2 192 3 A 3 183 4 A 4 193 5 A 5 214 6 A 6 172 7 A 7 196 8 A 8 198 9 A 9 174 10 A 10 196 11 B 1 212 12 B 2 198 13 B 3 194 14 B 4 181 15 B 5 203 16 B 6 234 17 B 7 221 18 B 8 179 19 B 9 182 20 B 10 170 ---- I wanted to add an extra column which would show what percentage of the values for that letter each number had. If we wrote that code standalone we'd have the following: [source,r] ---- > data %>% count(letter) Source: local data frame [26 x 2] letter n 1 A 1902 2 B 1974 3 C 1911 4 D 1948 5 E 1888 6 F 1975 7 G 1914 8 H 1886 9 I 1910 10 J 1924 11 K 1974 12 L 1891 13 M 1894 14 N 1946 15 O 1956 16 P 1934 17 Q 1865 18 R 1992 19 S 1946 20 T 1854 21 U 1919 22 V 1913 23 W 1928 24 X 1934 25 Y 1908 26 Z 1914 ---- We can also get that value by summing up the individual (letter, number) pairs from the previous data frame. The +++<cite>+++ungroup+++</cite>+++ function allows us to do so: [source,r] ---- > data %>% count(letter, number) %>% ungroup %>% group_by(letter) %>% mutate(sum.n = sum(n)) %>% head(20) Source: local data frame [20 x 4] Groups: letter letter number n sum.n 1 A 1 184 1902 2 A 2 192 1902 3 A 3 183 1902 4 A 4 193 1902 5 A 5 214 1902 6 A 6 172 1902 7 A 7 196 1902 8 A 8 198 1902 9 A 9 174 1902 10 A 10 196 1902 11 B 1 212 1974 12 B 2 198 1974 13 B 3 194 1974 14 B 4 181 1974 15 B 5 203 1974 16 B 6 234 1974 17 B 7 221 1974 18 B 8 179 1974 19 B 9 182 1974 20 B 10 170 1974 ---- Pretty neat!

r-dplyr-sum-for-group_by-multiple-columns

https://markhneedham.com/blog/2014/11/11/r-dplyr-sum-for-group_by-multiple-columns

2014-11-16 22:53:49

Spark: Parse CSV file and group by column value

I've found myself working with large CSV files quite frequently and realising that my existing toolset didn't let me explore them quickly I thought I'd spend a bit of time looking at http://spark.apache.org/[Spark] to see if it could help. I'm working with a https://data.cityofchicago.org/Public-Safety/Crimes-2001-to-present/ijzp-q8t2[crime data set released by the City of Chicago]: it's 1GB in size and contains details of 4 million crimes: [source,bash] ---- $ ls -alh ~/Downloads/Crimes_-_2001_to_present.csv -rw-r--r--@ 1 markneedham staff 1.0G 16 Nov 12:14 /Users/markneedham/Downloads/Crimes_-_2001_to_present.csv $ wc -l ~/Downloads/Crimes_-_2001_to_present.csv 4193441 /Users/markneedham/Downloads/Crimes_-_2001_to_present.csv ---- We can get a rough idea of the contents of the file by looking at the first row along with the header: [source,bash] ---- $ head -n 2 ~/Downloads/Crimes_-_2001_to_present.csv ID,Case Number,Date,Block,IUCR,Primary Type,Description,Location Description,Arrest,Domestic,Beat,District,Ward,Community Area,FBI Code,X Coordinate,Y Coordinate,Year,Updated On,Latitude,Longitude,Location 9464711,HX114160,01/14/2014 05:00:00 AM,028XX E 80TH ST,0560,ASSAULT,SIMPLE,APARTMENT,false,true,0422,004,7,46,08A,1196652,1852516,2014,01/20/2014 12:40:05 AM,41.75017626412204,-87.55494559131228,"(41.75017626412204, -87.55494559131228)" ---- I wanted to do a count of the 'Primary Type' column to see how many of each crime we have. Using just Unix command line tools this is how we'd do that: [source,bash] ---- $ time tail +2 ~/Downloads/Crimes_-_2001_to_present.csv | cut -d, -f6 | sort | uniq -c | sort -rn 859197 THEFT 757530 BATTERY 489528 NARCOTICS 488209 CRIMINAL DAMAGE 257310 BURGLARY 253964 OTHER OFFENSE 247386 ASSAULT 197404 MOTOR VEHICLE THEFT 157706 ROBBERY 137538 DECEPTIVE PRACTICE 124974 CRIMINAL TRESPASS 47245 PROSTITUTION 40361 WEAPONS VIOLATION 31585 PUBLIC PEACE VIOLATION 26524 OFFENSE INVOLVING CHILDREN 14788 CRIM SEXUAL ASSAULT 14283 SEX OFFENSE 10632 GAMBLING 8847 LIQUOR LAW VIOLATION 6443 ARSON 5178 INTERFERE WITH PUBLIC OFFICER 4846 HOMICIDE 3585 KIDNAPPING 3147 INTERFERENCE WITH PUBLIC OFFICER 2471 INTIMIDATION 1985 STALKING 355 OFFENSES INVOLVING CHILDREN 219 OBSCENITY 86 PUBLIC INDECENCY 80 OTHER NARCOTIC VIOLATION 12 RITUALISM 12 NON-CRIMINAL 6 OTHER OFFENSE 2 NON-CRIMINAL (SUBJECT SPECIFIED) 2 NON - CRIMINAL real 2m37.495s user 3m0.337s sys 0m1.471s ---- This isn't too bad but it seems like the type of calculation that Spark is made for so I had a look at how I could go about doing that. To start with I created an SBT project with the following build file: [source,sbt] ---- name := "playground" version := "1.0" scalaVersion := "2.10.4" libraryDependencies += "org.apache.spark" %% "spark-core" % "1.1.0" libraryDependencies += "net.sf.opencsv" % "opencsv" % "2.3" ideaExcludeFolders += ".idea" ideaExcludeFolders += ".idea_modules" ---- I http://spark.apache.org/downloads.html[downloaded Spark] and after unpacking it launched the Spark shell: [source,bash] ---- $ pwd /Users/markneedham/projects/spark-play/spark-1.1.0/spark-1.1.0-bin-hadoop1 $ ./bin/spark-shell ... Welcome to ____ __ / __/__ ___ _____/ /__ _\ \/ _ \/ _ `/ __/ '_/ /___/ .__/\_,_/_/ /_/\_\ version 1.1.0 /_/ Using Scala version 2.10.4 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_51) ... Spark context available as sc. scala> ---- I first import some classes I'm going to need: [source,scala] ---- scala> import au.com.bytecode.opencsv.CSVParser import au.com.bytecode.opencsv.CSVParser scala> import org.apache.spark.rdd.RDD import org.apache.spark.rdd.RDD ---- Now, following the http://spark.apache.org/docs/latest/quick-start.html[quick start example], we'll create a Resilient Distributed Dataset (RDD) from our Crime CSV file: [source,scala] ---- scala> val crimeFile = "/Users/markneedham/Downloads/Crimes_-_2001_to_present.csv" crimeFile: String = /Users/markneedham/Downloads/Crimes_-_2001_to_present.csv scala> val crimeData = sc.textFile(crimeFile).cache() 14/11/16 22:31:16 INFO MemoryStore: ensureFreeSpace(32768) called with curMem=0, maxMem=278302556 14/11/16 22:31:16 INFO MemoryStore: Block broadcast_0 stored as values in memory (estimated size 32.0 KB, free 265.4 MB) crimeData: org.apache.spark.rdd.RDD[String] = /Users/markneedham/Downloads/Crimes_-_2001_to_present.csv MappedRDD[1] at textFile at <console>:17 ---- Our next step is to process each line of the file using our CSV Parser. A simple way to do this would be to http://bzhangusc.wordpress.com/2014/06/18/csv-parser/[create a new CSVParser for each line]: [source,scala] ---- scala> crimeData.map(line => { val parser = new CSVParser(',') parser.parseLine(line).mkString(",") }).take(5).foreach(println) 14/11/16 22:35:49 INFO SparkContext: Starting job: take at <console>:23 ... 4/11/16 22:35:49 INFO SparkContext: Job finished: take at <console>:23, took 0.013904 s ID,Case Number,Date,Block,IUCR,Primary Type,Description,Location Description,Arrest,Domestic,Beat,District,Ward,Community Area,FBI Code,X Coordinate,Y Coordinate,Year,Updated On,Latitude,Longitude,Location 9464711,HX114160,01/14/2014 05:00:00 AM,028XX E 80TH ST,0560,ASSAULT,SIMPLE,APARTMENT,false,true,0422,004,7,46,08A,1196652,1852516,2014,01/20/2014 12:40:05 AM,41.75017626412204,-87.55494559131228,(41.75017626412204, -87.55494559131228) 9460704,HX113741,01/14/2014 04:55:00 AM,091XX S JEFFERY AVE,031A,ROBBERY,ARMED: HANDGUN,SIDEWALK,false,false,0413,004,8,48,03,1191060,1844959,2014,01/18/2014 12:39:56 AM,41.729576153145636,-87.57568059471686,(41.729576153145636, -87.57568059471686) 9460339,HX113740,01/14/2014 04:44:00 AM,040XX W MAYPOLE AVE,1310,CRIMINAL DAMAGE,TO PROPERTY,RESIDENCE,false,true,1114,011,28,26,14,1149075,1901099,2014,01/16/2014 12:40:00 AM,41.884543798701515,-87.72803579358926,(41.884543798701515, -87.72803579358926) 9461467,HX114463,01/14/2014 04:43:00 AM,059XX S CICERO AVE,0820,THEFT,$500 AND UNDER,PARKING LOT/GARAGE(NON.RESID.),false,false,0813,008,13,64,06,1145661,1865031,2014,01/16/2014 12:40:00 AM,41.785633535413176,-87.74148516669783,(41.785633535413176, -87.74148516669783) ---- That works but it's a bit wasteful to create a new CSVParser each time so instead let's just create one for each partition that Spark splits our file up into: [source,scala] ---- scala> crimeData.mapPartitions(lines => { val parser = new CSVParser(',') lines.map(line => { parser.parseLine(line).mkString(",") }) }).take(5).foreach(println) 14/11/16 22:38:44 INFO SparkContext: Starting job: take at <console>:25 ... 14/11/16 22:38:44 INFO SparkContext: Job finished: take at <console>:25, took 0.015216 s ID,Case Number,Date,Block,IUCR,Primary Type,Description,Location Description,Arrest,Domestic,Beat,District,Ward,Community Area,FBI Code,X Coordinate,Y Coordinate,Year,Updated On,Latitude,Longitude,Location 9464711,HX114160,01/14/2014 05:00:00 AM,028XX E 80TH ST,0560,ASSAULT,SIMPLE,APARTMENT,false,true,0422,004,7,46,08A,1196652,1852516,2014,01/20/2014 12:40:05 AM,41.75017626412204,-87.55494559131228,(41.75017626412204, -87.55494559131228) 9460704,HX113741,01/14/2014 04:55:00 AM,091XX S JEFFERY AVE,031A,ROBBERY,ARMED: HANDGUN,SIDEWALK,false,false,0413,004,8,48,03,1191060,1844959,2014,01/18/2014 12:39:56 AM,41.729576153145636,-87.57568059471686,(41.729576153145636, -87.57568059471686) 9460339,HX113740,01/14/2014 04:44:00 AM,040XX W MAYPOLE AVE,1310,CRIMINAL DAMAGE,TO PROPERTY,RESIDENCE,false,true,1114,011,28,26,14,1149075,1901099,2014,01/16/2014 12:40:00 AM,41.884543798701515,-87.72803579358926,(41.884543798701515, -87.72803579358926) 9461467,HX114463,01/14/2014 04:43:00 AM,059XX S CICERO AVE,0820,THEFT,$500 AND UNDER,PARKING LOT/GARAGE(NON.RESID.),false,false,0813,008,13,64,06,1145661,1865031,2014,01/16/2014 12:40:00 AM,41.785633535413176,-87.74148516669783,(41.785633535413176, -87.74148516669783) ---- You'll notice that we've still got the header being printed which isn't ideal - let's get rid of it!</p? I expected there to be a 'drop' function which would allow me to do that but in fact there isn't. Instead we can http://mail-archives.apache.org/mod_mbox/spark-user/201404.mbox/%3CCAEYYnxYuEaie518ODdn-fR7VvD39d71=CgB_Dxw_4COVXgmYYQ@mail.gmail.com%3E[make use of our knowledge that the first partition will contain the first line and strip it out] that way: ~~~scala scala> def dropHeader(data: RDD[String]): RDD[String] = { data.mapPartitionsWithIndex((idx, lines) \=> { if (idx == 0) { lines.drop(1) } lines }) } dropHeader: (data: org.apache.spark.rdd.RDD[String])org.apache.spark.rdd.RDD[String] ~~~ Now let's grab the first 5 lines again and print them out: ~~~scala scala> val withoutHeader: RDD[String] = dropHeader(crimeData) withoutHeader: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[7] at mapPartitionsWithIndex at +++<console>+++:14 scala> withoutHeader.mapPartitions(lines \=> { val parser = new CSVParser(',') lines.map(line \=> { parser.parseLine(line).mkString(",") }) }).take(5).foreach(println) 14/11/16 22:43:27 INFO SparkContext: Starting job: take at +++<console>+++:29 \... 14/11/16 22:43:27 INFO SparkContext: Job finished: take at +++<console>+++:29, took 0.018557 s 9464711,HX114160,01/14/2014 05:00:00 AM,028XX E 80TH ST,0560,ASSAULT,SIMPLE,APARTMENT,false,true,0422,004,7,46,08A,1196652,1852516,2014,01/20/2014 12:40:05 AM,41.75017626412204,-87.55494559131228,(41.75017626412204, -87.55494559131228) 9460704,HX113741,01/14/2014 04:55:00 AM,091XX S JEFFERY AVE,031A,ROBBERY,ARMED: HANDGUN,SIDEWALK,false,false,0413,004,8,48,03,1191060,1844959,2014,01/18/2014 12:39:56 AM,41.729576153145636,-87.57568059471686,(41.729576153145636, -87.57568059471686) 9460339,HX113740,01/14/2014 04:44:00 AM,040XX W MAYPOLE AVE,1310,CRIMINAL DAMAGE,TO PROPERTY,RESIDENCE,false,true,1114,011,28,26,14,1149075,1901099,2014,01/16/2014 12:40:00 AM,41.884543798701515,-87.72803579358926,(41.884543798701515, -87.72803579358926) 9461467,HX114463,01/14/2014 04:43:00 AM,059XX S CICERO AVE,0820,THEFT,$500 AND UNDER,PARKING LOT/GARAGE(NON.RESID.),false,false,0813,008,13,64,06,1145661,1865031,2014,01/16/2014 12:40:00 AM,41.785633535413176,-87.74148516669783,(41.785633535413176, -87.74148516669783) 9460355,HX113738,01/14/2014 04:21:00 AM,070XX S PEORIA ST,0820,THEFT,$500 AND UNDER,STREET,true,false,0733,007,17,68,06,1171480,1858195,2014,01/16/2014 12:40:00 AM,41.766348042591375,-87.64702037047671,(41.766348042591375, -87.64702037047671) ~~~ We're finally in good shape to extract the values from the 'Primary Type' column and count how many times each of those appears in our data set: ~~~scala scala> withoutHeader.mapPartitions(lines \=> { val parser=new CSVParser(',') lines.map(line \=> { val columns = parser.parseLine(line) Array(columns(5)).mkString(",") }) }).countByValue().toList.sortBy(-_._2).foreach(println) 14/11/16 22:45:20 INFO SparkContext: Starting job: countByValue at +++<console>+++:30 14/11/16 22:45:20 INFO DAGScheduler: Got job 7 (countByValue at +++<console>+++:30) with 32 output partitions (allowLocal=false) \... 14/11/16 22:45:30 INFO SparkContext: Job finished: countByValue at +++<console>+++:30, took 9.796565 s (THEFT,859197) (BATTERY,757530) (NARCOTICS,489528) (CRIMINAL DAMAGE,488209) (BURGLARY,257310) (OTHER OFFENSE,253964) (ASSAULT,247386) (MOTOR VEHICLE THEFT,197404) (ROBBERY,157706) (DECEPTIVE PRACTICE,137538) (CRIMINAL TRESPASS,124974) (PROSTITUTION,47245) (WEAPONS VIOLATION,40361) (PUBLIC PEACE VIOLATION,31585) (OFFENSE INVOLVING CHILDREN,26524) (CRIM SEXUAL ASSAULT,14788) (SEX OFFENSE,14283) (GAMBLING,10632) (LIQUOR LAW VIOLATION,8847) (ARSON,6443) (INTERFERE WITH PUBLIC OFFICER,5178) (HOMICIDE,4846) (KIDNAPPING,3585) (INTERFERENCE WITH PUBLIC OFFICER,3147) (INTIMIDATION,2471) (STALKING,1985) (OFFENSES INVOLVING CHILDREN,355) (OBSCENITY,219) (PUBLIC INDECENCY,86) (OTHER NARCOTIC VIOLATION,80) (NON-CRIMINAL,12) (RITUALISM,12) (OTHER OFFENSE ,6) (NON-CRIMINAL (SUBJECT SPECIFIED),2) (NON - CRIMINAL,2) ~~~ We get the same results as with the Unix commands except it took less than 10 seconds to calculate which is pretty cool!+++</console>++++++</console>++++++</console>++++++</console>++++++</console>++++++</console>+++

spark-parse-csv-file-and-group-by-column-value

https://markhneedham.com/blog/2014/11/16/spark-parse-csv-file-and-group-by-column-value

2014-11-17 00:53:11

R: ggmap - Overlay shapefile with filled polygon of regions

I've been playing around with plotting maps in R over the last week and got to the point where I wanted to have a google map in the background with a filled polygon on a shapefile in the foreground. The first bit is reasonably simple - we can just import the +++<cite>+++ggmap+++</cite>+++ library and make a call to +++<cite>+++get_map+++</cite>+++: [source,r] ---- > library(ggmap) > sfMap = map = get_map(location = 'San Francisco', zoom = 12) ---- image::{{<siteurl>}}/uploads/2014/11/2014-11-17_00-27-11.png[2014 11 17 00 27 11,600] Next I wanted to show the outlines of the different San Francisco zip codes and came across http://spatioanalytics.com/2014/02/20/shapefile-polygons-plotted-on-google-maps-using-ggplot-throw-some-throw-some-stats-on-that-mappart-2/[a blog post by Paul Bidanset on Baltimore neighbourhoods] which I was able to adapt. I downloaded https://data.sfgov.org/download/9q84-kc2y/ZIP[a shapefile of San Francisco's zip codes] from the https://data.sfgov.org/Geographic-Locations-and-Boundaries/San-Francisco-ZIP-Codes-Zipped-Shapefile-Format-/9q84-kc2y[DataSF website] and then loaded it into R using the +++<cite>+++readOGR+++</cite>+++ and +++<cite>+++spTransform+++</cite>+++ functions from the +++<cite>+++rgdal+++</cite>+++ package: [source,r] ---- > library(rgdal) > library(ggplot2) > sfn = readOGR(".","sfzipcodes") %>% spTransform(CRS("+proj=longlat +datum=WGS84")) > ggplot(data = sfn, aes(x = long, y = lat, group = group)) + geom_path() ---- image::{{<siteurl>}}/uploads/2014/11/2014-11-17_00-38-32.png[2014 11 17 00 38 32,600] +++<cite>+++sfn+++</cite>+++ is a spatial type of data frame\... [source,r] ---- > class(sfn) [1] "SpatialPolygonsDataFrame" attr(,"package") [1] "sp" ---- \...but we need a http://rstudio-pubs-static.s3.amazonaws.com/11196_2ac0fb4e6c93425ab7ddd4ccc61c5e47.html[normal data frame to be able to easily merge other data onto the map] and then plot it. We can use ggplot2's +++<cite>+++https://groups.google.com/forum/#!topic/ggplot2/PHaeJNq8eNs[fortify]+++</cite>+++ command to do this: [source,r] ---- > names(sfn) [1] "OBJECTID" "ZIP_CODE" "ID" > sfn.f = sfn %>% fortify(region = 'ZIP_CODE') SFNeighbourhoods = merge(sfn.f, sfn@data, by.x = 'id', by.y = 'ZIP_CODE') ---- I then made up some fake values for each zip code so that we could have different colour shadings for each zip code on the visualisation: [source,r] ---- > library(dplyr) > postcodes = SFNeighbourhoods %>% select(id) %>% distinct() > values = data.frame(id = c(postcodes), value = c(runif(postcodes %>% count() %>% unlist(),5.0, 25.0))) ---- I then merged those values onto +++<cite>+++SFNeighbourhoods+++</cite>+++: [source,r] ---- > sf = merge(SFNeighbourhoods, values, by.x='id') > sf %>% group_by(id) %>% do(head(., 1)) %>% head(10) Source: local data frame [10 x 10] Groups: id id long lat order hole piece group OBJECTID ID value 1 94102 -122.4193 37.77515 1 FALSE 1 94102.1 14 94102 6.184814 2 94103 -122.4039 37.77006 106 FALSE 1 94103.1 12 94103 21.659752 3 94104 -122.4001 37.79030 255 FALSE 1 94104.1 10 94104 5.173199 4 94105 -122.3925 37.79377 293 FALSE 1 94105.1 2 94105 15.723456 5 94107 -122.4012 37.78202 504 FALSE 1 94107.1 1 94107 8.402726 6 94108 -122.4042 37.79169 2232 FALSE 1 94108.1 11 94108 8.632652 7 94109 -122.4139 37.79046 2304 FALSE 1 94109.1 8 94109 20.129402 8 94110 -122.4217 37.73181 2794 FALSE 1 94110.1 16 94110 12.410610 9 94111 -122.4001 37.79369 3067 FALSE 1 94111.1 9 94111 10.185054 10 94112 -122.4278 37.73469 3334 FALSE 1 94112.1 18 94112 24.297588 ---- Now we can easily plot those colours onto our shapefile by calling +++<cite>+++geom_polgon+++</cite>+++ instead of +++<cite>+++geom_path+++</cite>+++: [source,r] ---- > ggplot(sf, aes(long, lat, group = group)) + geom_polygon(aes(fill = value)) ---- image::{{<siteurl>}}/uploads/2014/11/2014-11-17_00-49-11.png[2014 11 17 00 49 11,600] And finally let's wire it up to our google map: [source,r] ---- > ggmap(sfMap) + geom_polygon(aes(fill = value, x = long, y = lat, group = group), data = sf, alpha = 0.8, color = "black", size = 0.2) ---- image::{{<siteurl>}}/uploads/2014/11/2014-11-17_00-50-13.png[2014 11 17 00 50 13,600] I spent way too long with the +++<cite>+++alpha+++</cite>+++ value set to '0' on this last plot wondering why I wasn't seeing any shading so don't make that mistake!

r-ggmap-overlay-shapefile-with-filled-polygon-of-regions

https://markhneedham.com/blog/2014/11/17/r-ggmap-overlay-shapefile-with-filled-polygon-of-regions

2014-11-10 22:06:49

R: dplyr - Maximum value row in each group

In my continued work with R's http://cran.rstudio.com/web/packages/dplyr/vignettes/introduction.html[dplyr] I wanted to be able to group a data frame by some columns and then find the maximum value for each group. We'll continue with my favourite dummy data set: [source,r] ---- > library(dplyr) > data = data.frame( letter = sample(LETTERS, 50000, replace = TRUE), number = sample (1:10, 50000, replace = TRUE) ) ---- I started with the following code to count how many occurrences of each (letter, number) pair there were: [source,r] ---- > data %>% count(letter, number) Source: local data frame [260 x 3] Groups: letter letter number n 1 A 1 184 2 A 2 192 3 A 3 183 4 A 4 193 5 A 5 214 6 A 6 172 7 A 7 196 8 A 8 198 9 A 9 174 10 A 10 196 .. ... ... ... ---- I wanted to find the top number for each letter and with a http://stackoverflow.com/questions/24558328/how-to-select-the-maximum-value-in-each-group-in-r[bit of help from Stack Overflow] I ended up with the following: [source,r] ---- > data %>% count(letter, number) %>% filter(n == max(n)) Source: local data frame [26 x 3] Groups: letter letter number n 1 A 5 214 2 B 6 234 3 C 8 213 4 D 6 211 5 E 9 208 6 F 2 219 7 G 1 213 8 H 2 208 9 I 9 220 10 J 7 213 11 K 3 228 12 L 2 206 13 M 3 212 14 N 4 222 15 O 1 211 16 P 7 211 17 Q 9 210 18 R 5 224 19 S 2 211 20 T 9 204 21 U 8 217 22 V 6 220 23 W 2 213 24 X 2 214 25 Y 3 211 26 Z 3 206 ---- Here we're filtering over a collection of rows grouped by letter and only selecting the row which has the max value. We can see more clearly what's happening if we filter the data frame to only contain one letter: [source,r] ---- > letterA = data %>% filter(letter == "A") %>% count(letter, number) > letterA Source: local data frame [10 x 3] Groups: letter letter number n 1 A 1 184 2 A 2 192 3 A 3 183 4 A 4 193 5 A 5 214 6 A 6 172 7 A 7 196 8 A 8 198 9 A 9 174 10 A 10 196 ---- And now let's apply the filter command while also printing out information about each row: [source,r] ---- > letterA %>% filter(print(n), print(n == max(n)), n == max(n)) [1] 184 192 183 193 214 172 196 198 174 196 [1] FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE Source: local data frame [1 x 3] Groups: letter letter number n 1 A 5 214 ---- If instead of getting the top number by letter we wanted to get the top letter by number we just need to reorder the field names in the count method: [source,r] ---- > data %>% count(number, letter) %>% filter(n == max(n)) Source: local data frame [10 x 3] Groups: number number letter n 1 1 G 213 2 2 F 219 3 3 K 228 4 4 N 222 5 5 R 224 6 6 B 234 7 7 B 221 8 8 U 217 9 9 I 220 10 10 O 209 ---- And if we want to see the letter that shows up least frequently we can change the call to 'max' to an equivalent one to 'min': [source,r] ---- > data %>% count(number, letter) %>% filter(n == min(n)) Source: local data frame [11 x 3] Groups: number number letter n 1 1 H 166 2 2 O 160 3 3 E 156 4 4 R 169 5 5 L 169 6 6 I 164 7 7 H 170 8 7 I 170 9 8 Q 166 10 9 W 162 11 10 J 168 ----

r-maximum-value-row-in-each-group

https://markhneedham.com/blog/2014/11/10/r-maximum-value-row-in-each-group

2014-11-26 00:01:12

R: dplyr - Select 'random' rows from a data frame

Frequently I find myself wanting to take a sample of the rows in a data frame where just taking the head isn't enough. Let's say we start with the following data frame: [source,r] ---- data = data.frame( letter = sample(LETTERS, 50000, replace = TRUE), number = sample (1:10, 50000, replace = TRUE) ) ---- And we'd like to sample 10 rows to see what it contains. We'll start by http://blog.revolutionanalytics.com/2009/02/how-to-choose-a-random-number-in-r.html[generating 10 random numbers] to represent row numbers using the +++<cite>+++runif+++</cite>+++ function: [source,r] ---- > randomRows = sample(1:length(data[,1]), 10, replace=T) > randomRows [1] 8723 18772 4964 36134 27467 31890 16313 12841 49214 15621 ---- We can then pass that list of row numbers into dplyr's +++<cite>+++http://rpackages.ianhowson.com/cran/dplyr/man/slice.html[slice]+++</cite>+++ function like so: [source,r] ---- > data %>% slice(randomRows) letter number 1 Z 4 2 F 1 3 Y 6 4 R 6 5 Y 4 6 V 10 7 R 6 8 D 6 9 J 7 10 E 2 ---- If we're using that code throughout our code then we might want to pull out a function like so: [source,r] ---- pickRandomRows = function(df, numberOfRows = 10) { df %>% slice(runif(numberOfRows,0, length(df[,1]))) } ---- And then call it like so: [source,r] ---- > data %>% pickRandomRows() letter number 1 W 5 2 Y 3 3 E 6 4 Q 8 5 M 9 6 H 9 7 E 10 8 T 2 9 I 5 10 V 4 > data %>% pickRandomRows(7) letter number 1 V 7 2 N 4 3 W 1 4 N 8 5 G 7 6 V 1 7 N 7 ---- == Update https://twitter.com/tonkouts[Antonios] pointed out via email that we could just make use of the in-built +++<cite>+++sample_n+++</cite>+++ function which I didn't know about until now: [source,r] ---- > data %>% sample_n(10) letter number 29771 U 1 48666 T 10 30635 A 1 34865 X 7 20140 A 3 41715 T 10 43786 E 10 18284 A 7 21406 S 8 35542 J 8 ----

r-dplyr-select-random-rows-from-a-data-frame

https://markhneedham.com/blog/2014/11/26/r-dplyr-select-random-rows-from-a-data-frame

2014-11-07 01:29:09

R: Joining multiple data frames

I've been looking through the code from Martin Eastwood's excellent talk 'http://pena.lt/y/2014/11/02/predicting-football-using-r/[Predicting Football Using R]' and was intrigued by the code which reshaped the data into that expected by http://stat.ethz.ch/R-manual/R-patched/library/stats/html/glm.html[glm]. The original looks like this: [source,r] ---- df <- read.csv('http://www.football-data.co.uk/mmz4281/1314/E0.csv') # munge data into format compatible with glm function df <- apply(df, 1, function(row){ data.frame(team=c(row['HomeTeam'], row['AwayTeam']), opponent=c(row['AwayTeam'], row['HomeTeam']), goals=c(row['FTHG'], row['FTAG']), home=c(1, 0)) }) df <- do.call(rbind, df) ---- The initial data frame looks like this: [source,r] ---- > library(dplyr) > df %>% select(HomeTeam, AwayTeam, FTHG, FTAG) %>% head(1) HomeTeam AwayTeam FTHG FTAG 1 Arsenal Aston Villa 1 3~~~ <p>And we want to get it to look like this:</p> ~~~r > head(df, 2) team opponent goals home HomeTeam Arsenal Aston Villa 1 1 AwayTeam Aston Villa Arsenal 3 0 ---- So for each row in the initial data frame we want to have two rows: one representing each team, how many goals they scored in the match and whether they were playing at home or away. I really like dplyr's pipelining function so I thought I'd try and translate Martin's code to use that and other dplyr functions. I ended up with the following two sets of function calls: [source,r] ---- df %>% select(team = HomeTeam, opponent = AwayTeam, goals = FTHG) %>% mutate(home = 1) df %>% select(team = AwayTeam, opponent = HomeTeam, goals = FTAG) %>% mutate(home = 0) ---- I'm doing pretty much the same thing as Martin except I've used dplyr's select and mutate functions to transform the data frame. The next step was to join those two data frames together and with https://twitter.com/_nicolemargaret[Nicole's] help I realised that there are many ways we can do this. The functions that will do the job are: * http://www.endmemo.com/program/R/rbind.php[rbind] * http://stat.ethz.ch/R-manual/R-patched/library/base/html/sets.html[union] * plyr's http://www.inside-r.org/packages/cran/plyr/docs/join[join] with 'type = "full"' * dplyr's http://www3.nd.edu/~steve/computing_with_data/24_dplyr/dplyr.html[union] * http://stat.ethz.ch/R-manual/R-patched/library/base/html/merge.html[merge] with 'all = TRUE' We decided to http://adv-r.had.co.nz/Performance.html[benchmark] them to see which was able to transform the data frame the fastest: [source,r] ---- # load data into data.frame dfOrig <- read.csv('http://www.football-data.co.uk/mmz4281/1314/E0.csv') original = function(df) { df <- apply(df, 1, function(row){ data.frame(team=c(row['HomeTeam'], row['AwayTeam']), opponent=c(row['AwayTeam'], row['HomeTeam']), goals=c(row['FTHG'], row['FTAG']), home=c(1, 0)) }) do.call(rbind, df) } newRBind = function(df) { rbind(df %>% select(team = HomeTeam, opponent = AwayTeam, goals = FTHG) %>% mutate(home = 1), df %>% select(team = AwayTeam, opponent = HomeTeam, goals = FTAG) %>% mutate(home = 0)) } newUnion = function(df) { union(df %>% select(team = HomeTeam, opponent = AwayTeam, goals = FTHG) %>% mutate(home = 1), df %>% select(team = AwayTeam, opponent = HomeTeam, goals = FTAG) %>% mutate(home = 0)) } newJoin = function(df) { join(df %>% select(team = HomeTeam, opponent = AwayTeam, goals = FTHG) %>% mutate(home = 1), df %>% select(team = AwayTeam, opponent = HomeTeam, goals = FTAG) %>% mutate(home = 0), type = "full") } newMerge = function(df) { merge(df %>% select(team = HomeTeam, opponent = AwayTeam, goals = FTHG) %>% mutate(home = 1), df %>% select(team = AwayTeam, opponent = HomeTeam, goals = FTAG) %>% mutate(home = 0), all = TRUE) } ---- [source,r] ---- > library(microbenchmark) > microbenchmark(original(dfOrig)) Unit: milliseconds expr min lq mean median uq max neval original(dfOrig) 189.4 196.8 202.5 201 205.5 284 100 > microbenchmark(newRBind(dfOrig)) Unit: milliseconds expr min lq mean median uq max neval newRBind(dfOrig) 2.197 2.274 2.396 2.309 2.377 4.526 100 > microbenchmark(newUnion(dfOrig)) Unit: milliseconds expr min lq mean median uq max neval newUnion(dfOrig) 2.156 2.223 2.377 2.264 2.34 4.597 100 > microbenchmark(newJoin(dfOrig)) Unit: milliseconds expr min lq mean median uq max neval newJoin(dfOrig) 5.961 6.132 6.817 6.253 6.65 11.95 100 > microbenchmark(newMerge(dfOrig)) Unit: milliseconds expr min lq mean median uq max neval newMerge(dfOrig) 7.121 7.413 8.037 7.541 7.934 13.32 100 ---- We actually get a 100 time speed up over the original function if we use rbind or union whereas with merge or join it's around 35 times quicker. In this case using merge or join is a bit misleading because we're not actually connecting the data frames together based on any particular field - we are just appending one to the other. The code's https://gist.github.com/mneedham/98a4e423c1b37f05361c[available as a gist] if you want to have a play.

r-joining-multiple-data-frames

https://markhneedham.com/blog/2014/11/07/r-joining-multiple-data-frames

2014-11-09 00:11:48

R: Refactoring to dplyr

I've been looking back over some of the early code I wrote using R before I knew about the http://cran.r-project.org/web/packages/dplyr/vignettes/introduction.html[dplyr] library and thought it'd be an interesting exercise to refactor some of the snippets. We'll use the following data frame for each of the examples: [source,r] ---- library(dplyr) data = data.frame( letter = sample(LETTERS, 50000, replace = TRUE), number = sample (1:10, 50000, replace = TRUE) ) ---- == Take \{n} rows [source,r] ---- > data[1:5,] letter number 1 R 7 2 Q 3 3 B 8 4 R 3 5 U 2 ---- becomes: [source,r] ---- > data %>% head(5) letter number 1 R 7 2 Q 3 3 B 8 4 R 3 5 U 2 ---- == Order by numeric value descending [source,r] ---- > data[order(-(data$number)),][1:5,] letter number 14 H 10 17 G 10 63 L 10 66 W 10 73 R 10 ---- becomes: [source,r] ---- > data %>% arrange(desc(number)) %>% head(5) letter number 1 H 10 2 G 10 3 L 10 4 W 10 5 R 10 ---- == Count number of items [source,r] ---- > length(data[,1]) [1] 50000 ---- becomes: [source,r] ---- > data %>% count() Source: local data frame [1 x 1] n 1 50000 ---- == Filter by column value [source,r] ---- > length(subset(data, number == 1)[, 1]) [1] 4928 ---- becomes: [source,r] ---- > data %>% filter(number == 1) %>% count() Source: local data frame [1 x 1] n 1 4928 ---- == Group by variable and count [source,r] ---- > aggregate(data, by= list(data$number), function(x) length(x)) Group.1 letter number 1 1 4928 4928 2 2 5045 5045 3 3 5064 5064 4 4 4823 4823 5 5 5032 5032 6 6 5163 5163 7 7 4945 4945 8 8 5077 5077 9 9 5025 5025 10 10 4898 4898 ---- becomes: [source,r] ---- > data %>% count(number) Source: local data frame [10 x 2] number n 1 1 4928 2 2 5045 3 3 5064 4 4 4823 5 5 5032 6 6 5163 7 7 4945 8 8 5077 9 9 5025 10 10 4898 ---- == Select a range of rows [source,r] ---- > data[4:5,] letter number 4 R 3 5 U 2 ---- becomes: [source,r] ---- > data %>% slice(4:5) letter number 1 R 3 2 U 2 ---- There's certainly more code in some of the dplyr examples but I find it easier to remember how the dplyr code works when I come back to it and hence tend to favour that approach.

r-refactoring-to-dplyr

https://markhneedham.com/blog/2014/11/09/r-refactoring-to-dplyr

2014-11-09 09:30:09

R: dplyr - Ordering by count after multiple column group_by

I was recently trying to group a data frame by two columns and then sort by the count using dplyr but it wasn't sorting in the way I expecting which was initially very confusing. I started with this data frame: [source,r] ---- library(dplyr) data = data.frame( letter = sample(LETTERS, 50000, replace = TRUE), number = sample (1:10, 50000, replace = TRUE) ) ---- And I wanted to find out how many occurrences of each (letter, number) pair exist in the data set. I started with the following code: [source,r] ---- > data %>% count(letter, number, sort = TRUE) Source: local data frame [260 x 3] Groups: letter letter number n 1 A 4 205 2 A 9 201 3 A 3 197 4 A 1 195 5 A 10 191 6 A 2 189 7 A 8 184 8 A 7 183 9 A 5 181 10 A 6 173 .. ... ... ... ---- As you can see it's only showing A's which is interesting as I wouldn't expect there to be a bias towards that letter. Let's filter out the A's: [source,r] ---- > data %>% filter(letter != "A") %>% count(letter, number, sort = TRUE) Source: local data frame [250 x 3] Groups: letter letter number n 1 B 8 222 2 B 9 212 3 B 5 207 4 B 6 201 5 B 10 200 6 B 7 192 7 B 2 189 8 B 3 189 9 B 1 187 10 B 4 181 .. ... ... ... ---- Now all we see are B's and we can see that both (B,8) and (B,9) have a higher 'n' value than any of the A's. I put the code back into the more verbose form to see if it was the +++<cite>+++count+++</cite>+++ function that behaved unexpectedly: [source,r] ---- > data %>% group_by(letter, number) %>% summarise(n = n()) %>% arrange(desc(n)) Source: local data frame [260 x 3] Groups: letter letter number n 1 A 4 205 2 A 9 201 3 A 3 197 4 A 1 195 5 A 10 191 6 A 2 189 7 A 8 184 8 A 7 183 9 A 5 181 10 A 6 173 .. ... ... ... ---- Nope, still the same behaviour. At this point I vaguely remembered there being a function called +++<cite>+++ungroup+++</cite>+++ which I hadn't used and wondered if now was the time. [source,r] ---- > data %>% group_by(letter, number) %>% summarise(n = n()) %>% ungroup() %>% arrange(desc(n)) Source: local data frame [260 x 3] letter number n 1 L 2 236 2 V 1 231 3 Y 8 226 4 J 4 225 5 J 10 223 6 Q 7 223 7 B 8 222 8 O 9 222 9 Q 10 221 10 Z 9 221 .. ... ... ... ---- Indeed it was and now we can go back to our original version of the code using +++<cite>+++count+++</cite>+++ and handle the sorting afterwards: [source,r] ---- > data %>% count(letter, number) %>% ungroup() %>% arrange(desc(n)) Source: local data frame [260 x 3] letter number n 1 L 2 236 2 V 1 231 3 Y 8 226 4 J 4 225 5 J 10 223 6 Q 7 223 7 B 8 222 8 O 9 222 9 Q 10 221 10 Z 9 221 .. ... ... ... ----

r-dplyr-ordering-by-count-after-multiple-column-group_by

https://markhneedham.com/blog/2014/11/09/r-dplyr-ordering-by-count-after-multiple-column-group_by

2014-11-30 07:40:00

Spark: Write to CSV file

A couple of weeks ago I wrote how I'd been http://www.markhneedham.com/blog/2014/11/16/spark-parse-csv-file-and-group-by-column-value/[using Spark to explore a City of Chicago Crime data set] and having worked out how many of each crime had been committed I wanted to write that to a CSV file. Spark provides a +++<cite>+++saveAsTextFile+++</cite>+++ function which allows us to save RDD's so I refactored my code into the following format to allow me to use that: [source,scala] ---- import au.com.bytecode.opencsv.CSVParser import org.apache.spark.rdd.RDD import org.apache.spark.SparkContext._ def dropHeader(data: RDD[String]): RDD[String] = { data.mapPartitionsWithIndex((idx, lines) => { if (idx == 0) { lines.drop(1) } lines }) } // https://data.cityofchicago.org/Public-Safety/Crimes-2001-to-present/ijzp-q8t2 val crimeFile = "/Users/markneedham/Downloads/Crimes_-_2001_to_present.csv" val crimeData = sc.textFile(crimeFile).cache() val withoutHeader: RDD[String] = dropHeader(crimeData) val file = "/tmp/primaryTypes.csv" FileUtil.fullyDelete(new File(file)) val partitions: RDD[(String, Int)] = withoutHeader.mapPartitions(lines => { val parser = new CSVParser(',') lines.map(line => { val columns = parser.parseLine(line) (columns(5), 1) }) }) val counts = partitions. reduceByKey {case (x,y) => x + y}. sortBy {case (key, value) => -value}. map { case (key, value) => Array(key, value).mkString(",") } counts.saveAsTextFile(file) ---- If we run that code from the Spark shell we end up with a folder called +++<cite>+++/tmp/primaryTypes.csv+++</cite>+++ containing multiple part files: [source,bash] ---- $ ls -lah /tmp/primaryTypes.csv/ total 496 drwxr-xr-x 66 markneedham wheel 2.2K 30 Nov 07:17 . drwxrwxrwt 80 root wheel 2.7K 30 Nov 07:16 .. -rw-r--r-- 1 markneedham wheel 8B 30 Nov 07:16 ._SUCCESS.crc -rw-r--r-- 1 markneedham wheel 12B 30 Nov 07:16 .part-00000.crc -rw-r--r-- 1 markneedham wheel 12B 30 Nov 07:16 .part-00001.crc -rw-r--r-- 1 markneedham wheel 12B 30 Nov 07:16 .part-00002.crc -rw-r--r-- 1 markneedham wheel 12B 30 Nov 07:16 .part-00003.crc ... -rwxrwxrwx 1 markneedham wheel 0B 30 Nov 07:16 _SUCCESS -rwxrwxrwx 1 markneedham wheel 28B 30 Nov 07:16 part-00000 -rwxrwxrwx 1 markneedham wheel 17B 30 Nov 07:16 part-00001 -rwxrwxrwx 1 markneedham wheel 23B 30 Nov 07:16 part-00002 -rwxrwxrwx 1 markneedham wheel 16B 30 Nov 07:16 part-00003 ... ---- If we look at some of those part files we can see that it's written the crime types and counts as expected: [source,bash] ---- $ cat /tmp/primaryTypes.csv/part-00000 THEFT,859197 BATTERY,757530 $ cat /tmp/primaryTypes.csv/part-00003 BURGLARY,257310 ---- This is fine if we're going to http://stackoverflow.com/questions/23527941/how-to-write-to-csv-in-spark[pass those CSV files into another Hadoop based job] but I actually want a single CSV file so it's not quite what I want. One way to achieve this is to force everything to be calculated on one partition which will mean we only get one part file generated: [source,scala] ---- val counts = partitions.repartition(1). reduceByKey {case (x,y) => x + y}. sortBy {case (key, value) => -value}. map { case (key, value) => Array(key, value).mkString(",") } counts.saveAsTextFile(file) ---- part-00000 now looks like this: [source,bash] ---- $ cat !$ cat /tmp/primaryTypes.csv/part-00000 THEFT,859197 BATTERY,757530 NARCOTICS,489528 CRIMINAL DAMAGE,488209 BURGLARY,257310 OTHER OFFENSE,253964 ASSAULT,247386 MOTOR VEHICLE THEFT,197404 ROBBERY,157706 DECEPTIVE PRACTICE,137538 CRIMINAL TRESPASS,124974 PROSTITUTION,47245 WEAPONS VIOLATION,40361 PUBLIC PEACE VIOLATION,31585 OFFENSE INVOLVING CHILDREN,26524 CRIM SEXUAL ASSAULT,14788 SEX OFFENSE,14283 GAMBLING,10632 LIQUOR LAW VIOLATION,8847 ARSON,6443 INTERFERE WITH PUBLIC OFFICER,5178 HOMICIDE,4846 KIDNAPPING,3585 INTERFERENCE WITH PUBLIC OFFICER,3147 INTIMIDATION,2471 STALKING,1985 OFFENSES INVOLVING CHILDREN,355 OBSCENITY,219 PUBLIC INDECENCY,86 OTHER NARCOTIC VIOLATION,80 NON-CRIMINAL,12 RITUALISM,12 OTHER OFFENSE ,6 NON - CRIMINAL,2 NON-CRIMINAL (SUBJECT SPECIFIED),2 ---- This works but it's quite a bit slower than when we were doing the aggregation across partitions so it's not ideal. Instead, what we can do is make use of one of http://mail-archives.apache.org/mod_mbox/spark-user/201310.mbox/%3C5271F0B6.7000701@icsi.berkeley.edu%3E[Hadoop's merge functions] which squashes part files together into a single file. First we import Hadoop into our SBT file: [source,text] ---- libraryDependencies += "org.apache.hadoop" % "hadoop-hdfs" % "2.5.2" ---- Now let's bring our merge function into the Spark shell: [source,scala] ---- import org.apache.hadoop.conf.Configuration import org.apache.hadoop.fs._ def merge(srcPath: String, dstPath: String): Unit = { val hadoopConfig = new Configuration() val hdfs = FileSystem.get(hadoopConfig) FileUtil.copyMerge(hdfs, new Path(srcPath), hdfs, new Path(dstPath), false, hadoopConfig, null) } ---- And now let's make use of it: [source,scala] ---- val file = "/tmp/primaryTypes.csv" FileUtil.fullyDelete(new File(file)) val destinationFile= "/tmp/singlePrimaryTypes.csv" FileUtil.fullyDelete(new File(destinationFile)) val counts = partitions. reduceByKey {case (x,y) => x + y}. sortBy {case (key, value) => -value}. map { case (key, value) => Array(key, value).mkString(",") } counts.saveAsTextFile(file) merge(file, destinationFile) ---- And now we've got the best of both worlds: [source,bash] ---- $ cat /tmp/singlePrimaryTypes.csv THEFT,859197 BATTERY,757530 NARCOTICS,489528 CRIMINAL DAMAGE,488209 BURGLARY,257310 OTHER OFFENSE,253964 ASSAULT,247386 MOTOR VEHICLE THEFT,197404 ROBBERY,157706 DECEPTIVE PRACTICE,137538 CRIMINAL TRESPASS,124974 PROSTITUTION,47245 WEAPONS VIOLATION,40361 PUBLIC PEACE VIOLATION,31585 OFFENSE INVOLVING CHILDREN,26524 CRIM SEXUAL ASSAULT,14788 SEX OFFENSE,14283 GAMBLING,10632 LIQUOR LAW VIOLATION,8847 ARSON,6443 INTERFERE WITH PUBLIC OFFICER,5178 HOMICIDE,4846 KIDNAPPING,3585 INTERFERENCE WITH PUBLIC OFFICER,3147 INTIMIDATION,2471 STALKING,1985 OFFENSES INVOLVING CHILDREN,355 OBSCENITY,219 PUBLIC INDECENCY,86 OTHER NARCOTIC VIOLATION,80 RITUALISM,12 NON-CRIMINAL,12 OTHER OFFENSE ,6 NON - CRIMINAL,2 NON-CRIMINAL (SUBJECT SPECIFIED),2 ---- The full code is available as a https://gist.github.com/mneedham/2fa4752749c8aba7f6b3[gist] if you want to play around with it.

spark-write-to-csv-file

https://markhneedham.com/blog/2014/11/30/spark-write-to-csv-file

2014-11-30 08:21:54

Spark: Write to CSV file with header using saveAsFile

In my last blog post I showed http://www.markhneedham.com/blog/2014/11/30/spark-write-to-csv-file/[how to write to a single CSV file using Spark and Hadoop] and the next thing I wanted to do was add a header row to the resulting row. Hadoop's +++<cite>+++https://hadoop.apache.org/docs/current/api/org/apache/hadoop/fs/FileUtil.html#copyMerge(org.apache.hadoop.fs.FileSystem, org.apache.hadoop.fs.Path, org.apache.hadoop.fs.FileSystem, org.apache.hadoop.fs.Path, boolean, org.apache.hadoop.conf.Configuration, java.lang.String)[FileUtil#copyMerge]+++</cite>+++ function does take a String parameter but it adds this text to the end of each partition file which isn't quite what we want. However, if we copy that function into our own FileUtil class we can restructure it to do what we want: [source,java] ---- import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.*; import org.apache.hadoop.io.IOUtils; import java.io.IOException; public class MyFileUtil { public static boolean copyMergeWithHeader(FileSystem srcFS, Path srcDir, FileSystem dstFS, Path dstFile, boolean deleteSource, Configuration conf, String header) throws IOException { dstFile = checkDest(srcDir.getName(), dstFS, dstFile, false); if(!srcFS.getFileStatus(srcDir).isDir()) { return false; } else { FSDataOutputStream out = dstFS.create(dstFile); if(header != null) { out.write((header + "\n").getBytes("UTF-8")); } try { FileStatus[] contents = srcFS.listStatus(srcDir); for(int i = 0; i < contents.length; ++i) { if(!contents[i].isDir()) { FSDataInputStream in = srcFS.open(contents[i].getPath()); try { IOUtils.copyBytes(in, out, conf, false); } finally { in.close(); } } } } finally { out.close(); } return deleteSource?srcFS.delete(srcDir, true):true; } } private static Path checkDest(String srcName, FileSystem dstFS, Path dst, boolean overwrite) throws IOException { if(dstFS.exists(dst)) { FileStatus sdst = dstFS.getFileStatus(dst); if(sdst.isDir()) { if(null == srcName) { throw new IOException("Target " + dst + " is a directory"); } return checkDest((String)null, dstFS, new Path(dst, srcName), overwrite); } if(!overwrite) { throw new IOException("Target " + dst + " already exists"); } } return dst; } } ---- We can then update our merge function to call this instead: [source,scala] ---- def merge(srcPath: String, dstPath: String, header:String): Unit = { val hadoopConfig = new Configuration() val hdfs = FileSystem.get(hadoopConfig) MyFileUtil.copyMergeWithHeader(hdfs, new Path(srcPath), hdfs, new Path(dstPath), false, hadoopConfig, header) } ---- We call merge from our code like this: [source,scala] ---- merge(file, destinationFile, "type,count") ---- I wasn't sure how to import my Java based class into the Spark shell so I compiled the code into a JAR and submitted it as a job instead: [source,bash] ---- $ sbt package [info] Loading global plugins from /Users/markneedham/.sbt/0.13/plugins [info] Loading project definition from /Users/markneedham/projects/spark-play/playground/project [info] Set current project to playground (in build file:/Users/markneedham/projects/spark-play/playground/) [info] Compiling 3 Scala sources to /Users/markneedham/projects/spark-play/playground/target/scala-2.10/classes... [info] Packaging /Users/markneedham/projects/spark-play/playground/target/scala-2.10/playground_2.10-1.0.jar ... [info] Done packaging. [success] Total time: 8 s, completed 30-Nov-2014 08:12:26 $ time ./bin/spark-submit --class "WriteToCsvWithHeader" --master local[4] /path/to/playground/target/scala-2.10/playground_2.10-1.0.jar Spark assembly has been built with Hive, including Datanucleus jars on classpath Using Spark's default log4j profile: org/apache/spark/log4j-defaults.propertie ... 14/11/30 08:16:15 INFO TaskSchedulerImpl: Removed TaskSet 2.0, whose tasks have all completed, from pool 14/11/30 08:16:15 INFO SparkContext: Job finished: saveAsTextFile at WriteToCsvWithHeader.scala:49, took 0.589036 s real 0m13.061s user 0m38.977s sys 0m3.393s ---- And if we look at our destination file: [source,bash] ---- $ cat /tmp/singlePrimaryTypes.csv type,count THEFT,859197 BATTERY,757530 NARCOTICS,489528 CRIMINAL DAMAGE,488209 BURGLARY,257310 OTHER OFFENSE,253964 ASSAULT,247386 MOTOR VEHICLE THEFT,197404 ROBBERY,157706 DECEPTIVE PRACTICE,137538 CRIMINAL TRESPASS,124974 PROSTITUTION,47245 WEAPONS VIOLATION,40361 PUBLIC PEACE VIOLATION,31585 OFFENSE INVOLVING CHILDREN,26524 CRIM SEXUAL ASSAULT,14788 SEX OFFENSE,14283 GAMBLING,10632 LIQUOR LAW VIOLATION,8847 ARSON,6443 INTERFERE WITH PUBLIC OFFICER,5178 HOMICIDE,4846 KIDNAPPING,3585 INTERFERENCE WITH PUBLIC OFFICER,3147 INTIMIDATION,2471 STALKING,1985 OFFENSES INVOLVING CHILDREN,355 OBSCENITY,219 PUBLIC INDECENCY,86 OTHER NARCOTIC VIOLATION,80 RITUALISM,12 NON-CRIMINAL,12 OTHER OFFENSE ,6 NON - CRIMINAL,2 NON-CRIMINAL (SUBJECT SPECIFIED),2 ---- Happy days! The code is available as a https://gist.github.com/mneedham/881ee5dcb58456855174[gist] if you want to see all the details.

spark-write-to-csv-file-with-header-using-saveasfile

https://markhneedham.com/blog/2014/11/30/spark-write-to-csv-file-with-header-using-saveasfile

2014-11-08 22:29:01

R: dplyr - Group by field dynamically ('regroup' is deprecated / no applicable method for 'as.lazy' applied to an object of class "list" )

A few months ago I wrote a blog http://www.markhneedham.com/blog/2014/08/29/r-dplyr-group_by-dynamic-or-programmatic-field-variable-error-index-out-of-bounds/[explaining how to dynamically/programatically group a data frame by a field using dplyr] but that approach has been deprecated in the latest version. To recap, the original function looked like this: [source,r] ---- library(dplyr) groupBy = function(df, field) { df %.% regroup(list(field)) %.% summarise(n = n()) } ---- And if we execute that with a sample data frame we'll see the following: [source,r] ---- > data = data.frame( letter = sample(LETTERS, 50000, replace = TRUE), number = sample (1:10, 50000, replace = TRUE) ) > groupBy(data, 'letter') %>% head(5) Source: local data frame [5 x 2] letter n 1 A 1951 2 B 1903 3 C 1954 4 D 1923 5 E 1886 Warning messages: 1: %.% is deprecated. Please use %>% 2: %.% is deprecated. Please use %>% 3: 'regroup' is deprecated. Use 'group_by_' instead. See help("Deprecated") ---- I replaced each of the deprecated operators and ended up with this function: [source,r] ---- groupBy = function(df, field) { df %>% group_by_(list(field)) %>% summarise(n = n()) } ---- Now if we run that: [source,r] ---- > groupBy(data, 'letter') %>% head(5) Error in UseMethod("as.lazy") : no applicable method for 'as.lazy' applied to an object of class "list" ---- It turns out the 'group_by_' function doesn't want to receive a list of fields so let's remove the call to +++<cite>+++list+++</cite>+++: [source,r] ---- groupBy = function(df, field) { df %>% group_by_(field) %>% summarise(n = n()) } ---- And now if we run that: [source,r] ---- > groupBy(data, 'letter') %>% head(5) Source: local data frame [5 x 2] letter n 1 A 1951 2 B 1903 3 C 1954 4 D 1923 5 E 1886 ---- Good times! We get the correct result and no deprecation messages. If we want to group by multiple fields we can just pass in the field names like so: [source,r] ---- groupBy = function(df, field1, field2) { df %>% group_by_(field1, field2) %>% summarise(n = n()) } ---- [source,r] ---- > groupBy(data, 'letter', 'number') %>% head(5) Source: local data frame [5 x 3] Groups: letter letter number n 1 A 1 200 2 A 2 218 3 A 3 205 4 A 4 176 5 A 5 203 ---- Or with this simpler version: [source,r] ---- groupBy = function(df, ...) { df %>% group_by_(...) %>% summarise(n = n()) } ---- [source,r] ---- > groupBy(data, 'letter', 'number') %>% head(5) Source: local data frame [5 x 3] Groups: letter letter number n 1 A 1 200 2 A 2 218 3 A 3 205 4 A 4 176 5 A 5 203 ---- I realised that we can actually just use the +++<cite>+++group_by+++</cite>+++ itself and pass in the field names without quotes, something I couldn't get to work in earlier versions: [source,r] ---- groupBy = function(df, ...) { df %>% group_by(...) %>% summarise(n = n()) } ---- [source,r] ---- > groupBy(data, letter, number) %>% head(5) Source: local data frame [5 x 3] Groups: letter letter number n 1 A 1 200 2 A 2 218 3 A 3 205 4 A 4 176 5 A 5 203 ---- We could even get a bit of pipelining going on if we fancied it: [source,r] ---- > data %>% groupBy(letter, number) %>% head(5) Source: local data frame [5 x 3] Groups: letter letter number n 1 A 1 200 2 A 2 218 3 A 3 205 4 A 4 176 5 A 5 203 ---- And http://blog.rstudio.org/2014/10/13/dplyr-0-3-2/[as of dplyr 0.3] we can simplify our groupBy function to make use of the new +++<cite>+++count+++</cite>+++ function which combines +++<cite>+++group_by+++</cite>+++ and +++<cite>+++summarise+++</cite>+++: [source,r] ---- groupBy = function(df, ...) { df %>% count(...) } ---- [source,r] ---- > data %>% groupBy(letter, number) %>% head(5) Source: local data frame [5 x 3] Groups: letter letter number n 1 A 1 200 2 A 2 218 3 A 3 205 4 A 4 176 5 A 5 203 ----

r-dplyr-group-by-field-dynamically-regroup-is-deprecated-no-applicable-method-for-as-lazy-applied-to-an-object-of-class-list

https://markhneedham.com/blog/2014/11/08/r-dplyr-group-by-field-dynamically-regroup-is-deprecated-no-applicable-method-for-as-lazy-applied-to-an-object-of-class-list

2014-11-23 01:02:06

R: dplyr - "Variables not shown"

I recently ran into a problem where the result of applying some operations to a data frame wasn't being output the way I wanted. I started with this data frame: [source,r] ---- words = function(numberOfWords, lengthOfWord) { w = c(1:numberOfWords) for(i in 1:numberOfWords) { w[i] = paste(sample(letters, lengthOfWord, replace=TRUE), collapse = "") } w } numberOfRows = 100 df = data.frame(a = sample (1:numberOfRows, 10, replace = TRUE), b = sample (1:numberOfRows, 10, replace = TRUE), name = words(numberOfRows, 10)) ---- I wanted to group the data frame by +++<cite>+++a+++</cite>+++ and +++<cite>+++b+++</cite>+++ and output a comma separated list of the associated names. I started with this: [source,r] ---- > df %>% group_by(a,b) %>% summarise(n = n(), words = paste(name, collapse = ",")) %>% arrange(desc(n)) %>% head(5) Source: local data frame [5 x 4] Groups: a a b n 1 19 90 10 2 24 36 10 3 29 20 10 4 29 80 10 5 62 54 10 Variables not shown: words (chr) ---- Unfortunately the +++<cite>+++words+++</cite>+++ column has been excluded and I came across http://stackoverflow.com/questions/22471256/overwriting-variables-not-shown-in-dplyr[this Stack Overflow post] which suggested that the +++<cite>+++print.tbl_df+++</cite>+++ function was the one responsible for filtering columns. Browsing the docs I found a couple of ways to overwrite this behaviour: [source,r] ---- > df %>% group_by(a,b) %>% summarise(n = n(), words = paste(name, collapse = ",")) %>% arrange(desc(n)) %>% head(5) %>% print(width = Inf) ---- or [source,r] ---- > options(dplyr.width = Inf) > df %>% group_by(a,b) %>% summarise(n = n(), words = paste(name, collapse = ",")) %>% arrange(desc(n)) %>% head(5) ---- And now we see this output instead: [source,r] ---- Source: local data frame [5 x 4] Groups: a a b n words 1 19 90 10 dfhtcgymxt,zpemxbpnri,rfmkksuavp,jxaarxzdzd,peydpxjizc,trdzchaxiy,arthnxbaeg,kjbpdvvghm,kpvsddlsua,xmysfcynxw 2 24 36 10 wtokzdfecx,eprsvpsdcp,kzgxtwnqli,jbyuicevrn,klriuenjzu,qzgtmkljoy,bonbhmqfaz,uauoybprrl,rzummfbkbx,icyeorwzxl 3 29 20 10 ebubytlosp,vtligdgvqw,ejlqonhuit,jwidjvtark,kmdzcalblg,qzrlewxcsr,eckfgjnkys,vfdaeqbfqi,rumblliqmn,fvezcdfiaz 4 29 80 10 wputpwgayx,lpawiyhzuh,ufykwguynu,nyqnwjallh,abaxicpixl,uirudflazn,wyynsikwcl,usescualww,bkvsowfaab,gfhyifzepx 5 62 54 10 beuegfzssp,gfmegjtrys,wkubhvnkkk,rkhgprxttb,cwsrzulnpo,hzkvjbiywc,gbmiupnlbw,gffovxwtok,uxadfrjvdn,aojjfhxygs ---- Much better!

r-dplyr-variables-not-shown

https://markhneedham.com/blog/2014/11/23/r-dplyr-variables-not-shown

2014-10-20 15:53:51

Python: Converting a date string to timestamp

I've been playing around with Python over the last few days while cleaning up a data set and one thing I wanted to do was translate date strings into a timestamp. I started with a date in this format: [source,python] ---- date_text = "13SEP2014" ---- So the first step is to translate that into a Python date - the https://docs.python.org/2/library/datetime.html#strftime-strptime-behavior[strftime section of the documentation] is useful for figuring out which format code is needed: [source,python] ---- import datetime date_text = "13SEP2014" date = datetime.datetime.strptime(date_text, "%d%b%Y") print(date) ---- [source,bash] ---- $ python dates.py 2014-09-13 00:00:00 ---- The next step was to translate that to a UNIX timestamp. I thought there might be a method or property on the Date object that I could access but I couldn't find one and so ended up using https://docs.python.org/2/library/calendar.html#calendar.timegm[calendar] to do the transformation: [source,python] ---- import datetime import calendar date_text = "13SEP2014" date = datetime.datetime.strptime(date_text, "%d%b%Y") print(date) print(calendar.timegm(date.utctimetuple())) ---- [source,text] ---- $ python dates.py 2014-09-13 00:00:00 1410566400 ---- It's not too tricky so hopefully I shall remember next time.

python-converting-a-date-string-to-timestamp

https://markhneedham.com/blog/2014/10/20/python-converting-a-date-string-to-timestamp

2014-10-20 23:08:45

Neo4j: Modelling sub types

A question which sometimes comes up when discussing http://www.infoq.com/articles/let-me-graph-that-for-you[graph data modelling] is how you go about http://www.learndatamodeling.com/dm_super_type.php[modelling sub/super types]. In my experience there are two reasons why we might want to do this: * To ensure that certain properties exist on bits of data * To write drill down queries based on those types At the moment the former isn't built into Neo4j and you'd only be able to achieve it by wiring up some code in a pre commit hook of a http://docs.neo4j.org/chunked/stable/transactions-events.html[transaction event handler] so we'll focus on the latter. The typical example used for showing how to design sub types is the animal kingdom and I managed to find a data set from http://portal.louisvilleky.gov/dataset/animaltag-data?page=16&order=tag_tail&sort=asc[Louiseville, Kentucky's Animal Services] which we can use. In this case the sub types are used to represent the type of animal, breed group and breed. We then also have 'real data' in terms of actual dogs under the care of animal services. We effectively end up with two graphs in one - a model and a meta model: image::{{<siteurl>}}/uploads/2014/10/2014-10-20_22-32-31.png[2014 10 20 22 32 31,600] The cypher query to create this graph looks like this: [source,cypher] ---- LOAD CSV WITH HEADERS FROM "file:/Users/markneedham/projects/neo4j-subtypes/data/dogs.csv" AS line MERGE (animalType:AnimalType {name: "Dog"}) MERGE (breedGroup:BreedGroup {name: line.BreedGroup}) MERGE (breed:Breed {name: line.PrimaryBreed}) MERGE (animal:Animal {id: line.TagIdentity, primaryColour: line.PrimaryColour, size: line.Size}) MERGE (animalType)<-[:PARENT]-(breedGroup) MERGE (breedGroup)<-[:PARENT]-(breed) MERGE (breed)<-[:PARENT]-(animal) ---- We could then write a simple query to find out how many dogs we have: [source,cypher] ---- MATCH (animalType:AnimalType)<-[:PARENT*]-(animal) RETURN animalType, COUNT(*) AS animals ORDER BY animals DESC ---- [source,bash] ---- ==> +--------------------------------+ ==> | animalType | animals | ==> +--------------------------------+ ==> | Node[89]{name:"Dog"} | 131 | ==> +--------------------------------+ ==> 1 row ---- Or we could write a slightly more complex query to find the number of animals at each level of our type hierarchy: [source,cypher] ---- MATCH path = (animalType:AnimalType)<-[:PARENT]-(breedGroup)<-[:PARENT*]-(animal) RETURN [node IN nodes(path) | node.name][..-1] AS breed, COUNT(*) AS animals ORDER BY animals DESC LIMIT 5 ---- [source,text] ---- ==> +-----------------------------------------------------+ ==> | breed | animals | ==> +-----------------------------------------------------+ ==> | ["Dog","SETTER/RETRIEVE","LABRADOR RETR"] | 15 | ==> | ["Dog","SETTER/RETRIEVE","GOLDEN RETR"] | 13 | ==> | ["Dog","POODLE","POODLE MIN"] | 10 | ==> | ["Dog","TERRIER","MIN PINSCHER"] | 9 | ==> | ["Dog","SHEPHERD","WELSH CORGI CAR"] | 6 | ==> +-----------------------------------------------------+ ==> 5 rows ---- We might then decide to add an exercise sub graph which indicates how much exercise each type of dog requires: [source,cypher] ---- MATCH (breedGroup:BreedGroup) WHERE breedGroup.name IN ["SETTER/RETRIEVE", "POODLE"] MERGE (exercise:Exercise {type: "2 hours hard exercise"}) MERGE (exercise)<-[:REQUIRES_EXERCISE]-(breedGroup); ---- [source,cypher] ---- MATCH (breedGroup:BreedGroup) WHERE breedGroup.name IN ["TERRIER", "SHEPHERD"] MERGE (exercise:Exercise {type: "1 hour gentle exercise"}) MERGE (exercise)<-[:REQUIRES_EXERCISE]-(breedGroup); ---- We could then query that to find out which dogs need to come out for 2 hours of hard exercise: [source,cypher] ---- MATCH (exercise:Exercise {type: "2 hours hard exercise"})<-[:REQUIRES_EXERCISE]-()<-[:PARENT*]-(dog) WHERE NOT (dog)<-[:PARENT]-() RETURN dog LIMIT 10 ---- [source,bash] ---- ==> +-----------------------------------------------------------+ ==> | dog | ==> +-----------------------------------------------------------+ ==> | Node[541]{id:"664427",primaryColour:"BLACK",size:"SMALL"} | ==> | Node[542]{id:"543787",primaryColour:"BLACK",size:"SMALL"} | ==> | Node[543]{id:"584021",primaryColour:"BLACK",size:"SMALL"} | ==> | Node[544]{id:"584022",primaryColour:"BLACK",size:"SMALL"} | ==> | Node[545]{id:"664430",primaryColour:"BLACK",size:"SMALL"} | ==> | Node[546]{id:"535176",primaryColour:"BLACK",size:"SMALL"} | ==> | Node[567]{id:"613557",primaryColour:"WHITE",size:"SMALL"} | ==> | Node[568]{id:"531376",primaryColour:"WHITE",size:"SMALL"} | ==> | Node[569]{id:"613567",primaryColour:"WHITE",size:"SMALL"} | ==> | Node[570]{id:"531379",primaryColour:"WHITE",size:"SMALL"} | ==> +-----------------------------------------------------------+ ==> 10 rows ---- In this query we ensured that we only returned dogs rather than breeds by checking that there was no incoming +++<cite>+++PARENT+++</cite>+++ relationship. Alternatively we could have filtered on the +++<cite>+++Animal+++</cite>+++ label\... [source,cypher] ---- MATCH (exercise:Exercise {type: "2 hours hard exercise"})<-[:REQUIRES_EXERCISE]-()<-[:PARENT*]-(dog:Animal) RETURN dog LIMIT 10 ---- or if we wanted to only take the dogs out for exercise perhaps we'd have +++<cite>+++Dog+++</cite>+++ label on the appropriate nodes. People are often curious why labels don't have super/sub types between them but I tend to use labels for simple categorisation - anything more complicated and we may as well use the built in power of the graph model! The https://github.com/mneedham/neo4j-subtypes[code is on github] should you wish to play with it.

neo4j-modelling-sub-types

https://markhneedham.com/blog/2014/10/20/neo4j-modelling-sub-types

2014-10-18 10:49:07

Neo4j: LOAD CSV - The sneaky null character

I spent some time earlier in the week trying to import a CSV file extracted from Hadoop into Neo4j using Cypher's http://docs.neo4j.org/chunked/stable/query-load-csv.html[LOAD CSV] command and initially struggled due to some rogue characters. The CSV file looked like this: [source,bash] ---- $ cat foo.csv foo,bar,baz 1,2,3 ---- I wrote the following LOAD CSV query to extract some of the fields and compare others: [source,cypher] ---- load csv with headers from "file:/Users/markneedham/Downloads/foo.csv" AS line RETURN line.foo, line.bar, line.bar = "2" ---- [source,text] ---- ==> +--------------------------------------+ ==> | line.foo | line.bar | line.bar = "2" | ==> +--------------------------------------+ ==> | <null> | "2" | false | ==> +--------------------------------------+ ==> 1 row ---- I had expect to see a "1" in the first column and a 'true' in the third column, neither of which happened. I initially didn't have a text editor with hexcode mode available so I tried checking the length of the entry in the 'bar' field: [source,cypher] ---- load csv with headers from "file:/Users/markneedham/Downloads/foo.csv" AS line RETURN line.foo, line.bar, line.bar = "2", length(line.bar) ---- [source,text] ---- ==> +---------------------------------------------------------+ ==> | line.foo | line.bar | line.bar = "2" | length(line.bar) | ==> +---------------------------------------------------------+ ==> | <null> | "2" | false | 2 | ==> +---------------------------------------------------------+ ==> 1 row ---- The length of that value is 2 when we'd expect it to be 1 given it's a single character. I tried trimming the field to see if that made any difference\... [source,cypher] ---- load csv with headers from "file:/Users/markneedham/Downloads/foo.csv" AS line RETURN line.foo, trim(line.bar), trim(line.bar) = "2", length(line.bar) ---- [source,text] ---- ==> +---------------------------------------------------------------------+ ==> | line.foo | trim(line.bar) | trim(line.bar) = "2" | length(line.bar) | ==> +---------------------------------------------------------------------+ ==> | <null> | "2" | true | 2 | ==> +---------------------------------------------------------------------+ ==> 1 row ---- \...and it did! I thought there was probably a trailing whitespace character after the "2" which trim had removed and that 'foo' column in the header row had the same issue. I was able to see that this was the case by extracting the JSON dump of the query via the Neo4j browser: [source,javascript] ---- { "table":{ "_response":{ "columns":[ "line" ], "data":[ { "row":[ { "foo\u0000":"1\u0000", "bar":"2\u0000", "baz":"3" } ], "graph":{ "nodes":[ ], "relationships":[ ] } } ], ... } ---- It turns out there were null characters scattered around the file so I needed to http://stackoverflow.com/questions/2398393/identifying-and-removing-null-characters-in-unix[pre process the file to get rid of them]: [source,bash] ---- $ tr < foo.csv -d '\000' > bar.csv ---- Now if we process bar.csv it's a much smoother process: [source,cypher] ---- load csv with headers from "file:/Users/markneedham/Downloads/bar.csv" AS line RETURN line.foo, line.bar, line.bar = "2", length(line.bar) ---- [source,text] ---- ==> +---------------------------------------------------------+ ==> | line.foo | line.bar | line.bar = "2" | length(line.bar) | ==> +---------------------------------------------------------+ ==> | "1" | "2" | true | 1 | ==> +---------------------------------------------------------+ ==> 1 row ---- Note to self: *don't expect data to be clean, inspect it first!*

neo4j-load-csv-the-sneaky-null-character

https://markhneedham.com/blog/2014/10/18/neo4j-load-csv-the-sneaky-null-character

2014-10-18 06:35:49

R: Linear models with the lm function, NA values and Collinearity

In my continued playing around with R I've sometimes noticed 'NA' values in the linear regression models I created but hadn't really thought about what that meant. On the http://java.dzone.com/articles/r-first-attempt-linear#comment-120879[advice of Peter Huber] I recently started working my way through https://class.coursera.org/regmods-007[Coursera's Regression Models] which has a whole slide explaining its meaning: image::{{<siteurl>}}/uploads/2014/10/2014-10-17_06-21-07.png[2014 10 17 06 21 07,600] So in this case 'z' doesn't help us in predicting Fertility since it doesn't give us any more information that we can't already get from 'Agriculture' and 'Education'. Although in this case we know why 'z' doesn't have a coefficient sometimes it may not be clear which other variable the NA one is http://en.wikipedia.org/wiki/Multicollinearity[highly correlated with]. ____ *Multicollinearity* (also *collinearity*) is a statistical phenomenon in which two or more predictor variables in a multiple regression model are highly correlated, meaning that one can be linearly predicted from the others with a non-trivial degree of accuracy. ____ In that situation we can make use of the +++<cite>+++http://stat.ethz.ch/R-manual/R-devel/library/stats/html/alias.html[alias]+++</cite>+++ function to explain the collinearity as http://stats.stackexchange.com/questions/112442/what-are-aliased-coefficients[suggested in this StackOverflow post]: [source,r] ---- library(datasets); data(swiss); require(stats); require(graphics) z <- swiss$Agriculture + swiss$Education fit = lm(Fertility ~ . + z, data = swiss) ---- [source,r] ---- > alias(fit) Model : Fertility ~ Agriculture + Examination + Education + Catholic + Infant.Mortality + z Complete : (Intercept) Agriculture Examination Education Catholic Infant.Mortality z 0 1 0 1 0 0 ---- In this case we can see that 'z' is highly correlated with both Agriculture and Education which makes sense given its the sum of those two variables. When we notice that there's an NA coefficient in our model we can choose to exclude that variable and the model will still have the same coefficients as before: [source,r] ---- > require(dplyr) > summary(lm(Fertility ~ . + z, data = swiss))$coefficients Estimate Std. Error t value Pr(>|t|) (Intercept) 66.9151817 10.70603759 6.250229 1.906051e-07 Agriculture -0.1721140 0.07030392 -2.448142 1.872715e-02 Examination -0.2580082 0.25387820 -1.016268 3.154617e-01 Education -0.8709401 0.18302860 -4.758492 2.430605e-05 Catholic 0.1041153 0.03525785 2.952969 5.190079e-03 Infant.Mortality 1.0770481 0.38171965 2.821568 7.335715e-03 > summary(lm(Fertility ~ ., data = swiss))$coefficients Estimate Std. Error t value Pr(>|t|) (Intercept) 66.9151817 10.70603759 6.250229 1.906051e-07 Agriculture -0.1721140 0.07030392 -2.448142 1.872715e-02 Examination -0.2580082 0.25387820 -1.016268 3.154617e-01 Education -0.8709401 0.18302860 -4.758492 2.430605e-05 Catholic 0.1041153 0.03525785 2.952969 5.190079e-03 Infant.Mortality 1.0770481 0.38171965 2.821568 7.335715e-03 ---- If we call alias now we won't see any output: [source,r] ---- > alias(lm(Fertility ~ ., data = swiss)) Model : Fertility ~ Agriculture + Examination + Education + Catholic + Infant.Mortality ----

r-linear-models-with-the-lm-function-na-values-and-collinearity

https://markhneedham.com/blog/2014/10/18/r-linear-models-with-the-lm-function-na-values-and-collinearity

2014-10-27 06:55:34

Data Modelling: The Thin Model

About a third of the way through http://www.amazon.co.uk/Mastering-Data-Modeling-Driven-Approach/dp/020170045X/ref=sr_1_1?ie=UTF8&qid=1414364532&sr=8-1&keywords=mastering+data+modeling[Mastering Data Modeling] the authors describe common data modelling mistakes and one in particular resonated with me - '*Thin LDS, Lost Users*'. LDS stands for 'Logical Data Structure' which is a diagram depicting what kinds of data some person or group wants to remember. In other words, a tool to help derive the http://www.markhneedham.com/blog/2014/10/06/conceptual-model-vs-graph-model/[conceptual model] for our domain. They describe the problem that a thin model can cause as follows: ____ [\...] within 30 minutes [of the modelling session] the users were lost\...we determined that the model was too thin. That is, many entities had just identifying descriptors. While this is syntactically okay, when we revisited those entities asking, _What else is memorable here?_ the users had lots to say. When there was flesh on the bones, the uncertainty abated and the session took a positive course. ____ I found myself making the same mistake a couple of weeks ago during a graph modelling session. I tend to spend the majority of the time focused on the relationships between the bits of data and treat the meta data or attributes almost as an after thought. image::{{<siteurl>}}/uploads/2014/10/2014-10-27_06-41-19.png[2014 10 27 06 41 19,300] The nice thing about the graph model is that it encourages an iterative approach so I was quickly able to bring the model to life and the domain experts back onside. We can see a simple example of adding flesh to a model with a subset of the movies graph. We might start out with the model on the right hand side which just describes the structure of the graph but doesn't give us very much information about the entities. I tend to sketch out the structure of all the data before adding any attributes but I think some people find it easier to follow if you add at least some flesh before moving on to the next part of the model. In our next iteration of the movie graph we can add attributes to the actor and movie: image::{{<siteurl>}}/uploads/2014/10/2014-10-27_06-57-32.png[2014 10 27 06 57 32,600] We can then go on to evolve the model further but the lesson for me is *value the attributes more*, it's not all about the structure.

data-modelling-the-thin-model

https://markhneedham.com/blog/2014/10/27/data-modelling-the-thin-model

2014-10-11 10:52:01

Lessons from running Neo4j based 'hackathons'

Over the last 6 months my colleagues and I have been running http://www.meetup.com/graphdb-london/[hands on Neo4j based sessions] every few weeks and I was recently asked if I could write up the lessons we've learned. So in no particular order here are some of the things that we've learnt: == Have a plan but don't stick to it rigidly Something we learnt early on is that it's helpful to have a rough plan of how you're going to spend the session otherwise it can feel quite chaotic for attendees. We show people that plan at the beginning of the session so that they know what to expect and can plan their time accordingly if the second part doesn't interest them as much. Having said that, we've often gone off on a tangent and since people have been very interested in that we've just gone with it. This sometimes means that you don't cover everything you had in mind but the main thing is that people enjoy themselves so it's nothing to worry about. == Prepare for people to be unprepared We try to set expectations in advanced of the sessions with respect to what people should prepare or have installed on their machines but despite that you'll have people in varying levels of readiness. Having noticed this trend over a few months we now allot time in the schedule for getting people up and running and if we're really struggling then we'll ask people to pair with each other. There will also be experience level differences so we always factor in some time to go over the basics for those who are new. We also encourage experienced people to help the others out - after all http://www.markhneedham.com/blog/2009/04/21/learning-through-teaching/[you only really know if you know something when you try to teach someone else]! == Don't try to do too much Our first 'hackathon'-esque event involved an attempt to build a Java application based on a https://github.com/mneedham/neo4j-bl[British Library dataset]. I thought we'd be able to model the data set, import it and then wire up some queries to an application in a few hours. This proved to be *ever so slightly ambitious*! It took much longer than anticipated to do those first two steps and we didn't get to build any of the application - teaching people how to model in a graph is probably a session in its own right. == Show the end state Feedback we got from attendees to the first few versions was that they'd like to see what the end state should have looked like if they'd completed everything. In our Clojure Hackathon Rohit got the furthest so we https://github.com/neo4j-meetups/clojure-hackathon/commit/c17e6c9d866b50fd1255b59029bc4f21ea244077[shared his code] with everyone afterwards. An even better approach is to have the final solution ready in advance and have it checked in on a different branch that you can point people at afterwards. == Show the intermediate states Another thing we noticed was that if people got behind in the first part of the session then they'd never be able to catch up. Nigel therefore came up with the idea of snapshotting intermediate states so that people could reset themselves after each part of the session. This is something that the https://github.com/Polymer/polymer-tutorial[Polymer tutorial] does as well. We worked out that we have two solid one hour slots before people start getting distracted by their journey home so we came up with two distinct types of tasks for people to do and then https://github.com/neo4j-meetups/python-hackathon/branches[created a branch with the solution at the end of those tasks]. No doubt there will be more lessons to come as we run more sessions but this is where we are at the moment. If you fancy joining in our next session is http://www.meetup.com/graphdb-london/events/212631122/[Java based in a couple of weeks time]. Finally, if you want to see a really slick hands on meetup then you'll want to head over to the http://londonclojurians.org/[London Clojure Dojo] - https://twitter.com/otfrom[Bruce Durling] has even http://otfrom.wordpress.com/2012/07/04/how-to-run-a-london-clojure-dojo-in-20ish-easy-steps/[written up some tips on how you run one yourself].

lessons-from-running-neo4j-based-hackathons

https://markhneedham.com/blog/2014/10/11/lessons-from-running-neo4j-based-hackathons

2014-10-31 23:47:26

R: Converting a named vector to a data frame

I've been playing around with http://igraph.org/r/[igraph's] http://igraph.org/r/doc/page.rank.html[page rank] function to see who the most central nodes in the London NoSQL scene are and I wanted to put the result in a data frame to make the data easier to work with. I started off with a data frame containing pairs of people and the number of events that they'd both RSVP'd 'yes' to: [source,r] ---- > library(dplyr) > data %>% arrange(desc(times)) %>% head(10) p.name other.name times 1 Amit Nandi Anish Mohammed 51 2 Amit Nandi Enzo Martoglio 49 3 louis zheng 46 4 louis Raja Kolli 45 5 Raja Kolli Enzo Martoglio 43 6 Amit Nandi Raja Kolli 42 7 zheng Anish Mohammed 42 8 Raja Kolli Rohit 41 9 Amit Nandi zheng 40 10 louis Rohit 40 ---- I actually had ~ 900,000 such rows in the data frame: [source,r] ---- > length(data[,1]) [1] 985664 ---- I ran page rank over the data set like so: [source,r] ---- g = graph.data.frame(data, directed = F) pr = page.rank(g)$vector ---- If we evaluate +++<cite>+++pr+++</cite>+++ we can see the person's name and their page rank: [source,r] ---- > head(pr) Ioanna Eirini Mjay Baktash madhuban Karl Prior Keith Bolam 0.0002190 0.0001206 0.0001524 0.0008819 0.0001240 0.0005702 ---- I initially tried to convert this to a data frame with the following code\... [source,r] ---- > head(data.frame(pr)) pr Ioanna Eirini 0.0002190 Mjay 0.0001206 Baktash 0.0001524 madhuban 0.0008819 Karl Prior 0.0001240 Keith Bolam 0.0005702 ---- \...which unfortunately didn't create a column for the person's name. [source,R] ---- > colnames(data.frame(pr)) [1] "pr" ---- http://nicolewhite.github.io/[Nicole] pointed out that I actually had a http://www.r-tutor.com/r-introduction/vector/named-vector-members[named vector] and would need to explicitly extract the names from that vector into the data frame. I ended up with this: [source,r] ---- > prDf = data.frame(name = names(pr), rank = pr) > head(prDf) name rank Ioanna Eirini Ioanna Eirini 0.0002190 Mjay Mjay 0.0001206 Baktash Baktash 0.0001524 madhuban madhuban 0.0008819 Karl Prior Karl Prior 0.0001240 Keith Bolam Keith Bolam 0.0005702 ---- We can now sort the data frame to find the most central people on the NoSQL London scene based on meetup attendance: [source,r] ---- > data.frame(prDf) %>% + arrange(desc(pr)) %>% + head(10) name rank 1 louis 0.001708 2 Kannappan 0.001657 3 zheng 0.001514 4 Peter Morgan 0.001492 5 Ricki Long 0.001437 6 Raja Kolli 0.001416 7 Amit Nandi 0.001411 8 Enzo Martoglio 0.001396 9 Chris 0.001327 10 Rohit 0.001305 ----

r-converting-a-named-vector-to-a-data-frame

https://markhneedham.com/blog/2014/10/31/r-converting-a-named-vector-to-a-data-frame

2014-10-31 09:45:32

hdiutil: could not access / create failed - Operation canceled

Earlier in the year I wrote a http://www.markhneedham.com/blog/2014/04/07/install4j-and-applescript-creating-a-mac-os-x-application-bundle-for-a-java-application/[blog post showing how to build a Mac OS X DMG file for a Java application] and I recently revisited this script to update it to a new version and ran into a frustrating error message. I tried to run the following command to create a new DMG file from a source folder\... [source,text] ---- $ hdiutil create -volname "DemoBench" -size 100m -srcfolder dmg/ -ov -format UDZO pack.temp.dmg ---- \...but was met with the following error message: ~~~text \...could not access /Volumes/DemoBench/DemoBench.app/Contents/Resources/app/database-agent.jar - Operation canceled hdiutil: create failed - Operation canceled ~~~ I was initially a bit stumped and thought maybe the flags to hdiutil had changed but a quick look at the man page suggested that wasn't the issue. I decided to go back to my pre command line approach for creating a DMG - DiskUtility - and see if I could create it that way. This helped reveal the actual problem: image::{{<siteurl>}}/uploads/2014/10/2014-10-31_09-42-20.png[2014 10 31 09 42 20,600] I increased the volume size to 150 MB\... ~~~text $ hdiutil create -volname "DemoBench" -size 150m -srcfolder dmg/ -ov -format UDZO pack.temp.dmg ~~~ and all was well: ~~~text \...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\.... \...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\...\..... created: /Users/markneedham/projects/neo-technology/quality-tasks/park-bench/database-agent-desktop/target/pack.temp.dmg ~~~ And this post will serve as documentation to stop it catching me out next time!

hdiutil-could-not-access-create-failed-operation-canceled

https://markhneedham.com/blog/2014/10/31/hdiutil-could-not-access-create-failed-operation-canceled

2014-10-06 07:11:50

Conceptual Model vs Graph Model

We've started running some sessions on graph modelling in London and during the http://www.meetup.com/graphdb-london/events/203677112/[first session] it was pointed out that the process I'd described was very similar to that when modelling for a relational database. I thought I better do some reading on the way relational models are derived and I came across an excellent video by Joe Maguire titled 'https://www.youtube.com/watch?v=x4Q9JeLIyNo[Data Modelers Still Have Jobs: Adjusting For the NoSQL Environment]' Joe starts off by showing the following 'big picture framework' which describes the http://www.slideshare.net/slideshow/embed_code/23124875?startSlide=5[steps involved in coming up with a relational model]: image::{{<siteurl>}}/uploads/2014/10/2014-10-05_19-04-46.png[2014 10 05 19 04 46,400] A couple of slides later he points out that we often blur the lines between the different stages and end up designing a model which contains a lot of implementation details: image::{{<siteurl>}}/uploads/2014/10/2014-10-06_23-25-22.png[2014 10 06 23 25 22,400] If, on the other hand, we compare a conceptual model with a graph model this is less of an issue as the two models map quite closely: * Entities \-> Nodes / Labels * Attributes \-> Properties * Relationships \-> Relationships * Identifiers \-> Unique Constraints Unique Constraints don't quite capture everything that Identifiers do since it's possible to create a node of a specific label without specifying the property which is uniquely constrained. Other than that though each concept matches one for one. We often say that graphs are *white board friendly* by which we mean that that the model you sketch on a white board is the same as that stored in the database. For example, consider the following sketch of people and their interactions with various books: image::{{<siteurl>}}/uploads/2014/10/IMG_2342.jpg[IMG 2342,400] If we were to translate that into a write query using Neo4j's cypher query language it would look like this: [source,cypher] ---- CREATE (ian:Person {name: "Ian"}) CREATE (alan:Person {name: "Alan"}) CREATE (gg:Person:Author {name: "Graham Greene"}) CREATE (jlc:Person:Author {name: "John Le Carre"}) CREATE (omih:Book {name: "Our Man in Havana"}) CREATE (ttsp:Book {name: "Tinker Tailor, Soldier, Spy"}) CREATE (gg)-[:WROTE]->(omih) CREATE (jlc)-[:WROTE]->(ttsp) CREATE (ian)-[:PURCHASED {date: "05-02-2011"}]->(ttsp) CREATE (ian)-[:PURCHASED {date: "08-09-2011"}]->(omih) CREATE (alan)-[:PURCHASED {date: "05-07-2014"}]->(ttsp) ---- There are a few extra brackets and the 'CREATE' key word but we haven't lost any of the fidelity of the domain and in my experience a non technical / commercial person would be able to understand the query. By contrast http://www.toadworld.com/products/toad-data-modeler/w/wiki/399.data-modeling-reality-requires-super-and-sub-types.aspx[this article] shows the steps we might take from a conceptual model describing employees, departments and unions to the eventual relational model. If you don't have the time to read through that, we start with this initial model\... image::{{<siteurl>}}/uploads/2014/10/2014-10-07_00-13-51.png[2014 10 07 00 13 51,400] \...and by the time we've got to a model that can be stored in our relational database: image::{{<siteurl>}}/uploads/2014/10/2014-10-07_00-14-32.png[2014 10 07 00 14 32,400] You'll notice we've lost the relationship types and they've been replaced by 4 foreign keys that allow us to join the different tables/sets together. In a graph model we'd have been able to stay much closer to the conceptual model and therefore closer to the language of the business. I'm still exploring the world of data modelling and next up for me is to read Joe's 'http://www.amazon.co.uk/gp/product/020170045X/ref=oh_aui_detailpage_o00_s00?ie=UTF8&psc=1[Mastering Data Modeling]' book. I'm also curious how normal forms and data redundancy apply to graphs so I'll be looking into that as well. Thoughts welcome, as usual!

conceptual-model-vs-graph-model

https://markhneedham.com/blog/2014/10/06/conceptual-model-vs-graph-model

2014-10-23 05:56:57

Neo4j: Cypher - Avoiding the Eager

Although I love how easy Cypher's http://neo4j.com/docs/stable/query-load-csv.html[LOAD CSV] command makes it to get data into Neo4j, it currently breaks http://www.faqs.org/docs/artu/ch11s01.html[the rule of least surprise] in the way it eagerly loads in all rows for some queries even those using http://neo4j.com/docs/stable/query-periodic-commit.html[periodic commit]. image:{{<siteurl>}}/uploads/2014/10/neverwhere.jpg[Neverwhere] This is something that my colleague Michael noted in the http://jexp.de/blog/2014/10/load-cvs-with-success/[second] of his blog posts explaining http://jexp.de/blog/2014/06/load-csv-into-neo4j-quickly-and-successfully/[how to use LOAD CSV successfully]: ____ The *biggest issue* that people ran into, even when following the advice I gave earlier, was that for large imports of more than one million rows, Cypher ran into an out-of-memory situation. That was *not related to commit sizes*, so it happened even with PERIODIC COMMIT of small batches. ____ I recently spent a few days importing data into Neo4j on a Windows machine with 4GB RAM so I was seeing this problem even earlier than Michael suggested. Michael explains how to work out whether your query is suffering from unexpected eager evaluation: ____ If you profile that query you see that there is an "`Eager`" step in the query plan. That is where the "`pull in all data`" happens. ____ You can profile queries by prefixing the word 'PROFILE'. You'll need to run your query in the console of _/webadmin_ in your web browser or with the http://neo4j.com/docs/stable/shell-starting.html[Neo4j shell]. I did this for my queries and was able to identify query patterns which get evaluated eagerly and in some cases we can work around it. We'll use the https://github.com/mneedham/neo4j-northwind/blob/master/data/customerDb.csv[Northwind data set] to demonstrate how the Eager pipe can sneak into our queries but keep in mind that this data set is sufficiently small to not cause issues. This is what a row in the file looks like: [source,bash] ---- $ head -n 2 data/customerDb.csv OrderID,CustomerID,EmployeeID,OrderDate,RequiredDate,ShippedDate,ShipVia,Freight,ShipName,ShipAddress,ShipCity,ShipRegion,ShipPostalCode,ShipCountry,CustomerID,CustomerCompanyName,ContactName,ContactTitle,Address,City,Region,PostalCode,Country,Phone,Fax,EmployeeID,LastName,FirstName,Title,TitleOfCourtesy,BirthDate,HireDate,Address,City,Region,PostalCode,Country,HomePhone,Extension,Photo,Notes,ReportsTo,PhotoPath,OrderID,ProductID,UnitPrice,Quantity,Discount,ProductID,ProductName,SupplierID,CategoryID,QuantityPerUnit,UnitPrice,UnitsInStock,UnitsOnOrder,ReorderLevel,Discontinued,SupplierID,SupplierCompanyName,ContactName,ContactTitle,Address,City,Region,PostalCode,Country,Phone,Fax,HomePage,CategoryID,CategoryName,Description,Picture 10248,VINET,5,1996-07-04,1996-08-01,1996-07-16,3,32.38,Vins et alcools Chevalier,59 rue de l'Abbaye,Reims,,51100,France,VINET,Vins et alcools Chevalier,Paul Henriot,Accounting Manager,59 rue de l'Abbaye,Reims,,51100,France,26.47.15.10,26.47.15.11,5,Buchanan,Steven,Sales Manager,Mr.,1955-03-04,1993-10-17,14 Garrett Hill,London,,SW1 8JR,UK,(71) 555-4848,3453,\x,"Steven Buchanan graduated from St. Andrews University, Scotland, with a BSC degree in 1976. Upon joining the company as a sales representative in 1992, he spent 6 months in an orientation program at the Seattle office and then returned to his permanent post in London. He was promoted to sales manager in March 1993. Mr. Buchanan has completed the courses ""Successful Telemarketing"" and ""International Sales Management."" He is fluent in French.",2,http://accweb/emmployees/buchanan.bmp,10248,11,14,12,0,11,Queso Cabrales,5,4,1 kg pkg.,21,22,30,30,0,5,Cooperativa de Quesos 'Las Cabras',Antonio del Valle Saavedra,Export Administrator,Calle del Rosal 4,Oviedo,Asturias,33007,Spain,(98) 598 76 54,,,4,Dairy Products,Cheeses,\x ---- == MERGE, MERGE, MERGE The first thing we want to do is create a node for each employee and each order and then create a relationship between them. We might start with the following query: [source,cypher] ---- USING PERIODIC COMMIT 1000 LOAD CSV WITH HEADERS FROM "file:/Users/markneedham/projects/neo4j-northwind/data/customerDb.csv" AS row MERGE (employee:Employee {employeeId: row.EmployeeID}) MERGE (order:Order {orderId: row.OrderID}) MERGE (employee)-[:SOLD]->(order) ---- This does the job but if we profile the query like so\... [source,cypher] ---- PROFILE LOAD CSV WITH HEADERS FROM "file:/Users/markneedham/projects/neo4j-northwind/data/customerDb.csv" AS row WITH row LIMIT 0 MERGE (employee:Employee {employeeId: row.EmployeeID}) MERGE (order:Order {orderId: row.OrderID}) MERGE (employee)-[:SOLD]->(order) ---- \...we'll notice an 'Eager' lurking on the third line: [source,text] ---- ==> +----------------+------+--------+----------------------------------+-----------------------------------------+ ==> | Operator | Rows | DbHits | Identifiers | Other | ==> +----------------+------+--------+----------------------------------+-----------------------------------------+ ==> | EmptyResult | 0 | 0 | | | ==> | UpdateGraph(0) | 0 | 0 | employee, order, UNNAMED216 | MergePattern | ==> | Eager | 0 | 0 | | | ==> | UpdateGraph(1) | 0 | 0 | employee, employee, order, order | MergeNode; :Employee; MergeNode; :Order | ==> | Slice | 0 | 0 | | { AUTOINT0} | ==> | LoadCSV | 1 | 0 | row | | ==> +----------------+------+--------+----------------------------------+-----------------------------------------+ ---- _You'll notice that when we profile each query we're stripping off the periodic commit section and adding a 'WITH row LIMIT 0'. This allows us to generate enough of the query plan to identify the 'Eager' operator without actually importing any data._ We want to split that query into two so it can be processed in a non eager manner: [source,cypher] ---- USING PERIODIC COMMIT 1000 LOAD CSV WITH HEADERS FROM "file:/Users/markneedham/projects/neo4j-northwind/data/customerDb.csv" AS row WITH row LIMIT 0 MERGE (employee:Employee {employeeId: row.EmployeeID}) MERGE (order:Order {orderId: row.OrderID}) ---- [source,text] ---- ==> +-------------+------+--------+----------------------------------+-----------------------------------------+ ==> | Operator | Rows | DbHits | Identifiers | Other | ==> +-------------+------+--------+----------------------------------+-----------------------------------------+ ==> | EmptyResult | 0 | 0 | | | ==> | UpdateGraph | 0 | 0 | employee, employee, order, order | MergeNode; :Employee; MergeNode; :Order | ==> | Slice | 0 | 0 | | { AUTOINT0} | ==> | LoadCSV | 1 | 0 | row | | ==> +-------------+------+--------+----------------------------------+-----------------------------------------+ ---- Now that we've created the employees and orders we can join them together: [source,cypher] ---- USING PERIODIC COMMIT 1000 LOAD CSV WITH HEADERS FROM "file:/Users/markneedham/projects/neo4j-northwind/data/customerDb.csv" AS row MATCH (employee:Employee {employeeId: row.EmployeeID}) MATCH (order:Order {orderId: row.OrderID}) MERGE (employee)-[:SOLD]->(order) ---- [source,text] ---- ==> +----------------+------+--------+-------------------------------+-----------------------------------------------------------+ ==> | Operator | Rows | DbHits | Identifiers | Other | ==> +----------------+------+--------+-------------------------------+-----------------------------------------------------------+ ==> | EmptyResult | 0 | 0 | | | ==> | UpdateGraph | 0 | 0 | employee, order, UNNAMED216 | MergePattern | ==> | Filter(0) | 0 | 0 | | Property(order,orderId) == Property(row,OrderID) | ==> | NodeByLabel(0) | 0 | 0 | order, order | :Order | ==> | Filter(1) | 0 | 0 | | Property(employee,employeeId) == Property(row,EmployeeID) | ==> | NodeByLabel(1) | 0 | 0 | employee, employee | :Employee | ==> | Slice | 0 | 0 | | { AUTOINT0} | ==> | LoadCSV | 1 | 0 | row | | ==> +----------------+------+--------+-------------------------------+-----------------------------------------------------------+ ---- Not an Eager in sight! == MATCH, MATCH, MATCH, MERGE, MERGE If we fast forward a few steps we may now have refactored our import script to the point where we create our nodes in one query and the relationships in another query. Our create query works as expected: [source,cypher] ---- USING PERIODIC COMMIT 1000 LOAD CSV WITH HEADERS FROM "file:/Users/markneedham/projects/neo4j-northwind/data/customerDb.csv" AS row MERGE (employee:Employee {employeeId: row.EmployeeID}) MERGE (order:Order {orderId: row.OrderID}) MERGE (product:Product {productId: row.ProductID}) ---- [source,bash] ---- ==> +-------------+------+--------+----------------------------------------------------+--------------------------------------------------------------+ ==> | Operator | Rows | DbHits | Identifiers | Other | ==> +-------------+------+--------+----------------------------------------------------+--------------------------------------------------------------+ ==> | EmptyResult | 0 | 0 | | | ==> | UpdateGraph | 0 | 0 | employee, employee, order, order, product, product | MergeNode; :Employee; MergeNode; :Order; MergeNode; :Product | ==> | Slice | 0 | 0 | | { AUTOINT0} | ==> | LoadCSV | 1 | 0 | row | | ==> +-------------+------+--------+----------------------------------------------------+------------------------------------------------------------ ---- We've now got employees, products and orders in the graph. Now let's create relationships between the trio: [source,cypher] ---- USING PERIODIC COMMIT 1000 LOAD CSV WITH HEADERS FROM "file:/Users/markneedham/projects/neo4j-northwind/data/customerDb.csv" AS row MATCH (employee:Employee {employeeId: row.EmployeeID}) MATCH (order:Order {orderId: row.OrderID}) MATCH (product:Product {productId: row.ProductID}) MERGE (employee)-[:SOLD]->(order) MERGE (order)-[:PRODUCT]->(product) ---- If we profile that we'll notice Eager has sneaked in again! [source,bash] ---- ==> +----------------+------+--------+-------------------------------+-----------------------------------------------------------+ ==> | Operator | Rows | DbHits | Identifiers | Other | ==> +----------------+------+--------+-------------------------------+-----------------------------------------------------------+ ==> | EmptyResult | 0 | 0 | | | ==> | UpdateGraph(0) | 0 | 0 | order, product, UNNAMED318 | MergePattern | ==> | Eager | 0 | 0 | | | ==> | UpdateGraph(1) | 0 | 0 | employee, order, UNNAMED287 | MergePattern | ==> | Filter(0) | 0 | 0 | | Property(product,productId) == Property(row,ProductID) | ==> | NodeByLabel(0) | 0 | 0 | product, product | :Product | ==> | Filter(1) | 0 | 0 | | Property(order,orderId) == Property(row,OrderID) | ==> | NodeByLabel(1) | 0 | 0 | order, order | :Order | ==> | Filter(2) | 0 | 0 | | Property(employee,employeeId) == Property(row,EmployeeID) | ==> | NodeByLabel(2) | 0 | 0 | employee, employee | :Employee | ==> | Slice | 0 | 0 | | { AUTOINT0} | ==> | LoadCSV | 1 | 0 | row | | ==> +----------------+------+--------+-------------------------------+-----------------------------------------------------------+ ---- In this case the Eager happens on our second call to MERGE as Michael identified in his post: ____ The issue is that within a single Cypher statement you have to isolate changes that affect matches further on, e.g. when you CREATE nodes with a label that are suddenly matched by a later MATCH or MERGE operation. ____ We can work around the problem in this case by having separate queries to create the relationships: [source,cypher] ---- LOAD CSV WITH HEADERS FROM "file:/Users/markneedham/projects/neo4j-northwind/data/customerDb.csv" AS row MATCH (employee:Employee {employeeId: row.EmployeeID}) MATCH (order:Order {orderId: row.OrderID}) MERGE (employee)-[:SOLD]->(order) ---- [source,bash] ---- ==> +----------------+------+--------+-------------------------------+-----------------------------------------------------------+ ==> | Operator | Rows | DbHits | Identifiers | Other | ==> +----------------+------+--------+-------------------------------+-----------------------------------------------------------+ ==> | EmptyResult | 0 | 0 | | | ==> | UpdateGraph | 0 | 0 | employee, order, UNNAMED236 | MergePattern | ==> | Filter(0) | 0 | 0 | | Property(order,orderId) == Property(row,OrderID) | ==> | NodeByLabel(0) | 0 | 0 | order, order | :Order | ==> | Filter(1) | 0 | 0 | | Property(employee,employeeId) == Property(row,EmployeeID) | ==> | NodeByLabel(1) | 0 | 0 | employee, employee | :Employee | ==> | Slice | 0 | 0 | | { AUTOINT0} | ==> | LoadCSV | 1 | 0 | row | | ==> +----------------+------+--------+-------------------------------+-----------------------------------------------------------+ ---- [source,cypher] ---- USING PERIODIC COMMIT 1000 LOAD CSV WITH HEADERS FROM "file:/Users/markneedham/projects/neo4j-northwind/data/customerDb.csv" AS row MATCH (order:Order {orderId: row.OrderID}) MATCH (product:Product {productId: row.ProductID}) MERGE (order)-[:PRODUCT]->(product) ---- [source,bash] ---- ==> +----------------+------+--------+------------------------------+--------------------------------------------------------+ ==> | Operator | Rows | DbHits | Identifiers | Other | ==> +----------------+------+--------+------------------------------+--------------------------------------------------------+ ==> | EmptyResult | 0 | 0 | | | ==> | UpdateGraph | 0 | 0 | order, product, UNNAMED229 | MergePattern | ==> | Filter(0) | 0 | 0 | | Property(product,productId) == Property(row,ProductID) | ==> | NodeByLabel(0) | 0 | 0 | product, product | :Product | ==> | Filter(1) | 0 | 0 | | Property(order,orderId) == Property(row,OrderID) | ==> | NodeByLabel(1) | 0 | 0 | order, order | :Order | ==> | Slice | 0 | 0 | | { AUTOINT0} | ==> | LoadCSV | 1 | 0 | row | | ==> +----------------+------+--------+------------------------------+--------------------------------------------------------+ ---- == MERGE, SET I try to make LOAD CSV scripts as idempotent as possible so that if we add more rows or columns of data to our CSV we can rerun the query without having to recreate everything. This can lead you towards the following pattern where we're creating suppliers: [source,cypher] ---- USING PERIODIC COMMIT 1000 LOAD CSV WITH HEADERS FROM "file:/Users/markneedham/projects/neo4j-northwind/data/customerDb.csv" AS row MERGE (supplier:Supplier {supplierId: row.SupplierID}) SET supplier.companyName = row.SupplierCompanyName ---- We want to ensure that there's only one Supplier with that SupplierID but we might be incrementally adding new properties and decide to just replace everything by using the 'SET' command. If we profile that query, the Eager lurks: [source,bash] ---- ==> +----------------+------+--------+--------------------+----------------------+ ==> | Operator | Rows | DbHits | Identifiers | Other | ==> +----------------+------+--------+--------------------+----------------------+ ==> | EmptyResult | 0 | 0 | | | ==> | UpdateGraph(0) | 0 | 0 | | PropertySet | ==> | Eager | 0 | 0 | | | ==> | UpdateGraph(1) | 0 | 0 | supplier, supplier | MergeNode; :Supplier | ==> | Slice | 0 | 0 | | { AUTOINT0} | ==> | LoadCSV | 1 | 0 | row | | ==> +----------------+------+--------+--------------------+----------------------+ ---- We can work around this at the cost of a bit of duplication using 'ON CREATE SET' and 'ON MATCH SET': [source,cypher] ---- USING PERIODIC COMMIT 1000 LOAD CSV WITH HEADERS FROM "file:/Users/markneedham/projects/neo4j-northwind/data/customerDb.csv" AS row MERGE (supplier:Supplier {supplierId: row.SupplierID}) ON CREATE SET supplier.companyName = row.SupplierCompanyName ON MATCH SET supplier.companyName = row.SupplierCompanyName ---- [source,bash] ---- ==> +-------------+------+--------+--------------------+----------------------+ ==> | Operator | Rows | DbHits | Identifiers | Other | ==> +-------------+------+--------+--------------------+----------------------+ ==> | EmptyResult | 0 | 0 | | | ==> | UpdateGraph | 0 | 0 | supplier, supplier | MergeNode; :Supplier | ==> | Slice | 0 | 0 | | { AUTOINT0} | ==> | LoadCSV | 1 | 0 | row | | ==> +-------------+------+--------+--------------------+----------------------+ ---- With the data set I've been working with I was able to avoid OutOfMemory exceptions in some cases and reduce the amount of time it took to run the query by a factor of 3 in others. As time goes on I expect all of these scenarios will be addressed but as of Neo4j 2.1.5 these are the patterns that I've identified as being overly eager. If you know of any others do let me know and I can add them to the post or write a second part.

neo4j-cypher-avoiding-the-eager

https://markhneedham.com/blog/2014/10/23/neo4j-cypher-avoiding-the-eager

2014-10-13 23:59:25

The Hard Thing About Hard Things - Ben Horowitz: Book Review

I came across 'http://www.amazon.co.uk/The-Hard-Thing-About-Things/dp/0062273205/ref=sr_1_1?ie=UTF8&qid=1413108493&sr=8-1&keywords=hard+thing+about+hard+things[The Hard Thing About Hard Things]' while reading https://medium.com/life-learning/how-andreessen-horowitz-is-disrupting-silicon-valley-208041d6375d[an article about Ben Horowitz's venture capital firm] and it was intriguing enough that I bought it and then read through it over a couple of days. Although the blurb suggests that it's a book about about building and running a startup I think a *lot of the lessons are applicable for any business*. These were some of the main points that stood out for me: * *The Positivity Delusion* - CEOs should tell it like it is. + ____ My single biggest improvement as CEO occurred on the day when I stopped being too positive. ____ + Horowitz suggests that he used to be too positive and would shield bad news from his employees as he thought he'd make the problem worse by transferring the burden onto them. He came to the realisation that this was counter productive since he often wasn't the best placed person to fix a problem e.g. if it was a problem with the product then the engineering team needed to know so they could write the code to fix it. He goes on to suggest that\... + ____ A healthy company culture encourages people to share bad news. A company that discusses its problems freely and openly can quickly solve them. A company that covers up its problems frustrated everyone involved. ____ + I've certainly worked on projects in the past where the view projected by the most senior person is overly positive and seems to ignore any problems that seem obvious to everyone else. This eventually leads to people being unsure whether to take them seriously which isn't a great situation to be in. * Lead Bullets - *fix the problem, don't run away from it*. Horowitz describes a couple of situations where his products have been inferior to their competitors and it's been tempting to take the easy way out by not fixing the product. + ____ There comes a time in every company's life where it must fight for its life. If you find yourself running when you should be fighting, you need to ask yourself, "If our company isn't good enough to win, then do we need to exist at all?". ____ + I can't think of any examples around this from my experience but I really like the advice - I'm sure it'll come in handy in future. * *Give ground grudgingly* - dealing with the company increasing in size. Horowitz suggests that the following things become more difficult as a company grows in size: ** Communication ** Common Knowledge ** Decision Making + but\... + ____ If the company doesn't expand it will never be much\...so the challenge is to grow but degrade as slowly as possible. ____ + He uses the metaphor of an offensive linesman in American football who has to stop onrushing defensive linesman but giving ground to them slowly by backing up a little at a time. I've worked in a few different companies now and noticed things become more structured (and in my eyes worse!) as the company grew over time but I hadn't really thought about why that was happening. The chapter on scaling a company does a decent job. * *The Law of Crappy People* - people baseline against the worst person at a grade level. + ____ For any title level in a large organisation, the talent on that level will eventually converge to the crappiest person with that title. ____ + This is something that he's also http://www.bhorowitz.com/titles_and_promotions[written about on his blog] and certainly seems very recognisable. His suggestion for mitigating the problem is to have a "properly constructed and highly disciplined promotion process" in place. He describes this like so: + ____ When a manager wishes to promote an employee, she will submit that employee for review with an explanation of why she believes her employee satisfies the skill criteria required for the level. The committee should compare the employee to both the level's skill description and the skills of the other employees at that level to determine whether or not to approve the promotion. ____ * *Hire people with the right kind of ambition* + ____ The wrong kind of ambition is ambition for the executive's personal success regardless of the company's outcome. ____ + This suggestion comes from the chapter in which Horowitz discusses how to minimise politics in an organisation. I really like this idea but it seems like a difficult thing to judge/achieve. In my experience people often have their own goals which aren't necessarily completely aligned with the company's. Perhaps complete alignment isn't as important unless you're right at the top of the company? He also has quite a neat definition of politics: + ____ What do I mean by politics? I mean people advancing their careers or agendas by means other than merit and contribution. ____ + He goes on to describe a few stories of how political behaviour can subtly creep into a company without the CEO meaning for it to happen. This chapter was definitely eye opening for me. There are some other interesting chapters on the best types of CEOs for different companies, when to hire Senior external people, product management and much more. I realise that the things I've picked out are mostly a case of http://en.wikipedia.org/wiki/Confirmation_bias[confirmation bias] so I'm sure everyone will have different things that stand out for them. Definitely worth a read.

the-hard-thing-about-hard-things-ben-horowitz-book-review

https://markhneedham.com/blog/2014/10/13/the-hard-thing-about-hard-things-ben-horowitz-book-review

2014-07-02 06:30:50

R/plyr: ddply - Renaming the grouping/generated column when grouping by date

On https://twitter.com/_nicolemargaret[Nicole's] recommendation I've been having a look at R's http://cran.r-project.org/web/packages/plyr/index.html[plyr] package to see if I could simplify my http://www.markhneedham.com/blog/2014/06/30/neo4jr-grouping-meetup-members-by-join-timestamp/[meetup analysis] and I started by translating my code that grouped meetup join dates by day of the week. To refresh, the code without plyr looked like this: [source,r] ---- library(Rneo4j) timestampToDate <- function(x) as.POSIXct(x / 1000, origin="1970-01-01") query = "MATCH (:Person)-[:HAS_MEETUP_PROFILE]->()-[:HAS_MEMBERSHIP]->(membership)-[:OF_GROUP]->(g:Group {name: \"Neo4j - London User Group\"}) RETURN membership.joined AS joinDate" meetupMembers = cypher(graph, query) meetupMembers$joined <- timestampToDate(meetupMembers$joinDate) dd = aggregate(meetupMembers$joined, by=list(format(meetupMembers$joined, "%A")), function(x) length(x)) colnames(dd) = c("dayOfWeek", "count") ---- which returns the following: [source,r] ---- > dd dayOfWeek count 1 Friday 135 2 Monday 287 3 Saturday 80 4 Sunday 102 5 Thursday 187 6 Tuesday 286 7 Wednesday 211 ---- We need to use http://seananderson.ca/courses/12-plyr/plyr_2012.pdf[plyr's] ddply function which takes a data frame and transforms it into another one. To refresh, this is what the initial data frame looks like: [source,r] ---- > meetupMembers[1:10,] joinDate joined 1 1.376572e+12 2013-08-15 14:13:40 2 1.379491e+12 2013-09-18 08:55:11 3 1.349454e+12 2012-10-05 17:28:04 4 1.383127e+12 2013-10-30 09:59:03 5 1.372239e+12 2013-06-26 10:27:40 6 1.330295e+12 2012-02-26 22:27:00 7 1.379676e+12 2013-09-20 12:22:39 8 1.398462e+12 2014-04-25 22:41:19 9 1.331734e+12 2012-03-14 14:11:43 10 1.396874e+12 2014-04-07 13:32:26 ---- Most of the examples of using ddply show how to group by a specific 'column' e.g. joined but I want to group by part of the value in that column and eventually http://stackoverflow.com/questions/18110110/r-ddply-function-applied-to-certain-months-obtained-from-date-field[came across an example] which showed how to do it: [source,r] ---- > ddply(meetupMembers, .(format(joined, "%A")), function(x) { count <- length(x$joined) data.frame(count = count) }) format(joined, "%A") count 1 Friday 135 2 Monday 287 3 Saturday 80 4 Sunday 102 5 Thursday 187 6 Tuesday 286 7 Wednesday 211 ---- Unfortunately the generated column heading for the group by key isn't very readable and it took me way longer than it should have to work out how to name it as I wanted! This is how you do it: [source,r] ---- > ddply(meetupMembers, .(dayOfWeek=format(joined, "%A")), function(x) { count <- length(x$joined) data.frame(count = count) }) dayOfWeek count 1 Friday 135 2 Monday 287 3 Saturday 80 4 Sunday 102 5 Thursday 187 6 Tuesday 286 7 Wednesday 211 ---- If we want to sort that in descending order by 'count' we can http://stackoverflow.com/questions/5839265/r-plyr-ordering-results-from-ddply[wrap that ddply in another one]: [source,r] ---- > ddply(ddply(meetupMembers, .(dayOfWeek=format(joined, "%A")), function(x) { count <- length(x$joined) data.frame(count = count) }), .(count = count* -1)) dayOfWeek count 1 Monday 287 2 Tuesday 286 3 Wednesday 211 4 Thursday 187 5 Friday 135 6 Sunday 102 7 Saturday 80 ---- From reading a bit about ddply I gather that its slower than using some other approaches e.g. http://cran.r-project.org/web/packages/data.table/index.html[data.table] but I'm not dealing with much data so it's not an issue yet. Once I got the hang of how it worked ddply was quite nice to work with so I think I'll have a go at translating some of my other code to use it now.

rplyr-ddply-renaming-the-groupinggenerate-column-when-grouping-by-date

https://markhneedham.com/blog/2014/07/02/rplyr-ddply-renaming-the-groupinggenerate-column-when-grouping-by-date

2014-07-20 15:13:00

Neo4j 2.1.2: Finding where I am in a linked list

I was recently asked how to calculate the position of a node in a linked list and realised that as the list increases in size this is one of the occasions when we should write an http://docs.neo4j.org/chunked/stable/server-unmanaged-extensions.html[unmanaged extension] rather than using cypher. I wrote a quick bit of code to create a linked list with 10,000 elements in it: [source,java] ---- public class Chains { public static void main(String[] args) { String simpleChains = "/tmp/longchains"; populate( simpleChains, 10000 ); } private static void populate( String path, int chainSize ) { GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase( path ); try(Transaction tx = db.beginTx()) { Node currentNode = null; for ( int i = 0; i < chainSize; i++ ) { Node node = db.createNode(); if(currentNode != null) { currentNode.createRelationshipTo( node, NEXT ); } currentNode = node; } tx.success(); } db.shutdown(); } } ---- To find our distance from the end of the linked list we could write the following cypher query: [source,cypher] ---- match n where id(n) = {nodeId} with n match path = (n)-[:NEXT*]->() RETURN id(n) AS nodeId, length(path) AS length ORDER BY length DESC LIMIT 1; ---- For simplicity we're finding a node by it's internal node id and then finding the 'NEXT' relationships going out from this node recursively. We then filter the results so that we only get the longest path back which will be our distance to the end of the list. I noticed that this query would sometimes take 10s of seconds so I wrote a version using the http://docs.neo4j.org/chunked/stable/tutorial-traversal-java-api.html[Java Traversal API] to see whether I could get it any quicker. This is the Java version: [source,java] ---- try(Transaction tx = db.beginTx()) { Node startNode = db.getNodeById( nodeId ); TraversalDescription traversal = db.traversalDescription(); Traverser traverse = traversal .depthFirst() .relationships( NEXT, Direction.OUTGOING ) .sort( new Comparator<Path>() { @Override public int compare( Path o1, Path o2 ) { return Integer.valueOf( o2.length() ).compareTo( o1 .length() ); } } ) .traverse( startNode ); Collection<Path> paths = IteratorUtil.asCollection( traverse ); int maxLength = traverse.iterator().next().length(); System.out.print( maxLength ); tx.failure(); } ---- This is a bit more verbose than the cypher version but computes the same result. We've sorted the paths by length using a comparator to ensure we get the longest path back first. I created a little program to warm up the caches and kick off a few iterations where I queried from different nodes and returned the length and time taken. These were the results: [source,text] ---- -------- (Traversal API) Node: 1, Length: 9998, Time (ms): 15 (Cypher) Node: 1, Length: 9998, Time (ms): 26225 (Traversal API) Node: 456, Length: 9543, Time (ms): 10 (Cypher) Node: 456, Length: 9543, Time (ms): 24881 (Traversal API) Node: 761, Length: 9238, Time (ms): 9 (Cypher) Node: 761, Length: 9238, Time (ms): 9941 -------- (Traversal API) Node: 1, Length: 9998, Time (ms): 9 (Cypher) Node: 1, Length: 9998, Time (ms): 12537 (Traversal API) Node: 456, Length: 9543, Time (ms): 8 (Cypher) Node: 456, Length: 9543, Time (ms): 15690 (Traversal API) Node: 761, Length: 9238, Time (ms): 7 (Cypher) Node: 761, Length: 9238, Time (ms): 9202 -------- (Traversal API) Node: 1, Length: 9998, Time (ms): 8 (Cypher) Node: 1, Length: 9998, Time (ms): 11905 (Traversal API) Node: 456, Length: 9543, Time (ms): 7 (Cypher) Node: 456, Length: 9543, Time (ms): 22296 (Traversal API) Node: 761, Length: 9238, Time (ms): 8 (Cypher) Node: 761, Length: 9238, Time (ms): 8739 -------- ---- Interestingly when I reduced the size of the linked list to 1000 the difference wasn't so pronounced: [source,text] ---- -------- (Traversal API) Node: 1, Length: 998, Time (ms): 5 (Cypher) Node: 1, Length: 998, Time (ms): 174 (Traversal API) Node: 456, Length: 543, Time (ms): 2 (Cypher) Node: 456, Length: 543, Time (ms): 71 (Traversal API) Node: 761, Length: 238, Time (ms): 1 (Cypher) Node: 761, Length: 238, Time (ms): 13 -------- (Traversal API) Node: 1, Length: 998, Time (ms): 2 (Cypher) Node: 1, Length: 998, Time (ms): 111 (Traversal API) Node: 456, Length: 543, Time (ms): 1 (Cypher) Node: 456, Length: 543, Time (ms): 40 (Traversal API) Node: 761, Length: 238, Time (ms): 1 (Cypher) Node: 761, Length: 238, Time (ms): 12 -------- (Traversal API) Node: 1, Length: 998, Time (ms): 3 (Cypher) Node: 1, Length: 998, Time (ms): 129 (Traversal API) Node: 456, Length: 543, Time (ms): 2 (Cypher) Node: 456, Length: 543, Time (ms): 48 (Traversal API) Node: 761, Length: 238, Time (ms): 0 (Cypher) Node: 761, Length: 238, Time (ms): 12 -------- ---- which is good news as most linked lists that we'll create will be in the 10s - 100s range rather than 10,000 which was what I was faced with. I'm sure cypher will reach parity for this type of query in future which will be great as I like writing cypher much more than I do Java. For now though it's good to know we have a backup option to call on when necessary. The code is https://gist.github.com/mneedham/33d42fa1edca604946ec[available as a gist] if you want to play around with it further.

neo4j-2-1-2-finding-where-i-am-in-a-linked-list

https://markhneedham.com/blog/2014/07/20/neo4j-2-1-2-finding-where-i-am-in-a-linked-list

2014-07-20 16:50:55

R: ggplot - Plotting back to back bar charts

I've been http://www.markhneedham.com/blog/2014/07/20/r-ggplot-dont-know-how-to-automatically-pick-scale-for-object-of-type-difftime-discrete-value-supplied-to-continuous-scale/[playing around with R's ggplot library] to explore the Neo4j London meetup and the next thing I wanted to do was plot back to back bar charts showing 'yes' and 'no' RSVPs. I'd already done the 'yes' bar chart using the following code: [source,r] ---- query = "MATCH (e:Event)<-[:TO]-(response {response: 'yes'}) RETURN response.time AS time, e.time + e.utc_offset AS eventTime" allYesRSVPs = cypher(graph, query) allYesRSVPs$time = timestampToDate(allYesRSVPs$time) allYesRSVPs$eventTime = timestampToDate(allYesRSVPs$eventTime) allYesRSVPs$difference = as.numeric(allYesRSVPs$eventTime - allYesRSVPs$time, units="days") ggplot(allYesRSVPs, aes(x=difference)) + geom_histogram(binwidth=1, fill="green") ---- image::{{<siteurl>}}/uploads/2014/07/2014-07-20_01-15-391.png[2014 07 20 01 15 39,580] The next step was to create a similar thing for people who'd RSVP'd 'no' having originally RSVP'd 'yes' i.e. people who dropped out: [source,r] ---- query = "MATCH (e:Event)<-[:TO]-(response {response: 'no'})<-[:NEXT]-() RETURN response.time AS time, e.time + e.utc_offset AS eventTime" allNoRSVPs = cypher(graph, query) allNoRSVPs$time = timestampToDate(allNoRSVPs$time) allNoRSVPs$eventTime = timestampToDate(allNoRSVPs$eventTime) allNoRSVPs$difference = as.numeric(allNoRSVPs$eventTime - allNoRSVPs$time, units="days") ggplot(allNoRSVPs, aes(x=difference)) + geom_histogram(binwidth=1, fill="red") ---- image::{{<siteurl>}}/uploads/2014/07/2014-07-20_17-25-03.png[2014 07 20 17 25 03,570] As expected if people are going to drop out they do so a day or two before the event happens. By including the need for a 'NEXT' relationship we only capture the people who replied 'yes' and changed it to 'no'. We don't capture the people who said 'no' straight away. I thought it'd be cool to be able to have the two charts back to back using the same scale so I could compare them against each other which led to my first attempt: [source,r] ---- yes = ggplot(allYesRSVPs, aes(x=difference)) + geom_histogram(binwidth=1, fill="green") no = ggplot(allNoRSVPs, aes(x=difference)) + geom_histogram(binwidth=1, fill="red") + scale_y_reverse() library(gridExtra) grid.arrange(yes,no,ncol=1,widths=c(1,1)) ---- +++<cite>+++http://ggplot.yhathq.com/docs/scale_y_reverse.html[scale_y_reverse()]+++</cite>+++ flips the y axis so we'd see the 'no' chart upside down. The http://stackoverflow.com/questions/24765686/plotting-2-different-ggplot2-charts-with-the-same-y-axis[last line] plots the two charts in a grid containing 1 column which forces them to go next to each other vertically. image::{{<siteurl>}}/uploads/2014/07/2014-07-20_17-29-271.png[2014 07 20 17 29 27,570] When we compare them next to each other we can see that the 'yes' replies are much more spread out whereas if people are going to drop out it nearly always happens a week or so before the event happens. This is what we thought was happening but it's cool to have it confirmed by the data. One annoying thing about that visualisation is that the two charts aren't on the same scale. The 'no' chart only goes up to 100 days whereas the 'yes' one goes up to 120 days. In addition, the top end of the 'yes' chart is around 200 whereas the 'no' is around 400. Luckily we can solve that problem by http://stackoverflow.com/questions/3606697/how-to-set-limits-for-axes-in-ggplot2-r-plots[fixing the axes] for both plots: [source,r] ---- yes = ggplot(allYesRSVPs, aes(x=difference)) + geom_histogram(binwidth=1, fill="green") + xlim(0,120) + ylim(0, 400) no = ggplot(allNoRSVPs, aes(x=difference)) + geom_histogram(binwidth=1, fill="red") + xlim(0,120) + ylim(0, 400) + scale_y_reverse() ---- Now if we re-render it looks much better: image::{{<siteurl>}}/uploads/2014/07/2014-07-20_17-42-40.png[2014 07 20 17 42 40,573] From having comparable axes we can see that a lot more people drop out of an event (500) as it approaches than new people sign up (300). This is quite helpful for working out how many people are likely to show up. We've found that the number of people RSVP'd 'yes' to an event will drop by 15-20% overall from 2 days before an event up until the evening of the event and the data seems to confirm this. The only annoying thing about this approach is that the axes are repeated due to them being completely separate charts. I expect it would look better if I can work out how to combine the two data frames together and then pull out back to back charts based on a variable in the combined data frame. I'm still working on that so suggestions are most welcome. The https://github.com/mneedham/neo4j-meetup/blob/master/rScripts/rsvps.R[code is on github] if you want to play with it.

r-ggplot-plotting-back-to-back-bar-charts

https://markhneedham.com/blog/2014/07/20/r-ggplot-plotting-back-to-back-bar-charts

2014-07-20 00:21:17

R: ggplot - Don't know how to automatically pick scale for object of type difftime - Discrete value supplied to continuous scale

While reading 'http://www.fastcolabs.com/3030063/why-the-r-programming-language-is-good-for-business[Why The R Programming Language Is Good For Business]' I came across Udacity's 'https://www.udacity.com/course/viewer#!/c-ud651/l-685569241/e-824578546/m-824578547[Data Analysis with R]' courses - part of which focuses exploring data sets using visualisations, something I haven't done much of yet. I thought it'd be interesting to create some visualisations around the times that people RSVP 'yes' to the http://www.meetup.com/graphdb-london/[various Neo4j events that we run in London]. I started off with the following query which returns the date time that people replied 'Yes' to an event and the date time of the event: [source,r] ---- library(Rneo4j) query = "MATCH (e:Event)<-[:TO]-(response {response: 'yes'}) RETURN response.time AS time, e.time + e.utc_offset AS eventTime" allYesRSVPs = cypher(graph, query) allYesRSVPs$time = timestampToDate(allYesRSVPs$time) allYesRSVPs$eventTime = timestampToDate(allYesRSVPs$eventTime) > allYesRSVPs[1:10,] time eventTime 1 2011-06-05 12:12:27 2011-06-29 18:30:00 2 2011-06-05 14:49:04 2011-06-29 18:30:00 3 2011-06-10 11:22:47 2011-06-29 18:30:00 4 2011-06-07 15:27:07 2011-06-29 18:30:00 5 2011-06-06 20:21:45 2011-06-29 18:30:00 6 2011-07-04 19:49:04 2011-07-27 19:00:00 7 2011-07-05 16:40:10 2011-07-27 19:00:00 8 2011-08-19 07:41:10 2011-08-31 18:30:00 9 2011-08-24 12:47:40 2011-08-31 18:30:00 10 2011-08-18 09:56:53 2011-08-31 18:30:00 ---- I wanted to create a bar chart showing the amount of time in advance of a meetup that people RSVP'd 'yes' so I added the following column to my data frame: [source,r] ---- allYesRSVPs$difference = allYesRSVPs$eventTime - allYesRSVPs$time > allYesRSVPs[1:10,] time eventTime difference 1 2011-06-05 12:12:27 2011-06-29 18:30:00 34937.55 mins 2 2011-06-05 14:49:04 2011-06-29 18:30:00 34780.93 mins 3 2011-06-10 11:22:47 2011-06-29 18:30:00 27787.22 mins 4 2011-06-07 15:27:07 2011-06-29 18:30:00 31862.88 mins 5 2011-06-06 20:21:45 2011-06-29 18:30:00 33008.25 mins 6 2011-07-04 19:49:04 2011-07-27 19:00:00 33070.93 mins 7 2011-07-05 16:40:10 2011-07-27 19:00:00 31819.83 mins 8 2011-08-19 07:41:10 2011-08-31 18:30:00 17928.83 mins 9 2011-08-24 12:47:40 2011-08-31 18:30:00 10422.33 mins 10 2011-08-18 09:56:53 2011-08-31 18:30:00 19233.12 mins ---- I then tried to use ggplot to create a bar chart of that data: [source,r] ---- > ggplot(allYesRSVPs, aes(x=difference)) + geom_histogram(binwidth=1, fill="green") ---- Unfortunately that resulted in this error: [source,r] ---- Don't know how to automatically pick scale for object of type difftime. Defaulting to continuous Error: Discrete value supplied to continuous scale ---- I couldn't find anyone who had come across this problem before in my search but I did find the http://stat.ethz.ch/R-manual/R-devel/library/base/html/difftime.html[as.numeric] function which seemed like it would put the difference into an appropriate format: [source,r] ---- allYesRSVPs$difference = as.numeric(allYesRSVPs$eventTime - allYesRSVPs$time, units="days") > ggplot(allYesRSVPs, aes(x=difference)) + geom_histogram(binwidth=1, fill="green") ---- that resulted in the following chart: image::{{<siteurl>}}/uploads/2014/07/2014-07-20_01-15-39.png[2014 07 20 01 15 39,580] We can see there is quite a heavy concentration of people RSVPing yes in the few days before the event and then the rest are scattered across the first 30 days. We usually announce events 3/4 weeks in advance so I don't know that it tells us anything interesting other than that it seems like people sign up for events when an email is sent out about them. The date the meetup was announced (by email) isn't currently exposed by the API but https://groups.google.com/forum/#!topic/meetup-api/3kcvh4ye-O0[hopefully one day it will be]. The https://github.com/mneedham/neo4j-meetup/blob/master/rScripts/memberOverlap.R#L290[code is on github] if you want to have a play - any suggestions welcome.

r-ggplot-dont-know-how-to-automatically-pick-scale-for-object-of-type-difftime-discrete-value-supplied-to-continuous-scale

https://markhneedham.com/blog/2014/07/20/r-ggplot-dont-know-how-to-automatically-pick-scale-for-object-of-type-difftime-discrete-value-supplied-to-continuous-scale

2014-07-29 19:07:11

4 types of user

I've been working with Neo4j full time for slightly more than a year now and from interacting with the community I've noticed that while using different features of the product people fall into 4 categories. These are as follows: image::{{<siteurl>}}/uploads/2014/07/4types.jpg[4types,400] On one axis we have 'loudness' i.e. how vocal somebody is either on twitter, StackOverflow or by email and on the other we have 'success' which is how well a product feature is working for them. The people in the top half of the diagram will get the most attention because they're the most visible. Of those people we'll tend to spend more time on the people who are unhappy and vocal to try and help them solve the problems their having. When working with the people in the top left it's difficult to understand how representative they are for the whole user base. It could be the case that they aren't representative at all and actually there is a quiet majority who the product is working for and are just getting on with it with no fuss. However, it could equally be the case that they are *absolutely representative* and there are a lot of users quietly suffering / giving up using the product. I haven't come up with a good way to come across the less vocal users but in my experience they'll often be passive users of the user group or Stack Overflow i.e. they'll read existing issues but not post anything themselves. Given this uncertainty I think it makes sense to assume that the silent majority suffer the same problems as the more vocal minority. Another interesting thing I've noticed about this quadrant is that the people in the top right are often the best people in the community to help those who are struggling. It'd be interesting to know whether anyone has noticed a similar thing with the products they worked on, and if so what approach do you take to unveiling the silent majority?

4-types-of-user

https://markhneedham.com/blog/2014/07/29/4-types-of-user

2014-07-16 05:04:46

R: Apply a custom function across multiple lists

In my continued playing around with http://www.r-project.org/[R] I wanted to map a custom function over two lists comparing each item with its corresponding items. If we just want to use a built in function such as subtraction between two lists it's quite easy to do: [source,r] ---- > c(10,9,8,7,6,5,4,3,2,1) - c(5,4,3,4,3,2,2,1,2,1) [1] 5 5 5 3 3 3 2 2 0 0 ---- I wanted to do a slight variation on that where instead of returning the difference I wanted to return a text value representing the difference e.g. '5 or more', '3 to 5' etc. I spent a long time trying to figure out how to do that before finding http://nsaunders.wordpress.com/2010/08/20/a-brief-introduction-to-apply-in-r/[an excellent blog post which describes all the different 'apply' functions available in R]. As far as I understand 'apply' is the equivalent of 'map' in Clojure or other functional languages. In this case we want the +++<cite>+++http://stat.ethz.ch/R-manual/R-patched/library/base/html/mapply.html[mapply]+++</cite>+++ variant which we can use like so: [source,r] ---- > mapply(function(x, y) { if((x-y) >= 5) { "5 or more" } else if((x-y) >= 3) { "3 to 5" } else { "less than 5" } }, c(10,9,8,7,6,5,4,3,2,1),c(5,4,3,4,3,2,2,1,2,1)) [1] "5 or more" "5 or more" "5 or more" "3 to 5" "3 to 5" "3 to 5" "less than 5" [8] "less than 5" "less than 5" "less than 5" ---- We could then pull that out into a function if we wanted: [source,r] ---- summarisedDifference <- function(one, two) { mapply(function(x, y) { if((x-y) >= 5) { "5 or more" } else if((x-y) >= 3) { "3 to 5" } else { "less than 5" } }, one, two) } ---- which we could call like so: [source,r] ---- > summarisedDifference(c(10,9,8,7,6,5,4,3,2,1),c(5,4,3,4,3,2,2,1,2,1)) [1] "5 or more" "5 or more" "5 or more" "3 to 5" "3 to 5" "3 to 5" "less than 5" [8] "less than 5" "less than 5" "less than 5" ---- I also wanted to be able to compare a list of items to a single item which was much easier than I expected: [source,r] ---- > summarisedDifference(c(10,9,8,7,6,5,4,3,2,1), 1) [1] "5 or more" "5 or more" "5 or more" "5 or more" "5 or more" "3 to 5" "3 to 5" [8] "less than 5" "less than 5" "less than 5" ---- If we wanted to get a summary of the differences between the lists we could plug them into ddply like so: [source,r] ---- > library(plyr) > df = data.frame(x=c(10,9,8,7,6,5,4,3,2,1), y=c(5,4,3,4,3,2,2,1,2,1)) > ddply(df, .(difference=summarisedDifference(x,y)), summarise, count=length(x)) difference count 1 3 to 5 3 2 5 or more 3 3 less than 5 4 ----

r-apply-a-custom-function-across-multiple-lists

https://markhneedham.com/blog/2014/07/16/r-apply-a-custom-function-across-multiple-lists

2014-07-10 14:54:25

Neo4j: LOAD CSV - Processing hidden arrays in your CSV documents

I was recently asked how to process an 'array' of values inside a column in a CSV file using http://docs.neo4j.org/chunked/stable/query-load-csv.html[Neo4j's LOAD CSV] tool and although I initially thought this wouldn't be possible as every cell is treated as a String, https://twitter.com/mesirii[Michael] showed me a way of working around this which I thought was pretty neat. Let's say we have a CSV file representing people and their friends. It might look like this: [source,bash] ---- name,friends "Mark","Michael,Peter" "Michael","Peter,Kenny" "Kenny","Anders,Michael" ---- And what we want is to have the following nodes: * Mark * Michael * Peter * Kenny * Anders And the following friends relationships: * Mark \-> Michael * Mark \-> Peter * Michael \-> Peter * Michael \-> Kenny * Kenny \-> Anders * Kenny \-> Michael We'll start by loading the CSV file and returning each row: [source,cypher] ---- $ load csv with headers from "file:/Users/markneedham/Desktop/friends.csv" AS row RETURN row; +------------------------------------------------+ | row | +------------------------------------------------+ | {name -> "Mark", friends -> "Michael,Peter"} | | {name -> "Michael", friends -> "Peter,Kenny"} | | {name -> "Kenny", friends -> "Anders,Michael"} | +------------------------------------------------+ 3 rows ---- As expected the 'friends' column is being treated as a String which means we can use the http://docs.neo4j.org/chunked/stable/query-functions-string.html#functions-split[split] function to get an array of people that we want to be friends with: [source,cypher] ---- $ load csv with headers from "file:/Users/markneedham/Desktop/friends.csv" AS row RETURN row, split(row.friends, ",") AS friends; +-----------------------------------------------------------------------+ | row | friends | +-----------------------------------------------------------------------+ | {name -> "Mark", friends -> "Michael,Peter"} | ["Michael","Peter"] | | {name -> "Michael", friends -> "Peter,Kenny"} | ["Peter","Kenny"] | | {name -> "Kenny", friends -> "Anders,Michael"} | ["Anders","Michael"] | +-----------------------------------------------------------------------+ 3 rows ---- Now that we've got them as an array we can use http://docs.neo4j.org/chunked/stable/query-unwind.html[UNWIND] to get pairs of friends that we want to create: [source,cypher] ---- $ load csv with headers from "file:/Users/markneedham/Desktop/friends.csv" AS row WITH row, split(row.friends, ",") AS friends UNWIND friends AS friend RETURN row.name, friend; +-----------------------+ | row.name | friend | +-----------------------+ | "Mark" | "Michael" | | "Mark" | "Peter" | | "Michael" | "Peter" | | "Michael" | "Kenny" | | "Kenny" | "Anders" | | "Kenny" | "Michael" | +-----------------------+ 6 rows ---- And now we'll introduce some http://docs.neo4j.org/chunked/stable/query-merge.html[MERGE] statements to create the appropriate nodes and relationships: [source,cypher] ---- $ load csv with headers from "file:/Users/markneedham/Desktop/friends.csv" AS row WITH row, split(row.friends, ",") AS friends UNWIND friends AS friend MERGE (p1:Person {name: row.name}) MERGE (p2:Person {name: friend}) MERGE (p1)-[:FRIENDS_WITH]->(p2); +-------------------+ | No data returned. | +-------------------+ Nodes created: 5 Relationships created: 6 Properties set: 5 Labels added: 5 373 ms ---- And now if we query the database to get back all the nodes + relationships\... [source,cypher] ---- $ match (p1:Person)-[r]->(p2) RETURN p1,r, p2; +------------------------------------------------------------------------+ | p1 | r | p2 | +------------------------------------------------------------------------+ | Node[0]{name:"Mark"} | :FRIENDS_WITH[0]{} | Node[1]{name:"Michael"} | | Node[0]{name:"Mark"} | :FRIENDS_WITH[1]{} | Node[2]{name:"Peter"} | | Node[1]{name:"Michael"} | :FRIENDS_WITH[2]{} | Node[2]{name:"Peter"} | | Node[1]{name:"Michael"} | :FRIENDS_WITH[3]{} | Node[3]{name:"Kenny"} | | Node[3]{name:"Kenny"} | :FRIENDS_WITH[4]{} | Node[4]{name:"Anders"} | | Node[3]{name:"Kenny"} | :FRIENDS_WITH[5]{} | Node[1]{name:"Michael"} | +------------------------------------------------------------------------+ 6 rows ---- \...you'll see that we have everything. If instead of a comma separated list of people we have a literal array in the cell\... [source,text] ---- name,friends "Mark", "[Michael,Peter]" "Michael", "[Peter,Kenny]" "Kenny", "[Anders,Michael]" ---- \...we'd need to tweak the part of the query which extracts our friends to strip off the first and last characters: [source,cypher] ---- $ load csv with headers from "file:/Users/markneedham/Desktop/friendsa.csv" AS row RETURN row, split(substring(row.friends, 1, length(row.friends) -2), ",") AS friends; +-------------------------------------------------------------------------+ | row | friends | +-------------------------------------------------------------------------+ | {name -> "Mark", friends -> "[Michael,Peter]"} | ["Michael","Peter"] | | {name -> "Michael", friends -> "[Peter,Kenny]"} | ["Peter","Kenny"] | | {name -> "Kenny", friends -> "[Anders,Michael]"} | ["Anders","Michael"] | +-------------------------------------------------------------------------+ 3 rows ---- And then if we put the whole query together we end up with this: [source,cypher] ---- $ load csv with headers from "file:/Users/markneedham/Desktop/friendsa.csv" AS row WITH row, split(substring(row.friends, 1, length(row.friends) -2), ",") AS friends UNWIND friends AS friend MERGE (p1:Person {name: row.name}) MERGE (p2:Person {name: friend}) MERGE (p1)-[:FRIENDS_WITH]->(p2);; +-------------------+ | No data returned. | +-------------------+ Nodes created: 5 Relationships created: 6 Properties set: 5 Labels added: 5 ----

neo4j-load-csv-processing-hidden-arrays-in-your-csv-documents

https://markhneedham.com/blog/2014/07/10/neo4j-load-csv-processing-hidden-arrays-in-your-csv-documents

2014-07-07 06:07:29

R/plyr: ddply - Error in vector(type, length) : vector: cannot make a vector of mode 'closure'.

In my continued playing around with plyr's http://www.inside-r.org/packages/cran/plyr/docs/ddply[ddply] function I was trying to group a data frame by one of its columns and return a count of the number of rows with specific values and ran into a strange (to me) error message. I had a data frame: [source,r] ---- n = c(2, 3, 5) s = c("aa", "bb", "cc") b = c(TRUE, FALSE, TRUE) df = data.frame(n, s, b) ---- And wanted to group and count on column 'b' so I'd get back a count of 2 for TRUE and 1 for FALSE. I wrote this code: [source,r] ---- ddply(df, "b", function(x) { countr <- length(x$n) data.frame(count = count) }) ---- which when evaluated gave the following error: [source,r] ---- Error in vector(type, length) : vector: cannot make a vector of mode 'closure'. ---- It took me quite a while to realise that I'd just made a typo in assigned the count to a variable called 'countr' instead of 'count'. As a result of that typo I think the R compiler was trying to find a variable called 'count' somwhere else in the lexical scope but was unable to. If I'd defined the variable 'count' outside the call to ddply function then my typo wouldn't have resulted in an error but rather an unexpected resulte.g. [source,r] ---- > count = 10 ---- [source,r] ---- > ddply(df, "b", function(x) { + countr <- length(x$n) + data.frame(count = count) + }) b count 1 FALSE 4 2 TRUE 4 ---- Once I spotted the typo and fixed it things worked as expected: [source,r] ---- > ddply(df, "b", function(x) { + count <- length(x$n) + data.frame(count = count) + }) ---- [source,r] ---- b count 1 FALSE 1 2 TRUE 2 ----

rplyr-ddply-error-in-vectortype-length-vector-cannot-make-a-vector-of-mode-closure

https://markhneedham.com/blog/2014/07/07/rplyr-ddply-error-in-vectortype-length-vector-cannot-make-a-vector-of-mode-closure

2014-07-23 22:20:25

Java: Determining the status of data import using kill signals

A few weeks ago I was working on the initial import of ~ 60 million bits of data into Neo4j and we kept running into a problem where the import process just seemed to freeze and nothing else was imported. It was very difficult to tell what was happening inside the process - taking a thread dump merely informed us that it was attempting to process one line of a CSV line and was somehow unable to do so. One way to help debug this would have been to print out every single line of the CSV as we processed it and then watch where it got stuck but this seemed a bit over kill. Ideally we wanted to only print out the line we were processing on demand. As luck would have it we can do exactly this by sending a kill signal to our import process and have it print out where it had got up to. We had to make sure we picked a signal which wasn't already being handled by the JVM and decided to go with 'SIGTRAP' i.e. kill -5 [pid] We came across http://www.javawebdevelop.com/300909/[a neat blog post that explained how to wire everything up] and then created our own version: [source,java] ---- class Kill3Handler implements SignalHandler { private AtomicInteger linesProcessed; private AtomicReference<Map<String, Object>> lastRowProcessed; public Kill3Handler( AtomicInteger linesProcessed, AtomicReference<Map<String, Object>> lastRowProcessed ) { this.linesProcessed = linesProcessed; this.lastRowProcessed = lastRowProcessed; } @Override public void handle( Signal signal ) { System.out.println("Last Line Processed: " + linesProcessed.get() + " " + lastRowProcessed.get()); } } ---- We then wired that up like so: [source,java] ---- AtomicInteger linesProcessed = new AtomicInteger( 0 ); AtomicReference<Map<String, Object>> lastRowProcessed = new AtomicReference<>( ); Kill3Handler kill3Handler = new Kill3Handler( linesProcessed, lastRowProcessed ); Signal.handle(new Signal("TRAP"), kill3Handler); // as we iterate each line we update those variables linesProcessed.incrementAndGet(); lastRowProcessed.getAndSet( properties ); // properties = a representation of the row we're processing ---- This worked really well for us and we were able to work out that we had a slight problem with some of the data in our CSV file which was causing it to be processed incorrectly. We hadn't been able to see this by visual inspection since the CSV files were a few GB in size. We'd therefore only skimmed a few lines as a sanity check. I didn't even know you could do this but it's a neat trick to keep in mind - I'm sure it shall come in useful again.

java-determining-the-status-of-data-import-using-kill-signals

https://markhneedham.com/blog/2014/07/23/java-determining-the-status-of-data-import-using-kill-signals

2014-07-25 21:57:24

R: ggplot - Plotting back to back charts using facet_wrap

Earlier in the week I showed a way to http://www.markhneedham.com/blog/2014/07/20/r-ggplot-plotting-back-to-back-bar-charts/[plot back to back charts using R's ggplot library] but looking back on the code it felt like it was a bit hacky to 'glue' two charts together using a grid. I wanted to find a better way. To recap, I came up with the following charts showing the RSVPs to Neo4j London meetup events https://github.com/mneedham/neo4j-meetup/blob/master/rScripts/rsvps.R[using this code]: image::{{<siteurl>}}/uploads/2014/07/2014-07-20_17-42-401.png[2014 07 20 17 42 40,573] The first thing we need to do to simplify chart generation is to return 'yes' and 'no' responses in the same cypher query, like so: [source,cypher] ---- timestampToDate <- function(x) as.POSIXct(x / 1000, origin="1970-01-01", tz = "GMT") query = "MATCH (e:Event)<-[:TO]-(response {response: 'yes'}) WITH e, COLLECT(response) AS yeses MATCH (e)<-[:TO]-(response {response: 'no'})<-[:NEXT]-() WITH e, COLLECT(response) + yeses AS responses UNWIND responses AS response RETURN response.time AS time, e.time + e.utc_offset AS eventTime, response.response AS response" allRSVPs = cypher(graph, query) allRSVPs$time = timestampToDate(allRSVPs$time) allRSVPs$eventTime = timestampToDate(allRSVPs$eventTime) allRSVPs$difference = as.numeric(allRSVPs$eventTime - allRSVPs$time, units="days") ---- The query is a bit verbose because we want to capture the 'no' responses when they initially said yes which is why we check for a 'NEXT' relationship when looking for the negative responses. Let's inspect allRSVPs: [source,r] ---- > allRSVPs[1:10,] time eventTime response difference 1 2014-06-13 21:49:20 2014-07-22 18:30:00 no 38.86157 2 2014-07-02 22:24:06 2014-07-22 18:30:00 yes 19.83743 3 2014-05-23 23:46:02 2014-07-22 18:30:00 yes 59.78053 4 2014-06-23 21:07:11 2014-07-22 18:30:00 yes 28.89084 5 2014-06-06 15:09:29 2014-07-22 18:30:00 yes 46.13925 6 2014-05-31 13:03:09 2014-07-22 18:30:00 yes 52.22698 7 2014-05-23 23:46:02 2014-07-22 18:30:00 yes 59.78053 8 2014-07-02 12:28:22 2014-07-22 18:30:00 yes 20.25113 9 2014-06-30 23:44:39 2014-07-22 18:30:00 yes 21.78149 10 2014-06-06 15:35:53 2014-07-22 18:30:00 yes 46.12091 ---- We've returned the actual response with each row so that we can distinguish between responses. It will also come in useful for pivoting our single chart later on. The next step is to get ggplot to generate our side by side charts. I started off by plotting both types of response on the same chart: [source,r] ---- ggplot(allRSVPs, aes(x = difference, fill=response)) + geom_bar(binwidth=1) ---- image::{{<siteurl>}}/uploads/2014/07/2014-07-25_22-14-28.png[2014 07 25 22 14 28,519] This one stacks the 'yes' and 'no' responses on top of each other which isn't what we want as it's difficult to compare the two. What we need is the +++<cite>+++http://docs.ggplot2.org/0.9.3.1/facet_wrap.html[facet_wrap]+++</cite>+++ function which allows us to generate multiple charts grouped by key. We'll group by 'response': </p> [source,r] ---- ggplot(allRSVPs, aes(x = difference, fill=response)) + geom_bar(binwidth=1) + facet_wrap(~ response, nrow=2, ncol=1) ---- image::{{<siteurl>}}/uploads/2014/07/2014-07-25_22-34-46.png[2014 07 25 22 34 46,522] The only thing we're missing now is the red and green colours which is where the +++<cite>+++http://docs.ggplot2.org/0.9.3.1/scale_manual.html[scale_fill_manual] function comes in handy:+++</cite>+++ ~~~r ggplot(allRSVPs, aes(x = difference, fill=response)) + scale_fill_manual(values=c("#FF0000", "#00FF00")) + geom_bar(binwidth=1) + facet_wrap(~ response, nrow=2, ncol=1) ~~~ image::{{<siteurl>}}/uploads/2014/07/2014-07-25_22-39-56.png[2014 07 25 22 39 56,519] If we want to show the 'yes' chart on top we can pass in an extra parameter to +++<cite>+++facet_wrap+++</cite>+++ to change where it places the highest value: ~~~r ggplot(allRSVPs, aes(x = difference, fill=response)) + scale_fill_manual(values=c("#FF0000", "#00FF00")) + geom_bar(binwidth=1) + facet_wrap(~ response, nrow=2, ncol=1, as.table = FALSE) ~~~ image::{{<siteurl>}}/uploads/2014/07/2014-07-25_22-43-29.png[2014 07 25 22 43 29,519] We could go one step further and group by response and day. First let's add a 'day' column to our data frame: ~~~r allRSVPs$dayOfWeek = format(allRSVPs$eventTime, "%A") ~~~ And now let's plot the charts using both columns: ~~~r ggplot(allRSVPs, aes(x = difference, fill=response)) + scale_fill_manual(values=c("#FF0000", "#00FF00")) + geom_bar(binwidth=1) + facet_wrap(~ response + dayOfWeek, as.table = FALSE) ~~~ image::{{<siteurl>}}/uploads/2014/07/2014-07-25_22-49-57.png[2014 07 25 22 49 57,600] The distribution of dropouts looks fairly similar for all the days - Thursday is just at an order of magnitude below the other days because we haven't run many events on Thursdays so far. At a glance it doesn't appear that so many people sign up for Thursday events on the day or one day before. One potential hypothesis is that people have things planned for Thursday whereas they decide more last minute what to do on the other days. We'll have to run some more events on Thursdays to see whether that trend holds out. The https://github.com/mneedham/neo4j-meetup/blob/master/rScripts/rsvpsTake2.R[code is on github] if you want to play with it

r-ggplot-plotting-back-to-back-charts-using-facet_wrap

https://markhneedham.com/blog/2014/07/25/r-ggplot-plotting-back-to-back-charts-using-facet_wrap

2014-09-29 05:46:43

R: Filtering data frames by column type ('x' must be numeric)

I've been working through the exercises from http://www-bcf.usc.edu/~gareth/ISL/[An Introduction to Statistical Learning] and one of them required you to create a pair wise correlation matrix of variables in a data frame. The exercise uses the 'Carseats' data set which can be imported like so: [source,r] ---- > install.packages("ISLR") > library(ISLR) > head(Carseats) Sales CompPrice Income Advertising Population Price ShelveLoc Age Education Urban US 1 9.50 138 73 11 276 120 Bad 42 17 Yes Yes 2 11.22 111 48 16 260 83 Good 65 10 Yes Yes 3 10.06 113 35 10 269 80 Medium 59 12 Yes Yes 4 7.40 117 100 4 466 97 Medium 55 14 Yes Yes 5 4.15 141 64 3 340 128 Bad 38 13 Yes No 6 10.81 124 113 13 501 72 Bad 78 16 No Yes ---- filter the categorical variables from a data frame and If we try to run the 'http://www.statmethods.net/stats/correlations.html[cor]' function on the data frame we'll get the following error: [source,r] ---- > cor(Carseats) Error in cor(Carseats) : 'x' must be numeric ---- As the error message suggests, we can't pass non numeric variables to this function so we need to remove the categorical variables from our data frame. But first we need to http://r.789695.n4.nabble.com/Find-classes-for-each-column-of-a-data-frame-td2339918.html[work out which columns those are]: [source,r] ---- > sapply(Carseats, class) Sales CompPrice Income Advertising Population Price ShelveLoc Age Education "numeric" "numeric" "numeric" "numeric" "numeric" "numeric" "factor" "numeric" "numeric" Urban US "factor" "factor" ---- We can see a few columns of type 'factor' and luckily for us there's a function which will help us identify those more easily: [source,r] ---- > sapply(Carseats, is.factor) Sales CompPrice Income Advertising Population Price ShelveLoc Age Education FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE Urban US TRUE TRUE ---- Now we can remove those columns from our data frame and create the correlation matrix: [source,r] ---- > cor(Carseats[sapply(Carseats, function(x) !is.factor(x))]) Sales CompPrice Income Advertising Population Price Age Education Sales 1.00000000 0.06407873 0.151950979 0.269506781 0.050470984 -0.44495073 -0.231815440 -0.051955242 CompPrice 0.06407873 1.00000000 -0.080653423 -0.024198788 -0.094706516 0.58484777 -0.100238817 0.025197050 Income 0.15195098 -0.08065342 1.000000000 0.058994706 -0.007876994 -0.05669820 -0.004670094 -0.056855422 Advertising 0.26950678 -0.02419879 0.058994706 1.000000000 0.265652145 0.04453687 -0.004557497 -0.033594307 Population 0.05047098 -0.09470652 -0.007876994 0.265652145 1.000000000 -0.01214362 -0.042663355 -0.106378231 Price -0.44495073 0.58484777 -0.056698202 0.044536874 -0.012143620 1.00000000 -0.102176839 0.011746599 Age -0.23181544 -0.10023882 -0.004670094 -0.004557497 -0.042663355 -0.10217684 1.000000000 0.006488032 Education -0.05195524 0.02519705 -0.056855422 -0.033594307 -0.106378231 0.01174660 0.006488032 1.000000000 ----

r-filtering-data-frames-by-column-type-x-must-be-numeric

https://markhneedham.com/blog/2014/09/29/r-filtering-data-frames-by-column-type-x-must-be-numeric

2014-09-29 22:40:31

PostgreSQL: ERROR: column does not exist

I've been playing around with PostgreSQL recently and in particular https://code.google.com/p/northwindextended/downloads/detail?name=northwind.postgre.sql&can=2&q=[the Northwind dataset] typically used as an introductory data set for relational databases. Having imported the data I wanted to take a quick look at the employees table: [source,sql] ---- postgres=# select * from employees limit 1; EmployeeID | LastName | FirstName | Title | TitleOfCourtesy | BirthDate | HireDate | Address | City | Region | PostalCode | Country | HomePhone | Extension | Photo | Notes | ReportsTo | PhotoPath ------------+----------+-----------+----------------------+-----------------+------------+------------+-----------------------------+---------+--------+------------+---------+----------------+-----------+-------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------+-------------------------------------- 1 | Davolio | Nancy | Sales Representative | Ms. | 1948-12-08 | 1992-05-01 | 507 - 20th Ave. E.\nApt. 2A | Seattle | WA | 98122 | USA | (206) 555-9857 | 5467 | \x | Education includes a BA in psychology from Colorado State University in 1970. She also completed "The Art of the Cold Call." Nancy is a member of Toastmasters International. | 2 | http://accweb/emmployees/davolio.bmp (1 row) ---- That works fine but what if I only want to return the 'EmployeeID' field? [source,sql] ---- postgres=# select EmployeeID from employees limit 1; ERROR: column "employeeid" does not exist LINE 1: select EmployeeID from employees limit 1; ---- I hadn't realised (or had forgotten) that http://stackoverflow.com/questions/20878932/are-postgresql-column-names-case-sensitive[field names get lower cased] so we need to quote the name if it's been stored in mixed case: [source,sql] ---- postgres=# select "EmployeeID" from employees limit 1; EmployeeID ------------ 1 (1 row) ---- From my reading the suggestion seems to be to have your field names lower cased to avoid this problem but since it's just a dummy data set I guess I'll just put up with the quoting overhead for now.

postgresql-error-column-does-not-exist

https://markhneedham.com/blog/2014/09/29/postgresql-error-column-does-not-exist

2014-09-29 21:37:21

R: Deriving a new data frame column based on containing string

I've been playing around with R data frames a bit more and one thing I wanted to do was derive a new column based on the text contained in the existing column. I started with something like this: [source,r] ---- > x = data.frame(name = c("Java Hackathon", "Intro to Graphs", "Hands on Cypher")) > x name 1 Java Hackathon 2 Intro to Graphs 3 Hands on Cypher ---- And I wanted to derive a new column based on whether or not the session was a practical one. The https://stat.ethz.ch/R-manual/R-devel/library/base/html/grep.html[grepl] function seemed to be the best tool for the job: [source,r] ---- > grepl("Hackathon|Hands on|Hands On", x$name) [1] TRUE FALSE TRUE ---- We can then add a column to our data frame with that output: [source,r] ---- x$practical = grepl("Hackathon|Hands on|Hands On", x$name) ---- And we end up with the following: [source,r] ---- > x name practical 1 Java Hackathon TRUE 2 Intro to Graphs FALSE 3 Hands on Cypher TRUE ---- Not too tricky but it took me a bit too long to figure it out so I thought I'd save future Mark some time!

r-deriving-a-new-data-frame-column-based-on-containing-string

https://markhneedham.com/blog/2014/09/29/r-deriving-a-new-data-frame-column-based-on-containing-string

2014-09-16 16:59:21

R: ggplot - Plotting multiple variables on a line chart

In my continued playing around with meetup data I wanted to plot the number of members who join the Neo4j group over time. I started off with the variable 'byWeek' which shows how many members joined the group each week: [source,r] ---- > head(byWeek) Source: local data frame [6 x 2] week n 1 2011-06-02 8 2 2011-06-09 4 3 2011-06-30 2 4 2011-07-14 1 5 2011-07-21 1 6 2011-08-18 1 ---- I wanted to plot the actual count alongside http://www.markhneedham.com/blog/2014/09/13/r-calculating-rolling-or-moving-averages/[a rolling average] for which I created the following data frame: [source,r] ---- library(zoo) joinsByWeek = data.frame(actual = byWeek$n, week = byWeek$week, rolling = rollmean(byWeek$n, 4, fill = NA, align=c("right"))) ---- [source,text] ---- > head(joinsByWeek, 10) actual week rolling 1 8 2011-06-02 NA 2 4 2011-06-09 NA 3 2 2011-06-30 NA 4 1 2011-07-14 3.75 5 1 2011-07-21 2.00 6 1 2011-08-18 1.25 7 1 2011-10-13 1.00 8 2 2011-11-24 1.25 9 1 2012-01-05 1.25 10 3 2012-01-12 1.75 ---- The next step was to work out how to http://stackoverflow.com/questions/3777174/plotting-two-variables-as-lines-using-ggplot2-on-the-same-graph[plot both 'rolling' and 'actual' on the same line chart]. The easiest way is to make two calls to 'geom_line', like so: [source,r] ---- ggplot(joinsByWeek, aes(x = week)) + geom_line(aes(y = rolling), colour="blue") + geom_line(aes(y = actual), colour = "grey") + ylab(label="Number of new members") + xlab("Week") ---- image::{{<siteurl>}}/uploads/2014/09/2014-09-16_21-57-14.png[2014 09 16 21 57 14,600] Alternatively we can make use of the 'melt' function from the +++<cite>+++http://www.statmethods.net/management/reshape.html[reshape]+++</cite>+++ library\... [source,r] ---- library(reshape) meltedJoinsByWeek = melt(joinsByWeek, id = 'week') ---- [source,text] ---- > head(meltedJoinsByWeek, 20) week variable value 1 1 actual 8 2 2 actual 4 3 3 actual 2 4 4 actual 1 5 5 actual 1 6 6 actual 1 7 7 actual 1 8 8 actual 2 9 9 actual 1 10 10 actual 3 11 11 actual 1 12 12 actual 2 13 13 actual 4 14 14 actual 2 15 15 actual 3 16 16 actual 5 17 17 actual 1 18 18 actual 2 19 19 actual 1 20 20 actual 2 ---- \...which then means we can plot the chart with a single call to geom_line: [source,r] ---- ggplot(meltedJoinsByWeek, aes(x = week, y = value, colour = variable)) + geom_line() + ylab(label="Number of new members") + xlab("Week Number") + scale_colour_manual(values=c("grey", "blue")) ---- image::{{<siteurl>}}/uploads/2014/09/2014-09-16_22-17-40.png[2014 09 16 22 17 40,600]

r-ggplot-plotting-multiple-variables-on-a-line-chart

https://markhneedham.com/blog/2014/09/16/r-ggplot-plotting-multiple-variables-on-a-line-chart

2014-09-26 20:46:50

Neo4j: COLLECTing multiple values (Too many parameters for function 'collect')

One of my favourite functions in Neo4j's cypher query language is COLLECT which allows us to group items into an array for later consumption. However, I've noticed that people sometimes have trouble working out how to collect multiple items with COLLECT and struggle to find a way to do so. Consider the following data set: [source,cypher] ---- create (p:Person {name: "Mark"}) create (e1:Event {name: "Event1", timestamp: 1234}) create (e2:Event {name: "Event2", timestamp: 4567}) create (p)-[:EVENT]->(e1) create (p)-[:EVENT]->(e2) ---- If we wanted to return each person along with a collection of the event names they'd participated in we could write the following: [source,cypher] ---- $ MATCH (p:Person)-[:EVENT]->(e) > RETURN p, COLLECT(e.name); +--------------------------------------------+ | p | COLLECT(e.name) | +--------------------------------------------+ | Node[0]{name:"Mark"} | ["Event1","Event2"] | +--------------------------------------------+ 1 row ---- That works nicely, but what about if we want to collect the event name and the timestamp but don't want to return the entire event node? An approach I've seen a few people try during workshops is the following: [source,cypher] ---- MATCH (p:Person)-[:EVENT]->(e) RETURN p, COLLECT(e.name, e.timestamp) ---- Unfortunately this doesn't compile: [source,text] ---- SyntaxException: Too many parameters for function 'collect' (line 2, column 11) "RETURN p, COLLECT(e.name, e.timestamp)" ^ ---- As the error message suggests, the COLLECT function only takes one argument so we need to find another way to solve our problem. One way is to put the two values into a literal array which will result in an array of arrays as our return result: [source,cypher] ---- $ MATCH (p:Person)-[:EVENT]->(e) > RETURN p, COLLECT([e.name, e.timestamp]); +----------------------------------------------------------+ | p | COLLECT([e.name, e.timestamp]) | +----------------------------------------------------------+ | Node[0]{name:"Mark"} | [["Event1",1234],["Event2",4567]] | +----------------------------------------------------------+ 1 row ---- The annoying thing about this approach is that as you add more items you'll forget in which position you've put each bit of data so I think a preferable approach is to collect a map of items instead: [source,cypher] ---- $ MATCH (p:Person)-[:EVENT]->(e) > RETURN p, COLLECT({eventName: e.name, eventTimestamp: e.timestamp}); +--------------------------------------------------------------------------------------------------------------------------+ | p | COLLECT({eventName: e.name, eventTimestamp: e.timestamp}) | +--------------------------------------------------------------------------------------------------------------------------+ | Node[0]{name:"Mark"} | [{eventName -> "Event1", eventTimestamp -> 1234},{eventName -> "Event2", eventTimestamp -> 4567}] | +--------------------------------------------------------------------------------------------------------------------------+ 1 row ---- During the http://www.meetup.com/graphdb-london/events/194308602/[Clojure Neo4j Hackathon] that we ran earlier this week this proved to be a particularly pleasing approach as we could easily destructure the collection of maps in our Clojure code.

neo4j-collecting-multiple-values-too-many-parameters-for-function-collect

https://markhneedham.com/blog/2014/09/26/neo4j-collecting-multiple-values-too-many-parameters-for-function-collect

2014-09-30 16:47:29

Neo4j: Generic/Vague relationship names

An approach to modelling that I often see while working with Neo4j users is creating very generic relationships (e.g. HAS, CONTAINS, IS) and filtering on a relationship property or on a property/label at the end node. Intuitively this doesn't seem to make best use of the graph model as it means that you have to evaluate many relationships and nodes that you're not interested in. However, I've never actually tested the performance differences between the approaches so I thought I'd try it out. I created 4 different databases which had one node with 60,000 outgoing relationships - 10,000 which we wanted to retrieve and 50,000 that were irrelevant. I modelled the 'relationship' in 4 different ways\... * Using a specific relationship type + (node)-[:HAS_ADDRESS]\->(address) * Using a generic relationship type and then filtering by end node label + (node)-[:HAS]\->(address:Address) * Using a generic relationship type and then filtering by relationship property + (node)-[:HAS {type: "address"}]\->(address) * Using a generic relationship type and then filtering by end node property + (node)-[:HAS]\->(address {type: "address"}) \...and then measured how long it took to retrieve the 'has address' relationships. The https://gist.github.com/mneedham/a35f146dbe09266d574d[code is on github] if you want to take a look. Although it's obviously not as precise as a http://openjdk.java.net/projects/code-tools/jmh/[JMH] micro benchmark I think it's good enough to get a feel for the difference between the approaches. I ran a query against each database 100 times and then took the 50th, 75th and 99th percentiles (times are in ms): ~~~text Using a generic relationship type and then filtering by end node label 50%ile: 6.0 75%ile: 6.0 99%ile: 402.60999999999825 Using a generic relationship type and then filtering by relationship property 50%ile: 21.0 75%ile: 22.0 99%ile: 504.85999999999785 Using a generic relationship type and then filtering by end node label 50%ile: 4.0 75%ile: 4.0 99%ile: 145.65999999999931 Using a specific relationship type 50%ile: 0.0 75%ile: 1.0 99%ile: 25.749999999999872 ~~~ We can drill further into why there's a difference in the times for each of the approaches by profiling the equivalent cypher query. We'll start with the one which uses a specific relationship name +++<cite>+++Using a specific relationship type+++</cite>+++ ~~~cypher neo4j-sh (?)$ profile match (n) where id(n) = 0 match (n)-[:HAS_ADDRESS]\->() return count(n); +----------+ | count(n) | +----------+ | 10000 | +----------+ 1 row ColumnFilter | +EagerAggregation | +SimplePatternMatcher | +NodeByIdOrEmpty +----------------------+-------+--------+-----------------------------+-----------------------+ | Operator | Rows | DbHits | Identifiers | Other | +----------------------+-------+--------+-----------------------------+-----------------------+ | ColumnFilter | 1 | 0 | | keep columns count(n) | | EagerAggregation | 1 | 0 | | | | SimplePatternMatcher | 10000 | 10000 | n, UNNAMED53, UNNAMED35 | | | NodeByIdOrEmpty | 1 | 1 | n, n | { AUTOINT0} | +----------------------+-------+--------+-----------------------------+-----------------------+ Total database accesses: 10001 ~~~ Here we can see that there were 10,002 database accesses in order to get a count of our 10,000 HAS_ADDRESS relationships. We get a database access each time we load a node, relationship or property. By contrast the other approaches have to load in a lot more data only to then filter it out: +++<cite>+++Using a generic relationship type and then filtering by end node label+++</cite>+++ ~~~cypher neo4j-sh (?)$ profile match (n) where id(n) = 0 match (n)-[:HAS]\->(:Address) return count(n); +----------+ | count(n) | +----------+ | 10000 | +----------+ 1 row ColumnFilter | +EagerAggregation | +Filter | +SimplePatternMatcher | +NodeByIdOrEmpty +----------------------+-------+--------+-----------------------------+----------------------------------+ | Operator | Rows | DbHits | Identifiers | Other | +----------------------+-------+--------+-----------------------------+----------------------------------+ | ColumnFilter | 1 | 0 | | keep columns count(n) | | EagerAggregation | 1 | 0 | | | | Filter | 10000 | 10000 | | hasLabel( UNNAMED45:Address(0)) | | SimplePatternMatcher | 10000 | 60000 | n, UNNAMED45, UNNAMED35 | | | NodeByIdOrEmpty | 1 | 1 | n, n | { AUTOINT0} | +----------------------+-------+--------+-----------------------------+----------------------------------+ Total database accesses: 70001 ~~~ +++<cite>+++Using a generic relationship type and then filtering by relationship property+++</cite>+++ ~~~cypher neo4j-sh (?)$ profile match (n) where id(n) = 0 match (n)-[:HAS {type: "address"}]\->() return count(n); +----------+ | count(n) | +----------+ | 10000 | +----------+ 1 row ColumnFilter | +EagerAggregation | +Filter | +SimplePatternMatcher | +NodeByIdOrEmpty +----------------------+-------+--------+-----------------------------+--------------------------------------------------+ | Operator | Rows | DbHits | Identifiers | Other | +----------------------+-------+--------+-----------------------------+--------------------------------------------------+ | ColumnFilter | 1 | 0 | | keep columns count(n) | | EagerAggregation | 1 | 0 | | | | Filter | 10000 | 20000 | | Property( UNNAMED35,type(0)) == { AUTOSTRING1} | | SimplePatternMatcher | 10000 | 120000 | n, UNNAMED63, UNNAMED35 | | | NodeByIdOrEmpty | 1 | 1 | n, n | { AUTOINT0} | +----------------------+-------+--------+-----------------------------+--------------------------------------------------+ Total database accesses: 140001 ~~~ +++<cite>+++Using a generic relationship type and then filtering by end node property+++</cite>+++ ~~~cypher neo4j-sh (?)$ profile match (n) where id(n) = 0 match (n)-[:HAS]\->({type: "address"}) return count(n); +----------+ | count(n) | +----------+ | 10000 | +----------+ 1 row ColumnFilter | +EagerAggregation | +Filter | +SimplePatternMatcher | +NodeByIdOrEmpty +----------------------+-------+--------+-----------------------------+--------------------------------------------------+ | Operator | Rows | DbHits | Identifiers | Other | +----------------------+-------+--------+-----------------------------+--------------------------------------------------+ | ColumnFilter | 1 | 0 | | keep columns count(n) | | EagerAggregation | 1 | 0 | | | | Filter | 10000 | 20000 | | Property( UNNAMED45,type(0)) == { AUTOSTRING1} | | SimplePatternMatcher | 10000 | 120000 | n, UNNAMED45, UNNAMED35 | | | NodeByIdOrEmpty | 1 | 1 | n, n | { AUTOINT0} | +----------------------+-------+--------+-----------------------------+--------------------------------------------------+ Total database accesses: 140001 ~~~ So in summary\...specific relationships #ftw!

neo4j-genericvague-relationship-names

https://markhneedham.com/blog/2014/09/30/neo4j-genericvague-relationship-names

2014-09-30 22:20:05

R: A first attempt at linear regression

I've been working through http://www.dataschool.io/15-hours-of-expert-machine-learning-videos/[the videos that accompany the Introduction to Statistical Learning with Applications in R] book and thought it'd be interesting to try out the linear regression algorithm against my https://github.com/mneedham/neo4j-meetup[meetup data set]. I wanted to see how well a linear regression algorithm could predict how many people were likely to RSVP to a particular event. I started with the following code to build a data frame containing some potential predictors: [source,r] ---- library(RNeo4j) officeEventsQuery = "MATCH (g:Group {name: \"Neo4j - London User Group\"})-[:HOSTED_EVENT]->(event)<-[:TO]-({response: 'yes'})<-[:RSVPD]-(), (event)-[:HELD_AT]->(venue) WHERE (event.time + event.utc_offset) < timestamp() AND venue.name IN [\"Neo Technology\", \"OpenCredo\"] RETURN event.time + event.utc_offset AS eventTime,event.announced_at AS announcedAt, event.name, COUNT(*) AS rsvps" events = subset(cypher(graph, officeEventsQuery), !is.na(announcedAt)) events$eventTime <- timestampToDate(events$eventTime) events$day <- format(events$eventTime, "%A") events$monthYear <- format(events$eventTime, "%m-%Y") events$month <- format(events$eventTime, "%m") events$year <- format(events$eventTime, "%Y") events$announcedAt<- timestampToDate(events$announcedAt) events$timeDiff = as.numeric(events$eventTime - events$announcedAt, units = "days") ---- If we preview 'events' it contains the following columns: [source,r] ---- > head(events) eventTime announcedAt event.name rsvps day monthYear month year timeDiff 1 2013-01-29 18:00:00 2012-11-30 11:30:57 Intro to Graphs 24 Tuesday 01-2013 01 2013 60.270174 2 2014-06-24 18:30:00 2014-06-18 19:11:19 Intro to Graphs 43 Tuesday 06-2014 06 2014 5.971308 3 2014-06-18 18:30:00 2014-06-08 07:03:13 Neo4j World Cup Hackathon 24 Wednesday 06-2014 06 2014 10.476933 4 2014-05-20 18:30:00 2014-05-14 18:56:06 Intro to Graphs 53 Tuesday 05-2014 05 2014 5.981875 5 2014-02-11 18:00:00 2014-02-05 19:11:03 Intro to Graphs 35 Tuesday 02-2014 02 2014 5.950660 6 2014-09-04 18:30:00 2014-08-26 06:34:01 Hands On Intro to Cypher - Neo4j's Query Language 20 Thursday 09-2014 09 2014 9.497211 ---- We want to predict 'rsvps' from the other columns so I started off by creating a linear model which took all the other columns into account: [source,r] ---- > summary(lm(rsvps ~., data = events)) Call: lm(formula = rsvps ~ ., data = events) Residuals: Min 1Q Median 3Q Max -8.2582 -1.1538 0.0000 0.4158 10.5803 Coefficients: (14 not defined because of singularities) Estimate Std. Error t value Pr(>|t|) (Intercept) -9.365e+03 3.009e+03 -3.113 0.00897 ** eventTime 3.609e-06 2.951e-06 1.223 0.24479 announcedAt 3.278e-06 2.553e-06 1.284 0.22339 event.nameGraph Modelling - Do's and Don'ts 4.884e+01 1.140e+01 4.286 0.00106 ** event.nameHands on build your first Neo4j app for Java developers 3.735e+01 1.048e+01 3.562 0.00391 ** event.nameHands On Intro to Cypher - Neo4j's Query Language 2.560e+01 9.713e+00 2.635 0.02177 * event.nameIntro to Graphs 2.238e+01 8.726e+00 2.564 0.02480 * event.nameIntroduction to Graph Database Modeling -1.304e+02 4.835e+01 -2.696 0.01946 * event.nameLunch with Neo4j's CEO, Emil Eifrem 3.920e+01 1.113e+01 3.523 0.00420 ** event.nameNeo4j Clojure Hackathon -3.063e+00 1.195e+01 -0.256 0.80203 event.nameNeo4j Python Hackathon with py2neo's Nigel Small 2.128e+01 1.070e+01 1.989 0.06998 . event.nameNeo4j World Cup Hackathon 5.004e+00 9.622e+00 0.520 0.61251 dayTuesday 2.068e+01 5.626e+00 3.676 0.00317 ** dayWednesday 2.300e+01 5.522e+00 4.165 0.00131 ** monthYear01-2014 -2.350e+02 7.377e+01 -3.185 0.00784 ** monthYear02-2013 -2.526e+01 1.376e+01 -1.836 0.09130 . monthYear02-2014 -2.325e+02 7.763e+01 -2.995 0.01118 * monthYear03-2013 -4.605e+01 1.683e+01 -2.736 0.01805 * monthYear03-2014 -2.371e+02 8.324e+01 -2.848 0.01468 * monthYear04-2013 -6.570e+01 2.309e+01 -2.845 0.01477 * monthYear04-2014 -2.535e+02 8.746e+01 -2.899 0.01336 * monthYear05-2013 -8.672e+01 2.845e+01 -3.049 0.01011 * monthYear05-2014 -2.802e+02 9.420e+01 -2.975 0.01160 * monthYear06-2013 -1.022e+02 3.283e+01 -3.113 0.00897 ** monthYear06-2014 -2.996e+02 1.003e+02 -2.988 0.01132 * monthYear07-2014 -3.123e+02 1.054e+02 -2.965 0.01182 * monthYear08-2013 -1.326e+02 4.323e+01 -3.067 0.00976 ** monthYear08-2014 -3.060e+02 1.107e+02 -2.763 0.01718 * monthYear09-2013 NA NA NA NA monthYear09-2014 -3.465e+02 1.164e+02 -2.976 0.01158 * monthYear10-2012 2.602e+01 1.959e+01 1.328 0.20886 monthYear10-2013 -1.728e+02 5.678e+01 -3.044 0.01020 * monthYear11-2012 2.717e+01 1.509e+01 1.800 0.09704 . month02 NA NA NA NA month03 NA NA NA NA month04 NA NA NA NA month05 NA NA NA NA month06 NA NA NA NA month07 NA NA NA NA month08 NA NA NA NA month09 NA NA NA NA month10 NA NA NA NA month11 NA NA NA NA year2013 NA NA NA NA year2014 NA NA NA NA timeDiff NA NA NA NA --- Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1 Residual standard error: 5.287 on 12 degrees of freedom Multiple R-squared: 0.9585, Adjusted R-squared: 0.8512 F-statistic: 8.934 on 31 and 12 DF, p-value: 0.0001399 ---- As I understand it we can look at the R-squared value to understand how much of the variance in the data has been explained by the model - in this case it's 85%. A lot of the coefficients seem to be based around specific event names which seems a bit too specific to me so I wanted to see what would happen if I derived a feature which indicated whether a session was practical: [source,r] ---- events$practical = grepl("Hackathon|Hands on|Hands On", events$event.name) ---- We can now run the model again with the new column having excluded 'event.name' field: [source,r] ---- > summary(lm(rsvps ~., data = subset(events, select = -c(event.name)))) Call: lm(formula = rsvps ~ ., data = subset(events, select = -c(event.name))) Residuals: Min 1Q Median 3Q Max -18.647 -2.311 0.000 2.908 23.218 Coefficients: (13 not defined because of singularities) Estimate Std. Error t value Pr(>|t|) (Intercept) -3.980e+03 4.752e+03 -0.838 0.4127 eventTime 2.907e-06 3.873e-06 0.751 0.4621 announcedAt 3.336e-08 3.559e-06 0.009 0.9926 dayTuesday 7.547e+00 6.080e+00 1.241 0.2296 dayWednesday 2.442e+00 7.046e+00 0.347 0.7327 monthYear01-2014 -9.562e+01 1.187e+02 -0.806 0.4303 monthYear02-2013 -4.230e+00 2.289e+01 -0.185 0.8553 monthYear02-2014 -9.156e+01 1.254e+02 -0.730 0.4742 monthYear03-2013 -1.633e+01 2.808e+01 -0.582 0.5676 monthYear03-2014 -8.094e+01 1.329e+02 -0.609 0.5496 monthYear04-2013 -2.249e+01 3.785e+01 -0.594 0.5595 monthYear04-2014 -9.230e+01 1.401e+02 -0.659 0.5180 monthYear05-2013 -3.237e+01 4.654e+01 -0.696 0.4952 monthYear05-2014 -1.015e+02 1.509e+02 -0.673 0.5092 monthYear06-2013 -3.947e+01 5.355e+01 -0.737 0.4701 monthYear06-2014 -1.081e+02 1.604e+02 -0.674 0.5084 monthYear07-2014 -1.110e+02 1.678e+02 -0.661 0.5163 monthYear08-2013 -5.144e+01 6.988e+01 -0.736 0.4706 monthYear08-2014 -1.023e+02 1.784e+02 -0.573 0.5731 monthYear09-2013 -6.057e+01 7.893e+01 -0.767 0.4523 monthYear09-2014 -1.260e+02 1.874e+02 -0.672 0.5094 monthYear10-2012 9.557e+00 2.873e+01 0.333 0.7430 monthYear10-2013 -6.450e+01 9.169e+01 -0.703 0.4903 monthYear11-2012 1.689e+01 2.316e+01 0.729 0.4748 month02 NA NA NA NA month03 NA NA NA NA month04 NA NA NA NA month05 NA NA NA NA month06 NA NA NA NA month07 NA NA NA NA month08 NA NA NA NA month09 NA NA NA NA month10 NA NA NA NA month11 NA NA NA NA year2013 NA NA NA NA year2014 NA NA NA NA timeDiff NA NA NA NA practicalTRUE -9.388e+00 5.289e+00 -1.775 0.0919 . --- Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1 Residual standard error: 10.21 on 19 degrees of freedom Multiple R-squared: 0.7546, Adjusted R-squared: 0.4446 F-statistic: 2.434 on 24 and 19 DF, p-value: 0.02592 ---- Now we're only accounting for 44% of the variance and none of our coefficients are significant so this wasn't such a good change. I also noticed that we've got a bit of overlap in the date related features - we've got one column for monthYear and then separate ones for month and year. Let's strip out the combined one: [source,r] ---- > summary(lm(rsvps ~., data = subset(events, select = -c(event.name, monthYear)))) Call: lm(formula = rsvps ~ ., data = subset(events, select = -c(event.name, monthYear))) Residuals: Min 1Q Median 3Q Max -16.5745 -4.0507 -0.1042 3.6586 24.4715 Coefficients: (1 not defined because of singularities) Estimate Std. Error t value Pr(>|t|) (Intercept) -1.573e+03 4.315e+03 -0.364 0.7185 eventTime 3.320e-06 3.434e-06 0.967 0.3425 announcedAt -2.149e-06 2.201e-06 -0.976 0.3379 dayTuesday 4.713e+00 5.871e+00 0.803 0.4294 dayWednesday -2.253e-01 6.685e+00 -0.034 0.9734 month02 3.164e+00 1.285e+01 0.246 0.8075 month03 1.127e+01 1.858e+01 0.607 0.5494 month04 4.148e+00 2.581e+01 0.161 0.8736 month05 1.979e+00 3.425e+01 0.058 0.9544 month06 -1.220e-01 4.271e+01 -0.003 0.9977 month07 1.671e+00 4.955e+01 0.034 0.9734 month08 8.849e+00 5.940e+01 0.149 0.8827 month09 -5.496e+00 6.782e+01 -0.081 0.9360 month10 -5.066e+00 7.893e+01 -0.064 0.9493 month11 4.255e+00 8.697e+01 0.049 0.9614 year2013 -1.799e+01 1.032e+02 -0.174 0.8629 year2014 -3.281e+01 2.045e+02 -0.160 0.8738 timeDiff NA NA NA NA practicalTRUE -9.816e+00 5.084e+00 -1.931 0.0645 . --- Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1 Residual standard error: 10.19 on 26 degrees of freedom Multiple R-squared: 0.666, Adjusted R-squared: 0.4476 F-statistic: 3.049 on 17 and 26 DF, p-value: 0.005187 ---- Again none of the coefficients are statistically significant which is disappointing. I think the main problem may be that I have very few data points (only 42) making it difficult to come up with a general model. I think my next step is to look for some other features that could impact the number of RSVPs e.g. other events on that day, the weather. I'm a novice at this but trying to learn more so if you have any ideas of what I should do next please let me know.

r-a-first-attempt-at-linear-regression

https://markhneedham.com/blog/2014/09/30/r-a-first-attempt-at-linear-regression

2014-09-24 20:21:59

Neo4j: LOAD CSV - Column is null

One problem I've seen a few people have recently when using Neo4j's http://docs.neo4j.org/chunked/stable/query-load-csv.html[LOAD CSV] function is dealing with CSV files that have dodgy hidden characters at the beginning of the header line. For example, consider an import of this CSV file: [source,text] ---- $ cat ~/Downloads/dodgy.csv userId,movieId 1,2 ---- We might start by checking which columns it has: [source,cypher] ---- $ load csv with headers from "file:/Users/markneedham/Downloads/dodgy.csv" as line return line; +----------------------------------+ | line | +----------------------------------+ | {userId -> "1", movieId -> "2"} | +----------------------------------+ 1 row ---- Looks good so far but what about if we try to return just 'userId'? [source,cypher] ---- $ load csv with headers from "file:/Users/markneedham/Downloads/dodgy.csv" as line return line.userId; +-------------+ | line.userId | +-------------+ | <null> | +-------------+ 1 row ---- Hmmm it's null\...what about 'movieId'? [source,cypher] ---- $ load csv with headers from "file:/Users/markneedham/Downloads/dodgy.csv" as line return line.movieId; +--------------+ | line.movieId | +--------------+ | "2" | +--------------+ 1 row ---- That works fine so immediately we can suspect there are hidden characters at the beginning of the first line of the file. The easiest way to check if this is the case is open the file using a Hex Editor - I quite like http://ridiculousfish.com/hexfiend/[Hex Fiend] for the Mac. If we look at dodgy.csv we'll see the following: image::{{<siteurl>}}/uploads/2014/09/2014-09-24_21-20-06.png[2014 09 24 21 20 06,465] Let's delete the highlighted characters and try our cypher query again: [source,cypher] ---- $ load csv with headers from "file:/Users/markneedham/Downloads/dodgy.csv" as line return line.userId; +-------------+ | line.userId | +-------------+ | "1" | +-------------+ 1 row ---- All is well again, but something to keep in mind if you see a LOAD CSV near you behaving badly.

neo4j-load-csv-column-is-null

https://markhneedham.com/blog/2014/09/24/neo4j-load-csv-column-is-null

2014-09-13 11:41:39

R: ggplot - Plotting a single variable line chart (geom_line requires the following missing aesthetics: y)

I've been learning http://www.markhneedham.com/blog/2014/09/13/r-calculating-rolling-or-moving-averages/[how to do moving averages in R] and having done that calculation I wanted to plot these variables on a line chart using ggplot. The vector of rolling averages looked like this: [source,r] ---- > rollmean(byWeek$n, 4) [1] 3.75 2.00 1.25 1.00 1.25 1.25 1.75 1.75 1.75 2.50 2.25 2.75 3.50 2.75 2.75 [16] 2.25 1.50 1.50 2.00 2.00 2.00 2.00 1.25 1.50 2.25 2.50 3.00 3.25 2.75 4.00 [31] 4.25 5.25 7.50 6.50 5.75 5.00 3.50 4.00 5.75 6.25 6.25 6.00 5.25 6.25 7.25 [46] 7.75 7.00 4.75 2.75 1.75 2.00 4.00 5.25 5.50 11.50 11.50 12.75 14.50 12.50 11.75 [61] 11.00 9.25 5.25 4.50 3.25 4.75 7.50 8.50 9.25 10.50 9.75 15.25 16.00 15.25 15.00 [76] 10.00 8.50 6.50 4.25 3.00 4.25 4.75 7.50 11.25 11.00 11.50 10.00 6.75 11.25 12.50 [91] 12.00 11.50 6.50 8.75 8.50 8.25 9.50 8.50 8.75 9.50 8.00 4.25 4.50 7.50 9.00 [106] 12.00 19.00 19.00 22.25 23.50 22.25 21.75 19.50 20.75 22.75 22.75 24.25 28.00 23.00 26.00 [121] 24.25 21.50 26.00 24.00 28.25 25.50 24.25 31.50 31.50 35.75 35.75 29.00 28.50 27.25 25.50 [136] 27.50 26.00 23.75 ---- I initially tried to plot a line chart like this: [source,r] ---- library(ggplot2) library(zoo) rollingMean = rollmean(byWeek$n, 4) qplot(rollingMean) + geom_line() ---- which resulted in this error: [source,r] ---- stat_bin: binwidth defaulted to range/30. Use 'binwidth = x' to adjust this. Error: geom_line requires the following missing aesthetics: y ---- It turns out we need to provide an x and y value if we want to draw a line chart. In this case http://stackoverflow.com/questions/13837565/how-to-plot-one-variable-in-ggplot[we'll generate the 'x' value] - we only care that the y values get plotted in order from left to right: [source,r] ---- qplot(1:length(rollingMean), rollingMean, xlab ="Week Number") + geom_line() ---- image::{{<siteurl>}}/uploads/2014/09/2014-09-13_16-58-57.png[2014 09 13 16 58 57,600] If we want to use the 'ggplot' function then we need to put everything into a data frame first and then plot it: [source,r] ---- ggplot(data.frame(week = 1:length(rollingMean), rolling = rollingMean), aes(x = week, y = rolling)) + geom_line() ---- image::{{<siteurl>}}/uploads/2014/09/2014-09-13_17-11-13.png[2014 09 13 17 11 13,600]

r-ggplot-plotting-a-single-variable-line-chart-geom_line-requires-the-following-missing-aesthetics-y

https://markhneedham.com/blog/2014/09/13/r-ggplot-plotting-a-single-variable-line-chart-geom_line-requires-the-following-missing-aesthetics-y

2014-09-13 08:15:26

R: Calculating rolling or moving averages

I've been playing around with some time series data in R and since there's a bit of variation between consecutive points I wanted to smooth the data out by calculating the moving average. I struggled to find an in built function to do this but came across http://druedin.com/2012/08/11/moving-averages-in-r/[Didier Ruedin's blog post] which described the following function to do the job: [source,r] ---- mav <- function(x,n=5){filter(x,rep(1/n,n), sides=2)} ---- I tried plugging in some numbers to understand how it works: [source,r] ---- > mav(c(4,5,4,6), 3) Time Series: Start = 1 End = 4 Frequency = 1 [1] NA 4.333333 5.000000 NA ---- Here I was trying to do a rolling average which took into account the last 3 numbers so I expected to get just two numbers back - 4.333333 and 5 - and if there were going to be NA values I thought they'd be at the beginning of the sequence. In fact it turns out this is what the 'sides' parameter controls: [source,text] ---- sides for convolution filters only. If sides = 1 the filter coefficients are for past values only; if sides = 2 they are centred around lag 0. In this case the length of the filter should be odd, but if it is even, more of the filter is forward in time than backward. ---- So in our 'mav' function the rolling average looks both sides of the current value rather than just at past values. We can tweak that to get the behaviour we want: [source,r] ---- mav <- function(x,n=5){filter(x,rep(1/n,n), sides=1)} ---- [source,r] ---- > mav(c(4,5,4,6), 3) Time Series: Start = 1 End = 4 Frequency = 1 [1] NA NA 4.333333 5.000000 ---- The NA values are annoying for any plotting we want to do so let's get rid of them: [source,r] ---- > na.omit(mav(c(4,5,4,6), 3)) Time Series: Start = 3 End = 4 Frequency = 1 [1] 4.333333 5.000000 ---- Having got to this point I noticed that Didier had referenced the http://cran.r-project.org/web/packages/zoo/index.html[zoo] package in the comments and it has a built in function to take care of all this: [source,r] ---- > library(zoo) > rollmean(c(4,5,4,6), 3) [1] 4.333333 5.000000 ---- I also realised I can list all the functions in a package with the 'ls' function so I'll be scanning zoo's list of functions next time I need to do something time series related - there'll probably already be a function for it! [source,r] ---- > ls("package:zoo") [1] "as.Date" "as.Date.numeric" "as.Date.ts" [4] "as.Date.yearmon" "as.Date.yearqtr" "as.yearmon" [7] "as.yearmon.default" "as.yearqtr" "as.yearqtr.default" [10] "as.zoo" "as.zoo.default" "as.zooreg" [13] "as.zooreg.default" "autoplot.zoo" "cbind.zoo" [16] "coredata" "coredata.default" "coredata<-" [19] "facet_free" "format.yearqtr" "fortify.zoo" [22] "frequency<-" "ifelse.zoo" "index" [25] "index<-" "index2char" "is.regular" [28] "is.zoo" "make.par.list" "MATCH" [31] "MATCH.default" "MATCH.times" "median.zoo" [34] "merge.zoo" "na.aggregate" "na.aggregate.default" [37] "na.approx" "na.approx.default" "na.fill" [40] "na.fill.default" "na.locf" "na.locf.default" [43] "na.spline" "na.spline.default" "na.StructTS" [46] "na.trim" "na.trim.default" "na.trim.ts" [49] "ORDER" "ORDER.default" "panel.lines.its" [52] "panel.lines.tis" "panel.lines.ts" "panel.lines.zoo" [55] "panel.plot.custom" "panel.plot.default" "panel.points.its" [58] "panel.points.tis" "panel.points.ts" "panel.points.zoo" [61] "panel.polygon.its" "panel.polygon.tis" "panel.polygon.ts" [64] "panel.polygon.zoo" "panel.rect.its" "panel.rect.tis" [67] "panel.rect.ts" "panel.rect.zoo" "panel.segments.its" [70] "panel.segments.tis" "panel.segments.ts" "panel.segments.zoo" [73] "panel.text.its" "panel.text.tis" "panel.text.ts" [76] "panel.text.zoo" "plot.zoo" "quantile.zoo" [79] "rbind.zoo" "read.zoo" "rev.zoo" [82] "rollapply" "rollapplyr" "rollmax" [85] "rollmax.default" "rollmaxr" "rollmean" [88] "rollmean.default" "rollmeanr" "rollmedian" [91] "rollmedian.default" "rollmedianr" "rollsum" [94] "rollsum.default" "rollsumr" "scale_x_yearmon" [97] "scale_x_yearqtr" "scale_y_yearmon" "scale_y_yearqtr" [100] "Sys.yearmon" "Sys.yearqtr" "time<-" [103] "write.zoo" "xblocks" "xblocks.default" [106] "xtfrm.zoo" "yearmon" "yearmon_trans" [109] "yearqtr" "yearqtr_trans" "zoo" [112] "zooreg" ----

r-calculating-rolling-or-moving-averages

https://markhneedham.com/blog/2014/09/13/r-calculating-rolling-or-moving-averages

2014-08-11 16:47:35

R: Grouping by two variables

In my continued playing around with R and meetup data I wanted to group a data table by two variables - day and event - so I could see the most popular day of the week for meetups and which events we'd held on those days. I started off with the following data table: [source,r] ---- > head(eventsOf2014, 20) eventTime event.name rsvps datetime day monthYear 16 1.393351e+12 Intro to Graphs 38 2014-02-25 18:00:00 Tuesday 02-2014 17 1.403635e+12 Intro to Graphs 44 2014-06-24 18:30:00 Tuesday 06-2014 19 1.404844e+12 Intro to Graphs 38 2014-07-08 18:30:00 Tuesday 07-2014 28 1.398796e+12 Intro to Graphs 45 2014-04-29 18:30:00 Tuesday 04-2014 31 1.395772e+12 Intro to Graphs 56 2014-03-25 18:30:00 Tuesday 03-2014 41 1.406054e+12 Intro to Graphs 12 2014-07-22 18:30:00 Tuesday 07-2014 49 1.395167e+12 Intro to Graphs 45 2014-03-18 18:30:00 Tuesday 03-2014 50 1.401907e+12 Intro to Graphs 35 2014-06-04 18:30:00 Wednesday 06-2014 51 1.400006e+12 Intro to Graphs 31 2014-05-13 18:30:00 Tuesday 05-2014 54 1.392142e+12 Intro to Graphs 35 2014-02-11 18:00:00 Tuesday 02-2014 59 1.400611e+12 Intro to Graphs 53 2014-05-20 18:30:00 Tuesday 05-2014 61 1.390932e+12 Intro to Graphs 22 2014-01-28 18:00:00 Tuesday 01-2014 70 1.397587e+12 Intro to Graphs 47 2014-04-15 18:30:00 Tuesday 04-2014 7 1.402425e+12 Hands On Intro to Cypher - Neo4j's Query Language 38 2014-06-10 18:30:00 Tuesday 06-2014 25 1.397155e+12 Hands On Intro to Cypher - Neo4j's Query Language 28 2014-04-10 18:30:00 Thursday 04-2014 44 1.404326e+12 Hands On Intro to Cypher - Neo4j's Query Language 43 2014-07-02 18:30:00 Wednesday 07-2014 46 1.398364e+12 Hands On Intro to Cypher - Neo4j's Query Language 30 2014-04-24 18:30:00 Thursday 04-2014 65 1.400783e+12 Hands On Intro to Cypher - Neo4j's Query Language 26 2014-05-22 18:30:00 Thursday 05-2014 5 1.403203e+12 Hands on build your first Neo4j app for Java developers 34 2014-06-19 18:30:00 Thursday 06-2014 34 1.399574e+12 Hands on build your first Neo4j app for Java developers 28 2014-05-08 18:30:00 Thursday 05-2014 ---- I was able to work out the average number of RSVPs per day with the following code using plyr: [source,r] ---- > ddply(eventsOf2014, .(day=format(datetime, "%A")), summarise, count=length(datetime), rsvps=sum(rsvps), rsvpsPerEvent = rsvps / count) day count rsvps rsvpsPerEvent 1 Thursday 5 146 29.20000 2 Tuesday 13 504 38.76923 3 Wednesday 2 78 39.00000 ---- The next step was to show the names of events that happened on those days next to the row for that day. To do this we can make use of the http://stat.ethz.ch/R-manual/R-patched/library/base/html/paste.html[paste] function like so: [source,r] ---- > ddply(eventsOf2014, .(day=format(datetime, "%A")), summarise, events = paste(unique(event.name), collapse = ","), count=length(datetime), rsvps=sum(rsvps), rsvpsPerEvent = rsvps / count) day events count rsvps rsvpsPerEvent 1 Thursday Hands On Intro to Cypher - Neo4j's Query Language,Hands on build your first Neo4j app for Java developers 5 146 29.20000 2 Tuesday Intro to Graphs,Hands On Intro to Cypher - Neo4j's Query Language 13 504 38.76923 3 Wednesday Intro to Graphs,Hands On Intro to Cypher - Neo4j's Query Language 2 78 39.00000 ---- If we wanted to drill down further and see the number of RSVPs per day per event type then we could instead group by the day and event name: [source,r] ---- > ddply(eventsOf2014, .(day=format(datetime, "%A"), event.name), summarise, count=length(datetime), rsvps=sum(rsvps), rsvpsPerEvent = rsvps / count) day event.name count rsvps rsvpsPerEvent 1 Thursday Hands on build your first Neo4j app for Java developers 2 62 31.00000 2 Thursday Hands On Intro to Cypher - Neo4j's Query Language 3 84 28.00000 3 Tuesday Hands On Intro to Cypher - Neo4j's Query Language 1 38 38.00000 4 Tuesday Intro to Graphs 12 466 38.83333 5 Wednesday Hands On Intro to Cypher - Neo4j's Query Language 1 43 43.00000 6 Wednesday Intro to Graphs 1 35 35.00000 ---- There are too few data points for some of those to make any decisions but as we gather more data hopefully we'll see if there's a trend for people to come to events on certain days or not.

r-grouping-by-two-variables

https://markhneedham.com/blog/2014/08/11/r-grouping-by-two-variables

2014-08-29 00:25:33

R: Grouping by week, month, quarter

In my continued playing around with R and https://github.com/mneedham/neo4j-meetup[meetup data] I wanted to have a look at when people joined the London Neo4j group based on week, month or quarter of the year to see when they were most likely to do so. I started with the following query to get back the join timestamps: [source,r] ---- library(RNeo4j) query = "MATCH (:Person)-[:HAS_MEETUP_PROFILE]->()-[:HAS_MEMBERSHIP]->(membership)-[:OF_GROUP]->(g:Group {name: \"Neo4j - London User Group\"}) RETURN membership.joined AS joinTimestamp" meetupMembers = cypher(graph, query) > head(meetupMembers) joinTimestamp 1 1.376572e+12 2 1.379491e+12 3 1.349454e+12 4 1.383127e+12 5 1.372239e+12 6 1.330295e+12 ---- The first step was to get +++<cite>+++joinDate+++</cite>+++ into a nicer format that we can use in R more easily: [source,r] ---- timestampToDate <- function(x) as.POSIXct(x / 1000, origin="1970-01-01", tz = "GMT") meetupMembers$joinDate <- timestampToDate(meetupMembers$joinTimestamp) > head(meetupMembers) joinTimestamp joinDate 1 1.376572e+12 2013-08-15 13:13:40 2 1.379491e+12 2013-09-18 07:55:11 3 1.349454e+12 2012-10-05 16:28:04 4 1.383127e+12 2013-10-30 09:59:03 5 1.372239e+12 2013-06-26 09:27:40 6 1.330295e+12 2012-02-26 22:27:00 ---- Much better! I started off with grouping by month and quarter and http://stackoverflow.com/questions/6242955/converting-year-and-month-to-a-date-in-r[came across] the excellent http://cran.r-project.org/web/packages/zoo/index.html[zoo] library which makes it really easy to transform dates: [source,r] ---- library(zoo) meetupMembers$monthYear <- as.Date(as.yearmon(meetupMembers$joinDate)) meetupMembers$quarterYear <- as.Date(as.yearqtr(meetupMembers$joinDate)) > head(meetupMembers) joinTimestamp joinDate monthYear quarterYear 1 1.376572e+12 2013-08-15 13:13:40 2013-08-01 2013-07-01 2 1.379491e+12 2013-09-18 07:55:11 2013-09-01 2013-07-01 3 1.349454e+12 2012-10-05 16:28:04 2012-10-01 2012-10-01 4 1.383127e+12 2013-10-30 09:59:03 2013-10-01 2013-10-01 5 1.372239e+12 2013-06-26 09:27:40 2013-06-01 2013-04-01 6 1.330295e+12 2012-02-26 22:27:00 2012-02-01 2012-01-01 ---- The next step was to create a new data frame which grouped the data by those fields. I've been learning http://blog.rstudio.org/2014/01/17/introducing-dplyr/[dplyr] as part of https://www.udacity.com/course/ud651[Udacity's EDA course] so I thought I'd try and use that: [source,r] ---- > head(meetupMembers %.% group_by(monthYear) %.% summarise(n = n()), 20) monthYear n 1 2011-06-01 13 2 2011-07-01 4 3 2011-08-01 1 4 2011-10-01 1 5 2011-11-01 2 6 2012-01-01 4 7 2012-02-01 7 8 2012-03-01 11 9 2012-04-01 3 10 2012-05-01 9 11 2012-06-01 5 12 2012-07-01 16 13 2012-08-01 32 14 2012-09-01 14 15 2012-10-01 28 16 2012-11-01 31 17 2012-12-01 7 18 2013-01-01 52 19 2013-02-01 49 20 2013-03-01 22 ---- [source,r] ---- > head(meetupMembers %.% group_by(quarterYear) %.% summarise(n = n()), 20) quarterYear n 1 2011-04-01 13 2 2011-07-01 5 3 2011-10-01 3 4 2012-01-01 22 5 2012-04-01 17 6 2012-07-01 62 7 2012-10-01 66 8 2013-01-01 123 9 2013-04-01 139 10 2013-07-01 117 11 2013-10-01 94 12 2014-01-01 266 13 2014-04-01 359 14 2014-07-01 216 ---- Grouping by week number is a bit trickier but we can do it with a http://stackoverflow.com/questions/11395927/how-to-subset-data-frame-by-weeks-and-then-sum[bit of transformation] on our initial timestamp: [source,r] ---- meetupMembers$week <- as.Date("1970-01-01")+7*trunc((meetupMembers$joinTimestamp / 1000)/(3600*24*7)) > head(meetupMembers %.% group_by(week) %.% summarise(n = n()), 20) week n 1 2011-06-02 8 2 2011-06-09 4 3 2011-06-16 1 4 2011-06-30 2 5 2011-07-14 1 6 2011-07-21 1 7 2011-08-18 1 8 2011-10-13 1 9 2011-11-24 2 10 2012-01-05 1 11 2012-01-12 3 12 2012-02-09 1 13 2012-02-16 2 14 2012-02-23 4 15 2012-03-01 2 16 2012-03-08 3 17 2012-03-15 5 18 2012-03-29 1 19 2012-04-05 2 20 2012-04-19 1 ---- We can then plug that data frame into ggplot if we want to track membership sign up over time at different levels of granularity and create some bar charts of scatter plots depending on what we feel like!

r-grouping-by-week-month-quarter

https://markhneedham.com/blog/2014/08/29/r-grouping-by-week-month-quarter

2014-08-29 09:13:00

R: dplyr - group_by dynamic or programmatic field / variable (Error: index out of bounds)

In my http://www.markhneedham.com/blog/2014/08/29/r-grouping-by-week-month-quarter/[last blog post] I showed how to group timestamp based data by week, month and quarter and by the end we had the following code samples using http://cran.r-project.org/web/packages/dplyr/index.html[dplyr] and http://cran.r-project.org/web/packages/zoo/index.html[zoo]: [source,r] ---- library(RNeo4j) library(zoo) timestampToDate <- function(x) as.POSIXct(x / 1000, origin="1970-01-01", tz = "GMT") query = "MATCH (:Person)-[:HAS_MEETUP_PROFILE]->()-[:HAS_MEMBERSHIP]->(membership)-[:OF_GROUP]->(g:Group {name: \"Neo4j - London User Group\"}) RETURN membership.joined AS joinTimestamp" meetupMembers = cypher(graph, query) meetupMembers$joinDate <- timestampToDate(meetupMembers$joinTimestamp) meetupMembers$monthYear <- as.Date(as.yearmon(meetupMembers$joinDate)) meetupMembers$quarterYear <- as.Date(as.yearqtr(meetupMembers$joinDate)) meetupMembers %.% group_by(week) %.% summarise(n = n()) meetupMembers %.% group_by(monthYear) %.% summarise(n = n()) meetupMembers %.% group_by(quarterYear) %.% summarise(n = n()) ---- As you can see there's quite a bit of duplication going on - the only thing that changes in the last 3 lines is the name of the field that we want to group by. I wanted to pull this code out into a function and my first attempt was this: [source,r] ---- groupMembersBy = function(field) { meetupMembers %.% group_by(field) %.% summarise(n = n()) } ---- And now if we try to group by week: [source,r] ---- > groupMembersBy("week") Show Traceback Rerun with Debug Error: index out of bounds ---- It turns out if we want to do this then http://stackoverflow.com/questions/21815060/dplyr-how-to-use-group-by-inside-a-function[we actually want the +++<cite>+++regroup+++</cite>+++ function rather than +++<cite>+++group_by+++</cite>+++]: [source,r] ---- groupMembersBy = function(field) { meetupMembers %.% regroup(list(field)) %.% summarise(n = n()) } ---- And now if we group by week: [source,r] ---- > head(groupMembersBy("week"), 20) Source: local data frame [20 x 2] week n 1 2011-06-02 8 2 2011-06-09 4 3 2011-06-16 1 4 2011-06-30 2 5 2011-07-14 1 6 2011-07-21 1 7 2011-08-18 1 8 2011-10-13 1 9 2011-11-24 2 10 2012-01-05 1 11 2012-01-12 3 12 2012-02-09 1 13 2012-02-16 2 14 2012-02-23 4 15 2012-03-01 2 16 2012-03-08 3 17 2012-03-15 5 18 2012-03-29 1 19 2012-04-05 2 20 2012-04-19 1 ---- Much better!

r-dplyr-group_by-dynamic-or-programmatic-field-variable-error-index-out-of-bounds

https://markhneedham.com/blog/2014/08/29/r-dplyr-group_by-dynamic-or-programmatic-field-variable-error-index-out-of-bounds

2014-08-17 12:21:15

Ruby: Receive JSON in request body

I've been building a little http://www.sinatrarb.com/intro.html[Sinatra] app to play around with the Google Drive API and one thing I struggled with was processing JSON posted in the request body. I came across a few posts which suggested that the request body would be available as +++<cite>+++params['data']+++</cite>+++ or +++<cite>+++request['data']+++</cite>+++ but after trying several ways of sending a POST request that doesn't seem to be the case. I eventually came across http://stackoverflow.com/questions/17049569/how-to-parse-json-request-body-in-sinatra-just-once-and-expose-it-to-all-routes[this StackOverflow post] which shows how to do it: [source,ruby] ---- require 'sinatra' require 'json' post '/somewhere/' do request.body.rewind request_payload = JSON.parse request.body.read p request_payload "win" end ---- I can then POST to that endpoint and see the JSON printed back on the console: +++<cite>+++dummy.json+++</cite>+++ [source,json] ---- {"i": "am json"} ---- [source,bash] ---- $ curl -H "Content-Type: application/json" -XPOST http://localhost:9393/somewhere/ -d @dummy.json ---- [source,text] ---- {"i"=>"am json"} ---- Of course if I'd just http://www.sinatrarb.com/intro.html[RTFM] I could have found this out much more quickly!

ruby-receive-json-in-request-body

https://markhneedham.com/blog/2014/08/17/ruby-receive-json-in-request-body

2014-08-17 21:42:24

Ruby: Create and share Google Drive Spreadsheet

Over the weekend I've been trying to write some code to help me create and share a Google Drive spreadsheet and for the first bit Ihttp://www.markhneedham.com/blog/2014/08/17/ruby-google-drive-errorbadauthentication-googledriveauthenticationerror-infoinvalidsecondfactor/[started out with the Google Drive gem]. This worked reasonably well but that gem doesn't have an API for changing the permissions on a document so I ended up using the https://github.com/google/google-api-ruby-client[google-api-client] gem for that bit. https://developers.google.com/drive/web/quickstart/quickstart-ruby[This tutorial] provides a good quick start for getting up and running but it still has a manual step to copy/paste the 'OAuth token' which I wanted to get rid of. The first step is to create a project via the https://console.developers.google.com/project[Google Developers Console]. Once the project is created, click through to it and then click on 'credentials' on the left menu. Click on the "Create new Client ID" button to create the project credentials. You should see something like this on the right hand side of the screen: image::{{<siteurl>}}/uploads/2014/08/2014-08-17_16-29-39.png[2014 08 17 16 29 39,600] These are the credentials that we'll use in our code. Since I now have two libraries I need to satisfy the OAuth credentials for both, preferably without getting the user to go through the process twice. After a bit of trial and error I realised that it was easier to get the google-api-client to handle authentication and just pass in the token to the google-drive code. I wrote the following code using Sinatra to handle the OAuth authorisation with Google: [source,ruby] ---- require 'sinatra' require 'json' require "google_drive" require 'google/api_client' CLIENT_ID = 'my client id' CLIENT_SECRET = 'my client secret' OAUTH_SCOPE = 'https://www.googleapis.com/auth/drive https://docs.google.com/feeds/ https://docs.googleusercontent.com/ https://spreadsheets.google.com/feeds/' REDIRECT_URI = 'http://localhost:9393/oauth2callback' helpers do def partial (template, locals = {}) haml(template, :layout => false, :locals => locals) end end enable :sessions get '/' do haml :index end configure do google_client = Google::APIClient.new google_client.authorization.client_id = CLIENT_ID google_client.authorization.client_secret = CLIENT_SECRET google_client.authorization.scope = OAUTH_SCOPE google_client.authorization.redirect_uri = REDIRECT_URI set :google_client, google_client set :google_client_driver, google_client.discovered_api('drive', 'v2') end post '/login/' do client = settings.google_client redirect client.authorization.authorization_uri end get '/oauth2callback' do authorization_code = params['code'] client = settings.google_client client.authorization.code = authorization_code client.authorization.fetch_access_token! oauth_token = client.authorization.access_token session[:oauth_token] = oauth_token redirect '/' end ---- And this is the code for the index page: [source,haml] ---- %html %head %title Google Docs Spreadsheet %body .container %h2 Create Google Docs Spreadsheet %div - unless session['oauth_token'] %form{:name => "spreadsheet", :id => "spreadsheet", :action => "/login/", :method => "post", :enctype => "text/plain"} %input{:type => "submit", :value => "Authorise Google Account", :class => "button"} - else %form{:name => "spreadsheet", :id => "spreadsheet", :action => "/spreadsheet/", :method => "post", :enctype => "text/plain"} %input{:type => "submit", :value => "Create Spreadsheet", :class => "button"} ---- We initialise the Google API client inside the 'configure' block before each request gets handled and then from '/' the user can click a button which does a POST request to '/login/'. '/login/' redirects us to the OAuth authorisation URI where we select the Google account we want to use and login if necessary. We'll then get redirected back to '/oauth2callback' where we extract the authorisation code and then get an authorisation token. We'll store that token in the session so that we can use it later on. Now we need to create the spreadsheet and share that document with someone else: [source,ruby] ---- post '/spreadsheet/' do client = settings.google_client if session[:oauth_token] client.authorization.access_token = session[:oauth_token] end google_drive_session = GoogleDrive.login_with_oauth(session[:oauth_token]) spreadsheet = google_drive_session.create_spreadsheet(title = "foobar") ws = spreadsheet.worksheets[0] ws[2, 1] = "foo" ws[2, 2] = "bar" ws.save() file_id = ws.worksheet_feed_url.split("/")[-4] drive = settings.google_client_driver new_permission = drive.permissions.insert.request_schema.new({ 'value' => "some_other_email@gmail.com", 'type' => "user", 'role' => "reader" }) result = client.execute( :api_method => drive.permissions.insert, :body_object => new_permission, :parameters => { 'fileId' => file_id }) if result.status == 200 p result.data else puts "An error occurred: #{result.data['error']['message']}" end "spreadsheet created and shared" end ---- Here we create a spreadsheet with some arbitrary values using the google-drive gem before https://developers.google.com/drive/v2/reference/permissions/insert[granting permission] to a different email address than the one which owns it. I've given that other user read permission on the document. One other thing to keep in mind is which 'scopes' the OAuth authentication is for. If you authenticate for one URI and then try to do something against another one you'll get a 'http://geoffmcqueen.com/2010/03/14/token-invalid-authsub-token-has-wrong-scope-oauth-google-problem/[Token invalid - AuthSub token has wrong scope]' error.

ruby-create-and-share-google-drive-spreadsheet

https://markhneedham.com/blog/2014/08/17/ruby-create-and-share-google-drive-spreadsheet

2014-08-17 01:49:10

Ruby: Google Drive - Error=BadAuthentication (GoogleDrive::AuthenticationError) Info=InvalidSecondFactor

I've been using the https://github.com/gimite/google-drive-ruby[Google Drive gem] to try and interact with my Google Drive account and almost immediately ran into problems trying to login. I started out with the following code: [source,ruby] ---- require "rubygems" require "google_drive" session = GoogleDrive.login("me@mydomain.com", "mypassword") ---- I'll move it to use OAuth when I put it into my application but for spiking this approach works. Unfortunately I got the following error when running the script: [source,text] ---- /Users/markneedham/.rbenv/versions/1.9.3-p327/lib/ruby/gems/1.9.1/gems/google_drive-0.3.10/lib/google_drive/session.rb:93:in `rescue in login': Authentication failed for me@mydomain.com: Response code 403 for post https://www.google.com/accounts/ClientLogin: Error=BadAuthentication (GoogleDrive::AuthenticationError) Info=InvalidSecondFactor from /Users/markneedham/.rbenv/versions/1.9.3-p327/lib/ruby/gems/1.9.1/gems/google_drive-0.3.10/lib/google_drive/session.rb:86:in `login' from /Users/markneedham/.rbenv/versions/1.9.3-p327/lib/ruby/gems/1.9.1/gems/google_drive-0.3.10/lib/google_drive/session.rb:38:in `login' from /Users/markneedham/.rbenv/versions/1.9.3-p327/lib/ruby/gems/1.9.1/gems/google_drive-0.3.10/lib/google_drive.rb:18:in `login' from src/gdoc.rb:15:in `<main>' ---- Since I have two factor authentication enabled on my account https://github.com/gimite/google-drive-ruby/issues/40[it turns out] that I need to create an https://security.google.com/settings/security/apppasswords[app password] to login: image::{{<siteurl>}}/uploads/2014/08/2014-08-17_02-47-03.png[2014 08 17 02 47 03,600] It will then pop up with a password that we can use to login (I have revoked this one!): image::{{<siteurl>}}/uploads/2014/08/2014-08-17_02-46-29.png[2014 08 17 02 46 29,600] We can then use this password instead and everything works fine: [source,ruby] ---- require "rubygems" require "google_drive" session = GoogleDrive.login("me@mydomain.com", "tuceuttkvxbvrblf") ----

ruby-google-drive-errorbadauthentication-googledriveauthenticationerror-infoinvalidsecondfactor

https://markhneedham.com/blog/2014/08/17/ruby-google-drive-errorbadauthentication-googledriveauthenticationerror-infoinvalidsecondfactor

2014-08-31 22:10:42

R: ggplot - Cumulative frequency graphs

In my continued playing around with http://ggplot2.org/[ggplot] I wanted to create a chart showing the cumulative growth of the number of members of the http://www.meetup.com/graphdb-london/[Neo4j London meetup group]. My initial data frame looked like this: [source,r] ---- > head(meetupMembers) joinTimestamp joinDate monthYear quarterYear week dayMonthYear 1 1.376572e+12 2013-08-15 13:13:40 2013-08-01 2013-07-01 2013-08-15 2013-08-15 2 1.379491e+12 2013-09-18 07:55:11 2013-09-01 2013-07-01 2013-09-12 2013-09-18 3 1.349454e+12 2012-10-05 16:28:04 2012-10-01 2012-10-01 2012-10-04 2012-10-05 4 1.383127e+12 2013-10-30 09:59:03 2013-10-01 2013-10-01 2013-10-24 2013-10-30 5 1.372239e+12 2013-06-26 09:27:40 2013-06-01 2013-04-01 2013-06-20 2013-06-26 6 1.330295e+12 2012-02-26 22:27:00 2012-02-01 2012-01-01 2012-02-23 2012-02-26 ---- The first step was to transform the data so that I had a data frame where a row represented a day where a member joined the group. There would then be a count of how many members joined on that date. We can do this with dplyr like so: [source,r] ---- library(dplyr) > head(meetupMembers %.% group_by(dayMonthYear) %.% summarise(n = n())) Source: local data frame [6 x 2] dayMonthYear n 1 2011-06-05 7 2 2011-06-07 1 3 2011-06-10 1 4 2011-06-12 1 5 2011-06-13 1 6 2011-06-15 1 ---- To turn that into a chart we can plug it into ggplot and use the http://stat.ethz.ch/R-manual/R-devel/library/base/html/cumsum.html[cumsum] function to generate a line showing the cumulative total: [source,r] ---- ggplot(data = meetupMembers %.% group_by(dayMonthYear) %.% summarise(n = n()), aes(x = dayMonthYear, y = n)) + ylab("Number of members") + xlab("Date") + geom_line(aes(y = cumsum(n))) ---- image::{{<siteurl>}}/uploads/2014/08/2014-08-31_22-58-42.png[2014 08 31 22 58 42,600] Alternatively we could bring the call to cumsum forward and generate a data frame which has the cumulative total: [source,r] ---- > head(meetupMembers %.% group_by(dayMonthYear) %.% summarise(n = n()) %.% mutate(n = cumsum(n))) Source: local data frame [6 x 2] dayMonthYear n 1 2011-06-05 7 2 2011-06-07 8 3 2011-06-10 9 4 2011-06-12 10 5 2011-06-13 11 6 2011-06-15 12 ---- And if we plug that into ggplot we'll get the same curve as before: [source,r] ---- ggplot(data = meetupMembers %.% group_by(dayMonthYear) %.% summarise(n = n()) %.% mutate(n = cumsum(n)), aes(x = dayMonthYear, y = n)) + ylab("Number of members") + xlab("Date") + geom_line() ---- If we want the curve to be a bit smoother we can group it by quarter rather than by day: [source,r] ---- > head(meetupMembers %.% group_by(quarterYear) %.% summarise(n = n()) %.% mutate(n = cumsum(n))) Source: local data frame [6 x 2] quarterYear n 1 2011-04-01 13 2 2011-07-01 18 3 2011-10-01 21 4 2012-01-01 43 5 2012-04-01 60 6 2012-07-01 122 ---- Now let's plug that into ggplot: [source,r] ---- ggplot(data = meetupMembers %.% group_by(quarterYear) %.% summarise(n = n()) %.% mutate(n = cumsum(n)), aes(x = quarterYear, y = n)) + ylab("Number of members") + xlab("Date") + geom_line() ---- image::{{<siteurl>}}/uploads/2014/08/2014-08-31_23-08-24.png[2014 08 31 23 08 24,600]

r-ggplot-cumulative-frequency-graphs

https://markhneedham.com/blog/2014/08/31/r-ggplot-cumulative-frequency-graphs

2014-08-14 10:24:52

Where does r studio install packages/libraries?

As a newbie to R I wanted to look at the source code of some of the libraries/packages that I'd installed via R Studio which I initially struggled to do as I wasn't sure where the packages had been installed. I eventually came across http://stackoverflow.com/questions/15170399/changing-r-default-library-path-using-libpaths-in-rprofile-site-fails-to-work[a StackOverflow post] which described the +++<cite>+++http://stat.ethz.ch/R-manual/R-devel/library/base/html/libPaths.html[.libPaths]+++</cite>+++ function which tells us where that is: [source,r] ---- > .libPaths() [1] "/Library/Frameworks/R.framework/Versions/3.1/Resources/library" ---- If we want to see which libraries are installed we can use the +++<cite>+++http://stat.ethz.ch/R-manual/R-devel/library/base/html/list.files.html[list.files]+++</cite>+++ function: [source,r] ---- > list.files("/Library/Frameworks/R.framework/Versions/3.1/Resources/library") [1] "alr3" "assertthat" "base" "bitops" "boot" "brew" [7] "car" "class" "cluster" "codetools" "colorspace" "compiler" [13] "data.table" "datasets" "devtools" "dichromat" "digest" "dplyr" [19] "evaluate" "foreign" "formatR" "Formula" "gclus" "ggplot2" [25] "graphics" "grDevices" "grid" "gridExtra" "gtable" "hflights" [31] "highr" "Hmisc" "httr" "KernSmooth" "knitr" "labeling" [37] "Lahman" "lattice" "latticeExtra" "magrittr" "manipulate" "markdown" [43] "MASS" "Matrix" "memoise" "methods" "mgcv" "mime" [49] "munsell" "nlme" "nnet" "openintro" "parallel" "plotrix" [55] "plyr" "proto" "RColorBrewer" "Rcpp" "RCurl" "reshape2" [61] "RJSONIO" "RNeo4j" "Rook" "rpart" "rstudio" "scales" [67] "seriation" "spatial" "splines" "stats" "stats4" "stringr" [73] "survival" "swirl" "tcltk" "testthat" "tools" "translations" [79] "TSP" "utils" "whisker" "xts" "yaml" "zoo" ---- We can then drill into those directories to find the appropriate file - in this case I wanted to look at one of the http://cran.r-project.org/web/packages/Rook/Rook.pdf[Rook] examples: [source,text] ---- $ cat /Library/Frameworks/R.framework/Versions/3.1/Resources/library/Rook/exampleApps/helloworld.R app <- function(env){ req <- Rook::Request$new(env) res <- Rook::Response$new() friend <- 'World' if (!is.null(req$GET()[['friend']])) friend <- req$GET()[['friend']] res$write(paste('<h1>Hello',friend,'</h1>\n')) res$write('What is your name?\n') res$write('<form method="GET">\n') res$write('<input type="text" name="friend">\n') res$write('<input type="submit" name="Submit">\n</form>\n<br>') res$finish() } ----

where-does-r-studio-install-packageslibraries

https://markhneedham.com/blog/2014/08/14/where-does-r-studio-install-packageslibraries

2014-08-22 11:05:54

R: Rook - Hello world example - 'Cannot find a suitable app in file'

I've been playing around with the http://cran.r-project.org/web/packages/Rook/README.html[Rook] library and struggled a bit getting a basic Hello World application up and running so I thought I should document it for future me. I wanted to spin up a web server using Rook and serve a page with the text 'Hello World'. I https://docs.google.com/presentation/d/1AT8nQo6jrZ9SwPgdwqkHZI_2SeqGQormy-EWWmm_rlk/edit#slide=id.i112[started with the following code]: [source,r] ---- library(Rook) s <- Rhttpd$new() s$add(name='MyApp',app='helloworld.R') s$start() s$browse("MyApp") ---- where +++<cite>+++helloWorld.R+++</cite>+++ contained the following code: [source,r] ---- function(env){ list( status=200, headers = list( 'Content-Type' = 'text/html' ), body = paste('<h1>Hello World!</h1>') ) } ---- Unfortunately that failed on the 's$add' line with the following error message: [source,r] ---- > s$add(name='MyApp',app='helloworld.R') Error in .Object$initialize(...) : Cannot find a suitable app in file helloworld.R ---- I hadn't realised that you actually need to assign that function to a variable 'app' in order for it to be picked up: [source,r] ---- app <- function(env){ list( status=200, headers = list( 'Content-Type' = 'text/html' ), body = paste('<h1>Hello World!</h1>') ) } ---- Once I fixed that everything seemed to work as expected:s [source,r] ---- > s Server started on 127.0.0.1:27120 [1] MyApp http://127.0.0.1:27120/custom/MyApp Call browse() with an index number or name to run an application. ----

r-rook-hello-world-example-cannot-find-a-suitable-app-in-file

https://markhneedham.com/blog/2014/08/22/r-rook-hello-world-example-cannot-find-a-suitable-app-in-file

2014-08-22 12:51:36

Neo4j: LOAD CSV - Handling empty columns

A common problem that people encounter when trying to import CSV files into Neo4j using Cypher's http://docs.neo4j.org/chunked/stable/cypherdoc-importing-csv-files-with-cypher.html[LOAD CSV] command is how to handle empty or 'null' entries in said files. For example let's try and import the following file which has 3 columns, 1 populated, 2 empty: [source,text] ---- $ cat /tmp/foo.csv a,b,c mark,, ---- [source,cypher] ---- load csv with headers from "file:/tmp/foo.csv" as row MERGE (p:Person {a: row.a}) SET p.b = row.b, p.c = row.c RETURN p ---- When we execute that query we'll see that our Person node has properties 'b' and 'c' with no value: [source,cypher] ---- ==> +-----------------------------+ ==> | p | ==> +-----------------------------+ ==> | Node[5]{a:"mark",b:"",c:""} | ==> +-----------------------------+ ==> 1 row ==> Nodes created: 1 ==> Properties set: 3 ==> Labels added: 1 ==> 26 ms ---- That isn't what we want - we don't want those properties to be set unless they have a value. TO achieve this we need to introduce a conditional when setting the 'b' and 'c' properties. We'll assume that 'a' is always present as that's the key for our Person nodes. The following query will do what we want: [source,cypher] ---- load csv with headers from "file:/tmp/foo.csv" as row MERGE (p:Person {a: row.a}) FOREACH(ignoreMe IN CASE WHEN trim(row.b) <> "" THEN [1] ELSE [] END | SET p.b = row.b) FOREACH(ignoreMe IN CASE WHEN trim(row.c) <> "" THEN [1] ELSE [] END | SET p.c = row.c) RETURN p ---- Since there's no if or else statements in cypher we create our own conditional statement by using FOREACH. If there's a value in the CSV column then we'll loop once and set the property and if not we won't loop at all and therefore no property will be set. [source,cypher] ---- ==> +-------------------+ ==> | p | ==> +-------------------+ ==> | Node[4]{a:"mark"} | ==> +-------------------+ ==> 1 row ==> Nodes created: 1 ==> Properties set: 1 ==> Labels added: 1 ----

neo4j-load-csv-handling-empty-columns

https://markhneedham.com/blog/2014/08/22/neo4j-load-csv-handling-empty-columns

2014-01-27 11:32:03

Neo4j: org.eclipse.jetty.io.EofException - Caused by: java.io.IOException: Broken pipe

From scouring the Neo4j google group and Stack Overflow I've noticed that https://www.google.co.uk/search?q=neo4j+eofexception&oq=neo4j+eofexception&aqs=chrome..69i57.2370j0j4&sourceid=chrome&espv=210&es_sm=91&ie=UTF-8[a few people] have been hitting the following exception when executing queries against Neo4j server: [source,text] ---- SEVERE: The response of the WebApplicationException cannot be utilized as the response is already committed. Re-throwing to the HTTP container javax.ws.rs.WebApplicationException: javax.ws.rs.WebApplicationException: org.eclipse.jetty.io.EofException at org.neo4j.server.rest.repr.OutputFormat$1.write(OutputFormat.java:174) at com.sun.jersey.core.impl.provider.entity.StreamingOutputProvider.writeTo(StreamingOutputProvider.java:71) at com.sun.jersey.core.impl.provider.entity.StreamingOutputProvider.writeTo(StreamingOutputProvider.java:57) at com.sun.jersey.spi.container.ContainerResponse.write(ContainerResponse.java:306) at com.sun.jersey.server.impl.application.WebApplicationImpl._handleRequest(WebApplicationImpl.java:1437) at com.sun.jersey.server.impl.application.WebApplicationImpl.handleRequest(WebApplicationImpl.java:1349) at com.sun.jersey.server.impl.application.WebApplicationImpl.handleRequest(WebApplicationImpl.java:1339) at com.sun.jersey.spi.container.servlet.WebComponent.service(WebComponent.java:416) at com.sun.jersey.spi.container.servlet.ServletContainer.service(ServletContainer.java:537) at com.sun.jersey.spi.container.servlet.ServletContainer.service(ServletContainer.java:699) at javax.servlet.http.HttpServlet.service(HttpServlet.java:848) at org.eclipse.jetty.servlet.ServletHolder.handle(ServletHolder.java:698) at org.eclipse.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1506) at org.neo4j.server.rest.security.SecurityFilter.doFilter(SecurityFilter.java:112) at org.eclipse.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1477) at org.eclipse.jetty.servlet.ServletHandler.doHandle(ServletHandler.java:503) at org.eclipse.jetty.server.session.SessionHandler.doHandle(SessionHandler.java:211) at org.eclipse.jetty.server.handler.ContextHandler.doHandle(ContextHandler.java:1096) at org.eclipse.jetty.servlet.ServletHandler.doScope(ServletHandler.java:432) at org.eclipse.jetty.server.session.SessionHandler.doScope(SessionHandler.java:175) at org.eclipse.jetty.server.handler.ContextHandler.doScope(ContextHandler.java:1030) at org.eclipse.jetty.server.handler.ScopedHandler.handle(ScopedHandler.java:136) at org.eclipse.jetty.server.handler.HandlerList.handle(HandlerList.java:52) at org.eclipse.jetty.server.handler.HandlerWrapper.handle(HandlerWrapper.java:97) at org.eclipse.jetty.server.Server.handle(Server.java:445) at org.eclipse.jetty.server.HttpChannel.handle(HttpChannel.java:268) at org.eclipse.jetty.server.HttpConnection.onFillable(HttpConnection.java:229) at org.eclipse.jetty.io.AbstractConnection$ReadCallback.run(AbstractConnection.java:358) at org.eclipse.jetty.util.thread.QueuedThreadPool.runJob(QueuedThreadPool.java:601) at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:532) at java.lang.Thread.run(Thread.java:744) Caused by: javax.ws.rs.WebApplicationException: org.eclipse.jetty.io.EofException at org.neo4j.server.rest.repr.formats.StreamingJsonFormat$StreamingListWriter.writeValue(StreamingJsonFormat.java:316) at org.neo4j.server.rest.repr.ListWriter.writeValue(ListWriter.java:75) at org.neo4j.server.rest.repr.ValueRepresentation.addTo(ValueRepresentation.java:49) at org.neo4j.server.rest.repr.ListRepresentation.serialize(ListRepresentation.java:65) at org.neo4j.server.rest.repr.Serializer.serialize(Serializer.java:75) at org.neo4j.server.rest.repr.MappingSerializer.putList(MappingSerializer.java:61) at org.neo4j.server.rest.repr.ListRepresentation.putTo(ListRepresentation.java:85) at org.neo4j.server.rest.repr.ObjectRepresentation$PropertyGetter.putTo(ObjectRepresentation.java:133) at org.neo4j.server.rest.repr.ObjectRepresentation.serialize(ObjectRepresentation.java:144) at org.neo4j.server.rest.repr.MappingRepresentation.serialize(MappingRepresentation.java:41) at org.neo4j.server.rest.repr.OutputFormat$1.write(OutputFormat.java:160) ... 30 more Caused by: org.eclipse.jetty.io.EofException at org.eclipse.jetty.io.ChannelEndPoint.flush(ChannelEndPoint.java:186) at org.eclipse.jetty.io.WriteFlusher.write(WriteFlusher.java:335) at org.eclipse.jetty.io.AbstractEndPoint.write(AbstractEndPoint.java:125) at org.eclipse.jetty.server.HttpConnection$ContentCallback.process(HttpConnection.java:784) at org.eclipse.jetty.util.IteratingCallback.iterate(IteratingCallback.java:79) at org.eclipse.jetty.server.HttpConnection.send(HttpConnection.java:356) at org.eclipse.jetty.server.HttpChannel.sendResponse(HttpChannel.java:631) at org.eclipse.jetty.server.HttpChannel.write(HttpChannel.java:661) at org.eclipse.jetty.server.HttpOutput.write(HttpOutput.java:198) at com.sun.jersey.spi.container.servlet.WebComponent$Writer.write(WebComponent.java:307) at com.sun.jersey.spi.container.ContainerResponse$CommittingOutputStream.write(ContainerResponse.java:134) at org.codehaus.jackson.impl.Utf8Generator._flushBuffer(Utf8Generator.java:1754) at org.codehaus.jackson.impl.Utf8Generator.writeNumber(Utf8Generator.java:886) at org.codehaus.jackson.map.ser.StdSerializers$LongSerializer.serialize(StdSerializers.java:170) at org.codehaus.jackson.map.ser.StdSerializers$LongSerializer.serialize(StdSerializers.java:158) at org.codehaus.jackson.map.ser.StdSerializerProvider._serializeValue(StdSerializerProvider.java:610) at org.codehaus.jackson.map.ser.StdSerializerProvider.serializeValue(StdSerializerProvider.java:256) at org.codehaus.jackson.map.ObjectMapper.writeValue(ObjectMapper.java:1613) at org.codehaus.jackson.impl.JsonGeneratorBase.writeObject(JsonGeneratorBase.java:314) at org.neo4j.server.rest.repr.formats.StreamingJsonFormat$StreamingListWriter.writeValue(StreamingJsonFormat.java:312) ... 40 more Caused by: java.io.IOException: Broken pipe at sun.nio.ch.FileDispatcherImpl.writev0(Native Method) at sun.nio.ch.SocketDispatcher.writev(SocketDispatcher.java:51) at sun.nio.ch.IOUtil.write(IOUtil.java:148) at sun.nio.ch.SocketChannelImpl.write(SocketChannelImpl.java:524) at org.eclipse.jetty.io.ChannelEndPoint.flush(ChannelEndPoint.java:167) ... 59 more ---- I'd not come across it myself but the error message suggests that the client has closed the connection while the server is still trying to write out a response. This suggests that you need to write a query which runs for a long time. I created the following data set to try and force this to happen: [source,java] ---- public class DenseNodes { private static final DynamicRelationshipType FOO = DynamicRelationshipType.withName( "FOO" ); private static final Label BAR = DynamicLabel.label( "Bar" ); public static void main( String[] args ) throws IOException { String path = "/tmp/dense"; FileUtils.deleteRecursively( new File( path ) ); GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase( path ); for ( int i = 0; i < 10; i++ ) { try ( Transaction tx = db.beginTx() ) { Node node = db.createNode( BAR ); for ( int j = 0; j < 100_000; j++ ) { node.createRelationshipTo( db.createNode(), FOO ); } tx.success(); } } } } ---- This script creates 10 nodes with 100,000 relationships and as a by-product we have 1,000,000 nodes with 1 relationship. We can execute the following query using a Jersey client to take us over the timeout and force the EOFException: [source,java] ---- public class DenseMe { public static void main( String[] args ) throws IOException { String query = "MATCH (a:Bar)-[:`FOO`]->(b) RETURN a,b"; long start = System.currentTimeMillis(); executeViaHTTP( query ); long end = System.currentTimeMillis(); System.out.println(end - start); } private static void executeViaHTTP( String query ) throws IOException { ObjectNode entity = JsonNodeFactory.instance.objectNode(); entity.put("query", query ); ClientResponse response = client().resource( "http://localhost:7474/db/data/cypher" ) .accept( MediaType.APPLICATION_JSON_TYPE ) .type(MediaType.APPLICATION_JSON_TYPE) .post( ClientResponse.class, entity ); InputStream stream = response.getEntityInputStream(); BufferedReader reader = new BufferedReader( new InputStreamReader( stream ) ); char[] buffer = new char[1024]; int bytesRead; while ( (bytesRead = reader.read( buffer )) != -1 ) { for ( int i = 0; i < bytesRead; i++ ) { System.out.print( buffer[i] ); } } } private static Client client() { DefaultClientConfig defaultClientConfig = new DefaultClientConfig(); defaultClientConfig.getClasses().add( JacksonJsonProvider.class ); Client client = Client.create( defaultClientConfig ); return client; } } ---- There are two ways that we can attempt to work around this problem: . Increase the timeout on the Jersey Client . Stream the response to the client so we don't build up such a huge response on the server</p> </ol> + We'll start with the former, which requires the following tweak to the +++<cite>+++client+++</cite>+++ function: + ~~~java private static Client client() { DefaultClientConfig defaultClientConfig = new DefaultClientConfig(); defaultClientConfig.getClasses().add( JacksonJsonProvider.class ); Client client = Client.create( defaultClientConfig ); client.setConnectTimeout(1_000_000); client.setReadTimeout( 1_000_000 ); return client; } ~~~ + If we run that we'll end up with the following response using a 4GB heap: + ~~~text { "message" : "Java heap space", "exception" : "OutOfMemoryError", "fullname" : "java.lang.OutOfMemoryError", "stacktrace" : [ ] } ~~~ + I was tailing the GC logs while running the query and the majority of time was being spent in Full GC while the query was running: + ~~~text 2014-01-27T10:27:26.101+0000: 239848.812: Total time for which application threads were stopped: 5.5309550 seconds 2014-01-27T10:27:26.101+0000: 239848.812: [Full GC2014-01-27T10:27:26.101+0000: 239848.812: [CMS: 3512768K\->3512768K(3512768K), 5.4359920 secs] 4126207K\->4126207K(4126208K), [CMS Perm : 41512K\->41512K(69300K)], 5.4360820 secs] [Times: user=5.43 sys=0.00, real=5.43 secs] 2014-01-27T10:27:31.537+0000: 239854.249: [Full GC2014-01-27T10:27:31.537+0000: 239854.249: [CMS: 3512768K\->3512768K(3512768K), 5.4878690 secs] 4126207K\->4126207K(4126208K), [CMS Perm : 41512K\->41512K(69300K)], 5.4879470 secs] [Times: user=5.49 sys=0.01, real=5.49 secs] 2014-01-27T10:27:37.025+0000: 239859.737: Total time for which application threads were stopped: 10.9243140 seconds 2014-01-27T10:27:37.025+0000: 239859.737: [Full GC2014-01-27T10:27:37.025+0000: 239859.737: [CMS: 3512768K\->3512768K(3512768K), 5.4437040 secs] 4126207K\->4126207K(4126208K), [CMS Perm : 41512K\->41512K(69300K)], 5.4437790 secs] [Times: user=5.44 sys=0.01, real=5.44 secs] 2014-01-27T10:27:42.469+0000: 239865.181: [Full GC2014-01-27T10:27:42.469+0000: 239865.181: [CMS: 3512768K\->3512768K(3512768K), 5.4283480 secs] 4126207K\->4126207K(4126208K), [CMS Perm : 41512K\->41512K(69300K)], 5.4284400 secs] [Times: user=5.43 sys=0.00, real=5.43 secs] 2014-01-27T10:27:47.898+0000: 239870.609: Total time for which application threads were stopped: 10.8724950 seconds 2014-01-27T10:27:47.898+0000: 239870.609: [Full GC2014-01-27T10:27:47.898+0000: 239870.609: [CMS: 3512768K\->3512768K(3512768K), 5.4385630 secs] 4126208K\->4126207K(4126208K), [CMS Perm : 41512K\->41512K(69300K)], 5.4386540 secs] [Times: user=5.43 sys=0.01, real=5.44 secs] 2014-01-27T10:27:53.337+0000: 239876.048: Total time for which application threads were stopped: 5.4389110 seconds ~~~ + The second option is to http://docs.neo4j.org/chunked/stable/rest-api-streaming.html[stream back the response] by adding the following header to our request: + ~~~java ClientResponse response = client().resource( "http://localhost:7474/db/data/cypher" ) .accept( MediaType.APPLICATION_JSON_TYPE ) .type(MediaType.APPLICATION_JSON_TYPE) .header( "X-Stream", "true" ) .post( ClientResponse.class, entity ); ~~~ + If we do that then we'll get back the first rows of the query immediately although although we'll have to be careful with what we do with the response or we could see an OutOfMemory exception on the client instead. + We might also want to think whether we actually need to return that many rows in the first place. A lot of the time a subset is more than enough.

neo4j-org-eclipse-jetty-io-eofexception-caused-by-java-io-ioexception-broken-pipe

https://markhneedham.com/blog/2014/01/27/neo4j-org-eclipse-jetty-io-eofexception-caused-by-java-io-ioexception-broken-pipe

2014-01-27 09:42:18

Neo4j HA: org.neo4j.graphdb.TransactionFailureException: Timeout waiting for database to allow new transactions. Blocking components (1): []

As I http://www.markhneedham.com/blog/2014/01/24/neo4j-ha-election-could-not-pick-a-winner/[mentioned in my previous post], I've been spending quite a bit of time working with Neo4j HA and recently came across the following exception in +++<cite>+++data/graph.db/messages.log+++</cite>+++: [source,text] ---- org.neo4j.graphdb.TransactionFailureException: Timeout waiting for database to allow new transactions. Blocking components (1): [] at org.neo4j.kernel.ha.HighlyAvailableGraphDatabase.beginTx(HighlyAvailableGraphDatabase.java:199) at org.neo4j.kernel.TransactionBuilderImpl.begin(TransactionBuilderImpl.java:43) at org.neo4j.kernel.InternalAbstractGraphDatabase.beginTx(InternalAbstractGraphDatabase.java:949) at org.neo4j.server.rest.transactional.TransactionalRequestDispatcher.dispatch(TransactionalRequestDispatcher.java:52) at com.sun.jersey.server.impl.uri.rules.HttpMethodRule.accept(HttpMethodRule.java:288) at com.sun.jersey.server.impl.uri.rules.ResourceClassRule.accept(ResourceClassRule.java:108) at com.sun.jersey.server.impl.uri.rules.RightHandPathRule.accept(RightHandPathRule.java:147) at com.sun.jersey.server.impl.uri.rules.RootResourceClassesRule.accept(RootResourceClassesRule.java:84) at com.sun.jersey.server.impl.application.WebApplicationImpl._handleRequest(WebApplicationImpl.java:1469) at com.sun.jersey.server.impl.application.WebApplicationImpl._handleRequest(WebApplicationImpl.java:1400) at com.sun.jersey.server.impl.application.WebApplicationImpl.handleRequest(WebApplicationImpl.java:1349) at com.sun.jersey.server.impl.application.WebApplicationImpl.handleRequest(WebApplicationImpl.java:1339) at com.sun.jersey.spi.container.servlet.WebComponent.service(WebComponent.java:416) at com.sun.jersey.spi.container.servlet.ServletContainer.service(ServletContainer.java:537) at com.sun.jersey.spi.container.servlet.ServletContainer.service(ServletContainer.java:699) at javax.servlet.http.HttpServlet.service(HttpServlet.java:848) at org.eclipse.jetty.servlet.ServletHolder.handle(ServletHolder.java:698) at org.eclipse.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1506) at org.neo4j.server.rest.security.SecurityFilter.doFilter(SecurityFilter.java:112) at org.eclipse.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1477) at org.eclipse.jetty.servlet.ServletHandler.doHandle(ServletHandler.java:503) at org.eclipse.jetty.server.session.SessionHandler.doHandle(SessionHandler.java:211) at org.eclipse.jetty.server.handler.ContextHandler.doHandle(ContextHandler.java:1096) at org.eclipse.jetty.servlet.ServletHandler.doScope(ServletHandler.java:432) at org.eclipse.jetty.server.session.SessionHandler.doScope(SessionHandler.java:175) at org.eclipse.jetty.server.handler.ContextHandler.doScope(ContextHandler.java:1030) at org.eclipse.jetty.server.handler.ScopedHandler.handle(ScopedHandler.java:136) at org.eclipse.jetty.server.handler.HandlerList.handle(HandlerList.java:52) at org.eclipse.jetty.server.handler.HandlerWrapper.handle(HandlerWrapper.java:97) at org.eclipse.jetty.server.Server.handle(Server.java:445) at org.eclipse.jetty.server.HttpChannel.handle(HttpChannel.java:268) at org.eclipse.jetty.server.HttpConnection.onFillable(HttpConnection.java:229) at org.eclipse.jetty.io.AbstractConnection$ReadCallback.run(AbstractConnection.java:358) at org.eclipse.jetty.util.thread.QueuedThreadPool.runJob(QueuedThreadPool.java:601) at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:532) at java.lang.Thread.run(Thread.java:744) ---- I traced the error message back to https://github.com/neo4j/neo4j/blob/master/community/kernel/src/main/java/org/neo4j/kernel/AvailabilityGuard.java#L212[AvailabilityGuard#describeWhoIsBlocking] and discovered that this error message is thrown when we don't want the cluster to accept transactions. Usually the blocking component (the thing that's stopping transactions from being accepted) is described but in this case the error message indicates that the cluster hasn't been formed. I was able to reproduce the error message by trying to commit a transaction from a slave in a cluster which was misconfigured so that the slaves were unable to interact with the master. To find the root cause for this error message we need to scroll up the log a bit and look for the exception that happened immediately before this one. In this case we see the following: [source,text] ---- 2014-01-24 11:48:53.889+0000 WARN [o.n.k.h.c.HighAvailabilityModeSwitcher]: Consistency checker failed org.neo4j.com.ComException: MasterClient20 could not connect to /10.137.62.4:6001 at org.neo4j.com.Client$1.create(Client.java:141) ~[neo4j-com-2.0.0.jar:2.0.0] at org.neo4j.com.Client$1.create(Client.java:123) ~[neo4j-com-2.0.0.jar:2.0.0] at org.neo4j.com.ResourcePool.acquire(ResourcePool.java:175) ~[neo4j-com-2.0.0.jar:2.0.0] at org.neo4j.com.Client.getChannel(Client.java:336) ~[neo4j-com-2.0.0.jar:2.0.0] at org.neo4j.com.Client.sendRequest(Client.java:216) ~[neo4j-com-2.0.0.jar:2.0.0] at org.neo4j.kernel.ha.MasterClient20.getMasterIdForCommittedTx(MasterClient20.java:359) ~[neo4j-ha-2.0.0.jar:2.0.0] at org.neo4j.kernel.ha.cluster.HighAvailabilityModeSwitcher.checkDataConsistencyWithMaster(HighAvailabilityModeSwitcher.java:679) [neo4j-ha-2.0.0.jar:2.0.0] at org.neo4j.kernel.ha.cluster.HighAvailabilityModeSwitcher.checkDataConsistency(HighAvailabilityModeSwitcher.java:498) [neo4j-ha-2.0.0.jar:2.0.0] at org.neo4j.kernel.ha.cluster.HighAvailabilityModeSwitcher.access$900(HighAvailabilityModeSwitcher.java:110) [neo4j-ha-2.0.0.jar:2.0.0] at org.neo4j.kernel.ha.cluster.HighAvailabilityModeSwitcher$2.run(HighAvailabilityModeSwitcher.java:393) [neo4j-ha-2.0.0.jar:2.0.0] at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471) [na:1.7.0_51] at java.util.concurrent.FutureTask.run(FutureTask.java:262) [na:1.7.0_51] at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$201(ScheduledThreadPoolExecutor.java:178) [na:1.7.0_51] at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:292) [na:1.7.0_51] at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145) [na:1.7.0_51] at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615) [na:1.7.0_51] at java.lang.Thread.run(Thread.java:744) [na:1.7.0_51] ---- A quick configuration change was able to get me going again but you could also see this error message if firewall rules were misconfigured so that's something else to look out for.

neo4j-ha-org-neo4j-graphdb-transactionfailureexception-timeout-waiting-for-database-to-allow-new-transactions-blocking-components-1

https://markhneedham.com/blog/2014/01/27/neo4j-ha-org-neo4j-graphdb-transactionfailureexception-timeout-waiting-for-database-to-allow-new-transactions-blocking-components-1

2014-01-19 19:29:16

Neo4j Backup: java.lang.ClassCastException: org.jboss.netty.buffer.BigEndianHeapChannelBuffer cannot be cast to org.neo4j.cluster.com.message.Message

_(as Gabriel points out in the comments the ability to do a 'HA backup' doesn't exist in more recent versions of Neo4j. I'll leave this post here for people still running on older versions who encounter the error.)_ When using Neo4j's online backup facility there are two ways of triggering it, either by using the 'http://docs.neo4j.org/chunked/milestone/backup-embedded-and-server.html[single://]' or 'http://docs.neo4j.org/chunked/milestone/backup-ha.html[ha://]' syntax and these behave slightly differently. If you're using the 'single://' syntax and don't specify a port then it will connect to '6362' by default: [source,bash] ---- ./neo4j-backup -from single://192.168.1.34 -to /mnt/backup/neo4j-backup ---- If you've changed the backup port via the 'online_backup_server' property in +++<cite>+++conf/neo4j.properties+++</cite>+++ you'll need to set the port explicitly: [source,text] ---- online_backup_server=192.168.1.34:6363 ---- [source,bash] ---- ./neo4j-backup -from single://192.168.1.34:6363 -to /mnt/backup/neo4j-backup ---- If you're using the 'ha://' syntax then the backup client joins the HA cluster, works out which machine is the master and then creates a backup from that machine. In order for the backup client to join the cluster it connects to port '5001' by default: [source,bash] ---- ./neo4j-backup -from ha://192.168.1.34 -to /mnt/backup/neo4j-backup ---- If you've changed the 'ha.cluster_server' property then you'll need to set the port explicitly: [source,text] ---- ha.cluster_server=192.168.1.34:5002 ---- [source,bash] ---- ./neo4j-backup -from ha://192.168.1.34:5002 -to /mnt/backup/neo4j-backup ---- A mistake that I made when first using this utility was to use the 'ha://' syntax with the backup port. e.g. [source,bash] ---- ./neo4j-backup -from ha://192.168.1.34:6362 -to /mnt/backup/neo4j-backup ---- If you do this you'll end up with the following exception: [source,text] ---- 2014-01-19 19:24:30.842+0000 ERROR [o.n.c.c.NetworkSender]: Receive exception: java.lang.ClassCastException: org.jboss.netty.buffer.BigEndianHeapChannelBuffer cannot be cast to org.neo4j.cluster.com.message.Message at org.neo4j.cluster.com.NetworkSender$NetworkMessageSender.messageReceived(NetworkSender.java:409) ~[neo4j-cluster-2.0.0.jar:2.0.0] at org.jboss.netty.channel.Channels.fireMessageReceived(Channels.java:268) ~[netty-3.6.3.Final.jar:na] at org.jboss.netty.channel.Channels.fireMessageReceived(Channels.java:255) ~[netty-3.6.3.Final.jar:na] at org.jboss.netty.channel.socket.nio.NioWorker.read(NioWorker.java:88) ~[netty-3.6.3.Final.jar:na] at org.jboss.netty.channel.socket.nio.AbstractNioWorker.process(AbstractNioWorker.java:107) ~[netty-3.6.3.Final.jar:na] at org.jboss.netty.channel.socket.nio.AbstractNioSelector.run(AbstractNioSelector.java:312) ~[netty-3.6.3.Final.jar:na] at org.jboss.netty.channel.socket.nio.AbstractNioWorker.run(AbstractNioWorker.java:88) ~[netty-3.6.3.Final.jar:na] at org.jboss.netty.channel.socket.nio.NioWorker.run(NioWorker.java:178) ~[netty-3.6.3.Final.jar:na] at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145) [na:1.7.0_45] at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615) [na:1.7.0_45] at java.lang.Thread.run(Thread.java:744) [na:1.7.0_45] ---- Let me know in the comments if any of this doesn't make sense. There are lots of other examples to follow on http://docs.neo4j.org/chunked/milestone/re04.html[neo4j-backup's man page] in the manual as well.

neo4j-backup-java-lang-classcastexception-org-jboss-netty-buffer-bigendianheapchannelbuffer-cannot-be-cast-to-org-neo4j-cluster-com-message-message

https://markhneedham.com/blog/2014/01/19/neo4j-backup-java-lang-classcastexception-org-jboss-netty-buffer-bigendianheapchannelbuffer-cannot-be-cast-to-org-neo4j-cluster-com-message-message

2014-01-31 07:14:53

Neo4j 2.0.0: Cypher - Index Hints and Neo.ClientError.Schema.NoSuchIndex

One of the features added into the more recent versions of Neo4j's cypher query language is the ability to http://docs.neo4j.org/chunked/stable/query-using.html[tell Cypher which index you'd like to use in your queries]. We'll use the football dataset, so let's start by creating an index on the 'name' property of nodes labelled 'Player': [source,cypher] ---- CREATE INDEX ON :Player(name) ---- Let's say we want to write a query to find 'Wayne Rooney' while explicitly using this index. We might start with the following query: [source,cypher] ---- MATCH p USING INDEX p:Player(name) WHERE p.name = "Wayne Rooney" RETURN p ---- If we run that we'll see this error: [source,text] ---- Cannot use index hint in this context. The label and property comparison must be specified on a non-optional node Label: `Player` Property name: `name` Neo.ClientError.Schema.NoSuchIndex ---- We need to specify the label on the node in the 'MATCH' part of the query for our hint to work e.g. [source,cypher] ---- MATCH (p:Player) USING INDEX p:Player(name) WHERE p.name = "Wayne Rooney" RETURN p ---- Now we might decide that we want to find 'Wayne Rooney' or 'Robin Van Persie' so we change our query slightly: [source,cypher] ---- MATCH (p:Player) USING INDEX p:Player(name) WHERE p.name = "Wayne Rooney" OR p.name = "Robin Van Persie" RETURN p ---- But this one fails too! [source,cypher] ---- Cannot use index hint in this context. The label and property comparison must be specified on a non-optional node Label: `Player` Property name: `name` Neo.ClientError.Schema.NoSuchIndex ---- The problem here is that when you use 'OR' it's currently not using an index but rather a label scan so the hint to use the index doesn't make sense to Cypher. The final way I've seen people get confused using index hints is when matching node properties inline e.g. [source,cypher] ---- MATCH (p:Player {name: "Wayne Rooney"}) USING INDEX p:Player(name) RETURN p ---- If we run that we'll be back in the land of exceptions: [source,text] ---- Cannot use index hint in this context. The label and property comparison must be specified on a non-optional node Label: `Player` Property name: `name` Neo.ClientError.Schema.NoSuchIndex ---- We can work around that by pulling out the inline matching of the 'name' property": [source,cypher] ---- MATCH (p:Player) USING INDEX p:Player(name) WHERE p.name = "Wayne Rooney" RETURN p ----

neo4j-2-0-0-cypher-index-hints-and-neo-clienterror-schema-nosuchindex

https://markhneedham.com/blog/2014/01/31/neo4j-2-0-0-cypher-index-hints-and-neo-clienterror-schema-nosuchindex

2014-01-31 06:51:06

Java: Work out the serialVersionUID of a class

Earlier in the week I wanted to work out the +++<cite>+++serialVersionUID+++</cite>+++ of a serializable class so that I could override its +++<cite>+++toString+++</cite>+++ method without breaking everything. I came across http://betweengo.com/2005/07/30/serialver/[Frank Kim's blog post] which suggested using the +++<cite>+++serialver+++</cite>+++ tool which comes with the JDK. I created a little Maven project to test this tool out on a very simple class: [source,java] ---- import java.io.Serializable; public class SerialiseMe implements Serializable { } ---- If we compile that class into a JAR and then run the +++<cite>+++serialver+++</cite>+++ tool we see the following output: [source,bash] ---- $ serialver -classpath target/serialiser-0.0.1-SNAPSHOT.jar SerialiseMe SerialiseMe: static final long serialVersionUID = -6060222249255158490L; ---- I wanted to quickly confirm that I could serialise and deserialise this class using this value so I wrote the following bit of code to serialise the class (when it didn't have a serial version UID): [source,java] ---- public class Serialiser { public static void main( String[] args ) throws IOException, ClassNotFoundException { ByteArrayOutputStream bout = new ByteArrayOutputStream( ); ObjectOutputStream oout = new ObjectOutputStream( bout ); Object value = new SerialiseMe(); oout.writeObject( value ); oout.close(); byte[] bytes = bout.toByteArray(); FileOutputStream fileOuputStream = new FileOutputStream("/tmp/foo.txt"); fileOuputStream.write(bytes); fileOuputStream.close(); } } ---- After I'd done that, I wrote the following bit of code to deserialise the file: [source,java] ---- public class Deserialiser { public static void main( String[] args ) throws IOException, ClassNotFoundException { FileInputStream fileInputStream = new FileInputStream( new File( "/tmp/foo.txt" ) ); byte[] bytes = IOUtils.toByteArray( fileInputStream ); ByteArrayInputStream in = new ByteArrayInputStream( bytes, 0, bytes.length ); ObjectInputStream oin = new ObjectInputStream( in ); Object object = oin.readObject(); } } ---- I plugged the serial version UID into the class and was able to deserialise it correctly. I tried changing one of the digits just to check it would blow up and indeed it did: [source,java] ---- import java.io.Serializable; public class SerialiseMe implements Serializable { static final long serialVersionUID = -6060222249255158491L; } ---- [source,text] ---- Exception in thread "main" java.io.InvalidClassException: SerialiseMe; local class incompatible: stream classdesc serialVersionUID = -6060222249255158490, local class serialVersionUID = -6060222249255158491 at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:604) at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1620) at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1515) at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1769) at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1348) at java.io.ObjectInputStream.readObject(ObjectInputStream.java:370) at Deserialiser.main(Deserialiser.java:18) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:601) at com.intellij.rt.execution.application.AppMain.main(AppMain.java:120) ---- +++<cite>+++serialver+++</cite>+++ #ftw!

java-work-out-the-serialversionuid-of-a-class

https://markhneedham.com/blog/2014/01/31/java-work-out-the-serialversionuid-of-a-class

2014-01-31 23:59:58

Java: Handling a RuntimeException in a Runnable

At the end of last year I was playing around with http://www.markhneedham.com/blog/2013/11/17/java-schedule-a-job-to-run-on-a-time-interval/[running scheduled tasks to monitor a Neo4j cluster] and one of the problems I ran into was that the monitoring would sometimes exit. I eventually realised that this was because a RuntimeException was being thrown inside the Runnable method and I wasn't handling it. The following code demonstrates the problem: [source,java] ---- import java.util.ArrayList; import java.util.List; import java.util.concurrent.*; public class RunnableBlog { public static void main(String[] args) throws ExecutionException, InterruptedException { ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); executor.scheduleAtFixedRate(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis()); throw new RuntimeException("game over"); } }, 0, 1000, TimeUnit.MILLISECONDS).get(); System.out.println("exit"); executor.shutdown(); } } ---- If we run that code we'll see the RuntimeException but the executor won't exit because the thread died without informing it: [source,text] ---- Exception in thread "main" pool-1-thread-1 -> 1391212558074 java.util.concurrent.ExecutionException: java.lang.RuntimeException: game over at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:252) at java.util.concurrent.FutureTask.get(FutureTask.java:111) at RunnableBlog.main(RunnableBlog.java:11) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:601) at com.intellij.rt.execution.application.AppMain.main(AppMain.java:120) Caused by: java.lang.RuntimeException: game over at RunnableBlog$1.run(RunnableBlog.java:16) at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471) at java.util.concurrent.FutureTask$Sync.innerRunAndReset(FutureTask.java:351) at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:178) at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:178) at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:293) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603) at java.lang.Thread.run(Thread.java:722) ---- At the time I ended up adding a try catch block and printing the exception like so: [source,java] ---- public class RunnableBlog { public static void main(String[] args) throws ExecutionException, InterruptedException { ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); executor.scheduleAtFixedRate(new Runnable() { @Override public void run() { try { System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis()); throw new RuntimeException("game over"); } catch (RuntimeException e) { e.printStackTrace(); } } }, 0, 1000, TimeUnit.MILLISECONDS).get(); System.out.println("exit"); executor.shutdown(); } } ---- This allows the exception to be recognised and as far as I can tell means that the thread executing the Runnable doesn't die. [source,text] ---- java.lang.RuntimeException: game over pool-1-thread-1 -> 1391212651955 at RunnableBlog$1.run(RunnableBlog.java:16) at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471) at java.util.concurrent.FutureTask$Sync.innerRunAndReset(FutureTask.java:351) at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:178) at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:178) at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:293) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603) at java.lang.Thread.run(Thread.java:722) pool-1-thread-1 -> 1391212652956 java.lang.RuntimeException: game over at RunnableBlog$1.run(RunnableBlog.java:16) at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471) at java.util.concurrent.FutureTask$Sync.innerRunAndReset(FutureTask.java:351) at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:178) at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:178) at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:293) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603) at java.lang.Thread.run(Thread.java:722) pool-1-thread-1 -> 1391212653955 java.lang.RuntimeException: game over at RunnableBlog$1.run(RunnableBlog.java:16) at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471) at java.util.concurrent.FutureTask$Sync.innerRunAndReset(FutureTask.java:351) at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:178) at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:178) at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:293) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603) at java.lang.Thread.run(Thread.java:722) ---- This worked well and allowed me to keep monitoring the cluster. However, I recently started reading 'http://www.amazon.co.uk/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601[Java Concurrency in Practice]' (only 6 years after I bought it!) and realised that this might not be the proper way of handling the RuntimeException. <p.The authors suggest the proper way of handling an exception is to let the thread die but inform the framework that it's died so another thread can be spun up in its place. We end up with the following code instead: ~~~java public class RunnableBlog { public static void main(String[] args) throws ExecutionException, InterruptedException { ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); executor.scheduleAtFixedRate(new Runnable() { @Override public void run() { try { System.out.println(Thread.currentThread().getName() + " \-> " + System.currentTimeMillis()); throw new RuntimeException("game over"); } catch (RuntimeException e) { Thread t = Thread.currentThread(); t.getUncaughtExceptionHandler().uncaughtException(t, e); } } }, 0, 1000, TimeUnit.MILLISECONDS).get(); System.out.println("exit"); executor.shutdown(); } } ~~~ I don't see much difference between the two approaches so it'd be great if someone could explain to me why this approach is better than my previous one of catching the exception and printing the stack trace.

java-handling-a-runtimeexception-in-a-runnable

https://markhneedham.com/blog/2014/01/31/java-handling-a-runtimeexception-in-a-runnable

2014-01-31 22:41:57

Neo4j 2.0.0: Optimising a football query

A couple of months ago I wrote a blog post explaining http://www.markhneedham.com/blog/2013/11/08/neo4j-2-0-0-m06-applying-wes-freemans-cypher-optimisation-tricks/[how I'd applied Wes Freeman's Cypher optimisation patterns to a query] - since then Neo4j 2.0.0 has been released and I've extended the model so I thought I'd try again. The updated model looks like this: image::{{<siteurl>}}/uploads/2014/01/2014-01-31_22-25-20.png[2014 01 31 22 25 20,600] The query is similar to before - I want to calculate the top away goal scorers in the 2012-2013 season. I started off with this: [source,cypher] ---- MATCH (game)<-[:contains_match]-(season:Season), (team)<-[:away_team]-(game), (stats)-[:in]->(game), (team)<-[:for]-(stats)<-[:played]-(player) WHERE season.name = "2012-2013" RETURN player.name, COLLECT(DISTINCT team.name), SUM(stats.goals) as goals ORDER BY goals DESC LIMIT 10 ---- When I executed this query https://github.com/mneedham/cypher-query-tuning[using my Python query tuning tool] and the average time was 3.31 seconds. I separated the MATCH statements into smaller individual statements just to see what would happen: [source,cypher] ---- MATCH (game)<-[:contains_match]-(season:Season) MATCH (team)<-[:away_team]-(game) MATCH (stats)-[:in]->(game) MATCH (team)<-[:for]-(stats)<-[:played]-(player) WHERE season.name = "2012-2013" RETURN player.name, COLLECT(DISTINCT team.name), SUM(stats.goals) as goals ORDER BY goals DESC LIMIT 10 ---- That reduced the time to 178 milliseconds which is quite a nice improvement for so little effort. As I understand it, this is down to the traversal matcher handling smaller patterns more effectively than it handles longer patterns. The next step was to move the WHERE clause up so that it filtered out rows right at the beginning of the query rather than letting them hang around for another 3 MATCH statements: [source,cypher] ---- MATCH (game)<-[:contains_match]-(season:Season) WHERE season.name = "2012-2013" MATCH (team)<-[:away_team]-(game) MATCH (stats)-[:in]->(game) MATCH (team)<-[:for]-(stats)<-[:played]-(player) RETURN player.name, COLLECT(DISTINCT team.name), SUM(stats.goals) as goals ORDER BY goals DESC LIMIT 10 ---- That took the time down to 131 milliseconds. At this stage I also tried putting the 'MATCH (team)\<-[:away_team]-(game)' line first to see what would happen. [source,cypher] ---- MATCH (team)<-[:away_team]-(game) MATCH (game)<-[:contains_match]-(season:Season) WHERE season.name = "2012-2013" MATCH (stats)-[:in]->(game) MATCH (team)<-[:for]-(stats)<-[:played]-(player) RETURN player.name, COLLECT(DISTINCT team.name), SUM(stats.goals) as goals ORDER BY goals DESC LIMIT 10 ---- I expected it to be a bit slower since we were now keeping around more games than necessary again and as expected the time rose to 172 milliseconds - slightly quicker than our first attempt at tweaking. I reverted that change and realised that there would be a lot of 'stats' nodes which didn't have any goals associated with them and would therefore have a 'goals' property value of 0. I tried filtering those nodes out before the 'SUM' part of the query: [source,cypher] ---- MATCH (game)<-[:contains_match]-(season:Season) WHERE season.name = "2012-2013" MATCH (team)<-[:away_team]-(game) MATCH (stats)-[:in]->(game) MATCH (team)<-[:for]-(stats)<-[:played]-(player) WHERE stats.goals > 0 RETURN player.name, COLLECT(DISTINCT team.name), SUM(stats.goals) as goals ORDER BY goals DESC LIMIT 10 ---- This proved to be a very good optimisation - the time reduced to 47 milliseconds, an improvement of almost 3x on the previous optimisation and 63x quicker than the original query. The main optimisation pattern used here was reducing the number of rows being passed through the query. Ideally you don't want to be passing unnecessary rows through each stage of the query - rows can be filtered out either by using more specific MATCH clauses or in this case by a WHERE clause. Wes and I presented http://vimeo.com/84900121[a webinar on Cypher query optimisation] last week which so if you want to learn more about tuning queries that might be worth a watch.

neo4j-2-0-0-optimising-a-football-query

https://markhneedham.com/blog/2014/01/31/neo4j-2-0-0-optimising-a-football-query

2014-01-24 10:30:41

Neo4j HA: Election could not pick a winner

Recently I've been spending a reasonable chunk of my time helping people get up and running with their http://docs.neo4j.org/chunked/stable/ha-setup-tutorial.html[Neo4j High Availability cluster] and there's sometimes confusion around how it should be configured. A Neo4j cluster typically consists of a master and two slaves and you'd usually have it configured so that any machine can be the master. However, there is a http://docs.neo4j.org/chunked/stable/ha-configuration.html[configuration parameter] 'ha.slave_only' which can be set to 'true' to ensure that a machine will never be elected as master when an election takes place. We might configure our machine with that setting if it's acting as a reporting instance but we need to make sure that 2 members don't have that setting otherwise we won't have any failover in the cluster. For example, if we set two of the machines in the cluster to be slave only and then stop the master we'll see output similar to the following in +++<cite>+++data/graph.db/messages.log+++</cite>+++: [source,text] ---- 2014-01-23 11:17:24.510+0000 INFO [o.n.c.p.a.m.MultiPaxosContext$ElectionContextImpl]: Doing elections for role coordinator 2014-01-23 11:17:24.510+0000 DEBUG [o.n.c.p.e.ElectionState$2]: ElectionState: election-[performRoleElections]->election from:cluster://10.239.8.251:5001 conversation-id:3/13# 2014-01-23 11:17:24.513+0000 DEBUG [o.n.c.p.e.ElectionState$2]: ElectionState: election-[vote:coordinator]->election from:cluster://10.151.24.237:5001 conversation-id:3/13# 2014-01-23 11:17:24.515+0000 DEBUG [o.n.c.p.e.ElectionState$2]: ElectionState: election-[voted]->election from:cluster://10.138.29.197:5001 conversation-id:3/13# 2014-01-23 11:17:24.516+0000 DEBUG [o.n.c.p.e.ElectionState$2]: ElectionState: election-[voted]->election from:cluster://10.151.24.237:5001 conversation-id:3/13# 2014-01-23 11:17:24.519+0000 DEBUG [o.n.c.p.a.m.MultiPaxosContext$ElectionContextImpl$2]: Elections ended up with list [] 2014-01-23 11:17:24.519+0000 WARN [o.n.c.p.e.ElectionState]: Election could not pick a winner ---- This message initially looks confusing but what it's telling us is that the cluster was unable to elect a new master, in this case because there were no machines that could be elected as master. So if you see that message in your logs, check your config to make sure that there are actually machines to choose from.

neo4j-ha-election-could-not-pick-a-winner

https://markhneedham.com/blog/2014/01/24/neo4j-ha-election-could-not-pick-a-winner

2014-01-12 17:44:46

Learning about bitmaps

A few weeks ago https://twitter.com/apcj[Alistair] and I were working on the code used to model the http://docs.neo4j.org/chunked/milestone/graphdb-neo4j-labels.html[labels] that a node has attached to it in a Neo4j database. The way this works is that chunks of 32 nodes ids are represented as a 32 bit http://en.wikipedia.org/wiki/Bitmap[bitmap] for each label where a 1 for a bit means that a node has the label and a 0 means that it doesn't. For example, let's say we have node ids 0-31 where 0 is the highest bit and 31 is the lowest bit. If only node 0 has the label then that'd be represented as the following value: [source,java] ---- java> int bitmap = 1 << 31; int bitmap = -2147483648 ---- If we imagine the 32 bits positioned next to each other it would http://www.binaryconvert.com/convert_signed_int.html[look like this]: image::{{<siteurl>}}/uploads/2014/01/2014-01-12_15-45-16.png[2014 01 12 15 45 16,600] [source,java] ---- java> 0X80000000; Integer res16 = -2147483648 ---- The next thing we want to do is work out whether a node has a label applied or not. We can do this by using a bitwise AND. For example to check whether the highest bit is set we would write the following code: [source,java] ---- java> bitmap & (1 << 31); Integer res10 = -2147483648 ---- That is set as we would imagine. Now let's check a a few bits that we know aren't set: [source,java] ---- java> bitmap & (1 << 0); Integer res11 = 0 java> bitmap & (1 << 1); Integer res12 = 0 java> bitmap & (1 << 30); Integer res13 = 0 ---- Another operation we might want to do is set another bit on our existing bitmap for which we can use a bitwise inclusive OR. A bitwise inclusive OR means that a bit will be set if either value has the bit set or if both have it set. Let's set the second highest bit. and visualise that calculation: image::{{<siteurl>}}/uploads/2014/01/2014-01-12_15-45-161.png[2014 01 12 15 45 16,600] If we evaluate that we'd expect the two highest bits to be set: [source,java] ---- java> bitmap |= (1 << 30); Integer res14 = -1073741824 ---- Now if we visualise the bitmap we'll see that is indeed the case: image::{{<siteurl>}}/uploads/2014/01/2014-01-12_17-16-21.png[2014 01 12 17 16 21,600] [source,java] ---- java> 0XC0000000; Integer res15 = -1073741824 ---- The next operation we want to do is to unset a bit that we're already set for which we can use a bitwise exclusive OR. An exclusive OR means that a bit will only remain set if there's a combination of (0 and 1) or (1 and 0) in the calculation. If there are two 1's or 2 0's then it'll be unset. Let's unset the 2nd highest bit so that we're left with just the top bit being set. If we visualise that we have the following calculation: image::{{<siteurl>}}/uploads/2014/01/2014-01-12_17-33-21.png[2014 01 12 17 33 21,600] And if we evaluate that we're back to our original bitmap: [source,java] ---- java> bitmap ^= (1 << 30); Integer res2 = -2147483648 ---- I used the http://www.javarepl.com/console.html[Java REPL] to evaluate the code samples in this post and http://www.roseindia.net/java/master-java/bitwise-bitshift-operators.shtml[this article explains bitshift operators very clearly]. The Neo4j version of the bitmap described in this post is in the https://github.com/neo4j/neo4j/blob/master/community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/index/bitmaps/BitmapFormat.java[BitmapFormat] class on github.

learning-about-bitmaps

https://markhneedham.com/blog/2014/01/12/learning-about-bitmaps