protected function _executeTestsNormal($di)
{
$robot = new Robots();
$success = $robot->save(array('type' => 'mechanical', 'year' => 2018));
$this->assertEquals($success, false);
$this->assertEquals($robot->type, 'mechanical');
$this->assertEquals($robot->year, 2018);
$robot = new Robots();
$robot->assign(array('type' => 'mechanical', 'year' => 2018));
$this->assertEquals($robot->type, 'mechanical');
$this->assertEquals($robot->year, 2018);
//not assigns nonexistent fields
$robot = new Robots();
$robot->assign(array('field1' => 'mechanical', 'field2' => 2018));
$this->assertEquals(empty($robot->field1), true);
$this->assertEquals(empty($robot->field2), true);
//white list
$robot = new Robots();
$robot->assign(array('type' => 'mechanical', 'year' => 2018), null, array('type'));
$this->assertEquals($robot->type, 'mechanical');
$this->assertEquals(empty($robot->year), true);
//white list
$robot = new Robots();
$robot->assign(array('typeFromClient' => 'mechanical', 'yearFromClient' => 2018), array('typeFromClient' => 'type', 'yearFromClient' => 'year'), array('type'));
$this->assertEquals($robot->type, 'mechanical');
$this->assertEquals(empty($robot->year), true);
}
public static function findByRawSql($conditions, $params = null)
{
// A raw SQL statement
$sql = "SELECT * FROM robots WHERE {$conditions}";
// Base model
$robot = new Robots();
// Execute the query
return new Resultset(null, $robot, $robot->getReadConnection()->query($sql, $params));
}
public static function findByCreateInterval()
{
// A raw SQL statement
$sql = "SELECT * FROM robots WHERE id > 0";
// Base model
$robot = new Robots();
// Execute the query
return new Resultset(null, $robot, $robot->getReadConnection()->query($sql));
}
/**
* @covers itseo\test\Robots::test
* @todo Implement testTest().
*/
public function testTest()
{
$dummy_target = "http://www.google.es/";
$result = $this->object->test($dummy_target);
$this->assertArrayHasKey("name", $result);
$this->assertArrayHasKey("score", $result);
$this->assertArrayHasKey("total_score", $result);
$this->assertArrayHasKey("result", $result);
$this->assertEquals("robots", $result['name']);
}
protected function _executeTestsNormal($di)
{
$robot = new Robots();
$success = $robot->save(array('type' => 'mechanical', 'year' => 2018));
$this->assertEquals($success, false);
$this->assertEquals($robot->type, 'mechanical');
$this->assertEquals($robot->year, 2018);
$robot = new Robots();
$robot->assign(array('type' => 'mechanical', 'year' => 2018));
$this->assertEquals($robot->type, 'mechanical');
$this->assertEquals($robot->year, 2018);
}
public static function create($data)
{
$response = new Response();
try {
$data = json_decode($data, true);
/** @var Robots $robot */
$robot = new Robots();
$robot->setAttributes($data);
$response->data = $robot->create();
$response->status = $response::STATUS_CREATED;
} catch (Exception $e) {
$response->setException($e);
} finally {
return $response->toArray();
}
}
public function testSerialize()
{
$this->_prepareDI();
$robot = Robots::findFirst();
$serialized = serialize($robot);
$robot = unserialize($serialized);
$this->assertTrue($robot->save());
}
public function findAction()
{
$robots = $this->demoModel->find(array("conditions" => "id >= :id:", "columns" => "id, username,password", "order" => "username DESC", "offset" => 0, "limit" => 10, "group" => "id, username", "bind" => array("id" => 1)));
dump($robots->toArray());
exit;
// 也可以这样
$robots = Robots::query()->where("type = :type:")->andWhere("year < 2000")->bind(array("type" => "mechanical"))->order("name")->execute();
// 单条记录
$data = $this->demoModel->findFirst();
}
public function saveAction()
{
$this->db->begin();
$robot = new Robots();
$robot->name = "WALL·E";
$robot->created_at = date("Y-m-d");
if ($robot->save() == false) {
$this->db->rollback();
return;
}
$robotPart = new RobotParts();
$robotPart->robots_id = $robot->id;
$robotPart->type = "head";
if ($robotPart->save() == false) {
$this->db->rollback();
return;
}
$this->db->commit();
}
public function testCacheResultsetBinding()
{
$cache = $this->_getCache();
$initialId = 0;
$finalId = 4;
$cache->save('test-resultset', Robots::find(array('conditions' => 'id > :id1: and id < :id2:', 'bind' => array('id1' => $initialId, 'id2' => $finalId), 'order' => 'id')));
$this->assertTrue(file_exists(__DIR__ . '/cache/test-resultset'));
$robots = $cache->get('test-resultset');
$this->assertEquals(get_class($robots), 'Phalcon\\Mvc\\Model\\Resultset\\Simple');
$this->assertEquals(count($robots), 3);
$this->assertEquals($robots->count(), 3);
}
/**
* Tests an image tag with a bare minimum of information passed
*
* @author Nikos Dimopoulos <*****@*****.**>
* @since 2012-09-09
*/
public function testSelectBasic()
{
// Populate the table
// Empty the relationship table first
$this->emptyTable('robots_parts');
$this->populateTable('robots');
$this->populateTable('robots_parts');
$robots = \Robots::find();
$params = array('some_name', $robots, 'using' => array('id', 'name'));
$expected = '<select id="some_name" name="some_name">' . PHP_EOL . chr(9) . '<option value="1">Robotina</option>' . PHP_EOL . chr(9) . '<option value="2">Astro Boy</option>' . PHP_EOL . chr(9) . '<option value="3">Terminator</option>' . PHP_EOL . '</select>';
$actual = PhTag::select($params);
$this->assertEquals($expected, $actual, sprintf($this->message, 'select basic'));
}
public function testSerialize()
{
require 'unit-tests/config.db.php';
if (empty($configMysql)) {
$this->markTestSkipped('Test skipped');
return;
}
$this->_prepareDI();
$robot = Robots::findFirst();
$serialized = serialize($robot);
$robot = unserialize($serialized);
$this->assertTrue($robot->save());
}
protected function _executeTestsNormal($di)
{
$robot = Robots::findFirstById(1);
$this->assertEquals(get_class($robot), 'Robots');
$this->assertEquals($robot->id, 1);
$robot = Robots::findFirstById(2);
$this->assertEquals(get_class($robot), 'Robots');
$this->assertEquals($robot->id, 2);
$robots = Robots::findByType('mechanical');
$this->assertEquals(count($robots), 2);
$this->assertEquals($robots[0]->id, 1);
$number = Robots::countByType('mechanical');
$this->assertEquals($number, 2);
}
public function testCacheResultsetNormal()
{
require 'unit-tests/config.db.php';
if (empty($configMysql)) {
$this->markTestSkipped('Test skipped');
return;
}
$cache = $this->_getCache();
$cache->save('test-resultset', Robots::find(array('order' => 'id')));
$this->assertTrue(file_exists('unit-tests/cache/test-resultset'));
$robots = $cache->get('test-resultset');
$this->assertEquals(get_class($robots), 'Phalcon\\Mvc\\Model\\Resultset\\Simple');
$this->assertEquals(count($robots), 3);
$this->assertEquals($robots->count(), 3);
}
/**
* Getting crowler
* @param string $url
* @return boolean|\Crowler
*/
public static function getAnalyzer($url)
{
// Check is robots allowed
if (!Robots::robots_allowed($url, Config::$agent_name)) {
Providers::change_url_status($url, Providers::URLS_TYPE_ROBOTS_NOT_ALLOWED);
_w('Robots not allowed');
return false;
}
// Create object
$obj = new ContentAnalyzer($url);
if (!$obj->getCONTENT_DATA()) {
Providers::change_url_status($url, Providers::URLS_TYPE_ERROR_NO_DATA);
return false;
}
return $obj;
}
public function testJsonSerialize()
{
require 'unit-tests/config.db.php';
if (empty($configMysql)) {
$this->markTestSkipped('Test skipped');
return;
}
$di = $this->_getDI();
// Single model object json serialization
$robot = Robots::findFirst();
$json = json_encode($robot);
$this->assertTrue(is_string($json));
$this->assertTrue(strlen($json) > 10);
// make sure result is not "{ }"
$array = json_decode($json, true);
$this->assertEquals($robot->toArray(), $array);
// Result-set serialization
$robots = Robots::find();
$json = json_encode($robots);
$this->assertTrue(is_string($json));
$this->assertTrue(strlen($json) > 50);
// make sure result is not "{ }"
$array = json_decode($json, true);
$this->assertEquals($robots->toArray(), $array);
// Single row serialization
$result = $di->get('modelsManager')->executeQuery('SELECT id FROM Robots LIMIT 1');
$this->assertEquals(get_class($result), 'Phalcon\\Mvc\\Model\\Resultset\\Simple');
foreach ($result as $row) {
$this->assertEquals(get_class($row), 'Phalcon\\Mvc\\Model\\Row');
$this->assertEquals($row->id, $robot->id);
$json = json_encode($row);
$this->assertTrue(is_string($json));
$this->assertTrue(strlen($json) > 5);
// make sure result is not "{ }"
$array = json_decode($json, true);
$this->assertEquals($row->toArray(), $array);
}
}
protected function _executeTestsNormal($di)
{
$this->_prepareDb($di->getShared('db'));
//Count tests
$this->assertEquals(People::count(), Personas::count());
$params = array();
$this->assertEquals(People::count($params), Personas::count($params));
$params = array("estado='I'");
$this->assertEquals(People::count($params), Personas::count($params));
$params = "estado='I'";
$this->assertEquals(People::count($params), Personas::count($params));
$params = array("conditions" => "estado='I'");
$this->assertEquals(People::count($params), Personas::count($params));
//Find first
$people = People::findFirst();
$this->assertTrue(is_object($people));
$this->assertEquals(get_class($people), 'People');
$persona = Personas::findFirst();
$this->assertEquals($people->nombres, $persona->nombres);
$this->assertEquals($people->estado, $persona->estado);
$people = People::findFirst("estado='I'");
$this->assertTrue(is_object($people));
$persona = Personas::findFirst("estado='I'");
$this->assertTrue(is_object($persona));
$this->assertEquals($people->nombres, $persona->nombres);
$this->assertEquals($people->estado, $persona->estado);
$people = People::findFirst(array("estado='I'"));
$persona = Personas::findFirst(array("estado='I'"));
$this->assertEquals($people->nombres, $persona->nombres);
$this->assertEquals($people->estado, $persona->estado);
$params = array("conditions" => "estado='I'");
$people = People::findFirst($params);
$persona = Personas::findFirst($params);
$this->assertEquals($people->nombres, $persona->nombres);
$this->assertEquals($people->estado, $persona->estado);
$params = array("conditions" => "estado='A'", "order" => "nombres");
$people = People::findFirst($params);
$persona = Personas::findFirst($params);
$this->assertEquals($people->nombres, $persona->nombres);
$this->assertEquals($people->estado, $persona->estado);
$params = array("estado='A'", "order" => "nombres DESC", "limit" => 30);
$people = People::findFirst($params);
$persona = Personas::findFirst($params);
$this->assertEquals($people->nombres, $persona->nombres);
$this->assertEquals($people->estado, $persona->estado);
$params = array("estado=?1", "bind" => array(1 => 'A'), "order" => "nombres DESC", "limit" => 30);
$people = People::findFirst($params);
$persona = Personas::findFirst($params);
$this->assertEquals($people->nombres, $persona->nombres);
$this->assertEquals($people->estado, $persona->estado);
$params = array("estado=:estado:", "bind" => array("estado" => 'A'), "order" => "nombres DESC", "limit" => 30);
$people = People::findFirst($params);
$persona = Personas::findFirst($params);
$this->assertEquals($people->nombres, $persona->nombres);
$this->assertEquals($people->estado, $persona->estado);
$robot = Robots::findFirst(1);
$this->assertEquals(get_class($robot), 'Robots');
//Find tests
$personas = Personas::find();
$people = People::find();
$this->assertEquals(count($personas), count($people));
$personas = Personas::find("estado='I'");
$people = People::find("estado='I'");
$this->assertEquals(count($personas), count($people));
$personas = Personas::find(array("estado='I'"));
$people = People::find(array("estado='I'"));
$this->assertEquals(count($personas), count($people));
$personas = Personas::find(array("estado='A'", "order" => "nombres"));
$people = People::find(array("estado='A'", "order" => "nombres"));
$this->assertEquals(count($personas), count($people));
$personas = Personas::find(array("estado='A'", "order" => "nombres", "limit" => 100));
$people = People::find(array("estado='A'", "order" => "nombres", "limit" => 100));
$this->assertEquals(count($personas), count($people));
$params = array("estado=?1", "bind" => array(1 => "A"), "order" => "nombres", "limit" => 100);
$personas = Personas::find($params);
$people = People::find($params);
$this->assertEquals(count($personas), count($people));
$params = array("estado=:estado:", "bind" => array("estado" => "A"), "order" => "nombres", "limit" => 100);
$personas = Personas::find($params);
$people = People::find($params);
$this->assertEquals(count($personas), count($people));
$number = 0;
$peoples = Personas::find(array("conditions" => "estado='A'", "order" => "nombres", "limit" => 20));
foreach ($peoples as $people) {
$number++;
}
$this->assertEquals($number, 20);
$persona = new Personas($di);
$persona->cedula = 'CELL' . mt_rand(0, 999999);
$this->assertFalse($persona->save());
//Messages
$this->assertEquals(count($persona->getMessages()), 4);
$messages = array(0 => ModelMessage::__set_state(array('_type' => 'PresenceOf', '_message' => 'tipo_documento_id is required', '_field' => 'tipo_documento_id')), 1 => ModelMessage::__set_state(array('_type' => 'PresenceOf', '_message' => 'nombres is required', '_field' => 'nombres')), 2 => ModelMessage::__set_state(array('_type' => 'PresenceOf', '_message' => 'cupo is required', '_field' => 'cupo')), 3 => ModelMessage::__set_state(array('_type' => 'PresenceOf', '_message' => 'estado is required', '_field' => 'estado')));
$this->assertEquals($persona->getMessages(), $messages);
//Save
$persona = new Personas($di);
$persona->cedula = 'CELL' . mt_rand(0, 999999);
$persona->tipo_documento_id = 1;
$persona->nombres = 'LOST';
$persona->telefono = '1';
$persona->cupo = 20000;
$persona->estado = 'A';
$this->assertTrue($persona->save());
$persona = new Personas($di);
$persona->cedula = 'CELL' . mt_rand(0, 999999);
$persona->tipo_documento_id = 1;
$persona->nombres = 'LOST LOST';
$persona->telefono = '2';
$persona->cupo = 0;
$persona->estado = 'X';
$this->assertTrue($persona->save());
//Check correct save
$persona = Personas::findFirst(array("estado='X'"));
$this->assertNotEquals($persona, false);
$this->assertEquals($persona->nombres, 'LOST LOST');
$this->assertEquals($persona->estado, 'X');
//Update
$persona->cupo = 150000;
$persona->telefono = '123';
$this->assertTrue($persona->update());
//Checking correct update
$persona = Personas::findFirst(array("estado='X'"));
$this->assertNotEquals($persona, false);
$this->assertEquals($persona->cupo, 150000);
$this->assertEquals($persona->telefono, '123');
//Update
$this->assertTrue($persona->update(array('nombres' => 'LOST UPDATE', 'telefono' => '2121')));
//Checking correct update
$persona = Personas::findFirst(array("estado='X'"));
$this->assertNotEquals($persona, false);
$this->assertEquals($persona->nombres, 'LOST UPDATE');
$this->assertEquals($persona->telefono, '2121');
//Create
$persona = new Personas($di);
$persona->cedula = 'CELL' . mt_rand(0, 999999);
$persona->tipo_documento_id = 1;
$persona->nombres = 'LOST CREATE';
$persona->telefono = '1';
$persona->cupo = 21000;
$persona->estado = 'A';
$this->assertTrue($persona->create());
$persona = new Personas($di);
$this->assertTrue($persona->create(array('cedula' => 'CELL' . mt_rand(0, 999999), 'tipo_documento_id' => 1, 'nombres' => 'LOST CREATE', 'telefono' => '1', 'cupo' => 21000, 'estado' => 'A')));
//Grouping
$difEstados = People::count(array("distinct" => "estado"));
$this->assertEquals($difEstados, 3);
$group = People::count(array("group" => "estado"));
$this->assertEquals(count($group), 3);
//Deleting
$before = People::count();
$this->assertTrue($persona->delete());
$this->assertEquals($before - 1, People::count());
//Assign
$persona = new Personas();
$persona->assign(array('tipo_documento_id' => 1, 'nombres' => 'LOST CREATE', 'telefono' => '1', 'cupo' => 21000, 'estado' => 'A', 'notField' => 'SOME VALUE'));
$expected = array('cedula' => NULL, 'tipo_documento_id' => 1, 'nombres' => 'LOST CREATE', 'telefono' => '1', 'direccion' => NULL, 'email' => NULL, 'fecha_nacimiento' => NULL, 'ciudad_id' => NULL, 'creado_at' => NULL, 'cupo' => 21000, 'estado' => 'A');
$this->assertEquals($persona->toArray(), $expected);
//Refresh
$persona = Personas::findFirst();
$personaData = $persona->toArray();
$persona->assign(array('tipo_documento_id' => 1, 'nombres' => 'LOST CREATE', 'telefono' => '1', 'cupo' => 21000, 'estado' => 'A', 'notField' => 'SOME VALUE'));
$persona->refresh();
$this->assertEquals($personaData, $persona->toArray());
// Issue 1314
$parts = new Parts2();
$parts->save();
}
<?php
$robotPart = new RobotParts();
$robotPart->type = "head";
$robot = new Robots();
$robot->name = "WALL·E";
$robot->created_at = date("Y-m-d");
$robot->robotPart = $robotPart;
$robot->save();
//Creates an implicit transaction to store both records
public function testMetadataFiles()
{
$di = $this->_getDI();
$di->set('modelsMetadata', function () {
return new Phalcon\Mvc\Model\Metadata\Files(array('metaDataDir' => 'unit-tests/cache/'));
});
@unlink('unit-tests/cache/meta-robots-robots.php');
@unlink('unit-tests/cache/map-robots.php');
$metaData = $di->getShared('modelsMetadata');
$metaData->reset();
$this->assertTrue($metaData->isEmpty());
Robots::findFirst();
$this->assertEquals(require 'unit-tests/cache/meta-robots-robots.php', $this->_data['meta-robots-robots']);
$this->assertEquals(require 'unit-tests/cache/map-robots.php', $this->_data['map-robots']);
$this->assertFalse($metaData->isEmpty());
Robots::findFirst();
}
protected function _executeTestsNormal($di)
{
$number = 0;
$robots = Robots::find();
foreach ($robots as $robot) {
$this->assertTrue(is_object($robot));
$this->assertEquals(get_class($robot), 'Robots');
$number++;
}
$robots->setHydrateMode(Phalcon\Mvc\Model\Resultset::HYDRATE_RECORDS);
foreach ($robots as $robot) {
$this->assertTrue(is_object($robot));
$this->assertEquals(get_class($robot), 'Robots');
$number++;
}
$robots->setHydrateMode(Phalcon\Mvc\Model\Resultset::HYDRATE_ARRAYS);
foreach ($robots as $robot) {
$this->assertTrue(is_array($robot));
$this->assertEquals(count($robot), 4);
$number++;
}
$robots->setHydrateMode(Phalcon\Mvc\Model\Resultset::HYDRATE_OBJECTS);
foreach ($robots as $robot) {
$this->assertTrue(is_object($robot));
$this->assertEquals(get_class($robot), 'stdClass');
$number++;
}
$this->assertEquals($number, 12);
$number = 0;
$people = People::find(array('limit' => 33));
foreach ($people as $person) {
$this->assertTrue(is_object($person));
$this->assertEquals(get_class($person), 'People');
$number++;
}
$people->setHydrateMode(Phalcon\Mvc\Model\Resultset::HYDRATE_RECORDS);
foreach ($people as $person) {
$this->assertTrue(is_object($person));
$this->assertEquals(get_class($person), 'People');
$number++;
}
$people->setHydrateMode(Phalcon\Mvc\Model\Resultset::HYDRATE_ARRAYS);
foreach ($people as $person) {
$this->assertTrue(is_array($person));
$number++;
}
$people->setHydrateMode(Phalcon\Mvc\Model\Resultset::HYDRATE_OBJECTS);
foreach ($people as $person) {
$this->assertTrue(is_object($person));
$this->assertEquals(get_class($person), 'stdClass');
$number++;
}
$this->assertEquals($number, 33 * 4);
}
public function testMetadataRedis()
{
require __DIR__ . '/config.db.php';
if (empty($configMysql)) {
$this->markTestSkipped('Test skipped');
return;
}
if (!extension_loaded('redis')) {
$this->markTestSkipped('Warning: redis extension is not loaded');
return;
}
$di = $this->_getDI();
$di->set('modelsMetadata', function () {
return new Phalcon\Mvc\Model\Metadata\Redis(array("host" => "localhost", "port" => "6379"));
});
$metaData = $di->getShared('modelsMetadata');
$metaData->reset();
$this->assertTrue($metaData->isEmpty());
Robots::findFirst();
$this->assertEquals($metaData->read("meta-robots-robots"), $this->_data['meta-robots-robots']);
$this->assertEquals($metaData->read("map-robots"), $this->_data['map-robots']);
$this->assertFalse($metaData->isEmpty());
$metaData->reset();
$this->assertTrue($metaData->isEmpty());
Robots::findFirst();
}
<?php
use Phalcon\Mvc\Model\Resultset;
$robots = Robots::find(array('hydration' => Resultset::HYDRATE_ARRAYS));
foreach ($robots as $robot) {
echo $robot['year'], PHP_EOL;
}
/**
* Returns an array of allowed URLs
*
* @return array
*/
protected function allowedUrls()
{
return (array) Robots::config()->allowed_urls;
}
<?php
$robot = new Robots();
$robot->type = 'mechanical';
$robot->name = 'Astro Boy';
$robot->year = 1952;
if ($robot->save() == false) {
echo "Umh, We can't store robots right now ";
foreach ($robot->getMessages() as $message) {
echo $message;
}
} else {
echo "Great, a new robot was saved successfully!";
}
<?php
$robot = Robots::findFirst();
$robot->delete();
foreach (Robots::find() as $robot) {
$robot->delete();
}
<?php
$robot = Robots::findFirst(array("type = 'virtual'", "order" => "name DESC", "limit" => 30));
$robots = Robots::find(array("conditions" => "type = ?1", "bind" => array(1 => "virtual")));
public function _testSelectExecute($di)
{
$manager = $di->getShared('modelsManager');
$robots = $manager->executeQuery('SELECT * FROM Robots');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $robots);
$this->assertEquals(count($robots), 3);
$this->assertInstanceOf('Robots', $robots[0]);
$robots = $manager->executeQuery('SELECT * FROM Robots ORDER BY 1');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $robots);
$this->assertEquals(count($robots), 3);
$this->assertInstanceOf('Robots', $robots[0]);
$this->assertEquals($robots[0]->id, 1);
$robots = $manager->executeQuery('SELECT * FROM Robots ORDER BY id');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $robots);
$this->assertEquals(count($robots), 3);
$this->assertInstanceOf('Robots', $robots[0]);
$this->assertEquals($robots[0]->id, 1);
$robots = $manager->executeQuery('SELECT * FROM Robots ORDER BY Robots.id');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $robots);
$this->assertEquals(count($robots), 3);
$this->assertInstanceOf('Robots', $robots[0]);
$this->assertEquals($robots[0]->id, 1);
$robots = $manager->executeQuery('SELECT Robots.* FROM Robots');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $robots);
$this->assertInstanceOf('Robots', $robots[0]);
$this->assertEquals(count($robots), 3);
$robots = $manager->executeQuery('SELECT r.* FROM Robots r');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $robots);
$this->assertInstanceOf('Robots', $robots[0]);
$this->assertEquals(count($robots), 3);
$robots = $manager->executeQuery('SELECT * FROM Robots r');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $robots);
$this->assertInstanceOf('Robots', $robots[0]);
$this->assertEquals(count($robots), 3);
$robots = $manager->executeQuery('SELECT * FROM Robots AS r');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $robots);
$this->assertInstanceOf('Robots', $robots[0]);
$this->assertEquals(count($robots), 3);
$robots = $manager->executeQuery('SELECT * FROM Robots AS r');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $robots);
$this->assertInstanceOf('Robots', $robots[0]);
$this->assertEquals(count($robots), 3);
$result = $manager->executeQuery('SELECT id, name FROM Robots');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 3);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$result = $manager->executeQuery('SELECT Robots.name FROM Robots');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 3);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$result = $manager->executeQuery('SELECT LENGTH(name) AS the_length FROM Robots');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 3);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertTrue(isset($result[0]->the_length));
$this->assertEquals($result[0]->the_length, 8);
$result = $manager->executeQuery('SELECT LENGTH(Robots.name) AS the_length FROM Robots');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 3);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertTrue(isset($result[0]->the_length));
$this->assertEquals($result[0]->the_length, 8);
$result = $manager->executeQuery('SELECT Robots.id+1 AS nextId FROM Robots WHERE id = 1');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 1);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertTrue(isset($result[0]->nextId));
$this->assertEquals($result[0]->nextId, 2);
$result = $manager->executeQuery('SELECT Robots.id+1 AS nextId FROM Robots WHERE id = ?0', array(0 => 1));
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 1);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertTrue(isset($result[0]->nextId));
$this->assertEquals($result[0]->nextId, 2);
$result = $manager->executeQuery('SELECT Robots.id+1 AS nextId FROM Robots WHERE id = :id:', array('id' => 1));
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 1);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertTrue(isset($result[0]->nextId));
$this->assertEquals($result[0]->nextId, 2);
$result = $manager->executeQuery('SELECT Robots.id+1 AS nextId FROM Robots WHERE id = "1"');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 1);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertTrue(isset($result[0]->nextId));
$this->assertEquals($result[0]->nextId, 2);
$result = $manager->executeQuery('SELECT r.year FROM Robots r WHERE TRIM(name) != "Robotina"');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 2);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$result = $manager->executeQuery('SELECT Robots.id+1 AS nextId FROM Robots ORDER BY id');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertEquals(count($result), 3);
$this->assertTrue(isset($result[0]->nextId));
$this->assertEquals($result[0]->nextId, 2);
$result = $manager->executeQuery('SELECT Robots.id+1 AS nextId FROM Robots ORDER BY id LIMIT 2');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertEquals(count($result), 2);
$this->assertTrue(isset($result[0]->nextId));
$this->assertEquals($result[0]->nextId, 2);
$result = $manager->executeQuery('SELECT Robots.id+1 AS nextId FROM Robots ORDER BY id DESC LIMIT 2');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertEquals(count($result), 2);
$this->assertTrue(isset($result[0]->nextId));
$this->assertEquals($result[0]->nextId, 4);
$result = $manager->executeQuery('SELECT r.name FROM Robots r ORDER BY r.name DESC LIMIT 2');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 2);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertTrue(isset($result[0]->name));
$this->assertEquals($result[0]->name, 'Terminator');
$result = $manager->executeQuery('SELECT name le_name FROM Robots ORDER BY name ASC LIMIT 4');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 3);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertTrue(isset($result[0]->le_name));
$this->assertEquals($result[0]->le_name, 'Astro Boy');
$result = $manager->executeQuery('SELECT r.name le_name FROM Robots r ORDER BY r.name ASC LIMIT 4');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 3);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertTrue(isset($result[0]->le_name));
$this->assertEquals($result[0]->le_name, 'Astro Boy');
$result = $manager->executeQuery('SELECT r.name le_name FROM Robots r ORDER BY r.name ASC LIMIT 1,2');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 2);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertTrue(isset($result[0]->le_name));
$this->assertEquals($result[0]->le_name, 'Robotina');
$result = $manager->executeQuery('SELECT r.name le_name FROM Robots r ORDER BY r.name ASC LIMIT 2 OFFSET 1');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 2);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertTrue(isset($result[0]->le_name));
$this->assertEquals($result[0]->le_name, 'Robotina');
$result = $manager->executeQuery('SELECT r.type, COUNT(*) number FROM Robots r GROUP BY 1 ORDER BY r.type ASC');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 2);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertEquals($result[1]->number, 2);
$result = $manager->executeQuery('SELECT r.type, SUM(r.year-1000) age FROM Robots r GROUP BY 1 ORDER BY 2 DESC');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 2);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertEquals($result[0]->age, 1924);
$result = $manager->executeQuery('SELECT r.type, COUNT(*) number FROM Robots r GROUP BY 1 HAVING COUNT(*) = 2');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 1);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertEquals($result[0]->number, 2);
$result = $manager->executeQuery('SELECT r.type, COUNT(*) number FROM Robots r GROUP BY 1 HAVING COUNT(*) < 2');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertEquals(count($result), 1);
$this->assertEquals($result[0]->number, 1);
//Cast function
//TODO: CHAR in postgresql is acually a single char, but I can't specify a length
//for the field type like CHAR(10) because phalcon phql doesn't support it
$cast_type = "CHAR";
if ($di->get("db") instanceof Phalcon\Db\Adapter\Pdo\Postgresql) {
$cast_type = "TEXT";
}
$result = $manager->executeQuery("SELECT CAST(year AS {$cast_type}) test FROM Robots LIMIT 1");
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertEquals(Robots::findFirst()->year, $result[0]->test);
//Convert using... is supported only by mysql (and it's in the sql standards, bad postgresql/sqlite!)
if ($di->get("db") instanceof Phalcon\Db\Adapter\Pdo\Mysql) {
$result = $manager->executeQuery("SELECT CONVERT(year USING utf8) test FROM Robots LIMIT 1");
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertEquals(Robots::findFirst()->year, $result[0]->test);
}
//Nested Cast
$result = $manager->executeQuery("SELECT CAST(CAST(year AS {$cast_type}) AS DECIMAL) test FROM Robots LIMIT 1");
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertEquals(Robots::findFirst()->year, $result[0]->test);
$result = $manager->executeQuery('SELECT r.id, r.* FROM Robots r');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Complex', $result);
$this->assertNotEquals(gettype($result[0]->id), 'object');
$this->assertEquals(gettype($result[0]->r), 'object');
$this->assertEquals(count($result), 3);
$this->assertEquals($result[0]->id, 1);
$result = $manager->executeQuery('SELECT Robots.*, RobotsParts.* FROM Robots JOIN RobotsParts ORDER BY Robots.id, RobotsParts.id');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Complex', $result);
$this->assertEquals(gettype($result[0]->robots), 'object');
$this->assertEquals(get_class($result[0]->robots), 'Robots');
$this->assertEquals(gettype($result[0]->robotsParts), 'object');
$this->assertEquals(get_class($result[0]->robotsParts), 'RobotsParts');
$this->assertEquals(count($result), 3);
$this->assertEquals($result[0]->robots->id, 1);
$this->assertEquals($result[0]->robotsParts->id, 1);
$this->assertEquals($result[1]->robots->id, 1);
$this->assertEquals($result[1]->robotsParts->id, 2);
$result = $manager->executeQuery('SELECT Robots.*, RobotsParts.* FROM Robots JOIN RobotsParts ON Robots.id = RobotsParts.robots_id ORDER BY Robots.id, RobotsParts.id');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Complex', $result);
$this->assertEquals(gettype($result[0]->robots), 'object');
$this->assertEquals(get_class($result[0]->robots), 'Robots');
$this->assertEquals(gettype($result[0]->robotsParts), 'object');
$this->assertEquals(get_class($result[0]->robotsParts), 'RobotsParts');
$this->assertEquals(count($result), 3);
$this->assertEquals($result[0]->robots->id, 1);
$this->assertEquals($result[0]->robotsParts->id, 1);
$this->assertEquals($result[1]->robots->id, 1);
$this->assertEquals($result[1]->robotsParts->id, 2);
$result = $manager->executeQuery('SELECT r.*, p.* FROM Robots r JOIN RobotsParts p ON r.id = p.robots_id ORDER BY r.id, p.id');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Complex', $result);
$this->assertEquals(gettype($result[0]->r), 'object');
$this->assertEquals(get_class($result[0]->r), 'Robots');
$this->assertEquals(gettype($result[0]->p), 'object');
$this->assertEquals(get_class($result[0]->p), 'RobotsParts');
$this->assertEquals(count($result), 3);
$this->assertEquals($result[0]->r->id, 1);
$this->assertEquals($result[0]->p->id, 1);
$this->assertEquals($result[1]->r->id, 1);
$this->assertEquals($result[1]->p->id, 2);
//Joins with namespaces
$result = $manager->executeQuery('SELECT Some\\Robots.*, Some\\RobotsParts.* FROM Some\\Robots JOIN Some\\RobotsParts ON Some\\Robots.id = Some\\RobotsParts.robots_id ORDER BY Some\\Robots.id, Some\\RobotsParts.id');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Complex', $result);
$this->assertEquals(gettype($result[0]->{'some\\Robots'}), 'object');
$this->assertEquals(get_class($result[0]->{'some\\Robots'}), 'Some\\Robots');
$this->assertEquals(gettype($result[0]->{'some\\RobotsParts'}), 'object');
$this->assertEquals(get_class($result[0]->{'some\\RobotsParts'}), 'Some\\RobotsParts');
$this->assertEquals(count($result), 3);
$this->assertEquals($result[0]->{'some\\Robots'}->id, 1);
$this->assertEquals($result[0]->{'some\\RobotsParts'}->id, 1);
$this->assertEquals($result[1]->{'some\\Robots'}->id, 1);
$this->assertEquals($result[1]->{'some\\RobotsParts'}->id, 2);
//Joins with namespaces and aliases
$result = $manager->executeQuery('SELECT r.*, p.* FROM Some\\Robots r JOIN Some\\RobotsParts p ON r.id = p.robots_id ORDER BY r.id, p.id');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Complex', $result);
$this->assertEquals(gettype($result[0]->r), 'object');
$this->assertEquals(get_class($result[0]->r), 'Some\\Robots');
$this->assertEquals(gettype($result[0]->p), 'object');
$this->assertEquals(get_class($result[0]->p), 'Some\\RobotsParts');
$this->assertEquals(count($result), 3);
$this->assertEquals($result[0]->r->id, 1);
$this->assertEquals($result[0]->p->id, 1);
$this->assertEquals($result[1]->r->id, 1);
$this->assertEquals($result[1]->p->id, 2);
$result = $manager->executeQuery('SELECT id, name FROM Some\\Robots');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 3);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$result = $manager->executeQuery('SELECT id, name FROM Some\\Robots ORDER BY name DESC LIMIT 2');
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 2);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
// Issue 1011
$result = $manager->executeQuery('SELECT r.name le_name FROM Robots r ORDER BY r.name ASC LIMIT ?1,?2', array(1 => 1, 2 => 2), array(1 => \Phalcon\Db\Column::BIND_PARAM_INT, 2 => \Phalcon\Db\Column::BIND_PARAM_INT));
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Resultset\\Simple', $result);
$this->assertEquals(count($result), 2);
$this->assertInstanceOf('Phalcon\\Mvc\\Model\\Row', $result[0]);
$this->assertTrue(isset($result[0]->le_name));
$this->assertEquals($result[0]->le_name, 'Robotina');
}
<?php
$robots = Robots::find('id < 1000');
$robots = Robots::find('id > 100 AND type = "A"');
$robots = Robots::find('(id > 100 AND type = "A") AND id < 2000');
$robots = Robots::find(array('(id > ?0 AND type = "A") AND id < ?1', 'bind' => array(100, 2000), 'order' => 'type'));
<?php
$robots = Robots::find(array(array("type" => "mechanical")));
foreach ($robots as $robot) {
if ($robot->delete() == false) {
echo "Sorry, we can't delete the robot right now: \n";
foreach ($robot->getMessages() as $message) {
echo $message, "\n";
}
} else {
echo "The robot was deleted successfully!";
}
}
<?php
$robot = Robots::findFirst();
$form = new Form($robot);
$form->add(new Text("name"));
$form->add(new Text("year"));
