+<?php

+	class EArray implements ArrayAccess {

+		use Events;

+		private $data = [];

+		public static function from(array $data){

+			return new static($data);

+		}

+		protected function __construct(array $data){

+			$this->data = array_values($data);

+		}

+		public function offsetExists($offset){

+			$this->fire('exists', $offset);

+			return isset($this->data[$offset]);

+		}

+		public function offsetGet($offset){

+			$this->fire('get', $offset);

+			return $this->data[$offset];

+		}

+		public function offsetSet($offset, $value){

+			$this->fire('set', $offset, $value);

+			$this->data[$offset] = $value;

+		}

+		public function offsetUnset($offset){

+			$this->fire('unset', $offset, $this[$offset]);

+			unset($this->data[$offset]);

+		}

+		public function each(callable $fn){

+			foreach($this->data as $offset => $model){

+				$fn($model, $offset);

+			}

+			return $this;

+		}

+	}

+?>

+			return $this;

+			return $this;

+	require_once('relationship.class.php');

+		protected  static $table_name = null;

+							'foreign_key'=>$this->name.static::foreign_key_suffix()

+							'foreign_key'=>$alias.static::foreign_key_suffix()

+							'foreign_key'=>$this->name.static::foreign_key_suffix(),

+				if(isset($idOrData[static::primary_key()]) && self::cached($idOrData[static::primary_key()])){

+				$this->_data[static::primary_key()] = (int)$idOrData;

+					return static::table_name();

+				break;

+				case 'primary_key':

+					return static::primary_key();

+				break;

+				case 'foreign_key_suffix':

+					return static::foreign_key_suffix();

+				break;

+				case 'has_one':case 'has_many':case 'belongs_to':

+					return self::$aliases[$this->name][$name];

+					return $this->get(static::primary_key());

+			unset($this->$_data[static::primary_key()]);

+		public static function table_name(){

+			if(is_null(static::$table_name)){

+				return substr($name, strrpos($name, '\\') + 1);

+			return static::$table_name;

+		}

+		public static function primary_key(){

+			return static::$primary_key;

+		}

+		public static function foreign_key_suffix(){

+			return static::$foreign_key_suffix;

+				"from ".static::table_name().' '.

+				"where ".static::primary_key()." = ?",

+			$name = static::table_name();

+				"delete from ".static::table_name().' '.

+				"where ".static::primary_key()." = ?",

+			$name = static::table_name();

+				"select ".static::primary_key().' id '.

+				"from ".static::table_name().

+						"where ".static::primary_key()." = ?",

+						throw new Exception("{$this->name} with ".static::primary_key()." of {$this->id} does not exist");

+				if(!is_null($this->id) && !in_array(static::primary_key(), $this->_changed)){

+						"update {$this->name} {$set} where ".static::primary_key()." = ?",

+					$this->_data[static::primary_key()] = self::$sql->insert_id;

+				}

+				foreach($this->_related as $related){

+					$related->save();

+			if($key === static::primary_key() && !is_null($this->id)){

+			if(!isset($this->_related[$name])){

+				$aliases = self::$aliases[$this->name];

+				if($aliases['belongs_to'][$name]){

+					$alias = $aliases['has_many'][$name];

+					$class = "Models\\{$alias['model']}";

+					$this->_related[$name] = $class::fetch([$alias['foreign_key'] => $this->id])[0];

+				}elseif($aliases['has_one'][$name]){

+					$alias = $aliases['has_many'][$name];

+					$class = "Models\\{$alias['model']}";

+					$this->_related[$name] = $class::instance($this[$alias['foreign_key']]);

+				}elseif($aliases['has_many'][$name]){

+					$alias = $aliases['has_many'][$name];

+					$class = "Models\\{$alias['model']}";

+					$sql = "select ";

+					if($alias['through']){

+						$sql .= $class::table_name().$class::foreign_key_suffix()." id from {$alias['through']} ";

+					}else{

+						$sql .= $class::primary_key()." id from {$alias['model']} ";

+					}

+					$sql .= "where ".$alias['foreign_key']." = ?";

+					$related = [];

+					self::query(

+						$sql,

+						'i',

+						$this->id

+					)->each_assoc(function($row) use(&$related, $class){

+						$related[] = new $class($row['id']);

+					});

+					$this->_related[$name] = Relationship::from($this, $name, $alias, $related);

+<?php

+	namespace SQL {

+		/**

+		* Query class. Returned by \SQL::query()

+		*

+		* @class Query

+		* @constructor

+		*/

+		class Query {

+			private $query;

+			private $sql;

+			private $_result = false;

+			public function __construct($sql, $source, $types=null, ...$args){

+				$sql->queries[] = $this;

+				$args = array_merge([$types], $args);

+				$this->sql = $sql();

+				$this->query = $this->sql->stmt_init();

+				if(!$this->query->prepare($source)){

+					throw new Exception($this->query->error);

+				}

+				if(!is_null($types)){

+					if(!$this->query->bind_param(...\SQL::make_referenced($args))){

+						throw new Exception("Unable to bind parameter {$this->query->error}");

+					}

+				}

+			}

+			public function __destruct(){

+				if($this->_result){

+					$this->_result = false;

+					$this->query->free_result();

+				}

+				if($this->query){

+					$this->query->close();

+				}

+				$sql->queries = array_diff($sql->queries, [$this]);

+			}

+			public function __invoke(){

+				return $this->query;

+			}

+			public function execute(){

+				if($this->query){

+					$this->query->free_result();

+					$this->_result = false;

+					$this->query->reset();

+					$r = $this->query->execute();

+					$this->sql->commit();

+					return $r;

+				}else{

+					return false;

+				}

+			}

+			public function each_assoc(callable $fn){

+				if($this->query){

+					$r = $this->results;

+					while($row = $r->fetch_assoc()){

+						$fn($row);

+					}

+				}else{

+					return false;

+				}

+			}

+			public function each_num(callable $fn){

+				if($this->query){

+					$r = $this->results;

+					while($row = $r->fetch_num()){

+						$fn($row);

+					}

+				}else{

+					return false;

+				}

+			}

+			public function __get($name){

+				switch($name){

+					/**

+					* Returns the mysqli::results object for the

+					* query

+					* 

+					* @property results

+					* @type {mysqli::results}

+					* @public

+					*/

+					case 'results':

+						if(!$this->_result && $this->query){

+							$this->execute();

+							$this->_result = $this->query->get_result();

+							$this->query->close();

+						}

+						return $this->_result;

+					break;

+					/**

+					* Returns an associative array of the query resulsts

+					* 

+					* @property assoc_results

+					* @type {Array}

+					* @public

+					*/

+					/**

+					* Returns an associative array of the query resulsts

+					* 

+					* @property resulsts_assoc

+					* @type {Array}

+					* @public

+					*/

+					case 'assoc_results':case 'results_assoc':

+						if($this->query){

+							$a = [];

+							$r = $this->results;

+							while($row = $r->fetch_assoc()){

+								array_push($a,$row);

+							}

+							return $a;

+						}else{

+							return false;

+						}

+					break;

+					/**

+					* Returns a numbered array of the query results

+					* 

+					* @property num_results

+					* @type {Array}

+					* @public

+					*/

+					/**

+					* Returns a numbered array of the query results

+					* 

+					* @property resulsts_num

+					* @type {Array}

+					* @public

+					*/

+					case 'num_results':case 'results_num':

+						if($this->query){

+							$a = [];

+							$r = $this->results;

+							while($row = $r->fetch_num()){

+								array_push($a,$row);

+							}

+							return $a;

+						}else{

+							return false;

+						}

+					break;

+					case 'assoc_result':case 'result_assoc':

+						if($this->query){

+							$r = $this->results;

+							return $r?$r->fetch_assoc():false;

+						}else{

+							return false;

+						}

+					break;

+					case 'num_result':case 'result_num':

+						if($this->query){

+							$r = $this->results;

+							return $r?$r->fetch_num():false;

+						}else{

+							return false;

+						}

+					break;

+					case 'insert_id':

+						return $this->sql->insert_id;

+					break;

+					case 'affected_rows':

+						return $this->query->affected_rows;

+					break;

+				}

+			}

+		}

+	}

+?>

+<?php

+	require_once('earray.class.php');

+	class Relationship extends EArray {

+		private $model;

+		private $name;

+		private $alias;

+		private $removed = [];

+		private $added = [];

+		public static function from(ORM $model, string $name, array $alias, array $data){

+			$earray = parent::from($data)

+				->on('set', function(&$offset, &$value) use($earray){

+					$earray->added = array_merge($earray->added, [$value]);

+					$earray->removed = array_diff($earray->removed, [$value]);

+				})->on('unset', function($offset, $value) use($earray){

+					$earray->removed = array_merge($earray->removed, [$value]);

+					$earray->added = array_diff($earray->added, [$value]);

+				});

+			$earray->model = $model;

+			$earray->name = $name;

+			$earray->alias = $alias;

+			return $earray;

+		}

+		public function add(ORM $model){

+			$this[] = $model;

+			return $this;

+		}

+		public function remove(ORM $model){

+			$index = $this->index($model);

+			if($index !== false){

+				unset($this->data[$index]);

+			}

+			return $this;

+		}

+		public function has(ORM $model){

+			return $this->index($model) !== false;

+		}

+		public function index(ORM $model){

+			return array_search($model, $this->data);

+		}

+		public function dirty(){

+			return count($this->removed) + count($this->added) > 0;

+		}

+		public function reset(){

+			foreach($this->added as $model){

+				$index = array_search($model, $this->data);

+				if($index !== false){

+					unset($this->data[$index]);

+				}

+			}

+			$this->added = [];

+			foreach($this->removed as $model){

+				$this->data = array_merge($this->data, [$model]);

+			}

+			$this->removed = [];

+		}

+		public function save(){

+			if($this->dirty()){

+				$model = $this->model;

+				$alias = $this->$alias;

+				$name = $this->name;

+				$class = "Models\\{$alias['model']}";

+				if(isset($model->has_many[$name])){

+					throw new Exception("Invalid relationship {$name}");

+				}

+				if(isset($alias['through'])){

+					$rem_sql = "delete from {$alias['through']} where {$alias['foreign_key']} = ? and ".$class::table_name().$class::foreign_key_suffix()." = ?";

+					$rem_args = [$model->id];

+					$add_sql = "insert into {$alias['through']} ({$alias['foreign_key']}, ".$class::table_name().$class::foreign_key_suffix().") values (?, ?)";

+				}else{

+					$rem_sql = "update {$alias['model']} set {$alias['foreign_key']} = null where ".$class::primary_key()." = ?";

+					$rem_args = [];

+					$add_sql .= "update {$alias['model']} set {$alias['foreign_key']} = ? where ".$class::primary_key()." = ?";

+				}

+				$class = get_class($models);

+				foreach($this->removed as $item){

+					$class::query(

+						$rem_sql,

+						'ii',

+						...array_merge($rem_args, [$item->id])

+					)->execute();

+				}

+				$this->removed = [];

+				foreach($this->added as $item){

+					$class::query(

+						$add_sql,

+						'ii',

+						$model->id,

+						$item->id

+					)->execute();

+				}

+				$this->added = [];

+			}

+		}

+	}

+?>

+	require_once('query.class.php');

+			return new SQL\Query(...array_merge([$this], $args));