Like or Not Like - that's where the question

lib/Doctrine/Common/Collections/Expr/ClosureExpressionVisitor.php

@@ -155,6 +155,42 @@ public function walkComparison(Comparison $comparison)
                     return false !== strpos(ClosureExpressionVisitor::getObjectFieldValue($object, $field), $value);
                 };
 
+            case Comparison::LIKE:
+            case Comparison::NOTLIKE:
+                $like    = $comparison->getOperator() === Comparison::LIKE;
+                $pattern = null;
+
+                // Replace the escaped characters to placeholder
+                $tmpValue = str_replace('\%', 'SQLWILDCARDESCAPEDMANY', $value);
+                $tmpValue = str_replace('\_', 'SQLWILDCARDESCAPEDONE', $tmpValue);
+
+                // Check whether we have a wildcard characters, and build the regular expression
+                if(strpos($tmpValue, '%') !== false || strpos($tmpValue, '_') !== false) {
+                    // Build regexp
+                    $pattern = preg_quote($tmpValue, '/');
+                    $pattern = str_replace('%', '.*', $pattern);
+                    $pattern = str_replace('_', '.{1}', $pattern);
+                    $pattern = str_replace('SQLWILDCARDESCAPEDMANY', '\\%', $pattern);
+                    $pattern = str_replace('SQLWILDCARDESCAPEDONE', '\\_', $pattern);
+                    $pattern = '/^' . $pattern . '$/m';
+                }
+                else {
+                    // Replace the escaped characters to normal one
+                    $value = str_replace('\%', '%', $value);
+                    $value = str_replace('\_', '_', $value);
+                }
+
+                return function ($object) use ($field, $value, $like, $pattern) {
+                    $fieldValue = ClosureExpressionVisitor::getObjectFieldValue($object, $field);
+
+                    if($pattern) {
+                        return (bool) ($like ? preg_match($pattern, $fieldValue) : !preg_match($pattern, $fieldValue));
+                    }
+
+                    // The wildcard characters not exist, use regular comparison
+                    return ($like ? $fieldValue === $value : $fieldValue !== $value);
+                };
+
             default:
                 throw new \RuntimeException("Unknown comparison operator: " . $comparison->getOperator());
         }

lib/Doctrine/Common/Collections/Expr/Comparison.php

@@ -37,6 +37,8 @@ class Comparison implements Expression
     const IN        = 'IN';
     const NIN       = 'NIN';
     const CONTAINS  = 'CONTAINS';
+    const LIKE      = 'LIKE';
+    const NOTLIKE   = 'NOTLIKE';
 
     /**
      * @var string

lib/Doctrine/Common/Collections/ExpressionBuilder.php

@@ -163,4 +163,26 @@ public function contains($field, $value)
     {
         return new Comparison($field, Comparison::CONTAINS, new Value($value));
     }
+
+    /**
+     * @param string $field
+     * @param mixed  $value
+     *
+     * @return Comparison
+     */
+    public function like($field, $value)
+    {
+        return new Comparison($field, Comparison::LIKE, new Value($value));
+    }
+
+    /**
+     * @param string $field
+     * @param mixed  $value
+     *
+     * @return Comparison
+     */
+    public function notLike($field, $value)
+    {
+        return new Comparison($field, Comparison::NOTLIKE, new Value($value));
+    }
 }

tests/Doctrine/Tests/Common/Collections/ClosureExpressionVisitorTest.php

@@ -135,6 +135,22 @@ public function testWalkContainsComparison()
         $this->assertFalse($closure(new TestObject('world')));
     }
 
+    public function testWalkLikeComparison()
+    {
+        $closure = $this->visitor->walkComparison($this->builder->like('foo', 'H_llo! I%Robot!'));
+
+        $this->assertTrue($closure(new TestObject('Hello! I am Robot!')));
+        $this->assertFalse($closure(new TestObject('Hello! I am Robot?')));
+    }
+
+    public function testWalkNotLikeComparison()
+    {
+        $closure = $this->visitor->walkComparison($this->builder->notLike('foo', '%I a_ Robot?'));
+
+        $this->assertTrue($closure(new TestObject('Hello! I am Robot!')));
+        $this->assertFalse($closure(new TestObject('Hello! I am Robot?')));
+    }
+
     public function testWalkAndCompositeExpression()
     {
         $closure = $this->visitor->walkCompositeExpression(

tests/Doctrine/Tests/Common/Collections/ExpressionBuilderTest.php

@@ -122,4 +122,21 @@ public function testContains()
         $this->assertInstanceOf('Doctrine\Common\Collections\Expr\Comparison', $expr);
         $this->assertEquals(Comparison::CONTAINS, $expr->getOperator());
     }
+
+    public function testLike()
+    {
+        $expr = $this->builder->like("a", "b");
+
+        $this->assertInstanceOf('Doctrine\Common\Collections\Expr\Comparison', $expr);
+        $this->assertEquals(Comparison::LIKE, $expr->getOperator());
+    }
+
+    public function testNotLike()
+    {
+        $expr = $this->builder->notLike("a", "b");
+
+        $this->assertInstanceOf('Doctrine\Common\Collections\Expr\Comparison', $expr);
+        $this->assertEquals(Comparison::NOTLIKE, $expr->getOperator());
+    }
+
 }