Neo4j match Relationship parameters satisfying a certain schema - neo4j

Question

Using cypher, is there any way to match a path where the relationships satisfy a certain input schema generically?
I know I can do something like
parameters: {
"age": 20
}
MATCH (n)-[r:MY_RELATION]-() WHERE $age>18 AND $age<24 ...
when i want to match only relations satisfying the schema { "type": "integer", "minimum": 19, "maximum": 23 }.
But then i have to specify the min and max range within the relationship. What if I want to match strings against a schema, or even more complex types like address with subparameters etc.?
Is there a generic way to do it?
edit:
I'll try and state the question more clearly. What I want is a graph and a (parameterized) query to traverse that graph, such that:
i get all the nodes in the traversal
the relationships in the graph pose certain constraints on the query parameters (like minimum on an integer)
the traversal only follows edges where the constraint is met
i need to make constraints on integers, like min/max, but as well on strings, like pattern, etc.
edit 2:
What I want may not even be possible.
I want all of the information about the constraint to reside in the edge, including the parameter to test against. So I would want something along the lines of
parameters: { "age": 20, "location": "A" }
MATCH (n)-[r]-()
WHERE r.testtype='integer' AND getParameterByName(r.testparamname) < r.max
OR r.testtype='string' AND getParameterByName(r.testparamname)=r.allowedStringValue
Of course, as can be read in the neo4j documentation about parameter functionality it should not be possible to dynamically load the parameter via a name that resides in the DB.
There may yet be some workaround?

Answer 1

[UPDATED]
Original answer:
Your question is not stated very clearly, but I'll try to answer anyway.
I think something like this is what you want:
parameters: {
"minimum": 19,
"maximum": 23
}
MATCH (n)-[r:MY_RELATION]-() WHERE $maximum >= r.age >= $minimum
...
There is no need to specify a "type" parameter. Just make sure your parameter values are of the appropriate type.
New answer (based on updated question):
Suppose the parameters are specified this way (where test indicates the type of test):
parameters: {
"age": 20,
"test": "age_range"
}
Then you could do this (where r would contain the properties test, min, and max):
MATCH (n)-[r:MY_RELATION]-(m)
WHERE r.test = $test AND r.min <= $age <= r.max
RETURN n, r, m;
Or, if you do not need all the relationships to be of the same type, this should also work and may be easier to visualize (where r would be of, say, type "age_range", and contain the properties min and max):
MATCH (n)-[r]-(m)
WHERE TYPE(r) = $test AND r.min <= $age <= r.max
RETURN n, r, m;
To help you decide which approach to use, you should profile the two approaches with your code and some actual data to see which is faster for you.
Even Newer answer (based on edit 2 in question)
The following parameter and query should do what you want. Square brackets can be used to dyamically specify the name of a property.
parameters: {
"data": {
"age": 20,
"location": "A"
}
}
MATCH (n)-[r]-()
WHERE r.testtype='integer' AND $data[r.testparamname] < r.max
OR r.testtype='string' AND $data[r.testparamname]=r.allowedStringValue
...

Answer 2

Does this solution meet your requirements?
Considering the following small sample data set
MERGE (p1:Person {name: 'P 01'})
MERGE (p2:Person {name: 'P 02'})
MERGE (p3:Person {name: 'P 03'})
MERGE (p1)-[:MY_RELATION { minimum: 19, maximum: 23 }]->(p2)
MERGE (p2)-[:MY_RELATION { minimum: 19, maximum: 20 }]->(p3)
This query will only return the nodes and relationship where the supplied parameter fits the relationship constraints (e.g. $age = 21 should only return a single row). It is basically the inverse of #cybersam's proposal.
MATCH (s:Person)-[r:MY_RELATION]->(e:Person)
WHERE r.minimum <= $age <= r.maximum
RETURN *