Creating concise and re-useable queries over complex data

1. A process for creating re-usable queries over complex data, the process comprising:

defining a re-usable object-oriented query language with object-oriented classes treated as logical properties, wherein each logical property is defined by one or more specified classes of at least one complex data item;

relating inheritance, used to form new class with the specified classes, to the logical properties along with a plurality of virtual method calls that execute all applicable method implementations in at least one of the specified classes; and

dispatching on the logical properties to choose at least one most specific implementation of an operation, wherein a most specific implementation is in a class where no subclasses define a same method, wherein the dispatching on the logical properties further includes:

defining a named predicate p as predicate p(T 1 x 1 , . . . , T n x n ) {formula} for each one of the applicable method implementations, wherein the named predicate p has variables x 1 , . . . , x n . so as to restrict a range of a relation, which contains tuples (x 1 , . . . x n ) where each x i has a type T;

testing a receiver against each relevant type and choosing the applicable method implementations, wherein testing a type of the receiver is achieved by invoking a named constructor for each class defining a method of a relevant signature, regardless of static types;

implementing queries by translating actual or possibly recursive object-oriented queries to a query language using for each method and constructor of each class, a first special variable that holds a value that is a member of the class, and for each method that is not a predicate, a second special variable that holds a result of a method; and

rending queries concise by at least using multi-valued operations to avoid naming intermediate results in nested method calls.

2. The process as set forth in claim 1 , wherein the implementing queries includes mapping each constructor to a named characteristic predicate of its class, which tests whether a value belongs to the class, by taking a logical conjunction of characteristic predicates of all superclasses and a property specified in the constructor.

3. The process as set forth in claim 1 , wherein the implementing queries includes mapping instanceof tests and cast expressions to calls of such characteristic predicates.

4. The process as set forth in claim 1 , wherein the implementing queries includes mapping expressions including nested method calls to a conjunction of predicate calls, with a new named variable denoting an intermediate result of each method call.

5. The process as set forth in claim 1 , wherein the implementing queries by translating actual or possibly recursive object-oriented queries to the query language produces queries in Datalog and wherein at least one search engine is targeted by translating a same intermediate Datalog to different executable formats.

6. The process as set forth in claim 1 , wherein the queries are rendered concise by at least one of:

using a * notation and a + notation on multi-valued operations to indicate a chained application of such operations; and

using an aggregate notation with variables, a range condition and an expression (agg(vars|condition|expr)).

7. The process as set forth in claim 1 , wherein complex data is stored in a standard relational database, and column types are used to build a hierarchy of object-oriented classes on top of an existing relational database, by annotating an existing relational schema.

8. The process as set forth in claim 1 , wherein at least one complex data item is at least one of:

a data item in a hierarchy;

a tree; and

a graph.

9. The process as set forth in claim 1 , wherein an object-oriented query language is in any form depending on a domain of object-oriented query language use, including at least one of:

a textual form;

a graphical form;

a query-by-example user interface; and

embedded in a more general programming language.

10. The process as set forth in claim 1 , wherein complex data is stored in a plurality of datasource formats including at least one of:

a relational database;

a web service;

a web page; and

a file on hard disk and column types are used to build a hierarchy of object-oriented classes on top of such data formats, by annotating each relevant data format schema.

11. A computer program product for creating re-usable queries over complex data, the computer program product comprising:

a non-transitory computer readable storage medium, the non-transitory computer readable storage medium storing software programming instructions capable of performing with a processor programming code to carry out:

defining a re-usable object-oriented query language with object-oriented classes treated as logical properties, wherein each logical property is defined by one or more specified classes of at least one complex data item;

relating inheritance, used to form new class with the specified classes, to the logical properties along with a plurality of virtual method calls that execute all applicable method implementations in at least one of the specified classes; and

dispatching on the logical properties to choose at least one most specific implementation of an operation, wherein a most specific implementation is in a class where no subclasses define a same method, wherein the dispatching on the logical properties further includes:

defining a named predicate p as predicate p(T1x1, . . . , Tnxn) {formula} for each one of the applicable method implementations, wherein the named predicate p has variables x1, . . . , xn so as to restrict a range of a relation, which contains tuples (x1, . . . , xn) where each xi has a type Ti;

testing a receiver against each relevant type and choosing the applicable method implementations, wherein testing a type of the receiver is achieved by invoking a named constructor for each class defining a method of a relevant signature, regardless of static types;

implementing queries by translating actual or possibly recursive object-oriented queries to a query language using for each method and constructor of each class, a first special variable that holds a value that is a member of the class, and for each method that is not a predicate, a second special variable that holds a result of a method; and

rending queries concise by at least using multi-valued operations to avoid naming intermediate results in nested method calls.

12. The computer program product of claim 11 , wherein the implementing queries includes mapping each constructor to a named characteristic predicate of its class, which tests whether a value belongs to the class, by taking a logical conjunction of characteristic predicates of all superclasses and a property specified in the constructor.

13. The computer program product of claim 11 , wherein the implementing queries includes mapping instanceof tests and cast expressions to calls of such characteristic predicates.

14. The computer program product of claim 11 , wherein the implementing queries includes mapping expressions including nested method calls to a conjunction of predicate calls, with a new named variable denoting an intermediate result of each method call.

15. The computer program product of claim 11 , wherein the implementing queries by translating actual or possibly recursive object-oriented queries to the query language produces queries in Datalog and wherein at least one search engine is targeted by translating a same intermediate Datalog to different executable formats.

16. An information processing system for creating re-usable queries over complex data, the system comprising:

a computer memory capable of storing machine instructions; and

a processor in communication with said computer memory, said processor configured to access the memory, the processor performing

a re-usable object-oriented query language defined with object-oriented classes treated as logical properties, wherein each logical property is defined by one or more specified classes of at least one complex data item;

a new class formed by relating inheritance with the specified classes, to the logical properties along with a plurality of virtual method calls that execute all applicable method implementations in at least one of the specified classes; and

means for dispatching on the logical properties to choose at least one of a most specific implementation of an operation, wherein a most specific implementation is in class where no subclasses define a same method, wherein the dispatching on the logical properties further includes:

means for defining a named predicate p as predicate p(T 1 x 1 , . . . T n x n ) {formula} for each one of the applicable method implementations, wherein the named predicate p has variables x 1 , . . . x n . so as to restrict a range of a relation, which contains tuples (x 1 , . . . , x n ) where each x 1 has a type T i ;

means for testing a receiver against each relevant type and choosing the applicable method implementations, wherein testing a type of the receiver is achieved by invoking a named constructor for each class defining a method of a relevant signature, regardless of static types;

means for implementing queries by translating actual or possibly recursive object-oriented queries to a query language using for each method and constructor of each class, a first special variable that holds a value that is a member of the class, and for each method that is not a predicate, a second special variable that holds a result of a method; and

means for rending queries concise by at least using multi-valued operations to avoid naming intermediate results in nested method calls.

17. The system of claim 16 , wherein the implementing queries includes mapping each constructor to a named characteristic predicate of its class, which tests whether a value belongs to the class, by taking a logical conjunction of characteristic predicates of all superclasses and a property specified in the constructor.

18. The system of claim 16 , wherein the implementing queries includes mapping instanceof tests and cast expressions to calls of such characteristic predicates.

19. The system of claim 16 , wherein the implementing queries includes mapping expressions including nested method calls to a conjunction of predicate calls, with a new named variable denoting an intermediate result of each method call.

20. The system of claim 16 , wherein the implementing queries by translating actual or possibly recursive object-oriented queries to the query language produces queries in Datalog and wherein at least one search engine is targeted by translating a same intermediate Datalog to different executable formats.