Download the PHP package mf/query-builder-composer without Composer

Query Builder Composer

QueryBuilderComposer for easier composing Doctrine\\ORM\\QueryBuilder parts

Install

Compose parts for QueryBuilder

Parts are array of:

• modifiers
• rules

Modifier:

Modifier is ANY callable by this pattern: (QueryBuilder -> QueryBuilder)

example of Modifiers:

- (anonymus function): [ function(QueryBuilder $qb) { return $qb->select('...'); }, ... ]
- (static function)  : [ [$this, 'modifyQueryBuilder'], ... ]
- (closure)          : [ $addSelectModifier, ... ]
- (Modifier)         : [ new Modifier('...'), ... ]
- ...

Rule:

Rule represents any QueryBuilder method call

• array of strings
• array of single string (separator is space)
• just a single string (separator is space)

Let's say we have this QueryBuilder method call:

example of Rules:

(QueryBuilder method call) : (rule representation)

- $qb->select('t.column')    : ['select', 't.column']
- $qb->join('t.joined', 'j') : ['join', 't.joined', 'j']
- $qb->from('table', 't')    : ['from', 'table', 't']
- $qb->from('table', 't')    : ['from table t']
- $qb->from('table', 't')    : 'from table t'
- ...

Usage

Why? What is a problem?

If you have complex methods for building Query via QueryBuilder, you might be in same situation as I am. I have many similar methods to build different Queries and I cant see a clear way how to reuse my QueryBuilder parts.

So I decided to create this QueryBuilderComposer to make this issue easier.

Example of complex methods with duplicated parts

Methods are simplified so they might not be 100% correct.

Now you can have some idea of those parts which are same for more cases and they can be composed and defined once!

Composition of parts

Step 1 (rewrite to QueryBuilderComposer)

Step 2 (store common rules to class constants to allow easier reuse)

Step 3 (compose parts)

Step 4 (use syntax sugar over array_merge)

Difference between compose vs mergeCompose

Conclusion

You can merge, compose and reuse your QueryBuilder parts easy. Example above is just quick solution. You can do much more patterns over this composition:

• implement Modifier to do something with QueryBuilder
• implement Closure to be reapplied again
• ...

How to add complex rulex to QueryBuilder