Чтобы не забыть

PHP: интерфейсы Iterator и IteratorAggregate. Практика применения.

2012-02-10T03:59:27-08:00

Почему в php существует два интерфейса для создания объектов-коллекций, которые можно перебирать при помощи foreach?

Сначала посмотрим на сами интерфейсы.
Первый — это Iterator.

Iterator extends Traversable {
  // получить элемент в текущей позиции
  abstract public mixed current ( void )
  // получить ключ элемента в текущей позиции
  abstract public scalar key ( void )
  // перевести указатель на следующий элемент
  abstract public void next ( void )
  // сбросить положение указателя элемента в начало коллекции
  abstract public void rewind ( void )
  // Проверить, существует ли элемент в текущей позиции
  abstract public boolean valid ( void )
}

Теперь второй интерфейс — IteratorAggregate.

IteratorAggregate extends Traversable {
  // получить внешний итератор
  abstract public Traversable getIterator ( void )
}

Оба интерфейса являются наследниками Traversable. Этот интерфейс сигнализирует о том, что реализующий его объект является коллекцией и может выступать в качестве источника данных в цикле foreach.

Как их использовать?
Сначала Iterator.

class simple_iterator implements Iterator {
    private $position = 0;
    private $array = array(
        1,2,3,4,5,6,7,8,9
    );

    public function __construct() {
        $this->position = 0;
    }

    function rewind() {
        $this->position = 0;
    }

    function current() {
        return $this->array[$this->position];
    }

    function key() {
        return $this->position;
    }

    function next() {
        $this->position++;
    }

    function valid() {
        return isset($this->array[$this->position]);
    }
}

$it = new simple_iterator;

foreach($it as $key => $value) {
    echo $key. " ". $value;
    echo "\n";
}

$ php iterator.php
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9

Что-то тут не так? Верно? Внутри коллекции обычный массив. Который всегда можно перебрать в цикле foreach. А мы вынуждены реализовывать кучу методов для поддержания функционала.

Упростить? Запросто!
Интерфейс IteratorAggrerate — позволяет использовать уже имеющиеся механизмы перебора коллекций.

class simple_iterator implements IteratorAggregate {
    private $array = array(
        1,2,3,4,5,6,7,8,9
    );

    function getIterator()
    {
        return new ArrayIterator($this->array);
    }
}

$it = new simple_iterator;

foreach($it as $key => $value) {
    echo $key. " ". $value;
    echo "\n";
}

$ php iteratoraggregate.php
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9

Просто? Просто.
На этом примере очень хорошо видно, что применение IteratorAggregate оправдано тогда, когда в основу коллекции положена структура данных уже имеющая механизм перебора.

Нельзя реализовать оба интерфейса одновременно.

Вообще тема итераторов очень многогранна. Большинство книг либо вообще ее не затрагивают, либо описывают только ArrayIterator.
Хотя php содержит в себе целое семейство итераторов. Например итератор, кеширующий результаты обхода другого итератора — CachingIterator.

class simple_iterator implements Iterator {
    private $position = 0;
    private $array = array(
        1,2,3,4,5,6,7,8,9
    );

    public function __construct() {
        $this->position = 0;
    }

    function rewind() {
        $this->position = 0;
    }

    function current() {
        // тут мы делаем что-то очень-очень важное
        sleep(1);
        return $this->array[$this->position];
    }

    function key() {
        return $this->position;
    }

    function next() {
        $this->position++;
    }

    function valid() {
        return isset($this->array[$this->position]);
    }
}

$it = new simple_iterator;
$cache = new CachingIterator($it, CachingIterator::FULL_CACHE);

$start_time = time();
foreach($cache as $key => $value) {
    echo $key. " ". $value;
    echo "\n";
}
echo "time: ".(time() - $start_time)."\n";

$start_time = time();
foreach($cache->getCache() as $key => $value) {
    echo $key. " ". $value;
    echo "\n";
}
echo "time: ".(time() - $start_time)."\n";

$ php cacheiterator.php
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
time: 9
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
time: 0

Быстро, эффективно, полезно.

Источник.
Похожие записи:

PHP: как правильно обрабатывать массивы

2012-02-09T10:43:52-08:00

Сегодня у меня появился очень интересный повод понять, насколько эффективны различные способы вызова функций в php и как эффективнее обрабатывать массивы.
Все дело в том, что в php есть несколько встроенных функций для обработки массивов. Многие почему-то их не используют. Хотя код получается более эффективным (речь идет об экономии стотысячных долей секунды на обработку элементов. И еще он получается более логичным. Хотя это лично мое мнение.
Итак. Попробуем оценить эффективность работы функций обработки массивов и накладные расходы, затрачиваемые на вызов функций различными способами.

Подопытными функциями стали:

Обычная функция

function test($a)
{
	return $a+2;
}

Функция внутри пространства имен

namespace test1;
function test($a)
{
	return $a+2;
}

Статический метод класса

class test2
{
	static function test($a)
	{
		return $a+2;
	}
}

Метод объекта

class test3
{
	function test($a)
	{
		return $a+2;
	}
}

$test_class = new test3;
$test_class->test($a);

Лямбда-функция как значение переменно

$test_func = function($a)
{
	return $a+2;
};

Непосредственно передаваемая лямбда-функция

function($a){return $a+2;}

Первое испытание — это использование обычного цикла foreach для обработки массива размером 1000000 элементов.
Испытание было разбито на две секции:

Обработка значений без сохранения результатов
Сохранение результатов, возвращаемых функцией в тестовый массив

В свою очередь каждый этап был разбит на два маленьких этапа:

В первом случае вызов функции производился непосредственно
Во втором — через жопу вызов при помощи call_user_func

Результаты сведены в табличку

Тип подопытной функции	тип перебора
	без сохранения		с сохранением
	foreach	call_user_func inside foreach	foreach	call_user_func inside foreach
test($a)	0,000005	0,000011	0,000007	0,000013
test1\test($a)	0,000005	0,000012	0,000006	0,000014
test2::test($a)	0,000006	0,000013	0,000008	0,000015
$test($a)	0,000005	0,000011	0,000006	0,000012
$test_class->test($a)	0,000006	0,000015	0,000008	0,000016

И график

Выводы? Вывод только один использование call_user_func и call_user_func_array практически в два с половиной раза увеличивает время работы приложения. Если вы обрабатываете более сотни тысяч значений, то стоит от нее отказаться. И вообще использовании подобных методов очень редко является необходимостью. И чаще обозначает плохой дизайн системы.

Теперь второе испытание: использование встроенных функций по обработке массивов.
Принимали участие:

array_map
array_map + сохранение результирующего массива
array_walk

Что из этого получилось можно посмотреть в табличке результатов забега.

перелаваемая функция	тип функции-итератора
перелаваемая функция	array_map	array_map и сохранение	array_walk
test($a)	0,000007	0,000007	0,000006
test1\test($a)	0,000007	0,000007	0,000007
test2::test($a)	0,000006	0,000006	0,000005
$test_class->test($a)	0,000007	0,000007	0,000006
$test_func($a)	0,000007	0,000007	0,000005
lambda function($a)	0,000007	0,000007	0,000006

И график.

Что можно сказать?
Не стоит бояться использовать обход массивов при помощи встроенных функций. Они даже быстрее, нежели обработка при помощи foreach.
Многие ругают встроенные функции php, называя порядок аргументов нелогичным. Возможно.
Хотя для array_map: применить(функцию, [к]массиву). Для array_walk: обойти(массив, функцией). Простое правило для запоминания.

И еще array_map выделяет объем памяти для хранения результирующего массива еще до фактического запуска.

Что больше всего меня удивило — так это то, что обращение к функции внутри namespace почти всегда немного дороже, нежели обращение к остальным функциям. Хотя можно списать на погрешность вычислений.
Исходники можно скачать отсюда.
Похожие записи:

Консоль mysql: форматирование вывода

2012-02-05T08:23:03-08:00

Неожиданно. Копался в документации и совершенно случайно обнаружил очень удобный модификатор, который позволяет выводить результаты запроса вертикально.

Модификатор \G

Действует в консольном клиенте mysql.

mysql>select * from func\G

Получаем вывод в виде

*************************** 1. row ***************************
name: preg_capture
 ret: 0
  dl: lib_mysqludf_preg.so
type: function
*************************** 2. row ***************************
name: preg_check
 ret: 2
  dl: lib_mysqludf_preg.so
type: function
*************************** 3. row ***************************
name: preg_position
 ret: 2
  dl: lib_mysqludf_preg.so
type: function
*************************** 4. row ***************************
name: preg_replace
 ret: 0
  dl: lib_mysqludf_preg.so
type: function
*************************** 5. row ***************************
name: preg_rlike
 ret: 2
  dl: lib_mysqludf_preg.so
type: function
*************************** 6. row ***************************
name: lib_mysqludf_preg_info
 ret: 0
  dl: lib_mysqludf_preg.so
type: function
6 rows in set (0.02 sec)

Удобно

Источник.
Похожие записи:

PHP: паттерн наблюдатель (observer)

2012-01-28T07:35:47-08:00

Как часто нам приходится реализовывать сквозную функциональность? Часто! Очень и очень часто. А как сделать так, чтобы эта функциональность была реализована корректно?

Сквозной (в терминах ООП) называют функциональность, которая не может быть выделена в отдельную сущность. Примером может быть логгирование событий, проверка прав доступа и т.п.

Если мы не может выделить подобный функционал в отдельную сущность, то мы можем смягчить последствия внедрения подобного функционала.
Первым шагом станет выделение этого функцонала в отдельную сущность, которая каким-либо образом будет анализировать события. Для реализации подобных вещей лучше всего подходит паттерн наблюдатель (observer).

В чем преимущество паттерна? Он позволяет нескольким объектам системы неявно наблюдать за состоянием другого объекта. Т.е. если состояние наблюдаемого объекта изменяется, то объекты налблюдатели получают уведомление об изменении состояния.
Лучше всего понять данный паттерн на примере логгирования событий. Представим, что у нас есть некоторая сущность, действия которой мы просто обязаны сохранять где-нибудь.
У нас есть база данных. У нас есть memcache.
Топорным способом реализации будет расковырять объект и в каждое действие этого объекта вписать функционал по сохранинию записи в лог.

class object
{
  function save_log($message)
  {
    //тут код по сохранению сообщения в базу
    echo $message."\n";
  }

  function action_one()
  {
    $this->save_log('start action one');
  }

  function action_two()
  {
    $this->save_log('start action two');
  }
}

Пробуем.

$object = new object();
$object->action_one();
$object->action_two();

Вообще нормально.

~$ php simple.php
start action one
start action two

Вроде все работает, но остается много маленьких нюансов.
Теперь у нас появляется второй объект. Он тоже требует логирования. Чтобы не повторять куски кода мы вынесем этот функционал в отдельный класс.

class logger
{
  function save_log($message)
  {
    //тут код по сохранению сообщения в базу
    echo $message."\n";
  }
}

class object1
{
  private $log = null;

  function __construct()
  {
    $this->log = new logger();
  }

  function action_one()
  {
    $this->log->save_log('start action one from '.__CLASS__);
  }

  function action_two()
  {
    $this->log->save_log('start action two from '.__CLASS__);
  }
}

class object2
{
  private $log = null;

  function __construct()
  {
    $this->log = new logger();
  }

  function action_one()
  {
    $this->log->save_log('start action one from '.__CLASS__);
  }

  function action_two()
  {
    $this->log->save_log('start action two from '.__CLASS__);
  }
}

Пробуем.

$object1 = new object1();
$object1->action_one();
$object1->action_two();

$object2 = new object2();
$object2->action_one();
$object2->action_two();

$ php simple2.php
start action one from object1
start action two from object1
start action one from object2
start action two from object2

Вроде бы все. Как прилежные разработчики мы можем сделать для классов object1 и object2 общего предка, который инициализирует логгер. Мы можем превратить логгера в синглтон.
Но тут возникает кошмар любого разработчика. Нам нужно:

Добавить логгирование не только на консоль, но и в базу данных, сервер syslog и иже
Сделать так, чтобы каждый объект логгировал события в разные источники.

Почему это кошмар? Для первого требования мы можем поменять логгер, добавив в него нужные механизмы логгирования. Для второго случая мы можем сделать несколько функций. И вызывать эти функции в объектах. Что то-вроде:

log_to_database($message);
log_to_console($message)

Но это неправильно. Эти решения отнимают очень много времени на поддержание кода, на то, чтобы найти, где расположен нужный кусок кода. На то, чтобы просто ввести новый функционал.

Одна из основных проблем — это нарушения принципа «открытия-закрытия» (OCP)

Принцип «открытия-закрытия» (OCP) означает, что объект (класс или функция) должен быть закрыт для изменения, но открыт для расширения. Пример.

И как это починить? Применить паттерн «наблюдатель», который решает практически все проблемы, что были описаны выше.

Сначала рассмотрим объект события, который будет передаваться от наблюдаемого объекта к наблюдающим.

/**
 * Класс, описывающий событие.
 */
class Observer_Event
{
	/**
	 * @var string $message Сообщеине событиы
	 */
	private $message = '';

	/**
	 * Набор ключ->значение. Ключ будет замещаться значением при выводе $message
	 * @var array $value
	 */
	private $values = array();

	/**
	 * Сохраняет в событии мообщение и набор замещающих параметров
	 *
	 * @param $message
	 * @param array $values
	 */
	function __construct($message, $values = array())
	{
		$this->message = $message;
		$this->values = $values;
	}

	/**
	 * Преобразование сообщения в строку для вывода
	 * @return string
	 */
	function __toString()
	{
		return __($this->message, $this->values);
	}
}

Поскольку в качестве фреймворка использовалась kohanа, то грех не воспользоваться функцией локализации __.

Использовать сообщение очень просто.

$event = new Observer_Event("message with content \":value\"", array(':value' => "some content"))
echo $event;

Получим

php event_test.php
message with content "some content"

Теперь перейдем к реализации наблюдаемого объекта

/**
 * Реоализация добавления и удаления наблюдателей.
 */
class Observer_Observable
{
	const EVENT_ALL = 0;

	/**
	 * @var array $observers Стек наблюдателей
	 */
	private $observers = array();

	/**
	 * Возвращает код события по его имени
	 *
	 * Пример использования: ObservableClass::event("eventtype")
	 *
	 * @static
	 * @param $type
	 * @return mixed
	 */
	static function event($type)
	{
		$event_name = classname(self)."::EVENT_".strtoupper($type);
		return constant($event_name);
	}

	/**
	 * Добавление наблюдателя в список.
	 * Выполняет проверку на дублирование элементов.
	 *
	 * Возвращает ссылку на класс для реализации цепочек
	 *
	 * @param observer $observer Объект наблюдатель
	 * @param integer $event_type тип наблюдаемого события
	 * @return $this
	 */
	function attach(Observer_Observer $observer, $event_type = EVENT_ALL)
	{
		$this->observers[$event_type][] = $observer;
		return $this;
	}

	/**
	 * Передача события всем существующим наблюдателям
	 *
	 * @param $type Тип генерируемого сообщения
	 * @param Observer_Event $event сообщение
	 */
	function fire($type, Observer_Event $event)
	{
		$mapped_func = function(Observer_Observer $observer) use ($event)
		{
			$observer->fire($event);
		};
		//fire custom event
		array_map($mapped_func, Arr::get($this->observers, $type, array()));

		//fire event to EVENT_ALL listeners (if type is not event_all)
		if(self::EVENT_ALL != $type)
		{
			array_map($mapped_func, Arr::get($this->observers, self::EVENT_ALL, array()));
		}
	}
}

Ничего сложного. Регистрируются наблюдатели. Каждый наблюдатель может отслеживать либо все события (EVENT_ALL), либо события, которые объявлены наблюдаемым объектом.

Остался наблюдатель.

/**
 * Реализация паттерна observer
 */
abstract class Observer_Observer
{
	/**
	 * Обработка события наблюдаемного объекта
	 *
	 * @abstract
	 * @param Observer_Event $event
	 */
	abstract function fire(Observer_Event $event);
}

Абстрактный класс, который содержит обработчик события.
И теперь собираем все воедино

class logger extends Observer_Observer
{
	function fire(Observer_Event $event)
	{
		//тут код по сохранению сообщения в базу
		echo $event."\n";
	}
}

class object1 extends Observer_Observable
{
	function action_one()
	{
		$this->fire(self::EVENT_ALL, new Observer_Event('start action :method from :class',
			array(
				':class' => __CLASS__,
				':method' => __METHOD__,
			)
		));
	}

	function action_two()
	{
		$this->fire(self::EVENT_ALL, new Observer_Event('start action :method from :class',
			array(
				':class' => __CLASS__,
				':method' => __METHOD__,
			)
		));
	}
}

class object2 extends Observer_Observable
{
	function action_one()
	{
		$this->fire(self::EVENT_ALL, new Observer_Event('start action :method from :class',
			array(
				':class' => __CLASS__,
				':method' => __METHOD__,
			)
		));
	}

	function action_two()
	{
		$this->fire(self::EVENT_ALL, new Observer_Event('start action :method from :class',
			array(
				':class' => __CLASS__,
				':method' => __METHOD__,
			)
		));
	}
}

Запускаем

$observer = new logger();

$object1 = new object1();
$object1->attach($observer);
$object1->action_one();
$object1->action_two();

$object2 = new object2();
$object2->action_one();
$object2->action_two();

И получаем.

start action object1::action_one from object1
start action object1::action_two from object1

Следует заметить, что к объекту $object2 мы логгер не подключали. А следовательно на экран ничего и не было выведено.

Источники:

Похожие записи:

MySQL: генерация исключений.

2012-01-27T10:07:53-08:00

Ранее я писал об обработке ошибок. Вот только одна проблема: генерировать исключения нам никто не давал. Можно их было только перехватывать.
С появлением MySQL 5.5 появилась возможность генерировать собственные исключения. А так же пробрасывать перехваченные исключения после отлова их handler’ами.
Кратко рассмотрим возможности, которые отдали в наше распоряжение.

Проброс исключений

Небольшой пример.

try {
  $a = 10/0;
} catch (Exception $e) {
  write_log("На ноль делить нельзя"):
  throw $e;
}

Перехваченное исключение выбрасывается в систему вновь.
В mysql у нас есть отличная вещь: resignal. (А поскольку в mysql деление на 0 дает null, то напишем процедуру, выбирающую несуществющие данные)

delimiter | ;
create procedure select_magic()
begin
  declare _a int default null;
  declare exit handler for sqlexception
  begin
    select "this message print from exit handler" as `message`;
    resignal;
  end;
  select * from `test`;
end|

И вот что мы увидим:

mysql> call select_magic();
+--------------------------------------+
| message                              |
+--------------------------------------+
| this message print from exit handler |
+--------------------------------------+
1 row in set (0.00 sec)

ERROR 1146 (42S02): Table 'test.test' doesn't exist
mysql> show errors;
+-------+------+---------------------------------+
| Level | Code | Message                         |
+-------+------+---------------------------------+
| Error | 1146 | Table 'test.test' doesn't exist |
| Error | 1146 | Table 'test.test' doesn't exist |
+-------+------+---------------------------------+
2 rows in set (0.00 sec)

А теперь посмотрим, что могло быть в случае отсутствия resignal.

delimiter | ;
create procedure select_magic_2()
begin
  declare _a int default null;
  declare exit handler for sqlexception
  begin
    select "this message print from exit handler (without resignal)" as `message`;
  end;
  select * from `test`;
end|

mysql> call select_magic_2();
+---------------------------------------------------------+
| message                                                 |
+---------------------------------------------------------+
| this message print from exit handler (without resignal) |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> show errors;
+-------+------+---------------------------------+
| Level | Code | Message                         |
+-------+------+---------------------------------+
| Error | 1146 | Table 'test.test' doesn't exist |
+-------+------+---------------------------------+
1 row in set (0.00 sec)

Почему в первом случае мы выдим две ошибки а во втором только одну?
Все просто: resignal берет последнее исключение из диагностического стека. И дублирует его.
Важно, что в случае отсутствия активных handler’ов resignal работать не будет. Происходит это потому, что на вершине стека ошибок может лежать необработанное исключение. Тогда смысл resignal теряется.

На примере это выглядит так.

delimiter | ;
create procedure foo()
begin
  resignal;
end|

create procedure bar()
begin
  declare exit handler for sqlexception
  begin
    select "bar procedure" as `message`;
    call foo();
  end;
  select * from `test`;
end|

А теперь посмотрим. Сначала попробуем вызвать resignal без активных обработчиков, а потом с одним обработчиком.

mysql> call foo();
ERROR 1645 (0K000): RESIGNAL when handler not active
mysql> show errors;
+-------+------+----------------------------------+
| Level | Code | Message                          |
+-------+------+----------------------------------+
| Error | 1645 | RESIGNAL when handler not active |
+-------+------+----------------------------------+
1 row in set (0.00 sec)

mysql> call bar();
+---------------+
| message       |
+---------------+
| bar procedure |
+---------------+
1 row in set (0.00 sec)

ERROR 1146 (42S02): Table 'test.test' doesn't exist
mysql> show errors;
+-------+------+---------------------------------+
| Level | Code | Message                         |
+-------+------+---------------------------------+
| Error | 1146 | Table 'test.test' doesn't exist |
| Error | 1146 | Table 'test.test' doesn't exist |
+-------+------+---------------------------------+
2 rows in set (0.00 sec)

Как видно из примера, resignal не обязательно должен быть объявлен внутри хендлера. Достаточно, чтобы где-то выше по стеку вывозов был установлен хендлер.

Выше мы рассматривали самый простейший вариант resignal — вариант, который просто дублирует последнюю ошибку в стеке.
Всего же разновидностей resignal три:

Простой (рассмотрен ранее)
```
RESIGNAL
```
Изменяющий информацию об ошибке (можно изменить код ошибки или сообщение об ошибке)
```
RESIGNAL SET signal_information_item [, signal_information_item] ...
```
Меняющий класс исключения (Изменяет тип ошибки)
```
RESIGNAL condition_value
SET signal_information_item [, signal_information_item] ...
```

Чтобы изменить диагностическое сообщение или код ошибки можно воспользоваться вторым типом.

delimiter | ;
create procedure resignal_change_info()
begin
  declare _a int default null;
  declare exit handler for sqlexception
  begin
    select "simple message" as `message`;
    resignal set mysql_errno = 12000;
  end;
  select * from `test`;
end|

mysql> call resignal_change_info();
+----------------+
| message        |
+----------------+
| simple message |
+----------------+
1 row in set (0.00 sec)

ERROR 12000 (42S02): Table 'test.test' doesn't exist
mysql> show errors;
+-------+-------+---------------------------------+
| Level | Code  | Message                         |
+-------+-------+---------------------------------+
| Error |  1146 | Table 'test.test' doesn't exist |
| Error | 12000 | Table 'test.test' doesn't exist |
+-------+-------+---------------------------------+
2 rows in set (0.00 sec)

Третий тип позволяет изменять тип ошибки (о типе ошибок ниже)

delimiter | ;
create procedure resignal_change_condition()
begin
  declare _a int default null;
  declare exit handler for sqlexception
  begin
    select "simple message" as `message`;
    resignal sqlstate '01000' set mysql_errno = 12000;
  end;
  select * from `test`;
end|

mysql> call resignal_change_condition();
+----------------+
| message        |
+----------------+
| simple message |
+----------------+
1 row in set (0.00 sec)

Query OK, 0 rows affected, 2 warnings (0.00 sec)

mysql> show errors;
+-------+------+---------------------------------+
| Level | Code | Message                         |
+-------+------+---------------------------------+
| Error | 1146 | Table 'test.test' doesn't exist |
+-------+------+---------------------------------+
1 row in set (0.00 sec)

mysql> show warnings;
+---------+-------+---------------------------------+
| Level   | Code  | Message                         |
+---------+-------+---------------------------------+
| Error   |  1146 | Table 'test.test' doesn't exist |
| Warning | 12000 | Table 'test.test' doesn't exist |
+---------+-------+---------------------------------+
2 rows in set (0.00 sec)

Что вообще произошло? Почему на вершине стека ошибок не появилась новая ошибка?
А все просто sqlstate ’01000′ понизил класс ошибки с error до warning. И она не вызвала необходимости обработки.

Теперь о классах ошибок.
SQLSTATE — это пять цифр. Первые две обозначают класс состояния. Остальные три произвольные и характеризуют определенный тип состояния внутри класса.
Различают несколько типов состояний. ПО первым двум цифрам.

00 — успешное завершение. Недопустимо для ручной генерации
01 — warning. пишется в лог, но не мешает дальнейшей работе
02 — not found. если его не обработать, то исполнение завершается
>02 — exception. класс исключений
40 — стандартные исключения.

Ладно. Пробрасывать научились. А генерировать как?
Есть механизм signal

SIGNAL condition_value
    [SET signal_information_item
    [, signal_information_item] ...]

condition_value:
    SQLSTATE [VALUE] sqlstate_value
  | condition_name

signal_information_item:
    condition_information_item_name = simple_value_specification

condition_information_item_name:
    CLASS_ORIGIN
  | SUBCLASS_ORIGIN
  | MESSAGE_TEXT
  | MYSQL_ERRNO
  | CONSTRAINT_CATALOG
  | CONSTRAINT_SCHEMA
  | CONSTRAINT_NAME
  | CATALOG_NAME
  | SCHEMA_NAME
  | TABLE_NAME
  | COLUMN_NAME
  | CURSOR_NAME

delimiter | ;
create procedure mysignal()
begin
  signal sqlstate '03000' set message_text = 'first signal';
end|

mysql&gt call mysignal();
ERROR 1644 (03000): first signal

Будет правильным предположить, что signal способен работать не только с событиями прописанными при помощи sqlstate, но и с событиями, которые были объявлены при помощи declare condition.

Источник: http://dev.mysql.com/doc/refman/5.5/en/condition-handling.html
Похожие записи:

PHP: ленивые вычисления

2012-01-21T08:16:42-08:00

Очень часто при разработки проектов мы сталкиваемся с ситуацией, когда неизвестно, потребуются ли данные в дальнейшем или нет. Примером может быть логирование каких-либо событий.
Почему бы не вычислять данные тогда, когда это действительно необходимо?
Для этого я написал собственный велосипед, реализующий механизм отложенных вычислений подобно haskell.

Итак. Класс Callback_Deferred

/**
 * Механизм отложенного вызова
 *
 * Требуется, если нужно отложить вызов функции до момента реальной необходимости.
 * К примеру объект может вообще не затребовать вызов.
 */
class Callback_Deferred
{
	/**
	 * Callback-функция
	 * @var null
	 */
	private $func = null;

	/**
	 * Массив аргументов функции
	 * @var null
	 */
	private $args = null;

	/**
	 * Создание объектов отложенного вызова
	 * Возвращает объект отложенного вызова
	 *
	 * @static
	 * @param callback $func функция отложенного вызова
	 * @param array $args аргументы функции отложенного вызова
	 * @return Call_Deferred
	 */
	static function factory($func, $args)
	{
		return new self($func, $args);
	}

	/**
	 * Конструирование объекта отложенного вызова
	 *
	 * @param callback $func функция отложенного вызова
	 * @param array $args аргументы функции отложенного вызова
	 */
	private function __construct($func, $args)
	{
		$this->func = $func;
		$this->args = $args;
	}

	/**
	 * Преобразование результатов отложенного вызова в строку
	 * Фозможен только если функция возвращает тип string
	 * В противном случае будет выброшено исключение
	 *
	 * @return string
	 */
	public function __toString()
	{
		try
		{
			return (string)call_user_func_array($this->func, $this->args);
		}
		catch(Exception $e)
		{
			return '';
		}
	}

	/**
	 * Непосредственный вызов функции так,
	 * словно это был бы обычный вызов вида func_name($arg1, $arg2,  ...)
	 *
	 * @return mixed
	 */
	public function __invoke()
	{
		return call_user_func_array($this->func, $this->args);
	}
}

Теперь проверим этот механизм

/**
 * Функция, выполняющая очень долгие вычисления с $param
 * @param integer $param
 * @return результат вычислений
 */
$func = function($param)
{
  //long calculation
  sleep(1);
  return $param;
};

/**
 * Класс-агрегатор
 */
class log
{
  private $container;

  static private $instance = null;

  static function instance()
  {
    if( ! self::$instance)
    {
      self::$instance = new self();
    }
    return self::$instance;
  }

  function push($value)
  {
    $this->container[] = $value;
  }

  private function __construct()
  {
  }

  public function out()
  {
    array_map(function($value){
      echo $value."\n";
    },$this->container);
  }
}
//начинаем основной цикл вычислений
echo date("d/m/y : H:i:s:", time())." start\n";

//выволняем вычисления над некоторыми данными и добавляем в стек функцию печати лога
array_map(function($int){
        global $func;
        log::instance()->push(Callback_Deferred::factory($func, array($int)));
}, range(1,100));

echo date("d/m/y : H:i:s:", time())." end\n";
//Приступаем к выводу лога
echo date("d/m/y : H:i:s:", time())." start log out\n";
log::instance()->out();
echo date("d/m/y : H:i:s:", time())." end log out\n";

И получаем вывод в консоль:

$php callback.php
21/01/12 : 15:58:28: start
21/01/12 : 15:58:28: end
21/01/12 : 15:58:28: start log out
1
2
3
4
5
6
7
8
//много букв
97
98
99
100
21/01/12 : 16:00:08: end log out

Очевидно, что при непосредственно выволнении функции $func мы бы тормозили основные вычисления. В то же время результаты $func нам не нужны «здесь и сейчас». Поэтому логично выполнять эту функцию только тогда, когда данные необходимы.
Вот и все.
Похожие записи:

jQuery: анатомия событий

2012-01-15T03:23:26-08:00

Изначально статья предполагала, что будет описано простое создание чекбокса «выделить все» на базе jquery, но в итоге получился разбор реализации событий javascript в jquery.
А все потому, что очень часто на форумах появляются вопросы вроде: «а как же оно устроено»? И остаются без ответа.

Итак ТЗ: нужно сделать табличку, где в каждой строке есть чекбокс и чекбокс, который позволяет снять/поставить выделение на всех строках таблицы.

$('input.check_all').click(function(event){
  $('input.flags:checked').attr('checked',$(this).is(':checked'));
});

Вот. Просто!

А теперь у нас новый проект и новое ТЗ: на каждый чекбокс нужно повесить событие, которое как-то реагирует на нажатие этого самого чекбокса.
Например меняет уровень прозрачности чекбокса «выделить все» или еще что-нибудь.

Сначала пишем обработчики для элементов .flags (Это которые в строках)

$('input.flags').click(function(event){
  var name = $(this).attr('name');
  var check_info = ($(this).is(':checked'))?'выбран':'не выбран';
  say('checkbox '+name+', состояние: '+check_info);
});

Теперь нам надо добавить обработчик нажатия для той самой кнопки, которая должна включать и выключать все.

$('input.check_all').click(function(event){
  $('input.flags').attr('checked',$(this).is(':checked');
});

Не работает. Обработчик события при ручной установке атрибута не вызывается.
А что если мы будем генерировать событие клик так, словно это пользователь нажал на чекбокс?

$('input.check_all').click(function(event){
  var flag = $(this).is(':checked')?':not(:checked)':':checked';
  $('input.flags'+flag).trigger('click');
});

После проверки в нескольких браузерах видно, что поведения данного кода не совсем корректно.
События срабатывают не в том порядке, в каком должны.

В jquery есть triggerhandler() — функция вызывает обработчики события, установленные пользователем, но не вызывает браузерный обработчик.
Но при попытке использования нас ждет сюрприз — она срабатывает только для первого элемента в обернутом наборе.

Т.е. если мы сделаем

$('input.related[type=checkbox]').triggerHandler('click');

мы увидим только один алерт.Чтобы заставить эту функцию работать для всех элементов надо воспользоваться прямым перебором при помощи each.

$('input.check_all').click(function(event){
  var flag = $(this).is(':checked')?':not(:checked)':':checked';
  var new_state = $(this).is(':checked');
  $('input.flags'+flag).each(function(){
    $(this).attr('checked',new_state);
    $(this).triggerHandler('click');
  });
});

Работает
Теперь неприятный сюрприз: triggerHandler не работает с событиями, которые установлены при помощи live

$('input.flags').live('click',function(event){
  var name = $(this).attr('name');
  var check_info = ($(this).is(':checked'))?'выбран':'не выбран';
  say('checkbox '+name+', состояние: '+check_info);
});

Если обработчик установлен таким образом, то tiggerHandler Вам не поможет.
Для таких случаев можно вызвать обработчик более экстравагантным способом: запретить всплытие события по dom-дереву. Тем самым мы избавляемся от проблем с неработающими обработчиками.

Почему все это происходит? Неизвестно?

Напишем простой пример:

$('#toggle_flag').click(function(event){
  $('input.flags').trigger('click');
});
$('input.flags').each(function(){
  this.addEventListener('click',function(){
    var name = $(this).attr('name');
    var check_info = ($(this).is(':checked'))?'выбран':'не выбран';
    say('checkbox '+name+', состояние при всплытии: '+check_info);
  },false);
  this.addEventListener('click',function(){
    var name = $(this).attr('name');
    var check_info = ($(this).is(':checked'))?'выбран':'не выбран';
    say('checkbox '+name+', состояние при захвате: '+check_info);
  },true);
});

И этот пример работает.

Но почему?

Рассмотрим код
Нас интересует функция trigger (строки 2846-2976)

Ниже представлен урезанный код с комментариями, описывающими работу функции.

trigger: function( event, data, elem, onlyHandlers ) {
     // 2848-2888: тут идет подготовка данных и получение очереди обработчиков
     // Об очереди обработчиков более подробно описано дальше

     // 2891-2904: глобальный обработчик событий

     // 2907-2909: не вызываем обработчик на текстовых нодах и на комментариях
     // 2919-2927: cur - это текущий элемент
     var cur = elem,
          // IE doesn't like method names with a colon (#3533, #8272)
          ontype = type.indexOf(":") < 0 ? "on" + type : "";

     // 2924-2940: Вызываем обработчик элемента,
     // а затем эмулируем фазу всплытия события
     // обработка заканчивается если мы дойдем до корня DOM,
     // либо если обработчик выполнит event.stopPropagnation()
     do {
          var handle = jQuery._data( cur, "handle" );

          event.currentTarget = cur;
          if ( handle ) {
               handle.apply( cur, data );
          }

          // Вызываем инлайн-обработчики
          // (которые были установлены при помощи конструкций вида onclick="")
          if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
               event.result = false;
               event.preventDefault();
          }

          // Эмулируем фазу всплытия
          cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
     } while ( cur && !event.isPropagationStopped() );

     // 2943-2973: если ни один из обработчиков не остановил распространение события,
     // то вызываем браузерный обработчик
     if ( !event.isDefaultPrevented() ) {
          var old,
               special = jQuery.event.special[ type ] || {};
          // Если событие не "special" и не клик по ссылке
          if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) &&
               !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
               // То пробуев вызвать браузерный обработчик
               try {
                    if ( ontype && elem[ type ] ) {
                         // Создаем замещение для инлайн методов (чтобы не вызвать повторно
                         old = elem[ ontype ];

                         if ( old ) {
                              elem[ ontype ] = null;
                         }

                         // Глобальная переменная, предотвращающая повторный вызов обработчика
                         jQuery.event.triggered = type;
                         // Вызываем браузерный обработчик
                         elem[ type ]();
                    }
               } catch ( ieError ) {}
               // Возврат замещения для инлайн-скриптов
               if ( old ) {
                    elem[ ontype ] = old;
               }
               // сброс флага
               jQuery.event.triggered = undefined;
          }
     }

     return event.result;
}

А теперь кратко о том, что же мы тут видим.
На данный момент браузеры не поддерживают непосредственный вызов событий из скриптов (при помощи какой-нибудь triggerevent), поэтому jquery просто реализует такой функционал с нуля.
Находится элемент, для которого планируется вызвать событие; вызывается обработчик события и эмулируется фаза всплытия.
И только после всего этого вызывается событие браузера.
Это и объясняет, почему галочка на чекбоксе изменялась после того, как сработал хук.
Мало того, если вы добавляли к элементу свои обработчики при помощи addEventListener, то они могут не сработать если какой-то из обработчиков jquery остановил баблинг эвента.

И еще нас заинтересует функция add объекта jQuery.event, которая привязывает обработчик события непосредственно к элементу.
Ниже выдержки из этой функции

// 2590: объявление функции
add: function( elem, types, handler, data ) {
     // 2591-2612: выполняется проверка входных аргументов
     // и создание уникального идентификатора обработчика
     // (если его нет)

// 2615: получаем данные для элемента (обертка над jQuery.data)
     var elemData = jQuery._data( elem );
     // 2623: получаем функцию-обработчик jquery для элемента
     var events = elemData.events,
          eventHandle = elemData.handle;

     // 2626-2628: список событий, обработчики которых установлены у элемента
     if ( !events ) {
          elemData.events = events = {};
     }

     // 2630-2638: для каждого элемента создается единственный (!) обработчик
     // который "слушает" все события элемента
     if ( !eventHandle ) {
          elemData.handle = eventHandle = function( e ) {
               // Discard the second event of a jQuery.event.trigger() and
               // when an event is called after a page has unloaded
               return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
               jQuery.event.handle.apply( eventHandle.elem, arguments ) :
               undefined;
          };
     }

     // 2642-2648: обработка множества событий
     // например обработка случая bind("mouseup mousedown")

     while ( (type = types[ i++ ]) ) {
          // 2651-2653: любой обработчик - это объект: функция и данные
          // тут обрабатывается преобразование функции в объекты
          handleObj = handleObjIn ?
               jQuery.extend({}, handleObjIn) :
               { handler: handler, data: data };

          // 2656-2664: обработка неймспейсов
          handleObj.type = type;
          if ( !handleObj.guid ) {
               handleObj.guid = handler.guid;
          }

          // 2672-2673: получаем список обработчиков события event у элемента
          var handlers = events[ type ],
               special = jQuery.event.special[ type ] || {};

          // 2676-2691: инициализируем очередь обработчиков событий
          // (если ее еще нет)
          if ( !handlers ) {
               handlers = events[ type ] = [];

               // тут надо сказать, что такое "special events" в терминологии jquery
               // Это события live, ready, beforeunload
               // Эти события должны быть обработаны особым образом
               if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
                    // 2684-2689: добавление глобального "слушателя" событий,
                    // который был объявлен выше
                    if ( elem.addEventListener ) {
                         elem.addEventListener( type, eventHandle, false );

                    } else if ( elem.attachEvent ) {
                         elem.attachEvent( "on" + type, eventHandle );
                    }
               }
          }

          // 2693-2699: обработка special events

          // 2702: добавляем устанавливаемый обработчик события в очередь обработчиков
          handlers.push( handleObj );

          // 2705: сигнализируем, что для определенного типа события есть обработчики
          // нужно для оптимизации работы
          jQuery.event.global[ type ] = true;
     }

     // ... все остальное
}

Просматривая эту функцию становится понятно, что jquery абстрагирует от нативных событий браузера.
Кратко:

на каждый тип собитыя у элемента создается глобальный обработчик jquery,
каждый пользовательский обработчик попадает в очередь обработки,
при появлении события срабатывает обработчик jquery и вызывает все пользовательские обработчики.

Выводы:

как и всякая универсальная библиотека jquery не лишена недостатков,
если вы используете jquery, то лучше никогда не смешивать подходы к работе с событиями (поясню: не использовать нативную установку событый и установку при помощи jquery).

Ну а как же triggerHandler, спросите вы?

Так все просто

Четвертый аргумент функции trigger как раз и означает, что нужно выполнить останов распространения события.

triggerHandler: function( type, data ) {
     if ( this[0] ) {
          return jQuery.event.trigger( type, data, this[0], true );
     }
}

Да. Но как же событие live с которым не работает triggerHandler?
Тоже ничего сложного live-события - это трансформация обычного события в события вида live..
Соответственно на него заводится новый обработчик, привязанный к корню документа. Фазы всплытия при triggerHandler нет. Поэтому и обработчик не срабатывает.

Да. И теперь вы будете знать, почему выделение галочки при генерации события происходит позже, чем срабатывают обработчики click.
Кстати, отличная иллюстрация того, почему лучше не смешивать в своих проектах разные фреймворки.

З.Ы.: для изучения использовался jquery версии 1.6.3
Похожие записи:

Java, PhpStorm, ActiveDirectory, перенаправление папок и проблема запуска

2011-12-19T09:24:27-08:00

Как-то вечером я запустил PhpStorm на свежей windows 7, которая была введена в мой домашний домен. В домене настроено перенаправление папок пользователя на самба-сервер (не перемещаемые профили, а именно перенаправление отдельных папок).
И что же получилось? PhpStorm запустился только один раз. После он в упор отказывался запускаться ссылаясь на то, что файлы в .WebIde10\system\caches заблокированы для записи. Странно.

Оказалось, что багу в jvm уже почти 10 лет. Суть его в том, что содержимое внутренней переменной user.home вовсе не равно содержимому %USERPROFILE%.
Проверить это можно простым кодом

public class PropertyTest{
  public static void main(String[] args) {
    System.out.println(System.getProperty("user.home"));
  }
}

В моем случае это выглядело так:

C:\projects>java PropertyTest
\\samba\profiles\penguin

C:\projects>echo %userprofile%
C:\Users\penguin

Печально

Покопавшись в конфиге phpstorm (C:\Program Files (x86)\JetBrains\PhpStorm 3.0\bin\idea.properties) можно найти интересные строки

# Uncomment to disable Safe Write feature, which causes permission change on editing a (e.g. Samba-) mounted files.
#----------------------------------------------------------------------
#idea.no.safe.write=true

Раскомментировали и все работает как надо (только предварительно нужно снести папку .WebIde10 с шары. поскольку блокировки на запись там остались).
Похожие записи:

Windows 7 автоматически не уходит в спящий режим

2011-12-18T09:43:54-08:00

Недавно столкнулся с проблемой: windows 7 отказывалась автоматически уходить в спящий режим. Решение оказалось очень простым

Сначала нужно протрассировать события системы при попытке уйти в спящий режим

powercfg -energy

Система сгенерирует отчет, в котором можно будет найти причину ошибки.
В моем случае виноват быо драйвер rdbss

System Availability Requests:System Required Request
The device or driver has made a request to prevent the system from automatically entering sleep.
Driver Name \FileSystem\rdbss

Теперь нужно понять, почему он блокирует уход системы в спячку. Для этого нужно посмотреть список блокировок

powercfg -requests

Хм… Виновным оказался образ лиска, открытый в daemon tools с samba-ресурса

DISPLAY:
None.

SYSTEM:
[DRIVER] \FileSystem\rdbss
A file has been opened across the network. File name: [\samba\soft\win\disk.iso] Process ID: [2944]

AWAYMODE:
None.

Отмонтируем образ, проверяем систему.

DISPLAY:
None.

SYSTEM:
None.

AWAYMODE:
None.

Система спокойно уходит в спячку автоматически.
Похожие записи:

htaccess: избирательное открытие доступа к url

2011-11-30T07:02:14-08:00

Часто ли вы сталкивались с ситуацией, когда надо разрешить доступ к сайту только по логину паролю а потом разрешить вызов по определенному урлу без ввода пароля? Что может быть проще?

Код .htaccess

AuthType Basic
AuthName "Private zone. Only for administrator!"
AuthUserFile  .htpasswd
require valid-user

И создаем .htpasswd с учетной записью пользователя admin.

htpasswd -cm admin

А теперь нам надо избирательно разрешить доступ по определенным адресам. Чтобы у пользователя не запрашивалось пароля.

# Если урл начинается со строки /some/path
# то выставляем переменную some_path
SetEnvIf Request_URI "/some/path*" some_path
# Дальше стандартный код защиты при помощи .htpasswd
AuthType Basic
AuthName "Private zone. Only for administrator!"
AuthUserFile  .htpasswd
require valid-user
# Запрещаем все, что не разрешено
Deny from all
# И если установлена переменная окружения some_path,
# То разрешаем вызов без запроса авторизации
Allow from env=some_path
Satisfy any

Похожие записи: