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 addParameter($value) { if (!$value instanceof ValueExpression) { $value = ValueExpression::create($value); } $this->_parameters[] = $value; return $this; }