public function assembleEqualPredicate(EqualPredicate $predicate)
{
if ($predicate->isNullValue() && !$predicate->isOperatorForced()) {
return $this->assembleSegment($predicate->getField()) . ' IS NULL';
}
return $this->assembleOperator($predicate);
}
public function testAssemble()
{
$this->assertEquals('', QueryAssembler::stringify(PredicateSet::create()));
$eq = new EqualPredicate();
$eq->setField("first")->setExpression(ValueExpression::create('val1'));
$neq = new NotEqualPredicate();
$neq->setField("second")->setExpression(ValueExpression::create('val1'));
$set = PredicateSet::create($eq, $neq);
$this->assertEquals('(first = "val1" AND second <> "val1")', QueryAssembler::stringify($set));
}
public function testAssemble()
{
$clause = new SetClause();
$eq = new EqualPredicate();
$eq->setField('one')->setExpression((new StringExpression())->setValue('val'));
$clause->addPredicate($eq);
$this->assertEquals('SET one = "val"', QueryAssembler::stringify($clause));
$inc = new EqualPredicate();
$inc->setField('two')->setExpression(IncrementExpression::create('two', 5));
$clause->addPredicate($inc);
$this->assertEquals('SET one = "val", two = two + 5', QueryAssembler::stringify($clause));
}
public function testAssemble()
{
$clause = new WhereClause();
$eq = new EqualPredicate();
$eq->setField('one')->setExpression((new StringExpression())->setValue('val'));
$clause->addPredicate($eq);
$this->assertEquals('WHERE one = "val"', QueryAssembler::stringify($clause));
$eq = new GreaterThanPredicate();
$eq->setField('two')->setExpression((new NumericExpression())->setValue(5));
$clause->addPredicate($eq);
$this->assertEquals('WHERE one = "val" AND two > 5', QueryAssembler::stringify($clause));
}
public function testAssemble()
{
$clause = new FinalAbstractPredicateClause();
$eq = new EqualPredicate();
$string = (new StringExpression())->setValue('val');
$eq->setField('one')->setExpression($string);
$neq = new NotEqualPredicate();
$neq->setField('two')->setExpression($string);
$clause->addPredicate($eq);
$this->assertEquals('T one = "val"', QueryAssembler::stringify($clause));
$clause->clearPredicates();
$clause->setPredicates([$eq, $neq]);
$this->assertEquals('T one = "val" AND two <> "val"', QueryAssembler::stringify($clause));
}
public function testDuplicateKey()
{
$clause = new DuplicateKeyClause();
$clause->addPredicate(EqualPredicate::create('field1', FieldExpression::create('field2')));
$clause->addPredicate(EqualPredicate::create('field3', 5));
$this->assertEquals('ON DUPLICATE KEY UPDATE field1 = field2, field3 = 5', QueryAssembler::stringify($clause));
}
public function testCreate()
{
$class = new FinalJoinTrait();
$class->addClause((new FromClause())->setTable('tbl'));
$class->join(TableExpression::create('tbl2'), 'email');
$this->assertEquals("FROM tbl INNER JOIN tbl2 ON tbl.email = tbl2.email", QueryAssembler::stringify($class));
$class->join('tbl3', 'user', 'user_id');
$this->assertEquals('FROM tbl INNER JOIN tbl2 ON tbl.email = tbl2.email ' . 'INNER JOIN tbl3 ON tbl.user = tbl3.user_id', QueryAssembler::stringify($class));
$class->joinWithPredicates(TableSelectExpression::createWithAlias('tbl4', 't4'), EqualPredicate::create(FieldExpression::createWithTable('email', 'tbl2'), FieldExpression::createWithTable('email', 't4')));
$this->assertEquals('FROM tbl INNER JOIN tbl2 ON tbl.email = tbl2.email ' . 'INNER JOIN tbl3 ON tbl.user = tbl3.user_id ' . 'INNER JOIN tbl4 AS t4 ON tbl2.email = t4.email', QueryAssembler::stringify($class));
}
public function set($field, $value)
{
/**
* @var $this IStatement
*/
$set = $this->getClause('SET');
if ($set === null) {
$set = new SetClause();
$this->addClause($set);
}
$set->addPredicate(EqualPredicate::create($field, $value)->forceOperator());
return $this;
}
public function onDuplicateKeyUpdate($field, $value)
{
/**
* @var $this IStatement
* @var $clause DuplicateKeyClause
*/
$clause = $this->getClause('ONDUPLICATEKEYUPDATE');
if ($clause === null) {
$clause = new DuplicateKeyClause();
$this->addClause($clause);
}
$clause->addPredicate(EqualPredicate::create($field, $value)->forceOperator());
return $this;
}
public function testAssemblerPrepare()
{
$stm = new QueryStatement();
$stm->addClause(new SelectClause())->from('mytable');
$stm->where(EqualPredicate::create('field1', 'value1'));
$assembler = new QueryAssembler($stm, false);
$this->assertEmpty($assembler->getParameters());
$this->assertFalse($assembler->isForPrepare());
$this->assertEquals('SELECT * FROM mytable WHERE field1 = "value1"', (string) $assembler);
$stm->andWhere(['AND' => [EqualPredicate::create('field2', null), NotEqualPredicate::create('field3', null)], 'OR' => BetweenPredicate::create('field4', 123, 456)]);
$assembler = new QueryAssembler($stm, true);
$this->assertNotEmpty($assembler->getParameters());
$this->assertTrue($assembler->isForPrepare());
$this->assertEquals('SELECT * FROM mytable WHERE field1 = ? AND ((field2 IS NULL AND field3 IS NOT NULL) AND field4 BETWEEN ? AND ?)', (string) $assembler);
$this->assertEquals(['value1', 123, 456], $assembler->getParameters());
}
public function testAssemble()
{
$predicate = new EqualPredicate();
$predicate->setField('field');
$this->assertEquals('field IS NULL', QueryAssembler::stringify($predicate));
$predicate->setExpression((new NumericExpression())->setValue(1));
$this->assertEquals('field = 1', QueryAssembler::stringify($predicate));
$predicate->setExpression((new NumericExpression())->setValue('1'));
$this->assertEquals('field = 1', QueryAssembler::stringify($predicate));
$predicate->setExpression((new StringExpression())->setValue('abc'));
$this->assertEquals('field = "abc"', QueryAssembler::stringify($predicate));
$predicate = EqualPredicate::create('field', null);
$this->assertEquals('field IS NULL', QueryAssembler::stringify($predicate));
$predicate = EqualPredicate::create('field', 1);
$this->assertEquals('field = 1', QueryAssembler::stringify($predicate));
$predicate = EqualPredicate::create('field', '1');
$this->assertEquals('field = "1"', QueryAssembler::stringify($predicate));
$predicate = EqualPredicate::create('field', 'abc');
$this->assertEquals('field = "abc"', QueryAssembler::stringify($predicate));
}
public function testIfExpression()
{
$this->assertEquals('IF(test = 4,123,321)', QueryAssembler::stringify(IfExpression::create(EqualPredicate::create('test', 4), 123, 321)));
}
public function testCaseExpression()
{
$this->assertEquals('CASE WHEN(test = 4) THEN 123 ELSE 321 END', QueryAssembler::stringify(CaseExpression::create(EqualPredicate::create('test', 4), 123, 321)));
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage Key must be numeric for ListFieldExpression
*/
public function testFailListFieldExpression()
{
EqualPredicate::create(ListFieldExpression::create('myfield', 'test'), 'test');
}
public function testGetData()
{
$datastore = new MockCqlDataStore();
$connection = new MockCqlConnection();
$connection->setConfig('keyspace', 'packaged_dal');
$datastore->setConnection($connection);
$connection->setResolver(new DalResolver());
$dao = new MockCqlDao();
$dao->id = 'test1';
$dao->id2 = 5555;
$dao->username = '******';
$datastore->save($dao);
$eq = new EqualPredicate();
$eq->setField('id');
$eq->setExpression(ValueExpression::create('test1'));
$d = $datastore->getData(QueryBuilder::select()->from($dao->getTableName())->where($eq));
$testDao = new MockCqlDao();
$testDao->hydrateDao($d[0], true);
$testDao->markDaoAsLoaded();
$testDao->markDaoDatasetAsSaved();
$this->assertEquals($dao, $testDao);
}
<?php
use Packaged\QueryBuilder\Assembler\QueryAssembler;
use Packaged\QueryBuilder\Builder\QueryBuilder;
use Packaged\QueryBuilder\Predicate\EqualPredicate;
use Packaged\QueryBuilder\SelectExpression\AllSelectExpression;
include_once 'vendor/autoload.php';
for ($i = 0; $i < 100; $i++) {
$start = microtime(true);
$query = QueryBuilder::select(new AllSelectExpression());
$query->from('table');
$query->where(['a' => 'b', 'c' => 'd']);
$query->andWhere([EqualPredicate::create('e', 'f'), EqualPredicate::create('g', 'h')]);
QueryAssembler::stringify($query);
echo "Completed In: " . (microtime(true) - $start);
echo PHP_EOL;
}
public function testMapFieldExpression()
{
$this->assertEquals("myfield['mykey'] = 'test'", CqlAssembler::stringify(EqualPredicate::create(MapFieldExpression::create('myfield', 'mykey'), 'test')));
}
