SearchQuery introduction

As a demonstration of retrieving real nodes, this example lists all nodes of type "pools".

        MMBase mmbase = MMBase.getMMBase();
        MMObjectBuilder pools = mmbase.getBuilder("pools");
        MMObjectBuilder images = mmbase.getBuilder("images");
        InsRel insrel = mmbase.getInsRel();

        // EXAMPLE 1: query retrieving real nodes (of type pools).
        NodeSearchQuery query1 = new NodeSearchQuery(pools);

Note the use of NodeSearchQuery to produce a query that retrieves real nodes.

This will creates a query equivalent to:

        SELECT * FROM <basename>_pools pools

This code executes the query and prints the result - real nodes with these fields: number, otype, owner, name, description.

        // Execute, get result as real nodes.
        List nodes1 = pools.getNodes(query1);
        Iterator iNodes1 = nodes1.iterator();
        while (iNodes1.hasNext()) {
            MMObjectNode node = (MMObjectNode) iNodes1.next();
            System.out.println("Real node: " + node);
        }

As a demonstration of retrieving clusternodes, this example lists number fields of related pools and images, following relations from pools to images.

        // EXAMPLE 2: query retrieving clusternodes.
        BasicSearchQuery query2 = new BasicSearchQuery();
        BasicStep step2a = query2.addStep(pools);
        BasicRelationStep step2b = query2.addRelationStep(insrel, images);
        step2b.setDirectionality(RelationStep.DIRECTIONS_DESTINATION);
        Step step2c = step2b.getNext();
        // Add at least the number fields of all steps.
        query2.addField(step2a, pools.getField("number"));
        query2.addField(step2b, insrel.getField("number"));
        query2.addField(step2c, images.getField("number"));

This creates the following query:

        SELECT
            pools.number,
            insrel.number,
            images.number
        FROM
            <basename>_pools pools,
            <basename>_insrel insrel,
            <basename>_images images
        WHERE (pools.number = insrel.snumber
        AND images.number = insrel.dnumber)

This code executes the query and prints the results - clusternodes with these fields: pools.number, insrel.number, images.number.

        // Execute, result as clusternodes.
        ClusterBuilder clusterBuilder = mmbase.getClusterBuilder();
        List nodes2 = clusterBuilder.getClusterNodes(query2);
        Iterator iNodes2 = nodes2.iterator();
        while (iNodes2.hasNext()) {
            ClusterNode node = (ClusterNode) iNodes2.next();
            System.out.println("Clusternode: " + node);
        }

Alternatively we could use table aliases to use tablenames appended with a digit:

        // EXAMPLE 3: query retrieving clusternodes using table aliases.
        BasicSearchQuery query3 = new BasicSearchQuery();
        BasicStep step3a = query3.addStep(pools);
        BasicRelationStep step3b = query3.addRelationStep(insrel, images);
        step3b.setDirectionality(RelationStep.DIRECTIONS_DESTINATION);
        BasicStep step3c = (BasicStep) step3b.getNext();
        // Set table aliases.
        step3a.setAlias("pools0");
        step3c.setAlias("images3");
        // Add at least the number fields of all steps.
        query3.addField(step3a, pools.getField("number"));
        query3.addField(step3b, insrel.getField("number"));
        query3.addField(step3c, images.getField("number"));

This creates the following query:

        SELECT
            pools0.number,
            insrel.number,
            images3.number
        FROM
            <basename>_pools pools0,
            <basename>_insrel insrel,
            <basename>_images images3
        WHERE (pools0.number = insrel.snumber
        AND images3.number = insrel.dnumber)

Execution results in clusternodes with these fields: pools0.number, insrel.number, images3.number.

        // Execute, result as clusternodes.
        List nodes3 = clusterBuilder.getClusterNodes(query3);
        Iterator iNodes3 = nodes3.iterator();
        while (iNodes3.hasNext()) {
            ClusterNode node = (ClusterNode) iNodes3.next();
            System.out.println("Clusternode: " + node);
        }

As a demonstration of retrieving resultnodes, this example lists arbitrary fields of nodes of type "pools", using field aliases.

        // EXAMPLE 4: query retrieving resultnodes.
        BasicSearchQuery query4 = new BasicSearchQuery();
        BasicStep step4a = query4.addStep(pools);
        // Add some fields with field aliases.
        query4.addField(step4a, pools.getField("number")).setAlias("field1");
        query4.addField(step4a, pools.getField("name")).setAlias("field2");
        query4.addField(step4a, pools.getField("description")).setAlias("field3");

This creates the following query:

        SELECT
            number AS field1,
            name AS field2,
            description AS field3
        FROM
            <basename>_pools pools

This code executes the query and prints the results - resultnodes with these fields: field1, field2, field3

        // Execute, result as resultnodes.
        List nodes4 = handler.getNodes(query4, new ResultBuilder(mmbase, query4));
        Iterator iNodes4 = nodes4.iterator();
        while (iNodes4.hasNext()) {
            ResultNode node = (ResultNode) iNodes4.next();
            System.out.println("Resultnode: " + node);
        }

Finally, to demonstrate aggregating queries, this example lists the results of applying aggregating functions COUNT, MIN and MAX on the "number" field of all nodes of type "pools".

        // EXAMPLE 5: query retrieving aggregated resultnodes.
        BasicSearchQuery query5 = new BasicSearchQuery(true);
        BasicStep step5a = query5.addStep(pools);
        // Add some aggregated fields with field aliases.
        query5.addAggregatedField(step5a, pools.getField("number"),
            AggregatedField.AGGREGATION_TYPE_COUNT).setAlias("count");
        query5.addAggregatedField(step5a, pools.getField("number"),
            AggregatedField.AGGREGATION_TYPE_MIN).setAlias("min_number");
        query5.addAggregatedField(step5a, pools.getField("number"),
            AggregatedField.AGGREGATION_TYPE_MAX).setAlias("max_number");

This creates the following query:

        SELECT
            COUNT(number) AS pool_count,
            MIN(number) AS min_number,
            MAX(number) AS max_number
        FROM
            <basename>_pools pools

This code executes the query and prints the result - a resultnode with these fields: pool_count, min_number, max_number

        // Execute, result as resultnodes.
        List nodes5 = handler.getNodes(query5, new ResultBuilder(mmbase, query5));
        Iterator iNodes5 = nodes5.iterator();
        while (iNodes5.hasNext()) {
            ResultNode node = (ResultNode) iNodes5.next();
            System.out.println("Resultnode: " + node);
        }