public function testBooleanValue()
{
$expression = new ValueExpression();
$expression->setValue(true);
$this->assertEquals('true', QueryAssembler::stringify($expression));
$expression->setValue(false);
$this->assertEquals('false', QueryAssembler::stringify($expression));
}
public function predicateData()
{
$nameEq = (new EqualPredicate())->setField('name')->setExpression(ValueExpression::create('test'));
$set = new PredicateSet();
$set->addPredicate($nameEq);
return [[['name' => 'test'], [$nameEq]], [[$nameEq], [$nameEq]], [['AND' => ['name' => 'test']], [$set]]];
}
public function testChangingParameters()
{
$val2 = ValueExpression::create(123);
$assembler = new QueryAssembler(QueryBuilder::select(AllSelectExpression::create())->from('tbl')->where(['field1' => 'val1', 'field2' => $val2]));
$this->assertEquals(['val1', 123], $assembler->getParameters());
$val2->setValue(456);
$this->assertEquals(['val1', 456], $assembler->getParameters());
}
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 testNull()
{
$expression = ValueExpression::create(null);
$this->assertNull($expression->getValue());
$this->assertEquals('NULL', QueryAssembler::stringify($expression));
$stmt = QueryBuilder::update('tbl', ['field' => $expression]);
$assembler = new QueryAssembler($stmt);
$this->assertEquals('UPDATE tbl SET field = ?', $assembler->getQuery());
$this->assertEquals([null], $assembler->getParameters());
}
public static function create($value)
{
if (is_scalar($value)) {
$value = [$value];
}
foreach ($value as $k => $val) {
if (!$val instanceof ValueExpression) {
$value[$k] = ValueExpression::create($val);
}
}
return parent::create($value);
}
/**
* @param $field
* @param $value
*
* @return static
*/
public static function create($field, $value)
{
$predicate = new static();
$predicate->setField($field);
if ($value instanceof IExpression) {
$expression = $value;
} else {
$expression = ValueExpression::create($value);
}
$predicate->setExpression($expression);
return $predicate;
}
public function testAssemble()
{
$predicate = new NotInPredicate();
$predicate->setField('field');
$this->assertEquals('field NOT IN NULL', QueryAssembler::stringify($predicate));
$predicate->setExpression((new NumericExpression())->setValue(1));
$this->assertEquals('field NOT IN 1', QueryAssembler::stringify($predicate));
$predicate->setExpression(ArrayExpression::create(['1', 2, 3]));
$this->assertEquals('field NOT IN ("1",2,3)', QueryAssembler::stringify($predicate));
$predicate->setExpression(ValueExpression::create([4]));
$this->assertEquals('field NOT IN (4)', QueryAssembler::stringify($predicate));
}
public static function create($field, $start, $end)
{
$predicate = new static();
$predicate->setField($field);
if (is_scalar($start)) {
$start = ValueExpression::create($start);
}
if (is_scalar($end)) {
$end = ValueExpression::create($end);
}
$predicate->setValues($start, $end);
return $predicate;
}
public static function buildPredicates(array $input, $table = null, $inverse = false)
{
$predicates = [];
foreach ($input as $key => $value) {
if ($value === null || is_scalar($value) || $value instanceof ValueExpression) {
$pred = $inverse ? new NotEqualPredicate() : new EqualPredicate();
$pred->setField(FieldExpression::createWithTable($key, $table));
if (!$value instanceof ValueExpression) {
$value = ValueExpression::create($value);
}
$pred->setExpression($value);
$predicates[] = $pred;
} else {
if ($value instanceof IPredicate) {
$predicates[] = $value;
} else {
if (is_array($value)) {
if (is_int($key)) {
$predicates = array_merge($predicates, static::buildPredicates($value, $table, $inverse));
} else {
if (static::_isControlKeyword($key)) {
switch ($key) {
case 'NOT':
$predicates = array_merge($predicates, static::buildPredicates($value, $table, true));
break;
case 'OR':
$pred = new OrPredicateSet();
$pred->setPredicates(static::buildPredicates($value, $table, $inverse));
$predicates[] = $pred;
break;
case 'AND':
$pred = new PredicateSet();
$pred->setPredicates(static::buildPredicates($value, $table, $inverse));
$predicates[] = $pred;
break;
}
} else {
$pred = $inverse ? new NotInPredicate() : new InPredicate();
$pred->setField(FieldExpression::createWithTable($key, $table));
$pred->setExpression(ArrayExpression::create($value));
$predicates[] = $pred;
}
}
}
}
}
}
return $predicates;
}
public function values(...$values)
{
/**
* @var $this IStatement
* @var $clause ValuesClause
*/
$clause = new ValuesClause();
$this->addClause($clause);
foreach ($values as $value) {
if (!$value instanceof ValueExpression) {
$value = ValueExpression::create($value);
}
$clause->addExpression($value);
}
return $this;
}
public function testAssemble()
{
$statement = QueryBuilder::insertInto('tbl');
$this->assertEquals('INSERT INTO tbl ()', QueryAssembler::stringify($statement));
$statement = QueryBuilder::insertInto('tbl', 'field');
$this->assertEquals('INSERT INTO tbl (field)', QueryAssembler::stringify($statement));
$statement->insertInto('tbl', FieldExpression::create('id'), 'name');
$this->assertEquals('INSERT INTO tbl (id, name)', QueryAssembler::stringify($statement));
$statement->values(null, ValueExpression::create('Test'));
$this->assertEquals('INSERT INTO tbl (id, name) ' . 'VALUES (NULL, "Test")', QueryAssembler::stringify($statement));
$statement->values('row2v1', 'row2v2');
$this->assertEquals('INSERT INTO tbl (id, name) ' . 'VALUES (NULL, "Test"), ("row2v1", "row2v2")', QueryAssembler::stringify($statement));
$statement = QueryBuilder::insertInto('tbl', 'field1', 'field2')->values('value1', 'value2')->onDuplicateKeyUpdate('field1', IncrementExpression::create('field2', 1));
$assembler = new QueryAssembler($statement);
$this->assertEquals('INSERT INTO tbl (field1, field2) VALUES (?, ?) ON DUPLICATE KEY UPDATE field1 = field2 + ?', $assembler->getQuery());
$this->assertEquals(['value1', 'value2', 1], $assembler->getParameters());
}
public function testAssemble()
{
$predicate = new InPredicate();
$predicate->setField('field');
$this->assertEquals('field IN NULL', QueryAssembler::stringify($predicate));
$predicate->setExpression((new NumericExpression())->setValue(1));
$this->assertEquals('field IN 1', QueryAssembler::stringify($predicate));
$predicate->setExpression(ArrayExpression::create(['1', 'my "quoted" test', 3]));
$this->assertEquals('field IN ("1","my \\"quoted\\" test",3)', QueryAssembler::stringify($predicate));
$predicate->setExpression(ValueExpression::create([4]));
$this->assertEquals('field IN (4)', QueryAssembler::stringify($predicate));
$changeExpr = StringExpression::create('my "quoted" test');
$predicate->setExpression(ArrayExpression::create(['1', $changeExpr, 3]));
$stmt = QueryBuilder::select(AllSelectExpression::create());
$stmt->where($predicate);
$assembler = new QueryAssembler($stmt);
$this->assertEquals('SELECT * WHERE field IN (?,?,?)', $assembler->getQuery());
$this->assertEquals(['1', 'my "quoted" test', 3], $assembler->getParameters());
$changeExpr->setValue('changed text');
$this->assertEquals(['1', 'changed text', 3], $assembler->getParameters());
}
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);
}
public function assembleValueExpression(ValueExpression $expression)
{
$value = $expression->getValue();
if ($value === null) {
return $this->_assemblePrepared() ?: 'NULL';
} else {
if (is_scalar($value)) {
if (!is_string($value) && is_numeric($value)) {
return $this->assembleNumericExpression(NumericExpression::create($value));
} else {
if (is_bool($value)) {
return $this->assembleBooleanExpression(BooleanExpression::create($value));
}
}
} else {
if (is_array($value)) {
return $this->assembleArrayExpression(ArrayExpression::create($value));
}
}
}
return $this->assembleStringExpression(StringExpression::create($value));
}
public function addParameter($value)
{
if (!$value instanceof ValueExpression) {
$value = ValueExpression::create($value);
}
$this->_parameters[] = $value;
return $this;
}
