As with most Query tools in RedBean you can provide values to
be inserted in the SQL statement by populating the value
array parameter; you can either use the question mark notation
or the slot-notation (:keyname).
/** * Logs admin into the system * @param $login * @param $password * @return \SkullyAdmin\Models\Admin|null */ public function login($login, $password) { /** @var \RedBean_SimpleModel $adminBean */ $adminBean = R::findOne('admin', "status = ? and email = ?", array(Admin::STATUS_ACTIVE, $login)); if (!empty($adminBean)) { /** @var \SkullyAdmin\Models\Admin $admin */ $admin = $adminBean->box(); if ($admin->get('password_hash') == UtilitiesHelper::toHash($password, $admin->get('salt'), $this->app->config('globalSalt'))) { $adminSessions = R::find('adminsession', "admin_id = ?", array($admin->getID())); if (!empty($adminSessions)) { R::trashAll($adminSessions); } // when everything ok, regenerate session session_regenerate_id(true); // change session ID for the current session and invalidate old session ID $adminId = $admin->getID(); $sessionId = session_id(); $adminsession = $this->app->createModel('adminsession', array("admin_id" => $adminId, "session_id" => $sessionId)); $this->app->getSession()->set('adminId', $admin->getID()); R::store($adminsession); return $admin; } } return null; }
/** * Test to make sure stash cache works with recursively opening models * with FUSE. * * @return void */ public function testIssue259() { testpack('Testing Issue #259 - Stash Cache breaks model delegation in open().'); $mother = R::dispense('mother'); $mother->desc = 'I am mother'; R::store($mother); $child = R::dispense('child'); $child->mother = $mother; $child->desc = 'I am child'; $id = R::store($child); R::findOne('child', ' id = ?', array($id)); R::find('child', ' id = ? ', array($id)); R::load('child', $id); }
/** * In the past it was not possible to export beans * like 'feed' (Model_Feed). * * @return void */ public function testExportIssue() { R::nuke(); $feed = R::dispense('feed'); $feed->post = array('first', 'second'); R::store($feed); $rows = R::getAll('SELECT * FROM feed'); asrt($rows[0]['post'], '["first","second"]'); $feed = $feed->fresh(); asrt(is_array($feed->post), TRUE); asrt($feed->post[0], 'first'); asrt($feed->post[1], 'second'); R::store($feed); $rows = R::getAll('SELECT * FROM feed'); asrt($rows[0]['post'], '["first","second"]'); $feed = R::load('feed', $feed->id); $feed->post[] = 'third'; R::store($feed); $rows = R::getAll('SELECT * FROM feed'); asrt($rows[0]['post'], '["first","second","third"]'); $feed = $feed->fresh(); asrt(is_array($feed->post), TRUE); asrt($feed->post[0], 'first'); asrt($feed->post[1], 'second'); asrt($feed->post[2], 'third'); //now the catch: can we use export? //PHP Fatal error: Call to a member function export() on a non-object $feeds = R::exportAll(R::find('feed')); asrt(is_array($feeds), TRUE); $feed = reset($feeds); asrt($feed['post'][0], 'first'); asrt($feed['post'][1], 'second'); asrt($feed['post'][2], 'third'); //can we also dup()? $feedOne = R::findOne('feed'); R::store(R::dup($feedOne)); asrt(R::count('feed'), 2); //can we delete? R::trash($feedOne); asrt(R::count('feed'), 1); $feedTwo = R::findOne('feed'); $feed = $feedTwo->export(); asrt($feed['post'][0], 'first'); asrt($feed['post'][1], 'second'); asrt($feed['post'][2], 'third'); }
/** * Test effects of cache. * * @return void */ public function testCachingEffects() { testpack('Testing WriteCache Query Writer Cache'); R::useWriterCache(FALSE); R::debug(true, 1); $logger = R::getDatabaseAdapter()->getDatabase()->getLogger(); $book = R::dispense('book')->setAttr('title', 'ABC'); $book->ownPage[] = R::dispense('page'); $id = R::store($book); // Test load cache -- without $logger->clear(); $book = R::load('book', $id); $book = R::load('book', $id); asrt(count($logger->grep('SELECT')), 2); // With cache R::useWriterCache(TRUE); $logger->clear(); $book = R::load('book', $id); $book = R::load('book', $id); asrt(count($logger->grep('SELECT')), 1); R::useWriterCache(FALSE); // Test find cache $logger->clear(); $book = R::find('book'); $book = R::find('book'); asrt(count($logger->grep('SELECT')), 2); // With cache R::getWriter()->setUseCache(TRUE); $logger->clear(); $book = R::find('book'); $book = R::find('book'); asrt(count($logger->grep('SELECT')), 1); R::getWriter()->setUseCache(FALSE); // Test combinations $logger->clear(); $book = R::findOne('book', ' id = ? ', array($id)); $book->ownPage; R::batch('book', array($id)); $book = R::findOne('book', ' id = ? ', array($id)); $book->ownPage; R::batch('book', array($id)); asrt(count($logger->grep('SELECT')), 6); // With cache R::getWriter()->setUseCache(TRUE); $logger->clear(); R::batch('book', array($id)); $book = R::findOne('book', ' id = ? ', array($id)); $book->ownPage; $book = R::findOne('book', ' id = ? ', array($id)); $book->ownPage; asrt(count($logger->grep('SELECT')), 3); R::getWriter()->setUseCache(FALSE); // Test auto flush $logger->clear(); $book = R::findOne('book'); $book->name = 'X'; R::store($book); $book = R::findOne('book'); asrt(count($logger->grep('SELECT *')), 2); // With cache R::getWriter()->setUseCache(TRUE); $logger->clear(); $book = R::findOne('book'); $book->name = 'Y'; // Will flush R::store($book); $book = R::findOne('book'); // Now the same, auto flushed asrt(count($logger->grep('SELECT *')), 2); R::getWriter()->setUseCache(FALSE); // Test whether delete flushes as well (because uses selectRecord - might be a gotcha!) R::store(R::dispense('garbage')); $garbage = R::findOne('garbage'); $logger->clear(); $book = R::findOne('book'); R::trash($garbage); $book = R::findOne('book'); asrt(count($logger->grep('SELECT *')), 2); R::store(R::dispense('garbage')); $garbage = R::findOne('garbage'); // With cache R::getWriter()->setUseCache(TRUE); $logger->clear(); $book = R::findOne('book'); R::trash($garbage); $book = R::findOne('book'); // Now the same, auto flushed asrt(count($logger->grep('SELECT *')), 2); R::getWriter()->setUseCache(FALSE); R::store(R::dispense('garbage')); $garbage = R::findOne('garbage'); // With cache R::getWriter()->setUseCache(TRUE); $logger->clear(); $book = R::findOne('book'); R::getWriter()->queryRecord('garbage', array('id' => array($garbage->id))); $book = R::findOne('book'); // Now the same, auto flushed asrt(count($logger->grep('SELECT *')), 2); $page = R::dispense('page'); $book->sharedPage[] = $page; R::store($book); $logger->clear(); $link = R::getWriter()->queryRecordLink('book', 'page', $book->id, $page->id); asrt(count($logger->grep('SELECT')), 1); $link = R::getWriter()->queryRecordLink('book', 'page', $book->id, $page->id); asrt(count($logger->grep('SELECT')), 1); R::getWriter()->setUseCache(FALSE); $link = R::getWriter()->queryRecordLink('book', 'page', $book->id, $page->id); asrt(count($logger->grep('SELECT')), 2); R::getWriter()->setUseCache(TRUE); }
/** * Test common Facade usage scenarios. * * @return void */ public function testCommonUsageFacade() { $toolbox = R::getToolBox(); $adapter = $toolbox->getDatabaseAdapter(); $writer = $toolbox->getWriter(); $redbean = $toolbox->getRedBean(); $pdo = $adapter->getDatabase(); $a = new AssociationManager($toolbox); asrt(R::getRedBean() instanceof OODB, TRUE); asrt(R::getToolBox() instanceof ToolBox, TRUE); asrt(R::getDatabaseAdapter() instanceof Adapter, TRUE); asrt(R::getWriter() instanceof QueryWriter, TRUE); $book = R::dispense("book"); asrt($book instanceof OODBBean, TRUE); $book->title = "a nice book"; $id = R::store($book); asrt($id > 0, TRUE); $book = R::load("book", (int) $id); asrt($book->title, "a nice book"); asrt(R::load('book', 999)->title, NULL); R::freeze(TRUE); try { R::load('bookies', 999); fail(); } catch (\Exception $e) { pass(); } R::freeze(FALSE); $author = R::dispense("author"); $author->name = "me"; R::store($author); $book9 = R::dispense("book"); $author9 = R::dispense("author"); $author9->name = "mr Nine"; $a9 = R::store($author9); $book9->author_id = $a9; $bk9 = R::store($book9); $book9 = R::load("book", $bk9); $author = R::load("author", $book9->author_id); asrt($author->name, "mr Nine"); R::trash($author); R::trash($book9); pass(); $book2 = R::dispense("book"); $book2->title = "second"; R::store($book2); $book3 = R::dispense("book"); $book3->title = "third"; R::store($book3); asrt(count(R::find("book")), 3); asrt(count(R::findAll("book")), 3); asrt(count(R::findAll("book", " LIMIT 2")), 2); asrt(count(R::find("book", " id=id ")), 3); asrt(count(R::find("book", " title LIKE ?", array("third"))), 1); asrt(count(R::find("book", " title LIKE ?", array("%d%"))), 2); // Find without where clause asrt(count(R::findAll('book', ' order by id')), 3); R::trash($book3); R::trash($book2); asrt(count(R::getAll("SELECT * FROM book ")), 1); asrt(count(R::getCol("SELECT title FROM book ")), 1); asrt((int) R::getCell("SELECT 123 "), 123); $book = R::dispense("book"); $book->title = "not so original title"; $author = R::dispense("author"); $author->name = "Bobby"; R::store($book); $aid = R::store($author); $author = R::findOne("author", " name = ? ", array("Bobby")); }
/** * Test Facade bind function method. * Test for MySQL WKT spatial format. */ public function testFunctionFilters() { R::nuke(); R::bindFunc('read', 'location.point', 'asText'); R::bindFunc('write', 'location.point', 'GeomFromText'); R::store(R::dispense('location')); R::freeze(true); try { R::find('location'); fail(); } catch (SQL $exception) { pass(); } R::freeze(false); try { R::find('location'); pass(); } catch (SQL $exception) { fail(); } $location = R::dispense('location'); $location->point = 'POINT(14 6)'; R::store($location); $columns = R::inspect('location'); asrt($columns['point'], 'point'); $location = $location->fresh(); asrt($location->point, 'POINT(14 6)'); R::nuke(); $location = R::dispense('location'); $location->point = 'LINESTRING(0 0,1 1,2 2)'; R::store($location); $columns = R::inspect('location'); asrt($columns['point'], 'linestring'); $location->bustcache = 2; R::store($location); $location = $location->fresh(); asrt($location->point, 'LINESTRING(0 0,1 1,2 2)'); R::nuke(); $location = R::dispense('location'); $location->point = 'POLYGON((0 0,10 0,10 10,0 10,0 0),(5 5,7 5,7 7,5 7,5 5))'; R::store($location); $columns = R::inspect('location'); asrt($columns['point'], 'polygon'); $location->bustcache = 4; R::store($location); $location = $location->fresh(); asrt($location->point, 'POLYGON((0 0,10 0,10 10,0 10,0 0),(5 5,7 5,7 7,5 7,5 5))'); R::bindFunc('read', 'location.point', NULL); $location->bustcache = 1; R::store($location); $location = $location->fresh(); asrt($location->point === 'POLYGON((0 0,10 0,10 10,0 10,0 0),(5 5,7 5,7 7,5 7,5 5))', FALSE); $filters = AQueryWriter::getSQLFilters(); asrt(is_array($filters), TRUE); asrt(count($filters), 2); asrt(isset($filters[QueryWriter::C_SQLFILTER_READ]), TRUE); asrt(isset($filters[QueryWriter::C_SQLFILTER_WRITE]), TRUE); R::bindFunc('read', 'place.point', 'asText'); R::bindFunc('write', 'place.point', 'GeomFromText'); R::bindFunc('read', 'place.line', 'asText'); R::bindFunc('write', 'place.line', 'GeomFromText'); R::nuke(); $place = R::dispense('place'); $place->point = 'POINT(13.2 666.6)'; $place->line = 'LINESTRING(9.2 0,3 1.33)'; R::store($place); $columns = R::inspect('place'); asrt($columns['point'], 'point'); asrt($columns['line'], 'linestring'); $place = R::findOne('place'); asrt($place->point, 'POINT(13.2 666.6)'); asrt($place->line, 'LINESTRING(9.2 0,3 1.33)'); R::bindFunc('read', 'place.point', NULL); R::bindFunc('write', 'place.point', NULL); R::bindFunc('read', 'place.line', NULL); R::bindFunc('write', 'place.line', NULL); }
function accueil() { global $twig, $base, $titre; $personnes = R::find("personnes"); return $twig->render("accueil.html", compact("base", "titre", "personnes")); }
/** * Test many different scenarios with self referential * many-to-many relations. * * @return void */ public function testSelfReferentialCRUD() { R::nuke(); $buddies = R::dispense('buddy', 4); $buddies[0]->name = 'A'; $buddies[1]->name = 'B'; $buddies[2]->name = 'C'; $buddies[3]->name = 'D'; $buddies[0]->sharedBuddyList = array($buddies[1], $buddies[2]); $buddies[3]->sharedBuddyList = array($buddies[2]); R::storeAll($buddies); $buddies[0] = $buddies[0]->fresh(); asrt(count($buddies[0]->sharedBuddyList), 2); //does this yield valid combinations - cross relations / self ref n-m //need to symmetric.... $names = R::gatherLabels($buddies[0]->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'B,C'); unset($buddies[0]->sharedBuddy); R::storeAll($buddies); $buddies[0] = $buddies[0]->fresh(); asrt(count($buddies[0]->sharedBuddyList), 2); $buddies[3] = $buddies[3]->fresh(); asrt(count($buddies[3]->sharedBuddyList), 1); $names = R::gatherLabels($buddies[3]->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'C'); $buddies[2] = $buddies[2]->fresh(); asrt(count($buddies[2]->sharedBuddyList), 2); $names = R::gatherLabels($buddies[2]->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'A,D'); $buddies[1] = $buddies[1]->fresh(); asrt(count($buddies[1]->sharedBuddyList), 1); $names = R::gatherLabels($buddies[1]->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'A'); //Can we add one? $buddies[1]->sharedBuddyList[] = R::dispense('buddy')->setAttr('name', 'E'); R::store($buddies[1]); $buddies[0] = $buddies[0]->fresh(); asrt(count($buddies[0]->sharedBuddyList), 2); $names = R::gatherLabels($buddies[0]->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'B,C'); $buddies[1] = $buddies[1]->fresh(); asrt(count($buddies[1]->sharedBuddyList), 2); $names = R::gatherLabels($buddies[1]->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'A,E'); $all = R::find('buddy'); asrt(count($all), 5); foreach ($buddies[1]->sharedBuddy as $buddy) { if ($buddy->name === 'E') { $buddyE = $buddy; } } asrt(isset($buddyE), TRUE); asrt($buddyE->name, 'E'); //can we update? foreach ($buddies[0]->sharedBuddy as $buddy) { if ($buddy->name === 'C') { $buddy->name = 'C2'; } } R::store($buddies[0]); $buddies[0] = $buddies[0]->fresh(); asrt(count($buddies[0]->sharedBuddyList), 2); $names = R::gatherLabels($buddies[0]->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'B,C2'); $buddies[2] = $buddies[2]->fresh(); asrt(count($buddies[2]->sharedBuddyList), 2); $names = R::gatherLabels($buddies[2]->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'A,D'); //can we delete? foreach ($buddies[0]->sharedBuddyList as $id => $buddy) { if ($buddy->name === 'B') { unset($buddies[0]->sharedBuddyList[$id]); } } R::store($buddies[0]); $buddies[0] = $buddies[0]->fresh(); asrt(count($buddies[0]->sharedBuddyList), 1); $names = R::gatherLabels($buddies[0]->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'C2'); $buddies[1] = $buddies[1]->fresh(); asrt(count($buddies[1]->sharedBuddyList), 1); $names = R::gatherLabels($buddies[1]->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'E'); asrt(R::count('buddy'), 5); asrt(R::count('buddyBuddy'), 3); $buddies[3] = $buddies[3]->fresh(); asrt(count($buddies[3]->sharedBuddyList), 1); $names = R::gatherLabels($buddies[3]->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'C2'); $buddies[2] = $buddies[2]->fresh(); asrt(count($buddies[2]->sharedBuddyList), 2); $names = R::gatherLabels($buddies[2]->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'A,D'); $buddyE = $buddyE->fresh(); asrt(count($buddyE->sharedBuddyList), 1); $names = R::gatherLabels($buddyE->sharedBuddyList); sort($names); $names = implode(',', $names); asrt($names, 'B'); //can we access linked_by -- o dear mysql again! cant have alias in WHERE! if ($this->currentlyActiveDriverID === 'mysql') { $buddyE = $buddyE->fresh(); asrt(count($buddyE->with(' HAVING linked_by > 0 ')->sharedBuddyList), 1); $buddyE = $buddyE->fresh(); asrt(count($buddyE->with(' HAVING linked_by < 0 ')->sharedBuddyList), 0); } //even postgres sucks. Only SQLite knows how to handle this. //I dont give a f**k whether it's an SQL standard or not, it should just work. if ($this->currentlyActiveDriverID === 'sqlite') { $buddyE = $buddyE->fresh(); asrt(count($buddyE->withCondition(' linked_by > 0 ')->sharedBuddyList), 1); $buddyE = $buddyE->fresh(); asrt(count($buddyE->withCondition(' linked_by < 0 ')->sharedBuddyList), 0); } $buddyE = $buddyE->fresh(); asrt(count($buddyE->withCondition(' buddy_buddy.buddy_id > 0 AND buddy_buddy.buddy2_id > 0 ')->sharedBuddyList), 1); $buddyE = $buddyE->fresh(); asrt(count($buddyE->withCondition(' buddy_buddy.buddy_id < 0 AND buddy_buddy.buddy2_id < 0 ')->sharedBuddyList), 0); }
/** * Test Full fluid UUID support. * */ public function testFullSupport() { //Rewire objects to support UUIDs. $oldToolBox = R::getToolBox(); $oldAdapter = $oldToolBox->getDatabaseAdapter(); $uuidWriter = new \UUIDWriterPostgres($oldAdapter); $newRedBean = new OODB($uuidWriter); $newToolBox = new ToolBox($newRedBean, $oldAdapter, $uuidWriter); R::configureFacadeWithToolbox($newToolBox); list($mansion, $rooms, $ghosts, $key) = R::dispenseAll('mansion,room*3,ghost*4,key'); $mansion->name = 'Haunted Mansion'; $mansion->xownRoomList = $rooms; $rooms[0]->name = 'Green Room'; $rooms[1]->name = 'Red Room'; $rooms[2]->name = 'Blue Room'; $ghosts[0]->name = 'zero'; $ghosts[1]->name = 'one'; $ghosts[2]->name = 'two'; $ghosts[3]->name = 'three'; $rooms[0]->noLoad()->sharedGhostList = array($ghosts[0], $ghosts[1]); $rooms[1]->noLoad()->sharedGhostList = array($ghosts[0], $ghosts[2]); $rooms[2]->noLoad()->sharedGhostList = array($ghosts[1], $ghosts[3], $ghosts[2]); $rooms[2]->xownKey = array($key); //Can we store a bean hierachy with UUIDs? R::debug(1); $id = R::store($mansion); //exit; asrt(is_string($id), TRUE); asrt(strlen($id), 36); $haunted = R::load('mansion', $id); asrt($haunted->name, 'Haunted Mansion'); asrt(is_string($haunted->id), TRUE); asrt(strlen($haunted->id), 36); asrt(is_array($haunted->xownRoomList), TRUE); asrt(count($haunted->ownRoom), 3); $rooms = $haunted->xownRoomList; //Do some counting... $greenRoom = NULL; foreach ($rooms as $room) { if ($room->name === 'Green Room') { $greenRoom = $room; break; } } asrt(!is_null($greenRoom), TRUE); asrt(is_array($greenRoom->with(' ORDER BY id ')->sharedGhostList), TRUE); asrt(count($greenRoom->sharedGhostList), 2); $names = array(); foreach ($greenRoom->sharedGhost as $ghost) { $names[] = $ghost->name; } sort($names); $names = implode(',', $names); asrt($names, 'one,zero'); $rooms = $haunted->xownRoomList; $blueRoom = NULL; foreach ($rooms as $room) { if ($room->name === 'Blue Room') { $blueRoom = $room; break; } } asrt(!is_null($blueRoom), TRUE); asrt(is_array($blueRoom->sharedGhostList), TRUE); asrt(count($blueRoom->sharedGhostList), 3); $names = array(); foreach ($blueRoom->sharedGhost as $ghost) { $names[] = $ghost->name; } sort($names); $names = implode(',', $names); asrt($names, 'one,three,two'); $rooms = $haunted->xownRoomList; $redRoom = NULL; foreach ($rooms as $room) { if ($room->name === 'Red Room') { $redRoom = $room; break; } } $names = array(); foreach ($redRoom->sharedGhost as $ghost) { $names[] = $ghost->name; } sort($names); $names = implode(',', $names); asrt($names, 'two,zero'); asrt(!is_null($redRoom), TRUE); asrt(is_array($redRoom->sharedGhostList), TRUE); asrt(count($redRoom->sharedGhostList), 2); //Can we repaint a room? $redRoom->name = 'Yellow Room'; $id = R::store($redRoom); $yellowRoom = R::load('room', $id); asrt($yellowRoom->name, 'Yellow Room'); asrt(!is_null($yellowRoom), TRUE); asrt(is_array($yellowRoom->sharedGhostList), TRUE); asrt(count($yellowRoom->sharedGhostList), 2); //Can we throw one ghost out? array_pop($yellowRoom->sharedGhost); R::store($yellowRoom); $yellowRoom = $yellowRoom->fresh(); asrt($yellowRoom->name, 'Yellow Room'); asrt(!is_null($yellowRoom), TRUE); asrt(is_array($yellowRoom->sharedGhostList), TRUE); asrt(count($yellowRoom->sharedGhostList), 1); //can we remove one of the rooms? asrt(R::count('key'), 1); $list = $mansion->withCondition(' "name" = ? ', array('Blue Room'))->xownRoomList; $room = reset($list); unset($mansion->xownRoomList[$room->id]); R::store($mansion); asrt(R::count('room'), 2); //and what about its dependent beans? asrt(R::count('key'), 0); asrt(R::count('ghost_room'), 3); //and can we find ghosts? $ghosts = R::find('ghost'); asrt(count($ghosts), 4); $ghosts = R::findAll('ghost', 'ORDER BY id'); asrt(count($ghosts), 4); $ghosts = R::findAll('ghost', 'ORDER BY id LIMIT 2'); asrt(count($ghosts), 2); $ghostZero = R::findOne('ghost', ' "name" = ? ', array('zero')); asrt($ghostZero instanceof OODBBean, TRUE); //can we create link properties on existing tables? $blackRoom = R::dispense('room'); $blackRoom->name = 'Black Room'; $ghostZero->link('ghost_room', array('mood' => 'grumpy'))->room = $blackRoom; R::store($ghostZero); $ghostZero = $ghostZero->fresh(); $list = $ghostZero->sharedRoomList; asrt(count($list), 3); $ghostZero = $ghostZero->fresh(); $list = $ghostZero->withCondition(' ghost_room.mood = ? ', array('grumpy'))->sharedRoomList; asrt(count($list), 1); //can we load a batch? $ids = R::getCol('SELECT id FROM ghost'); $ghosts = R::batch('ghost', $ids); asrt(count($ghosts), 4); //can we do an aggregation? $ghosts = $greenRoom->aggr('ownGhostRoom', 'ghost', 'ghost'); asrt(count($ghosts), 2); //can we duplicate the mansion? asrt(R::count('mansion'), 1); asrt(R::count('room'), 3); asrt(R::count('ghost'), 4); $copy = R::dup($mansion); R::store($copy); asrt(R::count('mansion'), 2); asrt(R::count('room'), 5); //black room does not belong to mansion 1 asrt(R::count('ghost'), 4); //can we do some counting using the list? asrt($copy->countOwn('room'), 2); $rooms = $copy->withCondition(' "name" = ? ', array('Green Room'))->xownRoomList; $room = reset($rooms); asrt($room->countShared('ghost'), 2); //Finally restore old toolbox R::configureFacadeWithToolbox($oldToolBox); }
function deletePackageCost($id) { $packageCost = R::find('packagecost', 'id=?', [$id]); R::trashAll($packageCost); }
/** * @param int $startIndex * @param int $numItems * @return array */ public function getsystemlogs_paged($startIndex, $numItems, $userid = NULL) { try { $rows = R::find($this->tbname, ' LIMIT ? , ? ', array($startIndex, $numItems)); $rows = R::prepareForAMF(R::convertBeanToArray($rows), array(0 => $this->tbname)); return $rows; } catch (Exception $e) { throw new Exception($e->getMessage()); } }
/** * Test error handling of SQL states. * * @return void */ public function testFindError() { R::freeze(FALSE); $page = R::dispense('page'); $page->title = 'abc'; R::store($page); //Column does not exist, in fluid mode no error! try { R::find('page', ' xtitle = ? ', array('x')); pass(); } catch (SQL $e) { fail(); } //Table does not exist, in fluid mode no error! try { R::find('pagex', ' title = ? ', array('x')); pass(); } catch (SQL $e) { fail(); } //Syntax error, error in fluid mode if possible to infer from SQLSTATE (MySQL/Postgres) try { R::find('page', ' invalid SQL '); //In SQLite only get HY000 - not very descriptive so suppress more errors in fluid mode then. if ($this->currentlyActiveDriverID === 'sqlite' || $this->currentlyActiveDriverID === 'CUBRID') { pass(); } else { fail(); } } catch (SQL $e) { pass(); } //Frozen, always error... R::freeze(TRUE); //Column does not exist, in frozen mode error! try { R::find('page', ' xtitle = ? ', array('x')); fail(); } catch (SQL $e) { pass(); } //Table does not exist, in frozen mode error! try { R::find('pagex', ' title = ? ', array('x')); fail(); } catch (SQL $e) { pass(); } //Syntax error, in frozen mode error! try { R::find('page', ' invalid SQL '); fail(); } catch (SQL $e) { pass(); } R::freeze(FALSE); }
/** * Test exporting with filters. * * @return void */ public function ExportWithFilters() { testpack('Export with filters'); $book = R::dispense('book'); $pages = R::dispense('page', 2); $texts = R::dispense('text', 2); $images = R::dispense('image', 2); $author = R::dispense('author'); $pub = R::dispense('publisher'); $bookmarks = R::dispense('bookmark', 2); $pages[0]->ownText = array($texts[0]); $pages[0]->ownImage = array($images[0]); $pages[1]->ownText = array($texts[1]); $pages[1]->ownImage = array($images[1]); $pages[0]->sharedBookmark[] = $bookmarks[0]; $pages[1]->sharedBookmark[] = $bookmarks[1]; $bookmarks[0]->ownNote[] = R::dispense('note')->setAttr('text', 'a note'); $bookmarks[1]->ownNote[] = R::dispense('note')->setAttr('text', 'a note'); $book->ownPage = $pages; $book->author = $author; $author->publisher = $pub; $bookID = R::store($book); R::getDuplicationManager()->setTables(R::getWriter()->getTables()); $objects = R::exportAll(array($book), TRUE, array()); asrt(isset($objects[0]['ownPage']), TRUE); asrt(count($objects[0]['ownPage']), 2); asrt(isset($objects[0]['author']), TRUE); asrt(isset($objects[0]['ownPage'][0]['ownText']), TRUE); asrt(count($objects[0]['ownPage'][0]['ownText']), 1); asrt(isset($objects[0]['ownPage'][0]['ownImage']), TRUE); asrt(count($objects[0]['ownPage'][0]['ownImage']), 1); $objects = R::exportAll(array($book), TRUE, array('page', 'author', 'text', 'image')); asrt(isset($objects[0]['ownPage']), TRUE); asrt(count($objects[0]['ownPage']), 2); asrt(isset($objects[0]['author']), TRUE); asrt(isset($objects[0]['ownPage'][0]['ownText']), TRUE); asrt(count($objects[0]['ownPage'][0]['ownText']), 1); asrt(isset($objects[0]['ownPage'][0]['ownImage']), TRUE); asrt(count($objects[0]['ownPage'][0]['ownImage']), 1); $objects = R::exportAll(array($book), TRUE, 'author'); asrt(isset($objects[0]['ownPage']), FALSE); asrt(isset($objects[0]['ownPage'][0]['ownText']), FALSE); $objects = R::exportAll(array($book), TRUE, array('page')); asrt(isset($objects[0]['author']), FALSE); asrt(isset($objects[0]['ownPage'][0]['ownText']), FALSE); $objects = R::exportAll(array($book), TRUE, array('page', 'text')); asrt(isset($objects[0]['author']), FALSE); asrt(isset($objects[0]['ownPage']), TRUE); asrt(isset($objects[0]['ownPage'][0]['ownText']), TRUE); asrt(count($objects[0]['ownPage'][0]['ownText']), 1); asrt(isset($objects[0]['ownPage'][0]['ownImage']), FALSE); $objects = R::exportAll(array($book), TRUE, array('none')); asrt(isset($objects[0]['author']), FALSE); asrt(isset($objects[0]['ownPage']), FALSE); $texts = R::find('text'); R::getDuplicationManager()->setCacheTables(FALSE); testpack('Keyless export'); $book = R::load('book', $bookID); $book->ownPage; $export = $book->export(); asrt(isset($export['ownPage'][0]), TRUE); }
$lines = R::exportAll(R::find('line', 'WHERE start_point_id=' . $city[0]['id'])); $timetableCityDay = array(); foreach ($lines as $line) { $timetable = R::exportAll(R::find('timetable', 'WHERE line_id=' . $line['id'] . ' AND day=' . $day)); var_dump($timetable); if (!empty($timetable)) { $timetableCityDay[] = array($timetable[0]['start_time'], $line['end_point_id']); } } echo json_encode($timetableCityDay); }); //return all the cities with coordinates $app->get('/city', function () { $city = R::exportAll(R::find('city')); echo json_encode($city); }); //Return line,price,start_time and distance by name city departure and name city arrival $app->get('/nextStart/:cityNameDeparture/:cityNameArrival', function ($cityNameDeparture, $cityNameArrival) { $cityDeparture = R::exportAll(R::find('city', 'WHERE name="' . $cityNameDeparture . '"')); $cityArrival = R::exportAll(R::find('city', 'WHERE name="' . $cityNameArrival . '"')); $lines = R::exportAll(R::find('line', 'WHERE start_point_id=' . $cityDeparture[0]['id'] . ' AND end_point_id=' . $cityArrival[0]['id'])); $timetableTrip = array(); foreach ($lines as $line) { $timetable = R::exportAll(R::find('timetable', 'WHERE line_id=' . $line['id'])); if (!empty($timetable)) { $timetableTrip[] = array($timetable[0]['start_time'], $line['price'], $line['distance'], $line['end_point_id']); } } echo json_encode($timetableTrip); }); $app->run();