An unhandled exception was thrown

 351            $sql = $params['sql']; 
 352            $options = $params['options']; 
 353 
 354            $conn->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, $options['buffered']); 
 355 
 356            if (!($resource = $conn->query($sql)) instanceof PDOStatement) { 
 357                list($code, $error) = $self->error(); 
 358                throw new QueryException("{$sql}: {$error}", $code); 
 359            } 
 360            return $self->invokeMethod('_instance', array('result', compact('resource'))); 
 361        }); 

 351            $sql = $params['sql']; 
 352            $options = $params['options']; 
 353 
 354            $conn->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, $options['buffered']); 
 355 
 356            if (!($resource = $conn->query($sql)) instanceof PDOStatement) { 
 357                list($code, $error) = $self->error(); 
 358                throw new QueryException("{$sql}: {$error}", $code); 
 359            } 
 360            return $self->invokeMethod('_instance', array('result', compact('resource'))); 
 361        }); 

 233     */ 
 234    protected function _filter($method, $params, $callback, $filters = array()) { 
 235        list($class, $method) = explode('::', $method); 
 236 
 237        if (empty($this->_methodFilters[$method]) && empty($filters)) { 
 238            return $callback($this, $params, null); 
 239        } 
 240 
 241        $f = isset($this->_methodFilters[$method]) ? $this->_methodFilters[$method] : array(); 
 242        $data = array_merge($f, $filters, array($callback)); 
 243        return Filters::run($this, $params, compact('data', 'class', 'method')); 

 356            if (!($resource = $conn->query($sql)) instanceof PDOStatement) { 
 357                list($code, $error) = $self->error(); 
 358                throw new QueryException("{$sql}: {$error}", $code); 
 359            } 
 360            return $self->invokeMethod('_instance', array('result', compact('resource'))); 
 361        }); 
 362    } 
 363 
 364    protected function _results($results) { 
 365        /* @var $results PDOStatement */ 
 366        $numFields = $results->columnCount(); 

 162    public function invokeMethod($method, $params = array()) { 
 163        switch (count($params)) { 
 164            case 0: 
 165                return $this->{$method}(); 
 166            case 1: 
 167                return $this->{$method}($params[0]); 
 168            case 2: 
 169                return $this->{$method}($params[0], $params[1]); 
 170            case 3: 
 171                return $this->{$method}($params[0], $params[1], $params[2]); 
 172            case 4: 

 295                        }, $idData); 
 296                    $query->limit(false)->conditions(array("{$name}.{$key}" => $ids)); 
 297                } 
 298                $sql = $self->renderCommand($query); 
 299            } 
 300            $result = $self->invokeMethod('_execute', array($sql)); 
 301 
 302            switch ($return) { 
 303                case 'resource': 
 304                    return $result; 
 305                case 'array': 

 233     */ 
 234    protected function _filter($method, $params, $callback, $filters = array()) { 
 235        list($class, $method) = explode('::', $method); 
 236 
 237        if (empty($this->_methodFilters[$method]) && empty($filters)) { 
 238            return $callback($this, $params, null); 
 239        } 
 240 
 241        $f = isset($this->_methodFilters[$method]) ? $this->_methodFilters[$method] : array(); 
 242        $data = array_merge($f, $filters, array($callback)); 
 243        return Filters::run($this, $params, compact('data', 'class', 'method')); 

 319                case 'item': 
 320                    return $self->item($query->model(), array(), compact('query', 'result') + array( 
 321                        'class' => 'set' 
 322                    )); 
 323            } 
 324        }); 
 325    } 
 326 
 327    /** 
 328     * Updates a record in the database based on the given `Query`. 
 329     * 

 214            extract($params); 
 215 
 216            $name = $self->invokeMethod('_entityName', array($entity, array('quoted' => true))); 
 217            $columns = $self->read("DESCRIBE {$name}", array('return' => 'array', 'schema' => array( 
 218                'field', 'type', 'null', 'key', 'default', 'extra' 
 219            ))); 
 220            $fields = array(); 
 221 
 222            foreach ($columns as $column) { 
 223                $match = $self->invokeMethod('_column', array($column['type'])); 
 224 

 233     */ 
 234    protected function _filter($method, $params, $callback, $filters = array()) { 
 235        list($class, $method) = explode('::', $method); 
 236 
 237        if (empty($this->_methodFilters[$method]) && empty($filters)) { 
 238            return $callback($this, $params, null); 
 239        } 
 240 
 241        $f = isset($this->_methodFilters[$method]) ? $this->_methodFilters[$method] : array(); 
 242        $data = array_merge($f, $filters, array($callback)); 
 243        return Filters::run($this, $params, compact('data', 'class', 'method')); 

 226                    'null'     => ($column['null'] == 'YES' ? true : false), 
 227                    'default'  => $column['default'] 
 228                ); 
 229            } 
 230            return $fields; 
 231        }); 
 232    } 
 233 
 234    /** 
 235     * Gets or sets the encoding for the connection. 
 236     * 

 619 
 620        if ($field === false) { 
 621            return $self->_schema = array(); 
 622        } 
 623        if (!$self->_schema) { 
 624            $self->_schema = static::connection()->describe($self::meta('source'), $self->_meta); 
 625            $key = (array) self::meta('key'); 
 626            if ($self->_schema && array_intersect($key, array_keys($self->_schema)) != $key) { 
 627                throw new ConfigException('Missing key `' . implode(',', $key) . '` from schema.'); 
 628            } 
 629        } 

 650                    return $f; 
 651                } 
 652            } 
 653            return false; 
 654        } 
 655        $schema = static::schema(); 
 656        return ($schema && isset($schema[$field])); 
 657    } 
 658 
 659    /** 
 660     * Instantiates a new record or document object, initialized with any data passed in. For 

 644     *         the fields in the list are found. 
 645     */ 
 646    public static function hasField($field) { 
 647        if (is_array($field)) { 
 648            foreach ($field as $f) { 
 649                if (static::hasField($f)) { 
 650                    return $f; 
 651                } 
 652            } 
 653            return false; 
 654        } 

 523            $titleKeys = array('title', 'name'); 
 524 
 525            if (isset($self->_meta['key'])) { 
 526                $titleKeys = array_merge($titleKeys, (array) $self->_meta['key']); 
 527            } 
 528            $self->_meta['title'] = $self->_meta['title'] ?: static::hasField($titleKeys); 
 529        } 
 530        if (is_array($key) || !$key || $value) { 
 531            return $self->_meta; 
 532        } 
 533        return isset($self->_meta[$key]) ? $self->_meta[$key] : null; 

 407     * @return array Returns an array containing the configuration for a model relationship. 
 408     */ 
 409    public function relationship($class, $type, $name, array $config = array()) { 
 410        $field = Inflector::underscore(Inflector::singularize($name));//($type == 'hasMany') ?  : ; 
 411        $key = "{$field}_id"; 
 412        $primary = $class::meta('key'); 
 413 
 414        if (is_array($primary)) { 
 415            $key = array_combine($primary, $primary); 
 416        } elseif ($type == 'hasMany' || $type == 'hasOne') { 
 417            if ($type == 'hasMany') { 

 598        $self = static::_object(); 
 599 
 600        if (!isset($self->_relationTypes[$type])) { 
 601            throw new ConfigException("Invalid relationship type `{$type}` specified."); 
 602        } 
 603        $rel = static::connection()->relationship(get_called_class(), $type, $name, $config); 
 604        return $self->_relations[$name] = $rel; 
 605    } 
 606 
 607    /** 
 608     * Lazy-initialize the schema for this Model object, if it is not already manually set in the 

 1071            return; 
 1072        } 
 1073 
 1074        foreach ($self->_relationTypes as $type => $keys) { 
 1075            foreach (Set::normalize($self->{$type}) as $name => $config) { 
 1076                static::bind($type, $name, (array) $config); 
 1077            } 
 1078        } 
 1079    } 
 1080 
 1081    /** 

 374        $self->_meta = ($local + $source['meta'] + $meta); 
 375        $self->_meta['initialized'] = false; 
 376        $self->_schema += $schema + $source['schema']; 
 377 
 378        $self->_finders += $source['finders'] + $self->_findFilters(); 
 379        static::_relations(); 
 380    } 
 381 
 382    /** 
 383     * Allows the use of syntactic-sugar like `Model::all()` instead of `Model::find('all')`. 
 384     * 

 320     * 
 321     * @param array $options 
 322     * @return void 
 323     */ 
 324    public static function __init() { 
 325        static::config(); 
 326    } 
 327 
 328    /** 
 329     * Configures the model for use. This method is called by `Model::__init()`. 
 330     * 

 499        $path = isset(static::$_cachedPaths[$class]) ? static::$_cachedPaths[$class] : null; 
 500        $path = $path ?: static::path($class); 
 501 
 502        if ($path && include $path) { 
 503            static::$_cachedPaths[$class] = $path; 
 504            method_exists($class, '__init') ? $class::__init() : null; 
 505        } elseif ($require) { 
 506            throw new RuntimeException("Failed to load class `{$class}` from path `{$path}`."); 
 507        } 
 508    } 
 509 

 1814                $this->redirect ( "/users/logout" ); 
 1815                return; 
 1816            } 
 1817        } 
 1818 
 1819        $user = User::create (); 
 1820 
 1821        if ($this->request->is ( 'post' )) { 
 1822//            echo "<pre>";print_R($this->request);exit; 
 1823            if (Auth::check ( 'default', $this->request )) { 
 1824                $user = Session::read ( 'default' ); 

 160     * @return mixed  Returns the result of the method call 
 161     */ 
 162    public function invokeMethod($method, $params = array()) { 
 163        switch (count($params)) { 
 164            case 0: 
 165                return $this->{$method}(); 
 166            case 1: 
 167                return $this->{$method}($params[0]); 
 168            case 2: 
 169                return $this->{$method}($params[0], $params[1]); 
 170            case 3: 

 180            if (!method_exists($self, $action)) { 
 181                throw new DispatchException("Action `{$action}` not found."); 
 182            } 
 183            $render['template'] = $render['template'] ?: $action; 
 184 
 185            if ($result = $self->invokeMethod($action, $args)) { 
 186                if (is_string($result)) { 
 187                    $self->render(array('text' => $result)); 
 188                    return $self->response; 
 189                } 
 190                if (is_array($result)) { 

 233     */ 
 234    protected function _filter($method, $params, $callback, $filters = array()) { 
 235        list($class, $method) = explode('::', $method); 
 236 
 237        if (empty($this->_methodFilters[$method]) && empty($filters)) { 
 238            return $callback($this, $params, null); 
 239        } 
 240 
 241        $f = isset($this->_methodFilters[$method]) ? $this->_methodFilters[$method] : array(); 
 242        $data = array_merge($f, $filters, array($callback)); 
 243        return Filters::run($this, $params, compact('data', 'class', 'method')); 

 194 
 195            if (!$render['hasRendered'] && $render['auto']) { 
 196                $self->render(); 
 197            } 
 198            return $self->response; 
 199        }); 
 200    } 
 201 
 202    /** 
 203     * This method is used to pass along any data from the controller to the view and layout 
 204     * 

 257     */ 
 258    protected static function _call($callable, $request, $params) { 
 259        $params = compact('callable', 'request', 'params'); 
 260        return static::_filter(__FUNCTION__, $params, function($self, $params) { 
 261            if (is_callable($callable = $params['callable'])) { 
 262                return $callable($params['request'], $params['params']); 
 263            } 
 264            throw new DispatchException('Result not callable.'); 
 265        }); 
 266    } 
 267} 

 114    protected static function _filter($method, $params, $callback, $filters = array()) { 
 115        $class = get_called_class(); 
 116        $hasNoFilters = empty(static::$_methodFilters[$class][$method]); 
 117 
 118        if ($hasNoFilters && !$filters && !Filters::hasApplied($class, $method)) { 
 119            return $callback($class, $params, null); 
 120        } 
 121        if (!isset(static::$_methodFilters[$class][$method])) { 
 122            static::$_methodFilters += array($class => array()); 
 123            static::$_methodFilters[$class][$method] = array(); 
 124        } 

 260        return static::_filter(__FUNCTION__, $params, function($self, $params) { 
 261            if (is_callable($callable = $params['callable'])) { 
 262                return $callable($params['request'], $params['params']); 
 263            } 
 264            throw new DispatchException('Result not callable.'); 
 265        }); 
 266    } 
 267} 
 268 
 269 

 70             case 1: 
 71                 return static::$method($params[0]); 
 72             case 2: 
 73                 return static::$method($params[0], $params[1]); 
 74             case 3: 
 75                 return static::$method($params[0], $params[1], $params[2]); 
 76             case 4: 
 77                 return static::$method($params[0], $params[1], $params[2], $params[3]); 
 78             case 5: 
 79                 return static::$method($params[0], $params[1], $params[2], $params[3], $params[4]); 
 80             default: 

 149 
 150            if (!$params) { 
 151                throw new DispatchException('Could not route request.'); 
 152            } 
 153            $callable = $self::invokeMethod('_callable', array($result, $params, $options)); 
 154            return $self::invokeMethod('_call', array($callable, $result, $params)); 
 155        }); 
 156    } 
 157 
 158    /** 
 159     * Attempts to apply a set of formatting rules from `$_rules` to a `$params` array, where each 

 197    public function next($self, $params, $chain) { 
 198        if (empty($self) || empty($chain)) { 
 199            return parent::next(); 
 200        } 
 201        $next = parent::next(); 
 202        return $next($self, $params, $chain); 
 203    } 
 204 
 205    /** 
 206     * Gets the method name associated with this filter chain.  This is the method being filtered. 
 207     * 

 38 /** 
 39  * Caches paths for auto-loaded and service-located classes when in production. 
 40  */ 
 41 Dispatcher::applyFilter('run', function($self, $params, $chain) { 
 42     if (!Environment::is('production')) { 
 43         return $chain->next($self, $params, $chain); 
 44     } 
 45     $key = md5(LITHIUM_APP_PATH) . '.core.libraries'; 
 46  
 47     if ($cache = Cache::read('default', $key)) { 
 48         $cache = (array) $cache + Libraries::cache(); 

 197    public function next($self, $params, $chain) { 
 198        if (empty($self) || empty($chain)) { 
 199            return parent::next(); 
 200        } 
 201        $next = parent::next(); 
 202        return $next($self, $params, $chain); 
 203    } 
 204 
 205    /** 
 206     * Gets the method name associated with this filter chain.  This is the method being filtered. 
 207     * 

 46             continue; 
 47         } 
 48         $file = "{$config['path']}/config/routes.php"; 
 49         file_exists($file) ? call_user_func(function() use ($file) { include $file; }) : null; 
 50     } 
 51     return $chain->next($self, $params, $chain); 
 52 }); 
 53  
 54 // filter controller logic - before and after when a controller action is invoked 
 55 Dispatcher::applyFilter('_callable', function ($self, $params, $chain) { 
 56     $controller = $chain->next($self, $params, $chain); 

 197    public function next($self, $params, $chain) { 
 198        if (empty($self) || empty($chain)) { 
 199            return parent::next(); 
 200        } 
 201        $next = parent::next(); 
 202        return $next($self, $params, $chain); 
 203    } 
 204 
 205    /** 
 206     * Gets the method name associated with this filter chain.  This is the method being filtered. 
 207     * 

 261        $wrap = static::$_exceptionHandler; 
 262        $_self = get_called_class(); 
 263 
 264        $filter = function($self, $params, $chain) use ($_self, $conditions, $handler, $wrap) { 
 265            try { 
 266                return $chain->next($self, $params, $chain); 
 267            } catch (Exception $e) { 
 268                if (!$_self::matches($e, $conditions)) { 
 269                    throw $e; 
 270                } 
 271                return $handler($wrap($e, true), $params); 

 178            } 
 179        } 
 180 
 181        $chain = new Filters($options); 
 182        $next = $chain->rewind(); 
 183        return $next($class, $params, $chain); 
 184    } 
 185 
 186    /** 
 187     * Provides short-hand convenience syntax for filter chaining. 
 188     * 

 121        if (!isset(static::$_methodFilters[$class][$method])) { 
 122            static::$_methodFilters += array($class => array()); 
 123            static::$_methodFilters[$class][$method] = array(); 
 124        } 
 125        $data = array_merge(static::$_methodFilters[$class][$method], $filters, array($callback)); 
 126        return Filters::run($class, $params, compact('data', 'class', 'method')); 
 127    } 
 128 
 129    /** 
 130     * Gets and caches an array of the parent methods of a class. 
 131     * 

 150            if (!$params) { 
 151                throw new DispatchException('Could not route request.'); 
 152            } 
 153            $callable = $self::invokeMethod('_callable', array($result, $params, $options)); 
 154            return $self::invokeMethod('_call', array($callable, $result, $params)); 
 155        }); 
 156    } 
 157 
 158    /** 
 159     * Attempts to apply a set of formatting rules from `$_rules` to a `$params` array, where each 
 160     * formatting rule is applied if the key of the rule in `$_rules` is present and not empty in 

 50  * @see lithium\action\Response 
 51  * @see lithium\action\Dispatcher 
 52  * @see lithium\net\http\Router 
 53  * @see lithium\action\Controller 
 54  */ 
 55 echo lithium\action\Dispatcher::run(new lithium\action\Request()); 
 56  
 57