protected function connect($db_conf)
{
try {
if ($db_conf == null) {
$resource_id = ezcDbFactory::create('mysql://localhost/');
} else {
$resource_id = ezcDbFactory::create('mysql://' . $db_conf['username'] . ':' . $db_conf['password'] . '@' . $db_conf['host'] . ':' . $db_conf['port'] . '/' . $db_conf['db_name']);
}
} catch (Exception $ex) {
return false;
}
$this->_dbConfig = $db_conf;
$this->_ezDb = $resource_id;
/*
try{
$sQuery = 'SET NAMES UTF8';
$rResult = $this->Query($sQuery);
$sQuery = 'SET CHARACTER SET UTF8';
$rResult = $this->Query($sQuery);
$sQuery = 'SET COLLATION_CONNECTION = "utf8_general_ci"';
$rResult = $this->Query($sQuery);
}catch(Exception $ex){
}
*/
return true;
}
function step2()
{
$Errors = array();
$database = $this->settings['db'];
foreach ($database as $key => $value) {
if (!filter_var($database[$key], FILTER_UNSAFE_RAW)) {
$Errors[] = "Please enter database {$key}";
}
}
if (!filter_var($database['database'], FILTER_SANITIZE_STRING)) {
$Errors[] = 'Please enter database name';
}
if (count($Errors) == 0) {
try {
$db = ezcDbFactory::create("mysql://{$database['user']}:{$database['password']}@{$database['host']}:{$database['port']}/{$database['database']}");
} catch (Exception $e) {
$Errors[] = "Cannot login with provided logins. Returned message: " . $e->getMessage();
}
}
if (count($Errors) == 0) {
$cfgSite = erConfigClassLhConfig::getInstance();
foreach ($database as $key => $value) {
$cfgSite->setSetting('db', $key, $value);
}
$cfgSite->setSetting('site', 'secrethash', substr(md5(time() . ":" . mt_rand()), 0, 10));
return true;
} else {
return $Errors;
}
}
function R3AppInitDB()
{
global $mdb2;
global $dsn;
require_once 'MDB2.php';
if (!isset($dsn) || $dsn == '') {
throw new Exception('Missing $dsn');
}
$txtDsn = $dsn['dbtype'] . '://' . $dsn['dbuser'] . ':' . $dsn['dbpass'] . '@' . $dsn['dbhost'] . '/' . $dsn['dbname'];
$db = ezcDbFactory::create($txtDsn);
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
PEAR::setErrorHandling(PEAR_ERROR_EXCEPTION);
$mdb2 = MDB2::singleton($txtDsn);
// Needed by user manager and import/export
ezcDbInstance::set($db);
if (isset($dsn['charset'])) {
$db->exec("SET client_encoding TO '{$dsn['charset']}'");
$mdb2->exec("SET client_encoding TO '{$dsn['charset']}'");
}
if (isset($dsn['search_path'])) {
$db->exec("SET search_path TO {$dsn['search_path']}, public");
$mdb2->exec("SET search_path TO {$dsn['search_path']}, public");
}
$db->exec("SET datestyle TO ISO");
$mdb2->exec("SET datestyle TO ISO");
}
public static function create()
{
// create instance
if (self::$dbParams === null) {
throw new Exception("Missing database " . "connection parameteters.");
}
return ezcDbFactory::create(self::$dbParams);
}
public function setUp()
{
try {
$this->db = ezcDbFactory::create('sqlite://:memory:');
} catch (Exception $e) {
$this->markTestSkipped('Missing SQLite support to use query abstraction.');
}
}
protected function getEmptyDb()
{
$schema = ezcDbSchema::createFromFile('xml', TESTPATH . '../src/schema.xml');
// $db = ezcDbFactory::create("sqlite://:memory:");
$db = ezcDbFactory::create("sqlite:///home/ymc-toko/sqlite");
$schema->writeToDb($db);
return $db;
}
static function configureObject($identifier)
{
if ($identifier !== false) {
switch ($identifier) {
case 'delayed1':
return ezcDbFactory::create('sqlite://:memory:');
}
}
}
public function testUppercaseDataTypes()
{
$path = dirname(__FILE__) . '/testfiles/bug13072.sqlite';
$db = ezcDbFactory::create("sqlite://{$path}");
$newSchema = ezcDbSchema::createFromDb($db);
$schema = $newSchema->getSchema();
self::assertEquals('integer', $schema['authors']->fields['id']->type);
self::assertEquals('text', $schema['authors']->fields['firstname']->type);
self::assertEquals('text', $schema['ownership']->fields['critique']->type);
}
public static function configureObject($instance)
{
switch ($instance) {
case false:
// Default instance
return ezcDbFactory::create('mysql://*****:*****@host/database');
case 'sqlite':
return ezcDbFactory::create('sqlite://:memory:');
}
}
public static function configureObject($instance)
{
switch ($instance) {
case false:
return ezcDbFactory::create('sqlite://' . __DIR__ . '/tmp/mkvmanager.db');
break;
case 'sickbeard':
return ezcDbFactory::create('sqlite://' . ezcConfigurationManager::getInstance()->getSetting('sickbeard', 'GeneralSettings', 'DatabasePath'));
break;
}
}
public static function parseDSN($dsn)
{
$parts = ezcDbFactory::parseDSN($dsn);
if (isset($parts['hostspec'])) {
$parts['host'] = $parts['hostspec'];
$parts['server'] = $parts['hostspec'];
}
if (isset($parts['username'])) {
$parts['user'] = $parts['username'];
}
return $parts;
}
public static function configureObject( $instance )
{
//Ignoring $instance
$dsn = self::lazyDbHelper();
return ezcDbFactory::create( $dsn );
}
public function testValidFromDb()
{
$type = ezcTestSettings::getInstance()->db->phptype;
$dsn = ezcTestSettings::getInstance()->db->dsn;
if ($dsn === null || $type === null || $dsn === "sqlite://:memory:") {
$this->markTestSkipped("DSN or database type not set or DSN not supported.");
}
// setup this test
$destination = $this->createTempDir("PersObjDatSchem");
$db = ezcDbFactory::create($dsn);
$fileSource = dirname(__FILE__) . "/data/webbuilder.schema.xml";
$schema = ezcDbSchema::createFromFile("xml", $fileSource);
$schema->writeToDb($db);
// real test
$res = `php PersistentObjectDatabaseSchemaTiein/src/rungenerator.php -f "{$type}" -s "{$dsn}" "{$destination}"`;
$this->assertEquals(1, preg_match('(PersistentObject\\sdefinition\\ssuccessfully\\swritten\\sto)s', $res), 'No success message found in generated output.');
foreach (glob(dirname(__FILE__) . "/data/definition_only/definitions/*.php") as $file) {
$this->assertEquals(file_get_contents($file), file_get_contents($destination . "/" . basename($file)), "Geneator generated an invalid persistent object definition file.");
}
$this->removeTempDir();
}
protected function handleDsn($value)
{
try {
$ts = ezcTestSettings::getInstance();
$settings = ezcDbFactory::parseDSN($value);
$ts->db->value = $value;
try {
$ts->setDatabaseSettings($settings);
$db = ezcDbFactory::create($settings);
ezcDbInstance::set($db);
} catch (ezcDbException $e) {
die($e->getMessage());
}
} catch (Exception $e) {
die("Database initialization error: {$e->getMessage()}\n");
}
}
}
if (!$form->hasValidData('DatabasePassword')) {
$Errors[] = 'Please enter database password';
}
if (!$form->hasValidData('DatabaseHost') || $form->DatabaseHost == '') {
$Errors[] = 'Please enter database host';
}
if (!$form->hasValidData('DatabasePort') || $form->DatabasePort == '') {
$Errors[] = 'Please enter database post';
}
if (!$form->hasValidData('DatabaseDatabaseName') || $form->DatabaseDatabaseName == '') {
$Errors[] = 'Please enter database name';
}
if (count($Errors) == 0) {
try {
$db = ezcDbFactory::create("mysql://{$form->DatabaseUsername}:{$form->DatabasePassword}@{$form->DatabaseHost}:{$form->DatabasePort}/{$form->DatabaseDatabaseName}");
} catch (Exception $e) {
$Errors[] = 'Cannot login with provided logins. Returned message: <br/>' . $e->getMessage();
}
}
if (count($Errors) == 0) {
$cfgSite = erConfigClassLhConfig::getInstance();
$cfgSite->setSetting('db', 'host', $form->DatabaseHost);
$cfgSite->setSetting('db', 'user', $form->DatabaseUsername);
$cfgSite->setSetting('db', 'password', $form->DatabasePassword);
$cfgSite->setSetting('db', 'database', $form->DatabaseDatabaseName);
$cfgSite->setSetting('db', 'port', $form->DatabasePort);
$cfgSite->setSetting('site', 'secrethash', substr(md5(time() . ":" . mt_rand()), 0, 10));
$cfgSite->save();
$tpl->setFile('lhinstall/install3.tpl.php');
} else {
public function step2Action()
{
$this->reloadConfig();
configureTheme(APPLICATION_THEME, 'install');
$session = new Zend_Session_Namespace('Install');
// Create tables
$xmlSchema = ezcDbSchema::createFromFile('xml', APPLICATION_DIRECTORY . '/data/schema.xml');
$schema =& $xmlSchema->getSchema();
if ($this->config->db->prefix != "") {
$keys = array_keys($schema);
foreach ($keys as $tableName) {
$schema[$this->config->db->prefix . $tableName] = clone $schema[$tableName];
unset($schema[$tableName]);
}
}
$dbconfig = new Zend_Config_Xml(DB_CONFIG_LOCATION, 'zend_db');
$db = ezcDbFactory::create($dbconfig->connection_string);
$xmlSchema->writeToDb($db);
$db = Zend_Registry::get("db");
$db->delete($this->config->db->prefix . $this->config->dbtables->categories, array("name='General'"));
$db->insert($this->config->db->prefix . $this->config->dbtables->categories, array('id' => 0, 'name' => 'General', 'link' => 'general', 'orderindex' => 100, 'parent' => 0));
// Make the form
$this->adminForm = new Zend_Form();
$this->adminForm->setAction($this->view->baseUrl . "/install/step2")->setMethod('post')->setLegend('Administrator credentials');
$notEmpty = new Zend_Validate_NotEmpty();
$realname = $this->adminForm->createElement('text', 'realname')->setLabel('Your name:')->addFilter('StripTags')->addFilter('StringTrim')->addFilter('HtmlEntities')->setAttrib('class', 'validate[required]')->addValidator($notEmpty->setMessage($this->view->translate("Real name is mandatory")))->setRequired(true);
$notEmpty = clone $notEmpty;
$username = $this->adminForm->createElement('text', 'username')->setLabel('Username:'******'StripTags')->addFilter('StringTrim')->addFilter('HtmlEntities')->setAttrib('class', 'validate[required]')->addValidator($notEmpty->setMessage($this->view->translate("Username is mandatory")))->setRequired(true);
$notEmpty = clone $notEmpty;
$password = $this->adminForm->createElement('text', 'password')->setLabel('Password:'******'StripTags')->addFilter('StringTrim')->addFilter('HtmlEntities')->setAttrib('class', 'validate[required]')->addValidator($notEmpty->setMessage($this->view->translate("Password is mandatory")))->setRequired(true);
$notEmpty = clone $notEmpty;
$emailValidator = new Zend_Validate_EmailAddress();
$email = $this->adminForm->createElement('text', 'email')->setLabel('Email:')->addFilter('StripTags')->addFilter('StringTrim')->addFilter('HtmlEntities')->setAttrib('class', 'validate[email,required]')->addValidator($notEmpty->setMessage($this->view->translate("Email is mandatory")))->addValidator($emailValidator->setMessage($this->view->translate("Email is invalid")))->setRequired(true);
$submit = $this->adminForm->createElement('submit', 'save')->setLabel('Save');
$this->adminForm->addElement($realname)->addElement($username)->addElement($password)->addElement($email)->addElement($submit);
$dg = $this->adminForm->addDisplayGroup(array('realname', 'username', 'password', 'email', 'save'), 'user');
if ($this->getRequest()->isPost()) {
$this->validateAdminUser();
return;
}
$this->view->form = $this->adminForm->render();
}
<?php
//ini_set( 'include_path', ini_get( 'include_path' ) . ':/htdocs/ezc_trunk/:.' );
ini_set('session.gc_maxlifetime', 864000);
require 'Base/src/ezc_bootstrap.php';
// ezcDbInstance::set( ezcDbFactory::create( 'sqlite://'. dirname( __FILE__ ) . '/share.sqlite' ) );
ezcDbInstance::set(ezcDbFactory::create('mysql://*****:*****@127.0.0.1/UnTrucBien'));
$options = new ezcBaseAutoloadOptions(array('debug' => true));
ezcBase::setOptions($options);
ezcBase::addClassRepository(dirname(__FILE__) . '/lib/share', null, 'share');
ezcBase::addClassRepository(dirname(__FILE__) . '/lib/debug', null, 'debug');
$log = ezcLog::getInstance();
$mapper = $log->getMapper();
$writer = new ezcLogUnixFileWriter("/tmp", "thewire-web.log");
$filter = new ezcLogFilter();
$rule = new ezcLogFilterRule($filter, $writer, true);
$mapper->appendRule($rule);
$reader = new ezcConfigurationIniReader();
$reader->init(dirname(__FILE__), 'settings');
$ini = $reader->load();
if ($ini->getBoolSetting('DevelopmentSettings', 'Debug')) {
ezcBase::setRunMode(ezcBase::MODE_DEVELOPMENT);
$debugHandler = ezcDebug::getInstance();
$debugHandler->setOutputFormatter(new debugHtmlFormatter());
debugLogger::setHandler($debugHandler);
}
$tc = ezcTemplateConfiguration::getInstance();
$tc->templatePath = dirname(__FILE__) . '/templates';
$tc->compilePath = dirname(__FILE__) . '/cache';
$tc->addExtension("shareTemplateFunctions");
<?php
require_once __DIR__ . '/tutorial_example_01.php';
$pdo = new PDO('mysql:host=localhost;dbname=test', 'root', '');
// $db = new ezcDbHandlerMysql($pdo);
$db = ezcDbFactory::wrapper($pdo);
ezcDbInstance::set($db, 'wrapper');
ezcDbInstance::chooseDefault('wrapper');
$db = ezcDbInstance::get();
$res = $db->getAttribute(PDO::ATTR_DRIVER_NAME);
print_r($db);
print_r($res);
echo "\n----\n";
$pdo = new PDO('mysql:host=localhost;dbname=test', 'root', '');
// $db = new ezcDbHandlerMysql($pdo);
$db = ezcDbFactory::create($pdo);
ezcDbInstance::set($db, 'wrapper-1');
ezcDbInstance::chooseDefault('wrapper-1');
$db = ezcDbInstance::get();
$res = $db->getAttribute(PDO::ATTR_DRIVER_NAME);
print_r($db);
print_r($res);
public static function configureObject($instance)
{
$cfg = erConfigClassLhConfig::getInstance();
switch ($instance) {
case 'slave':
if ($cfg->getSetting('db', 'use_slaves') === true) {
try {
$dbSlaves = $cfg->getSetting('db', 'db_slaves');
$slaveParams = $dbSlaves[rand(0, count($dbSlaves) - 1)];
$db = ezcDbFactory::create("mysql://{$slaveParams['user']}:{$slaveParams['password']}@{$slaveParams['host']}:{$slaveParams['port']}/{$slaveParams['database']}");
$db->query('SET NAMES utf8');
} catch (Exception $e) {
die('Cannot connect to database.');
}
return $db;
} else {
// Perhaps connection is already done with master?
if (isset(self::$connectionMaster)) {
return self::$connectionMaster;
}
try {
$db = ezcDbFactory::create("mysql://{$cfg->getSetting('db', 'user')}:{$cfg->getSetting('db', 'password')}@{$cfg->getSetting('db', 'host')}:{$cfg->getSetting('db', 'port')}/{$cfg->getSetting('db', 'database')}");
$db->query('SET NAMES utf8');
self::$connectionMaster = $db;
return $db;
} catch (Exception $e) {
die('Cannot connect to database.....');
}
}
break;
case 'dbmongo':
try {
$cfg = erConfigClassLhConfig::getInstance();
$db = ezcDbFactory::create("mongodb://{$cfg->getSetting('dbmongo', 'user')}:{$cfg->getSetting('dbmongo', 'password')}@{$cfg->getSetting('dbmongo', 'host')}:{$cfg->getSetting('dbmongo', 'port')}/{$cfg->getSetting('dbmongo', 'database')}");
return $db;
} catch (Exception $e) {
print_r($e);
die('Cannot connect to mongo database.');
}
break;
case false:
try {
if (isset(self::$connectionMaster)) {
return self::$connectionMaster;
}
// If we do not user slaves and slave request already got connection
$db = ezcDbFactory::create("mysql://{$cfg->getSetting('db', 'user')}:{$cfg->getSetting('db', 'password')}@{$cfg->getSetting('db', 'host')}:{$cfg->getSetting('db', 'port')}/{$cfg->getSetting('db', 'database')}");
$db->query('SET NAMES utf8');
self::$connectionMaster = $db;
erLhcoreClassInstance::setupInstance(self::$connectionMaster);
return $db;
} catch (Exception $e) {
// Are we installed?
if ($cfg->getSetting('site', 'installed') == false) {
header('Location: ' . erLhcoreClassDesign::baseurldirect('site_admin/install/install'));
exit;
}
die('Cannot connect to database. If you are installing application please use /index.php/install/install url. If you keep getting this error please check that application can write to cache folder and cgi.fix_pathinfo = 1');
}
case 'sqlite':
return ezcDbFactory::create('sqlite://:memory:');
}
}
* Note: This is intended to be replaced by Doctrine DBAL stuff for abstract
* SQL database needs like schema and possibly the absolute minimum data
* needed in the database to function.
*
* + For future data dump we aim to write a tool that writes to and from a
* XML format suitable for XMLReader & XMLWriter so it can be used for large
* data-sets, for speed it might need to use SPI. But that would make it
* unusable for import from other sources, for that API with its validation
* and conventions is a must.
*/
require "./vendor/autoload.php";
if (false === isset($argv[1]) || false === isset($argv[2])) {
echo 'Usage: ', PHP_EOL, basename(__FILE__), ' "mysql://*****:*****@localhost/database_name" <dump-file>', PHP_EOL;
exit(1);
}
$db = ezcDbFactory::create($argv[1]);
// Get eZ tables
$tables = array();
$result = $db->query('SHOW TABLES');
while ($row = $result->fetch(PDO::FETCH_COLUMN)) {
// Only add ez tables but not ezx_ (eznetwork) tables
if (strpos($row, 'ez') === 0 && strpos($row, 'ezx_') !== 0) {
$tables[] = $row;
}
}
// Get data
$fixture = array();
foreach ($tables as $table) {
$result = $db->query('SELECT * FROM ' . $table);
$fixture[$table] = array();
while ($row = $result->fetch(PDO::FETCH_ASSOC)) {
<?php
/**
* @package JetFuelCore
*/
require_once 'core/common.php';
$output = new ezcConsoleOutput();
$output->formats->info->color = 'blue';
// create a database schema from a database connection:
$db = ezcDbFactory::create(DB_DSN);
$dbSchema = ezcDbSchema::createFromDb($db);
// save a database schema to an XML file:
$dbSchema->writeToFile('xml', 'saved-schema.xml');
$messages = ezcDbSchemaValidator::validate($dbSchema);
foreach ($messages as $message) {
$output->outputLine($message, 'info');
}
$readerClass = ezcDbSchemaHandlerManager::getReaderByFormat('xml');
$reader = new $readerClass();
$schema = ezcDbSchema::createFromFile('xml', 'saved-schema.xml');
$writer = new ezcDbSchemaPersistentWriter(true, null);
$writer->saveToFile('app/model/definitions', $schema);
$output->outputLine("Class files successfully written to app/model/definitions.", 'info');
/**
* Db constructor
* @param array|string $dsn Connection DSN string or array of parameters
* @return void
*/
public function __construct($dsn = '')
{
$db = \ezcDbFactory::create($dsn);
\ezcDbInstance::set($db);
}
<?php
// Set up database connection.
$db = ezcDbFactory::create('mysql://test@localhost/test');
// Set up workflow definition storage (database).
$definition = new ezcWorkflowDatabaseDefinitionStorage($db);
// Load latest version of workflow named "Test".
$workflow = $definition->loadByName('Test');
// Set up database-based workflow executer.
$execution = new ezcWorkflowDatabaseExecution($db);
// Pass workflow object to workflow executer.
$execution->workflow = $workflow;
// Start workflow execution.
$id = $execution->start();
public function testParamsSqliteDatabase2()
{
if (!ezcBaseFeatures::hasExtensionSupport('pdo_sqlite')) {
$this->markTestSkipped();
return;
}
$db = ezcDbFactory::create(array('handler' => 'sqlite', 'port' => 'memory'));
$this->assertEquals(false, file_exists('memory'));
}
ezcBase::autoload($className);
@(include SITE_ROOT . '/app/model/' . $className . '.php');
}
define('SITE_ROOT', dirname(__FILE__) . '/..');
define('APP_ROOT', dirname(__FILE__) . '/../app');
$cfg = ezcConfigurationManager::getInstance();
$cfg->init('ezcConfigurationIniReader', SITE_ROOT . '/settings');
define('DIR_DEFINITIONS', SITE_ROOT . '/app/model/definitions');
ezcBase::addClassRepository('.', SITE_ROOT . '/core/autoloads');
$driver = $cfg->getSetting('config', 'Database', 'Driver');
$host = $cfg->getSetting('config', 'Database', 'Host');
$port = $cfg->getSetting('config', 'Database', 'Port');
$username = $cfg->getSetting('config', 'Database', 'User');
$password = $cfg->getSetting('config', 'Database', 'Password');
$database = $cfg->getSetting('config', 'Database', 'Database');
$dsn = $driver . '://' . $username . ':' . $password . '@' . $host . '/' . $database;
define('DB_DSN', $dsn);
$dbInstance = ezcDbFactory::create(DB_DSN);
ezcDbInstance::set($dbInstance);
@(include_once SITE_ROOT . '/settings/log.php');
/*
$dbSession = new ezcPersistentSession( $dbInstance,
new ezcPersistentCacheManager( new ezcPersistentCodeManager( DIR_DEFINITIONS ) ) );
*/
$dbSession = new ezcPersistentSession($dbInstance, new ezcPersistentCacheManager(new JFPersistentDefinitionManager()));
$identityMap = new ezcPersistentBasicIdentityMap($dbSession->definitionManager);
$session = new ezcPersistentSessionIdentityDecorator($dbSession, $identityMap);
ezcPersistentSessionInstance::set($session);
// set default session
// retrieve the session
//$session = ezcPersistentSessionInstance::get();
/**
* Run the generator.
* Process the given options and generate a PersistentObject definition from it.
*
* @return void
*/
public function run()
{
try {
$this->input->process();
} catch (ezcConsoleException $e) {
$this->raiseError("Error while processing your options: {$e->getMessage()}", true);
}
if ($this->input->getOption('h')->value === true) {
$this->output->outputText($this->input->getHelpText(ezcPersistentObjectSchemaGenerator::PROGRAM_DESCRIPTION, 80, true), "help");
exit(0);
}
$defDir = $this->input->argumentDefinition["def dir"]->value;
$classDir = $this->input->argumentDefinition["class dir"]->value;
$schema = null;
try {
$readerClass = ezcDbSchemaHandlerManager::getReaderByFormat($this->input->getOption("format")->value);
$reader = new $readerClass();
switch (true) {
case $reader instanceof ezcDbSchemaDbReader:
$db = ezcDbFactory::create($this->input->getOption("source")->value);
$schema = ezcDbSchema::createFromDb($db);
break;
case $reader instanceof ezcDbSchemaFileReader:
$schema = ezcDbSchema::createFromFile($this->input->getOption("format")->value, $this->input->getOption("source")->value);
break;
default:
$this->raiseError("Reader class not supported: '{$readerClass}'.");
break;
}
} catch (Exception $e) {
$this->raiseError("Error reading schema: {$e->getMessage()}");
}
try {
$writer = new ezcDbSchemaPersistentWriter($this->input->getOption("overwrite")->value, $this->input->getOption("prefix")->value);
$writer->saveToFile($defDir, $schema);
if ($classDir !== null) {
$writer = new ezcDbSchemaPersistentClassWriter($this->input->getOption("overwrite")->value, $this->input->getOption("prefix")->value);
$writer->saveToFile($classDir, $schema);
}
} catch (ezcBaseException $e) {
$this->raiseError("Error writing schema: {$e->getMessage()}");
}
$this->output->outputLine("PersistentObject definition successfully written to {$defDir}.", 'info');
if ($classDir !== null) {
$this->output->outputLine("Class files successfully written to {$classDir}.", 'info');
}
}
<?php
$db = ezcDbFactory::create('mysql://*****:*****@host/database');
ezcDbInstance::set($db);
// anywhere later in your program you can retrieve the db instance again using
$db = ezcDbInstance::get();
<?php
require 'ezc-setup.php';
$db = ezcDbFactory::create('mysql://root@localhost/geolocation');
$sq = $db->createSelectQuery();
$stmt = $sq->select('name', 'country', 'lat', 'lon')->from('city')->where($sq->expr->like('normalized_name', $sq->bindValue('vanco%')))->orderBy('country', 'name')->prepare();
$stmt->execute();
foreach ($stmt as $entry) {
list($name, $country, $lat, $lon) = $entry;
printf('%s, %s is @ %.2f%s %.2f%s<br/>', $name, $country, abs($lat), $lat > 0 ? "N" : "S", abs($lon), $lon > 0 ? "E" : "W");
}
<?php
require_once 'ezc/Base/base.php';
spl_autoload_register(array('ezcBase', 'autoload'));
ezcBase::addClassRepository('./lib', './lib/autoload');
$options = new ezcBaseAutoloadOptions();
$options->debug = true;
ezcBase::setOptions($options);
$rootdir = dirname(__FILE__);
$db = ezcDbFactory::create("sqlite://{$rootdir}/tmp/mergequeue.db");
ezcDbInstance::set($db);
<?php
require_once 'tutorial_autoload.php';
$dbh = ezcDbFactory::create('sqlite://:memory:');
$dbh->exec(<<<ENDSQL
CREATE TABLE nested_set (
'id' varchar(255) NOT NULL,
'parent_id' varchar(255),
'lft' integer NOT NULL,
'rgt' integer NOT NULL
);
CREATE UNIQUE INDEX 'nested_set_pri' on 'nested_set' ( 'id' );
CREATE INDEX 'nested_set_left' on 'nested_set' ( 'lft' );
CREATE INDEX 'nested_set_right' on 'nested_set' ( 'rgt' );
CREATE TABLE data (
'node_id' varchar(255) NOT NULL,
'data_field' varchar(255) NOT NULL
);
CREATE UNIQUE INDEX 'data_pri' on 'data' ( 'node_id' );
ENDSQL
);
$store = new ezcTreeDbExternalTableDataStore($dbh, 'data', 'node_id', 'data_field');
$tree = new ezcTreeDbNestedSet($dbh, 'nested_set', $store);
$tree->setRootNode($rootNode = $tree->createNode('Elements', 'Elements'));
$rootNode->addChild($nonMetal = $tree->createNode('NonMetals', 'Non-Metals'));
$rootNode->addChild($nobleGasses = $tree->createNode('NobleGasses', 'Noble Gasses'));
$nonMetal->addChild($tree->createNode('H', 'Hydrogen'));
echo $tree->fetchNodeById('H')->data, "\n";
