Cypher query on variable length path with specified end point - neo4j

Question

My graph model holds information on data lineage and how data moves from one column to another through column mappings in our ETL tool. A basic one hop pattern would look like this...
(source:Column)-[:SOURCE_OF_MAPPING]->(map:ColumnMapping)-[:TARGET_OF_MAPPING]->(target:Column)
so
source might be a column called "STAGING_TABLE_1.FULL_NAME",
target might be a column called "STAGING_TABLE_2.FULL_NAME" and
map would be whatever was specified in the select query within the ETL tool's dataflow. Perhaps something like "UPPER(STAGING_TABLE_1.FULL_NAME || STAGING_TABLE_1.TITLE)"
What I need to be able to do is say if I look at a specific target column, lets say "DATA_MART_FACT_1.FULL_NAME", from which column does this data originate from?
The following is the cypher query I am trying to use but this only pulls back a single hop, i.e. the source and column mapping where the target is "DATA_MART_FACT_1.FULL_NAME".
MATCH (source:Column)-[:SOURCE_OF_MAPPING*]->(c:ColumnMapping)-[:TARGET_OF_MAPPING*]->(target:Column)
WHERE target.name = 'DATA_MART_FACT_1.FULL_NAME'
RETURN source, target, c
I have tried removing the relationship names, and just having an asterisk in the square brackets, but this just kills my neo4j installation (Currently sitting at 5GB memory and 50% CPU usage and hanging for around 10 minutes). There are constraints on all of the unique properties.
I know the data contains what I need because in the neo4j browser I can expand the nodes and follow the path through as I would expect to be able. Can anyone provide me with a cypher query that will allow me to do this? Perhaps my graph model needs a slight refactor in terms of relationship names and directions to allow this to work, which I'm perfectly happy to explore.
Here is some cypher to generate a basic example.
CREATE
(_0:`Column` {`name`:"STAGING_TABLE_1.FULL_NAME"}),
(_1:`Column` {`name`:"STAGING_TABLE_2.FULL_NAME"}),
(_2:`Column` {`name`:"DATA_MART_FACT_1.FULL_NAME"}),
(_3:`ColumnMapping` {`mappingText`:"UPPER(STAGING_TABLE_1.FULL_NAME)"}),
(_4:`ColumnMapping` {`mappingText`:"LOWER(STAGING_TABLE_2.FULL_NAME)"}),
(_0)-[:`SOURCE_OF_MAPPING`]->(_3),
(_3)-[:`MAPS_TO`]->(_1),
(_1)-[:`SOURCE_OF_MAPPING`]->(_4),
(_4)-[:`MAPS_TO`]->(_2)
Then the query I used only return a single hop
MATCH (source:Column)-[:SOURCE_OF_MAPPING*..10]->(c:ColumnMapping)-[:MAPS_TO*..10]->(target:Column) WHERE target.name = 'DATA_MART_FACT_1.FULL_NAME' RETURN source, target, c
Then next query kind of returns what I'm after but is missing the relationship between the first 2 nodes.
MATCH (source:Column)-[:SOURCE_OF_MAPPING|MAPS_TO*..10]->(n)-[:MAPS_TO]->(target:Column)
WHERE target.name = 'DATA_MART_FACT_1.FULL_NAME'
AND (n:Column or n:ColumnMapping)
RETURN *;
The end result that I would like from this is as follows (note, aliases are just included here to illustrate the dataflow, and for my requirements the actual results don't need to be aliased)...
(c1:Column)-[:SOURCE_OF_MAPPING]->(cm1:ColumnMapping)-[:MAPS_TO]->(c2:Column)-[:SOURCE_OF_MAPPING]->(cm2:ColumnMapping)-[:MAPS_TO]-(target:Column)
and in tabular format
source | mapping | target
STAGING_TABLE_1.FULL_NAME | UPPER(STAGING_TABLE_1.FULL_NAME) | STAGING_TABLE_2.FULL_NAME
STAGING_TABLE_2.FULL_NAME | LOWER(STAGING_TABLE_2.FULL_NAME) | DATA_MART_FACT_1.FULL_NAME
Oddly, when I created an an interactive example (the site can be flaky and can sometimes take a few refreshes before it works) and although the table returns one row as per my local installation, the visual graph representation shows all of the expected nodes and relationships.
Any and all advice is appreciated. Thanks in advance.
EDIT: I've refactored my column mapping to target column relationship direction to make the flow core natural as if it were the data flowing from source, to column mapping, to target. There was no change in behaviour though.

Answer 1

You could try breaking your query using WITH, as:
MATCH (t:Column {name:'DATA_MART_FACT_1.FULL_NAME'})-[:TARGET_OF_MAPPING*]->(c)
WITH t, c
MATCH (c)-[:SOURCE_OF_MAPPING*]->(s)
RETURN s,t,c
That can cut down on the Cartesian product situations. I haven't tried in your case, but it's generally a good way to look at queries. Also, trim the fat on criteria--if :TARGET_OF_MAPPING only connects to :ColumnMapping, then you may not need to specify and test for that.

Answer 2

For the example, the following is how to get the start to the end
MATCH (n)-[:SOURCE_OF_MAPPING|MAPS_TO*..4]->(target:Column)
WHERE target.name = 'DATA_MART_FACT_1.FULL_NAME'
AND (n:Column or n:ColumnMapping)
RETURN *;
I suspect for a real life example, where there may be many consecutive column mappings the results may have to be aggregated in some way in order to avoid killing performance with open ended variable length paths.