What is the name of this "query builder" pattern I am looking for?

Question

I have a microservice I am designing for getting "Book" information, and one of the capabilities is to query Solr and fuse it with some DB results that I queried.

I am looking for, what I am calling a "query maker pattern" something that will generate dynamic solr queries. The idea in my head was a class like

public class Query {
    public Attribute[]; 
}

public class Attribute {
    public String type; 
    public String value;
}

But I'm not sure what the best way to generate dynamic queries in an object oriented way. There is a bad way of having a bunch of functions that append strings like:

public function String addSort(String value, Boolean isAscending){
    return value + "+" + (isAscending ? "asc" : "desc");
}
public function String addFacet(String facetName){
    etc etc
}

It would be best to have something like a toString() function for the Query object, and then using that as a the request to Solr?

Answer 1

I believe the pattern you are looking for is the Builder Pattern

---

It should look something like this:

public class Query {
    public Attribute[]; 

    public Query(string suffix) {
        // ...
    }

}

public class QueryBuilder {

    string suffix;

    public QueryBuilder() {
        this.suffix = "";
    } 

    public QueryBuilder WithFacet() {
        // etc etc
        return this;
    }

    public QueryBuilder WithSort(bool isAscending) {
        suffix += "+" + (isAscending ? "asc" : "desc");
        return this;
    }

    public Query Build() {
        return new Query(this.suffix);
    }

}

Usage:

Query myQuery = QueryBuilder.WithFacet().WithSort(true).Build();

---

Depending on the language you are programming you can even add some syntactic sugar:

public static class A
{
    public QueryBuilder Query => new QueryBuilder();
}

public class QueryBuilder {

    // ...
    public implicit operator Query(QueryBuilder builder) => builder.Build();
}

Usage:

Query myQuery = A.Query.WithFacet().WithSort(true);

Answer 2

To build a query, you can build an expression tree then compile that into the domain-specific language.

C# does this extensively, for example it allows you to construct an IQueryable in memory and linq-to-sql will translate it into SQL.

Apparently, there is a linq-to-solr.