miBadger / miBadger.ActiveRecord

src/ActiveRecordInterface.php

Indentation +71 added lines, -71 removed lines

@@ -19,83 +19,83 @@
  */
 interface ActiveRecordInterface
 {
-	/**
-	 * Returns this active record after creating an entry with the records attributes.
-	 *
-	 * @return $this
-	 * @throws ActiveRecordException on failure.
-	 */
-	public function create();
+    /**
+     * Returns this active record after creating an entry with the records attributes.
+     *
+     * @return $this
+     * @throws ActiveRecordException on failure.
+     */
+    public function create();
 
-	/**
-	 * Returns this active record after reading the attributes from the entry with the given identifier.
-	 *
-	 * @param mixed $id
-	 * @return $this
-	 * @throws ActiveRecordException on failure.
-	 */
-	public function read($id);
+    /**
+     * Returns this active record after reading the attributes from the entry with the given identifier.
+     *
+     * @param mixed $id
+     * @return $this
+     * @throws ActiveRecordException on failure.
+     */
+    public function read($id);
 
-	/**
-	 * Returns this active record after updating the attributes to the corresponding entry.
-	 *
-	 * @return $this
-	 * @throws ActiveRecordException on failure.
-	 */
-	public function update();
+    /**
+     * Returns this active record after updating the attributes to the corresponding entry.
+     *
+     * @return $this
+     * @throws ActiveRecordException on failure.
+     */
+    public function update();
 
-	/**
-	 * Returns this record after deleting the corresponding entry.
-	 *
-	 * @return $this
-	 * @throws ActiveRecordException on failure.
-	 */
-	public function delete();
+    /**
+     * Returns this record after deleting the corresponding entry.
+     *
+     * @return $this
+     * @throws ActiveRecordException on failure.
+     */
+    public function delete();
 
-	/**
-	 * Returns this record after synchronizing it with the corresponding entry.
-	 * A new entry is created if this active record does not have a corresponding entry.
-	 *
-	 * @return $this
-	 * @throws ActiveRecordException on failure.
-	 */
-	public function sync();
+    /**
+     * Returns this record after synchronizing it with the corresponding entry.
+     * A new entry is created if this active record does not have a corresponding entry.
+     *
+     * @return $this
+     * @throws ActiveRecordException on failure.
+     */
+    public function sync();
 
-	/**
-	 * Returns true if this active record has a corresponding entry.
-	 *
-	 * @return bool true if this active record has a corresponding entry.
-	 */
-	public function exists();
+    /**
+     * Returns true if this active record has a corresponding entry.
+     *
+     * @return bool true if this active record has a corresponding entry.
+     */
+    public function exists();
 
-	/**
-	 * Returns this record after filling it with the given attributes.
-	 *
-	 * @param array $attributes = []
-	 * @return $this
-	 * @throws ActiveRecordException on failure.
-	 */
-	public function fill(array $attributes);
+    /**
+     * Returns this record after filling it with the given attributes.
+     *
+     * @param array $attributes = []
+     * @return $this
+     * @throws ActiveRecordException on failure.
+     */
+    public function fill(array $attributes);
 
-	/**
-	 * Returns this record after filling it with the attributes of the first entry with the given where and order by clauses.
-	 *
-	 * @param array $where = []
-	 * @param array $orderBy = []
-	 * @return $this
-	 * @throws ActiveRecordException on failure.
-	 */
-	public function searchOne(array $where = [], array $orderBy = []);
+    /**
+     * Returns this record after filling it with the attributes of the first entry with the given where and order by clauses.
+     *
+     * @param array $where = []
+     * @param array $orderBy = []
+     * @return $this
+     * @throws ActiveRecordException on failure.
+     */
+    public function searchOne(array $where = [], array $orderBy = []);
 
-	/**
-	 * Returns the records with the given where, order by, limit and offset clauses.
-	 *
-	 * @param array $where = []
-	 * @param array $orderBy = []
-	 * @param int $limit = -1
-	 * @param int $offset = 0
-	 * @return static[] the records with the given where, order by, limit and offset clauses.
-	 * @throws ActiveRecordException on failure.
-	 */
-	public function search(array $where = [], array $orderBy = [], $limit = -1, $offset = 0);
+    /**
+     * Returns the records with the given where, order by, limit and offset clauses.
+     *
+     * @param array $where = []
+     * @param array $orderBy = []
+     * @param int $limit = -1
+     * @param int $offset = 0
+     * @return static[] the records with the given where, order by, limit and offset clauses.
+     * @throws ActiveRecordException on failure.
+     */
+    public function search(array $where = [], array $orderBy = [], $limit = -1, $offset = 0);
 }

src/ColumnProperty.php

Indentation +6 added lines, -6 removed lines

@@ -5,10 +5,10 @@
 
 class ColumnProperty
 {
-	const NONE = 0;
-	const UNIQUE = 1;
-	const NOT_NULL = 2;
-	const IMMUTABLE = 4;
-	const AUTO_INCREMENT = 8;
-	const PRIMARY_KEY = 16;
+    const NONE = 0;
+    const UNIQUE = 1;
+    const NOT_NULL = 2;
+    const IMMUTABLE = 4;
+    const AUTO_INCREMENT = 8;
+    const PRIMARY_KEY = 16;
 }
\ No newline at end of file

src/Traits/Pagination.php

Indentation +1 added lines, -1 removed lines

@@ -6,5 +6,5 @@
 
 trait Pagination
 {
-	// @TODO: This one would most likely only be relevant for api requests (and perhaps supply a public method for searching with a page)
+    // @TODO: This one would most likely only be relevant for api requests (and perhaps supply a public method for searching with a page)
 }
\ No newline at end of file

test-bootstrap.php

Spacing +2 added lines, -2 removed lines

@@ -9,7 +9,7 @@ 
 // Cleanup SQL
 $user_delete = "DROP USER IF EXISTS $dbuser@'localhost'; ";
 $database_delete = "DROP DATABASE IF EXISTS $dbname; ";
-$sql_cleanup = $user_delete . $database_delete;
+$sql_cleanup = $user_delete.$database_delete;
 
 // Setup SQL
 $db_create = "CREATE DATABASE $dbname; ";
@@ -17,7 +17,7 @@ 
 $user_alter = "ALTER USER '$dbuser'@'localhost' IDENTIFIED with mysql_native_password BY '$dbpass'; ";
 $user_grant = "GRANT ALL PRIVILEGES ON *.* TO '$dbuser'@'localhost';";
 
-$sql_setup = $sql_cleanup . $db_create . $user_create . $user_alter . $user_grant;
+$sql_setup = $sql_cleanup.$db_create.$user_create.$user_alter.$user_grant;
 print $sql_setup;
 echo "Please enter mysql root password to set up a database environment for testing\n";
 exec("echo \"$sql_setup\" | mysql -u root -p");

src/Traits/Address.php

Indentation +144 added lines, -144 removed lines

@@ -11,154 +11,154 @@
 
 trait Address
 {
-	/** @var string the address line */
-	protected $address;
-
-	/** @var string the zipcode */
-	protected $zipcode;
-
-	/** @var string the city */
-	protected $city;
-
-	/** @var string the country */
-	protected $country;
-
-	/**
-	 * Registers the Address trait on the including class
-	 * @return void
-	 */
-	protected function initAddress() 
-	{
-		$this->extendTableDefinition(TRAIT_ADDRESS_FIELD_ADDRESS, [
-			'value' => &$this->address,
-			'validate' => null,
-			'type' => 'VARCHAR',
-			'length' => 1024,
-			'properties' => null
-		]);
-
-		$this->extendTableDefinition(TRAIT_ADDRESS_FIELD_ZIPCODE, [
-			'value' => &$this->zipcode,
-			'validate' => null,
-			'type' => 'VARCHAR',
-			'length' => 1024,
-			'properties' => null
-		]);
-
-		$this->extendTableDefinition(TRAIT_ADDRESS_FIELD_CITY, [
-			'value' => &$this->city,
-			'validate' => null,
-			'type' => 'VARCHAR',
-			'length' => 1024,
-			'properties' => null
-		]);
-
-		$this->extendTableDefinition(TRAIT_ADDRESS_FIELD_COUNTRY, [
-			'value' => &$this->country,
-			'validate' => null,
-			'type' => 'VARCHAR',
-			'length' => 1024,
-			'properties' => null
-		]);
-
-		$this->address = null;
-		$this->zipcode = null;
-		$this->city = null;
-		$this->country = null;
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getAddress()
-	{
-		return $this->address;
-	}
+    /** @var string the address line */
+    protected $address;
+
+    /** @var string the zipcode */
+    protected $zipcode;
+
+    /** @var string the city */
+    protected $city;
+
+    /** @var string the country */
+    protected $country;
+
+    /**
+     * Registers the Address trait on the including class
+     * @return void
+     */
+    protected function initAddress() 
+    {
+        $this->extendTableDefinition(TRAIT_ADDRESS_FIELD_ADDRESS, [
+            'value' => &$this->address,
+            'validate' => null,
+            'type' => 'VARCHAR',
+            'length' => 1024,
+            'properties' => null
+        ]);
+
+        $this->extendTableDefinition(TRAIT_ADDRESS_FIELD_ZIPCODE, [
+            'value' => &$this->zipcode,
+            'validate' => null,
+            'type' => 'VARCHAR',
+            'length' => 1024,
+            'properties' => null
+        ]);
+
+        $this->extendTableDefinition(TRAIT_ADDRESS_FIELD_CITY, [
+            'value' => &$this->city,
+            'validate' => null,
+            'type' => 'VARCHAR',
+            'length' => 1024,
+            'properties' => null
+        ]);
+
+        $this->extendTableDefinition(TRAIT_ADDRESS_FIELD_COUNTRY, [
+            'value' => &$this->country,
+            'validate' => null,
+            'type' => 'VARCHAR',
+            'length' => 1024,
+            'properties' => null
+        ]);
+
+        $this->address = null;
+        $this->zipcode = null;
+        $this->city = null;
+        $this->country = null;
+    }
+
+    /**
+     * @return string
+     */
+    public function getAddress()
+    {
+        return $this->address;
+    }
 	
-	/**
-	 * @param string $address
-	 */
-	public function setAddress($address)
-	{
-		$this->address = $address;
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getZipcode()
-	{
-		return $this->zipcode;
-	}
+    /**
+     * @param string $address
+     */
+    public function setAddress($address)
+    {
+        $this->address = $address;
+    }
+
+    /**
+     * @return string
+     */
+    public function getZipcode()
+    {
+        return $this->zipcode;
+    }
 	
-	/**
-	 * @param string $zipcode
-	 */
-	public function setZipcode($zipcode)
-	{
-		$this->zipcode = $zipcode;
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getCity()
-	{
-		return $this->city;
-	}
+    /**
+     * @param string $zipcode
+     */
+    public function setZipcode($zipcode)
+    {
+        $this->zipcode = $zipcode;
+    }
+
+    /**
+     * @return string
+     */
+    public function getCity()
+    {
+        return $this->city;
+    }
 	
-	/**
-	 * @param string $city
-	 */
-	public function setCity($city)
-	{
-		$this->city = $city;
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getCountry()
-	{
-		return $this->country;
-	}
+    /**
+     * @param string $city
+     */
+    public function setCity($city)
+    {
+        $this->city = $city;
+    }
+
+    /**
+     * @return string
+     */
+    public function getCountry()
+    {
+        return $this->country;
+    }
 	
-	/**
-	 * @param string $country
-	 */
-	public function setCountry($country)
-	{
-		$this->country = $country;
-	}
-
-	/**
-	 * @return void
-	 */
-	abstract protected function extendTableDefinition($columnName, $definition);
+    /**
+     * @param string $country
+     */
+    public function setCountry($country)
+    {
+        $this->country = $country;
+    }
+
+    /**
+     * @return void
+     */
+    abstract protected function extendTableDefinition($columnName, $definition);
 	
-	/**
-	 * @return void
-	 */
-	abstract protected function registerSearchHook($columnName, $fn);
-
-	/**
-	 * @return void
-	 */
-	abstract protected function registerDeleteHook($columnName, $fn);
-
-	/**
-	 * @return void
-	 */
-	abstract protected function registerUpdateHook($columnName, $fn);
-
-	/**
-	 * @return void
-	 */
-	abstract protected function registerReadHook($columnName, $fn);
-
-	/**
-	 * @return void
-	 */
-	abstract protected function registerCreateHook($columnName, $fn);
+    /**
+     * @return void
+     */
+    abstract protected function registerSearchHook($columnName, $fn);
+
+    /**
+     * @return void
+     */
+    abstract protected function registerDeleteHook($columnName, $fn);
+
+    /**
+     * @return void
+     */
+    abstract protected function registerUpdateHook($columnName, $fn);
+
+    /**
+     * @return void
+     */
+    abstract protected function registerReadHook($columnName, $fn);
+
+    /**
+     * @return void
+     */
+    abstract protected function registerCreateHook($columnName, $fn);
 	
 }
\ No newline at end of file

src/Traits/SoftDelete.php

Indentation +96 added lines, -96 removed lines

@@ -9,102 +9,102 @@
 
 trait SoftDelete
 {
-	/** @var boolean the soft delete status for the entity this trait is embedded into. */
-	protected $softDelete;
-
-	/**
-	 * this method is required to be called in the constructor for each class that uses this trait. 
-	 * It adds the required fields to the table definition and registers hooks
-	 */
-	protected function initSoftDelete()
-	{
-		$this->softDelete = false;
-
-		$this->extendTableDefinition(TRAIT_SOFT_DELETE_FIELD_KEY, [
-			'value' => &$this->softDelete,
-			'validate' => null,
-			'default' => 0,
-			'type' => 'INT',
-			'length' => 1,
-			'properties' => ColumnProperty::NOT_NULL
-		]);
-
-		$this->registerSearchHook(TRAIT_SOFT_DELETE_FIELD_KEY, 'softDeleteSearchHook');
-	}
-
-	/**
-	 * The hook that gets called whenever a query is made
-	 */
-	protected function softDeleteSearchHook(Query $query)
-	{
-		$query->where(TRAIT_SOFT_DELETE_FIELD_KEY, '=', 0);
-	}
-
-	/**
-	 * returns the name for the soft delete field in the database
-	 * @return string
-	 */
-	public function getSoftDeleteFieldName()
-	{
-		return TRAIT_SOFT_DELETE_FIELD_KEY;
-	}
+    /** @var boolean the soft delete status for the entity this trait is embedded into. */
+    protected $softDelete;
+
+    /**
+     * this method is required to be called in the constructor for each class that uses this trait. 
+     * It adds the required fields to the table definition and registers hooks
+     */
+    protected function initSoftDelete()
+    {
+        $this->softDelete = false;
+
+        $this->extendTableDefinition(TRAIT_SOFT_DELETE_FIELD_KEY, [
+            'value' => &$this->softDelete,
+            'validate' => null,
+            'default' => 0,
+            'type' => 'INT',
+            'length' => 1,
+            'properties' => ColumnProperty::NOT_NULL
+        ]);
+
+        $this->registerSearchHook(TRAIT_SOFT_DELETE_FIELD_KEY, 'softDeleteSearchHook');
+    }
+
+    /**
+     * The hook that gets called whenever a query is made
+     */
+    protected function softDeleteSearchHook(Query $query)
+    {
+        $query->where(TRAIT_SOFT_DELETE_FIELD_KEY, '=', 0);
+    }
+
+    /**
+     * returns the name for the soft delete field in the database
+     * @return string
+     */
+    public function getSoftDeleteFieldName()
+    {
+        return TRAIT_SOFT_DELETE_FIELD_KEY;
+    }
 	
-	/**
-	 * Mark the current record as soft deleted
-	 * @return $this
-	 */
-	public function softDelete()
-	{
-		$this->softDelete = true;
-		return $this;
-	}
-
-	/**
-	 * Undo the current soft deletion status (mark it as non-soft deleted)
-	 * @return $this
-	 */
-	public function softRestore()
-	{
-		$this->softDelete = false;
-		return $this;
-	}
-
-	/**
-	 * returns the current soft deletion status
-	 * @return $this
-	 */
-	public function getDeletionStatus() 
-	{
-		return $this->softDelete;
-	}
-
-	/**
-	 * @return void
-	 */
-	abstract protected function extendTableDefinition($columnName, $definition);
+    /**
+     * Mark the current record as soft deleted
+     * @return $this
+     */
+    public function softDelete()
+    {
+        $this->softDelete = true;
+        return $this;
+    }
+
+    /**
+     * Undo the current soft deletion status (mark it as non-soft deleted)
+     * @return $this
+     */
+    public function softRestore()
+    {
+        $this->softDelete = false;
+        return $this;
+    }
+
+    /**
+     * returns the current soft deletion status
+     * @return $this
+     */
+    public function getDeletionStatus() 
+    {
+        return $this->softDelete;
+    }
+
+    /**
+     * @return void
+     */
+    abstract protected function extendTableDefinition($columnName, $definition);
 	
-	/**
-	 * @return void
-	 */
-	abstract protected function registerSearchHook($columnName, $fn);
-
-	/**
-	 * @return void
-	 */
-	abstract protected function registerDeleteHook($columnName, $fn);
-
-	/**
-	 * @return void
-	 */
-	abstract protected function registerUpdateHook($columnName, $fn);
-
-	/**
-	 * @return void
-	 */
-	abstract protected function registerReadHook($columnName, $fn);
-
-	/**
-	 * @return void
-	 */
-	abstract protected function registerCreateHook($columnName, $fn);
+    /**
+     * @return void
+     */
+    abstract protected function registerSearchHook($columnName, $fn);
+
+    /**
+     * @return void
+     */
+    abstract protected function registerDeleteHook($columnName, $fn);
+
+    /**
+     * @return void
+     */
+    abstract protected function registerUpdateHook($columnName, $fn);
+
+    /**
+     * @return void
+     */
+    abstract protected function registerReadHook($columnName, $fn);
+
+    /**
+     * @return void
+     */
+    abstract protected function registerCreateHook($columnName, $fn);
 }
\ No newline at end of file

src/AbstractActiveRecord.php

Indentation +699 added lines, -699 removed lines

@@ -18,710 +18,710 @@
  */
 abstract class AbstractActiveRecord implements ActiveRecordInterface
 {
-	const COLUMN_NAME_ID = 'id';
-	const COLUMN_TYPE_ID = 'INT UNSIGNED';
-
-	/** @var \PDO The PDO object. */
-	protected $pdo;
-
-	/** @var null|int The ID. */
-	private $id;
-
-	/** @var array A map of column name to functions that hook the insert function */
-	protected $registeredCreateHooks;
-
-	/** @var array A map of column name to functions that hook the read function */
-	protected $registeredReadHooks;
-
-	/** @var array A map of column name to functions that hook the update function */
-	protected $registeredUpdateHooks;
-
-	/** @var array A map of column name to functions that hook the update function */
-	protected $registeredDeleteHooks;	
-
-	/** @var array A map of column name to functions that hook the search function */
-	protected $registeredSearchHooks;
-
-	/** @var array A list of table column definitions */
-	protected $tableDefinition;
-
-	/**
-	 * Construct an abstract active record with the given PDO.
-	 *
-	 * @param \PDO $pdo
-	 */
-	public function __construct(\PDO $pdo)
-	{
-		$pdo->setAttribute(\PDO::ATTR_DEFAULT_FETCH_MODE, \PDO::FETCH_ASSOC);
-		$pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
-
-		$this->setPdo($pdo);
-		$this->tableDefinition = $this->getActiveRecordTableDefinition();
-		$this->registeredCreateHooks = [];
-		$this->registeredReadHooks = [];
-		$this->registeredUpdateHooks = [];
-		$this->registeredDeleteHooks = [];
-		$this->registeredSearchHooks = [];
-
-		// Extend table definition with default ID field, throw exception if field already exists
-		if (array_key_exists('id', $this->tableDefinition)) {
-			$message = "Table definition in record contains a field with name \"id\"";
-			$message .= ", which is a reserved name by ActiveRecord";
-			throw new ActiveRecordException($message, 0);
-		}
-
-		$this->tableDefinition[self::COLUMN_NAME_ID] =
-		[
-			'value' => &$this->id,
-			'validate' => null,
-			'type' => self::COLUMN_TYPE_ID,
-			'properties' => ColumnProperty::NOT_NULL | ColumnProperty::IMMUTABLE | ColumnProperty::AUTO_INCREMENT | ColumnProperty::PRIMARY_KEY
-		];
-	}
-
-	private function checkHookConstraints($columnName, $hookMap)
-	{
-		// Check whether column exists
-		if (!array_key_exists($columnName, $this->tableDefinition)) 
-		{
-			throw new ActiveRecordException("Hook is trying to register on non-existing column \"$columnName\"", 0);
-		}
-
-		// Enforcing 1 hook per table column
-		if (array_key_exists($columnName, $hookMap)) {
-			$message = "Hook is trying to register on an already registered column \"$columnName\", ";
-			$message .= "do you have conflicting traits?";
-			throw new ActiveRecordException($message, 0);
-		}
-	}
-
-	/**
-	 * Register a new hook for a specific column that gets called before execution of the create() method
-	 * Only one hook per column can be registered at a time
-	 * @param string $columnName The name of the column that is registered.
-	 * @param string|callable $fn Either a callable, or the name of a method on the inheriting object.
-	 */
-	public function registerCreateHook($columnName, $fn)
-	{
-		$this->checkHookConstraints($columnName, $this->registeredCreateHooks);
-
-		if (is_string($fn) && is_callable([$this, $fn])) {
-			$this->registeredCreateHooks[$columnName] = [$this, $fn];
-		} else if (is_callable($fn)) {
-			$this->registeredCreateHooks[$columnName] = $fn;
-		} else {
-			throw new ActiveRecordException("Provided hook on column \"$columnName\" is not callable", 0);
-		}
-	}
-
-	/**
-	 * Register a new hook for a specific column that gets called before execution of the read() method
-	 * Only one hook per column can be registered at a time
-	 * @param string $columnName The name of the column that is registered.
-	 * @param string|callable $fn Either a callable, or the name of a method on the inheriting object.
-	 */
-	public function registerReadHook($columnName, $fn)
-	{
-		$this->checkHookConstraints($columnName, $this->registeredReadHooks);
-
-		if (is_string($fn) && is_callable([$this, $fn])) {
-			$this->registeredReadHooks[$columnName] = [$this, $fn];
-		} else if (is_callable($fn)) {
-			$this->registeredReadHooks[$columnName] = $fn;
-		} else {
-			throw new ActiveRecordException("Provided hook on column \"$columnName\" is not callable", 0);
-		}
-	}
-
-	/**
-	 * Register a new hook for a specific column that gets called before execution of the update() method
-	 * Only one hook per column can be registered at a time
-	 * @param string $columnName The name of the column that is registered.
-	 * @param string|callable $fn Either a callable, or the name of a method on the inheriting object.
-	 */
-	public function registerUpdateHook($columnName, $fn)
-	{
-		$this->checkHookConstraints($columnName, $this->registeredUpdateHooks);
-
-		if (is_string($fn) && is_callable([$this, $fn])) {
-			$this->registeredUpdateHooks[$columnName] = [$this, $fn];
-		} else if (is_callable($fn)) {
-			$this->registeredUpdateHooks[$columnName] = $fn;
-		} else {
-			throw new ActiveRecordException("Provided hook on column \"$columnName\" is not callable", 0);
-		}
-	}
-
-	/**
-	 * Register a new hook for a specific column that gets called before execution of the delete() method
-	 * Only one hook per column can be registered at a time
-	 * @param string $columnName The name of the column that is registered.
-	 * @param string|callable $fn Either a callable, or the name of a method on the inheriting object.
-	 */
-	public function registerDeleteHook($columnName, $fn)
-	{
-		$this->checkHookConstraints($columnName, $this->registeredDeleteHooks);
-
-		if (is_string($fn) && is_callable([$this, $fn])) {
-			$this->registeredDeleteHooks[$columnName] = [$this, $fn];
-		} else if (is_callable($fn)) {
-			$this->registeredDeleteHooks[$columnName] = $fn;
-		} else {
-			throw new ActiveRecordException("Provided hook on column \"$columnName\" is not callable", 0);
-		}
-	}
-
-	/**
-	 * Register a new hook for a specific column that gets called before execution of the search() method
-	 * Only one hook per column can be registered at a time
-	 * @param string $columnName The name of the column that is registered.
-	 * @param string|callable $fn Either a callable, or the name of a method on the inheriting object. The callable is required to take one argument: an instance of miBadger\Query\Query; 
-	 */
-	public function registerSearchHook($columnName, $fn)
-	{
-		$this->checkHookConstraints($columnName, $this->registeredSearchHooks);
-
-		if (is_string($fn) && is_callable([$this, $fn])) {
-			$this->registeredSearchHooks[$columnName] = [$this, $fn];
-		} else if (is_callable($fn)) {
-			$this->registeredSearchHooks[$columnName] = $fn;
-		} else {
-			throw new ActiveRecordException("Provided hook on column \"$columnName\" is not callable", 0);
-		}
-	}
-
-	/**
-	 * Adds a new column definition to the table.
-	 * @param string $columnName The name of the column that is registered.
-	 * @param Array $definition The definition of that column.
-	 */
-	public function extendTableDefinition($columnName, $definition)
-	{
-		if ($this->tableDefinition === null) {
-			throw new ActiveRecordException("tableDefinition is null, most likely due to parent class not having been initialized in constructor");
-		}
-
-		// Enforcing table can only be extended with new columns
-		if (array_key_exists($columnName, $this->tableDefinition)) {
-			$message = "Table is being extended with a column that already exists, ";
-			$message .= "\"$columnName\" conflicts with your table definition";
-			throw new ActiveRecordException($message, 0);
-		}
-
-		$this->tableDefinition[$columnName] = $definition;
-	}
-
-	/**
-	 * Returns the type string as it should appear in the mysql create table statement for the given column
-	 * @return string The type string
-	 */
-	private function getDatabaseTypeString($colName, $type, $length)
-	{
-		switch (strtoupper($type)) {
-			case '':
-				throw new ActiveRecordException(sprintf("Column %s has invalid type \"NULL\"", $colName));
+    const COLUMN_NAME_ID = 'id';
+    const COLUMN_TYPE_ID = 'INT UNSIGNED';
+
+    /** @var \PDO The PDO object. */
+    protected $pdo;
+
+    /** @var null|int The ID. */
+    private $id;
+
+    /** @var array A map of column name to functions that hook the insert function */
+    protected $registeredCreateHooks;
+
+    /** @var array A map of column name to functions that hook the read function */
+    protected $registeredReadHooks;
+
+    /** @var array A map of column name to functions that hook the update function */
+    protected $registeredUpdateHooks;
+
+    /** @var array A map of column name to functions that hook the update function */
+    protected $registeredDeleteHooks;	
+
+    /** @var array A map of column name to functions that hook the search function */
+    protected $registeredSearchHooks;
+
+    /** @var array A list of table column definitions */
+    protected $tableDefinition;
+
+    /**
+     * Construct an abstract active record with the given PDO.
+     *
+     * @param \PDO $pdo
+     */
+    public function __construct(\PDO $pdo)
+    {
+        $pdo->setAttribute(\PDO::ATTR_DEFAULT_FETCH_MODE, \PDO::FETCH_ASSOC);
+        $pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
+
+        $this->setPdo($pdo);
+        $this->tableDefinition = $this->getActiveRecordTableDefinition();
+        $this->registeredCreateHooks = [];
+        $this->registeredReadHooks = [];
+        $this->registeredUpdateHooks = [];
+        $this->registeredDeleteHooks = [];
+        $this->registeredSearchHooks = [];
+
+        // Extend table definition with default ID field, throw exception if field already exists
+        if (array_key_exists('id', $this->tableDefinition)) {
+            $message = "Table definition in record contains a field with name \"id\"";
+            $message .= ", which is a reserved name by ActiveRecord";
+            throw new ActiveRecordException($message, 0);
+        }
+
+        $this->tableDefinition[self::COLUMN_NAME_ID] =
+        [
+            'value' => &$this->id,
+            'validate' => null,
+            'type' => self::COLUMN_TYPE_ID,
+            'properties' => ColumnProperty::NOT_NULL | ColumnProperty::IMMUTABLE | ColumnProperty::AUTO_INCREMENT | ColumnProperty::PRIMARY_KEY
+        ];
+    }
+
+    private function checkHookConstraints($columnName, $hookMap)
+    {
+        // Check whether column exists
+        if (!array_key_exists($columnName, $this->tableDefinition)) 
+        {
+            throw new ActiveRecordException("Hook is trying to register on non-existing column \"$columnName\"", 0);
+        }
+
+        // Enforcing 1 hook per table column
+        if (array_key_exists($columnName, $hookMap)) {
+            $message = "Hook is trying to register on an already registered column \"$columnName\", ";
+            $message .= "do you have conflicting traits?";
+            throw new ActiveRecordException($message, 0);
+        }
+    }
+
+    /**
+     * Register a new hook for a specific column that gets called before execution of the create() method
+     * Only one hook per column can be registered at a time
+     * @param string $columnName The name of the column that is registered.
+     * @param string|callable $fn Either a callable, or the name of a method on the inheriting object.
+     */
+    public function registerCreateHook($columnName, $fn)
+    {
+        $this->checkHookConstraints($columnName, $this->registeredCreateHooks);
+
+        if (is_string($fn) && is_callable([$this, $fn])) {
+            $this->registeredCreateHooks[$columnName] = [$this, $fn];
+        } else if (is_callable($fn)) {
+            $this->registeredCreateHooks[$columnName] = $fn;
+        } else {
+            throw new ActiveRecordException("Provided hook on column \"$columnName\" is not callable", 0);
+        }
+    }
+
+    /**
+     * Register a new hook for a specific column that gets called before execution of the read() method
+     * Only one hook per column can be registered at a time
+     * @param string $columnName The name of the column that is registered.
+     * @param string|callable $fn Either a callable, or the name of a method on the inheriting object.
+     */
+    public function registerReadHook($columnName, $fn)
+    {
+        $this->checkHookConstraints($columnName, $this->registeredReadHooks);
+
+        if (is_string($fn) && is_callable([$this, $fn])) {
+            $this->registeredReadHooks[$columnName] = [$this, $fn];
+        } else if (is_callable($fn)) {
+            $this->registeredReadHooks[$columnName] = $fn;
+        } else {
+            throw new ActiveRecordException("Provided hook on column \"$columnName\" is not callable", 0);
+        }
+    }
+
+    /**
+     * Register a new hook for a specific column that gets called before execution of the update() method
+     * Only one hook per column can be registered at a time
+     * @param string $columnName The name of the column that is registered.
+     * @param string|callable $fn Either a callable, or the name of a method on the inheriting object.
+     */
+    public function registerUpdateHook($columnName, $fn)
+    {
+        $this->checkHookConstraints($columnName, $this->registeredUpdateHooks);
+
+        if (is_string($fn) && is_callable([$this, $fn])) {
+            $this->registeredUpdateHooks[$columnName] = [$this, $fn];
+        } else if (is_callable($fn)) {
+            $this->registeredUpdateHooks[$columnName] = $fn;
+        } else {
+            throw new ActiveRecordException("Provided hook on column \"$columnName\" is not callable", 0);
+        }
+    }
+
+    /**
+     * Register a new hook for a specific column that gets called before execution of the delete() method
+     * Only one hook per column can be registered at a time
+     * @param string $columnName The name of the column that is registered.
+     * @param string|callable $fn Either a callable, or the name of a method on the inheriting object.
+     */
+    public function registerDeleteHook($columnName, $fn)
+    {
+        $this->checkHookConstraints($columnName, $this->registeredDeleteHooks);
+
+        if (is_string($fn) && is_callable([$this, $fn])) {
+            $this->registeredDeleteHooks[$columnName] = [$this, $fn];
+        } else if (is_callable($fn)) {
+            $this->registeredDeleteHooks[$columnName] = $fn;
+        } else {
+            throw new ActiveRecordException("Provided hook on column \"$columnName\" is not callable", 0);
+        }
+    }
+
+    /**
+     * Register a new hook for a specific column that gets called before execution of the search() method
+     * Only one hook per column can be registered at a time
+     * @param string $columnName The name of the column that is registered.
+     * @param string|callable $fn Either a callable, or the name of a method on the inheriting object. The callable is required to take one argument: an instance of miBadger\Query\Query; 
+     */
+    public function registerSearchHook($columnName, $fn)
+    {
+        $this->checkHookConstraints($columnName, $this->registeredSearchHooks);
+
+        if (is_string($fn) && is_callable([$this, $fn])) {
+            $this->registeredSearchHooks[$columnName] = [$this, $fn];
+        } else if (is_callable($fn)) {
+            $this->registeredSearchHooks[$columnName] = $fn;
+        } else {
+            throw new ActiveRecordException("Provided hook on column \"$columnName\" is not callable", 0);
+        }
+    }
+
+    /**
+     * Adds a new column definition to the table.
+     * @param string $columnName The name of the column that is registered.
+     * @param Array $definition The definition of that column.
+     */
+    public function extendTableDefinition($columnName, $definition)
+    {
+        if ($this->tableDefinition === null) {
+            throw new ActiveRecordException("tableDefinition is null, most likely due to parent class not having been initialized in constructor");
+        }
+
+        // Enforcing table can only be extended with new columns
+        if (array_key_exists($columnName, $this->tableDefinition)) {
+            $message = "Table is being extended with a column that already exists, ";
+            $message .= "\"$columnName\" conflicts with your table definition";
+            throw new ActiveRecordException($message, 0);
+        }
+
+        $this->tableDefinition[$columnName] = $definition;
+    }
+
+    /**
+     * Returns the type string as it should appear in the mysql create table statement for the given column
+     * @return string The type string
+     */
+    private function getDatabaseTypeString($colName, $type, $length)
+    {
+        switch (strtoupper($type)) {
+            case '':
+                throw new ActiveRecordException(sprintf("Column %s has invalid type \"NULL\"", $colName));
 				
-			case 'DATETIME':
-			case 'DATE':
-			case 'TIME':
-			case 'TEXT':
-			case 'INT UNSIGNED':
-				return $type;
-
-			case 'VARCHAR':
-				if ($length === null) {
-					throw new ActiveRecordException(sprintf("field type %s requires specified column field \"LENGTH\"", $colName));
-				} else {
-					return sprintf('%s(%d)', $type, $length);	
-				}
-
-			case 'INT':
-			case 'TINYINT':
-			case 'BIGINT':
-			default: 	
-				// @TODO(Default): throw exception, or implicitly assume that type is correct? (For when using SQL databases with different types)
-				if ($length === null) {
-					return $type;
-				} else {
-					return sprintf('%s(%d)', $type, $length);	
-				}
-		}
-	}
-
-	/**
-	 * Builds the part of a MySQL create table statement that corresponds to the supplied column
-	 * @param string $colName 	Name of the database column
-	 * @param string $type 		The type of the string
-	 * @param int $properties 	The set of Column properties that apply to this column (See ColumnProperty for options)
-	 * @return string
-	 */
-	private function buildCreateTableColumnEntry($colName, $type, $length, $properties, $default)
-	{
-		$stmnt = sprintf('`%s` %s ', $colName, $this->getDatabaseTypeString($colName, $type, $length));
-		if ($properties & ColumnProperty::NOT_NULL) {
-			$stmnt .= 'NOT NULL ';
-		} else {
-			$stmnt .= 'NULL ';
-		}
-
-		if ($default !== NULL) {
-			$stmnt .= ' DEFAULT ' . $default . ' ';
-		}
-
-		if ($properties & ColumnProperty::AUTO_INCREMENT) {
-			$stmnt .= 'AUTO_INCREMENT ';
-		}
-
-		if ($properties & ColumnProperty::UNIQUE) {
-			$stmnt .= 'UNIQUE ';
-		}
-
-		if ($properties & ColumnProperty::PRIMARY_KEY) {
-			$stmnt .= 'PRIMARY KEY ';
-		}
-
-		return $stmnt;
-	}
-
-	/**
-	 * Sorts the column statement components in the order such that the id appears first, 
-	 * 		followed by all other columns in alphabetical ascending order
-	 * @param   Array $colStatements Array of column statements
-	 * @return  Array
-	 */
-	private function sortColumnStatements($colStatements)
-	{
-		// Find ID statement and put it first
-		$sortedStatements = [];
-
-		$sortedStatements[] = $colStatements[self::COLUMN_NAME_ID];
-		unset($colStatements[self::COLUMN_NAME_ID]);
-
-		// Sort remaining columns in alphabetical order
-		$columns = array_keys($colStatements);
-		sort($columns);
-		foreach ($columns as $colName) {
-			$sortedStatements[] = $colStatements[$colName];
-		}
-
-		return $sortedStatements;
-	}
-
-	/**
-	 * Builds the MySQL Create Table statement for the internal table definition
-	 * @return string
-	 */
-	public function buildCreateTableSQL()
-	{
-		$columnStatements = [];
-		foreach ($this->tableDefinition as $colName => $definition) {
-			// Destructure column definition
-			$type    = $definition['type'] ?? null;
-			$default = $definition['default'] ?? null;
-			$length  = $definition['length'] ?? null;
-			$properties = $definition['properties'] ?? null;
-
-			if (isset($definition['relation']) && $type !== null) {
-				$msg = "Column \"$colName\": ";
-				$msg .= "Relationship columns have an automatically inferred type, so type should be omitted";
-				throw new ActiveRecordException($msg);
-			} else if (isset($definition['relation'])) {
-				$type = self::COLUMN_TYPE_ID;
-			}
-
-			$columnStatements[$colName] = $this->buildCreateTableColumnEntry($colName, $type, $length, $properties, $default);
-		}
-
-		// Sort table (first column is id, the remaining are alphabetically sorted)
-		$columnStatements = $this->sortColumnStatements($columnStatements);
-
-		$sql = 'CREATE TABLE ' . $this->getActiveRecordTable() . ' ';
-		$sql .= "(\n";
-		$sql .= implode(",\n", $columnStatements);
-		$sql .= "\n);";
-
-		return $sql;
-	}
-
-	/**
-	 * Creates the entity as a table in the database
-	 */
-	public function createTable()
-	{
-		$this->pdo->query($this->buildCreateTableSQL());
-	}
-
-	/**
-	 * builds a MySQL constraint statement for the given parameters
-	 * @param string $parentTable
-	 * @param string $parentColumn
-	 * @param string $childTable
-	 * @param string $childColumn
-	 * @return string The MySQL table constraint string
-	 */
-	protected function buildConstraint($parentTable, $parentColumn, $childTable, $childColumn)
-	{
-		$template = <<<SQL
+            case 'DATETIME':
+            case 'DATE':
+            case 'TIME':
+            case 'TEXT':
+            case 'INT UNSIGNED':
+                return $type;
+
+            case 'VARCHAR':
+                if ($length === null) {
+                    throw new ActiveRecordException(sprintf("field type %s requires specified column field \"LENGTH\"", $colName));
+                } else {
+                    return sprintf('%s(%d)', $type, $length);	
+                }
+
+            case 'INT':
+            case 'TINYINT':
+            case 'BIGINT':
+            default: 	
+                // @TODO(Default): throw exception, or implicitly assume that type is correct? (For when using SQL databases with different types)
+                if ($length === null) {
+                    return $type;
+                } else {
+                    return sprintf('%s(%d)', $type, $length);	
+                }
+        }
+    }
+
+    /**
+     * Builds the part of a MySQL create table statement that corresponds to the supplied column
+     * @param string $colName 	Name of the database column
+     * @param string $type 		The type of the string
+     * @param int $properties 	The set of Column properties that apply to this column (See ColumnProperty for options)
+     * @return string
+     */
+    private function buildCreateTableColumnEntry($colName, $type, $length, $properties, $default)
+    {
+        $stmnt = sprintf('`%s` %s ', $colName, $this->getDatabaseTypeString($colName, $type, $length));
+        if ($properties & ColumnProperty::NOT_NULL) {
+            $stmnt .= 'NOT NULL ';
+        } else {
+            $stmnt .= 'NULL ';
+        }
+
+        if ($default !== NULL) {
+            $stmnt .= ' DEFAULT ' . $default . ' ';
+        }
+
+        if ($properties & ColumnProperty::AUTO_INCREMENT) {
+            $stmnt .= 'AUTO_INCREMENT ';
+        }
+
+        if ($properties & ColumnProperty::UNIQUE) {
+            $stmnt .= 'UNIQUE ';
+        }
+
+        if ($properties & ColumnProperty::PRIMARY_KEY) {
+            $stmnt .= 'PRIMARY KEY ';
+        }
+
+        return $stmnt;
+    }
+
+    /**
+     * Sorts the column statement components in the order such that the id appears first, 
+     * 		followed by all other columns in alphabetical ascending order
+     * @param   Array $colStatements Array of column statements
+     * @return  Array
+     */
+    private function sortColumnStatements($colStatements)
+    {
+        // Find ID statement and put it first
+        $sortedStatements = [];
+
+        $sortedStatements[] = $colStatements[self::COLUMN_NAME_ID];
+        unset($colStatements[self::COLUMN_NAME_ID]);
+
+        // Sort remaining columns in alphabetical order
+        $columns = array_keys($colStatements);
+        sort($columns);
+        foreach ($columns as $colName) {
+            $sortedStatements[] = $colStatements[$colName];
+        }
+
+        return $sortedStatements;
+    }
+
+    /**
+     * Builds the MySQL Create Table statement for the internal table definition
+     * @return string
+     */
+    public function buildCreateTableSQL()
+    {
+        $columnStatements = [];
+        foreach ($this->tableDefinition as $colName => $definition) {
+            // Destructure column definition
+            $type    = $definition['type'] ?? null;
+            $default = $definition['default'] ?? null;
+            $length  = $definition['length'] ?? null;
+            $properties = $definition['properties'] ?? null;
+
+            if (isset($definition['relation']) && $type !== null) {
+                $msg = "Column \"$colName\": ";
+                $msg .= "Relationship columns have an automatically inferred type, so type should be omitted";
+                throw new ActiveRecordException($msg);
+            } else if (isset($definition['relation'])) {
+                $type = self::COLUMN_TYPE_ID;
+            }
+
+            $columnStatements[$colName] = $this->buildCreateTableColumnEntry($colName, $type, $length, $properties, $default);
+        }
+
+        // Sort table (first column is id, the remaining are alphabetically sorted)
+        $columnStatements = $this->sortColumnStatements($columnStatements);
+
+        $sql = 'CREATE TABLE ' . $this->getActiveRecordTable() . ' ';
+        $sql .= "(\n";
+        $sql .= implode(",\n", $columnStatements);
+        $sql .= "\n);";
+
+        return $sql;
+    }
+
+    /**
+     * Creates the entity as a table in the database
+     */
+    public function createTable()
+    {
+        $this->pdo->query($this->buildCreateTableSQL());
+    }
+
+    /**
+     * builds a MySQL constraint statement for the given parameters
+     * @param string $parentTable
+     * @param string $parentColumn
+     * @param string $childTable
+     * @param string $childColumn
+     * @return string The MySQL table constraint string
+     */
+    protected function buildConstraint($parentTable, $parentColumn, $childTable, $childColumn)
+    {
+        $template = <<<SQL
 ALTER TABLE `%s`
 ADD CONSTRAINT
 FOREIGN KEY (`%s`)
 REFERENCES `%s`(`%s`)
 ON DELETE CASCADE;
 SQL;
-		return sprintf($template, $childTable, $childColumn, $parentTable, $parentColumn);
-	}
-
-	/**
-	 * Iterates over the specified constraints in the table definition, 
-	 * 		and applies these to the database.
-	 */
-	public function createTableConstraints()
-	{
-		// Iterate over columns, check whether "relation" field exists, if so create constraint
-		foreach ($this->tableDefinition as $colName => $definition) {
-			if (isset($definition['relation']) && $definition['relation'] instanceof AbstractActiveRecord) {
-				// Forge new relation
-				$target = $definition['relation'];
-				$constraintSql = $this->buildConstraint($target->getActiveRecordTable(), 'id', $this->getActiveRecordTable(), $colName);
-
-				$this->pdo->query($constraintSql);
-			}
-		}
-	}
-
-	/**
-	 * Returns the name -> variable mapping for the table definition.
-	 * @return Array The mapping
-	 */
-	protected function getActiveRecordColumns()
-	{
-		$bindings = [];
-		foreach ($this->tableDefinition as $colName => $definition) {
-
-			// Ignore the id column (key) when inserting or updating
-			if ($colName == self::COLUMN_NAME_ID) {
-				continue;
-			}
-
-			$bindings[$colName] = &$definition['value'];
-		}
-		return $bindings;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function create()
-	{
-		foreach ($this->registeredCreateHooks as $colName => $fn) {
-			// @TODO: Would it be better to pass the Query to the function?
-			$fn();
-		}
-
-		try {
-			(new Query($this->getPdo(), $this->getActiveRecordTable()))
-				->insert($this->getActiveRecordColumns())
-				->execute();
-
-			$this->setId(intval($this->getPdo()->lastInsertId()));
-		} catch (\PDOException $e) {
-			throw new ActiveRecordException($e->getMessage(), 0, $e);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function read($id)
-	{
-		foreach ($this->registeredReadHooks as $colName => $fn) {
-			// @TODO: Would it be better to pass the Query to the function?
-			$fn();
-		}
-
-		try {
-			$row = (new Query($this->getPdo(), $this->getActiveRecordTable()))
-				->select()
-				->where('id', '=', $id)
-				->execute()
-				->fetch();
-
-			if ($row === false) {
-				throw new ActiveRecordException(sprintf('Can not read the non-existent active record entry %d from the `%s` table.', $id, $this->getActiveRecordTable()));
-			}
-
-			$this->fill($row)->setId($id);
-		} catch (\PDOException $e) {
-			throw new ActiveRecordException($e->getMessage(), 0, $e);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function update()
-	{
-		foreach ($this->registeredUpdateHooks as $colName => $fn) {
-			// @TODO: Would it be better to pass the Query to the function?
-			$fn();
-		}
-
-		try {
-			(new Query($this->getPdo(), $this->getActiveRecordTable()))
-				->update($this->getActiveRecordColumns())
-				->where('id', '=', $this->getId())
-				->execute();
-		} catch (\PDOException $e) {
-			throw new ActiveRecordException($e->getMessage(), 0, $e);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function delete()
-	{
-		foreach ($this->registeredDeleteHooks as $colName => $fn) {
-			// @TODO: Would it be better to pass the Query to the function?
-			$fn();
-		}
-
-		try {
-			(new Query($this->getPdo(), $this->getActiveRecordTable()))
-				->delete()
-				->where('id', '=', $this->getId())
-				->execute();
-
-			$this->setId(null);
-		} catch (\PDOException $e) {
-			throw new ActiveRecordException($e->getMessage(), 0, $e);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function sync()
-	{
-		if (!$this->exists()) {
-			return $this->create();
-		}
-
-		return $this->update();
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function exists()
-	{
-		return $this->getId() !== null;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function fill(array $attributes)
-	{
-		$columns = $this->getActiveRecordColumns();
-		$columns['id'] = &$this->id;
-
-		foreach ($attributes as $key => $value) {
-			if (array_key_exists($key, $columns)) {
-				$columns[$key] = $value;
-			}
-		}
-
-		return $this;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function searchOne(array $where = [], array $orderBy = [])
-	{
-		try {
-			$row = $this->getSearchQueryResult($where, $orderBy, 1)->fetch();
-
-			if ($row === false) {
-				throw new ActiveRecordException(sprintf('Can not search one non-existent entry from the `%s` table.', $this->getActiveRecordTable()));
-			}
-
-			return $this->fill($row)->setId($row['id']);
-		} catch (\PDOException $e) {
-			throw new ActiveRecordException($e->getMessage(), 0, $e);
-		}
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function search(array $where = [], array $orderBy = [], $limit = -1, $offset = 0)
-	{
-		try {
-			$queryResult = $this->getSearchQueryResult($where, $orderBy, $limit, $offset);
-			$result = [];
-
-			foreach ($queryResult as $row) {
-				$new = clone $this;
-
-				$result[] = $new->fill($row)->setId($row['id']);
-			}
-
-			return $result;
-		} catch (\PDOException $e) {
-			throw new ActiveRecordException($e->getMessage(), 0, $e);
-		}
-	}
-
-	/**
-	 * Returns the search query result with the given where, order by, limit and offset clauses.
-	 *
-	 * @param array $where = []
-	 * @param array $orderBy = []
-	 * @param int $limit = -1
-	 * @param int $offset = 0
-	 * @return \miBadger\Query\QueryResult the search query result with the given where, order by, limit and offset clauses.
-	 */
-	private function getSearchQueryResult(array $where = [], array $orderBy = [], $limit = -1, $offset = 0)
-	{
-		$query = (new Query($this->getPdo(), $this->getActiveRecordTable()))
-			->select();
-
-		$this->getSearchQueryWhere($query, $where);
-		$this->getSearchQueryOrderBy($query, $orderBy);
-		$this->getSearchQueryLimit($query, $limit, $offset);
-
-		// Ignore all trait modifiers for which a where clause was specified
-		$registeredSearchHooks = $this->registeredSearchHooks;
-		foreach ($where as $index => $clause) {
-			$colName = $clause[0];
-			unset($registeredSearchHooks[$colName]);
-		}
-
-		// Allow traits to modify the query
-		foreach ($registeredSearchHooks as $column => $searchFunction) {
-			$searchFunction($query);
-		}
-
-		return $query->execute();
-	}
-
-	/**
-	 * Returns the given query after adding the given where conditions.
-	 *
-	 * @param \miBadger\Query\Query $query
-	 * @param array $where
-	 * @return \miBadger\Query\Query the given query after adding the given where conditions.
-	 */
-	private function getSearchQueryWhere($query, $where)
-	{
-		foreach ($where as $key => $value) {
-			$query->where($value[0], $value[1], $value[2]);
-		}
-
-		return $query;
-	}
-
-	/**
-	 * Returns the given query after adding the given order by conditions.
-	 *
-	 * @param \miBadger\Query\Query $query
-	 * @param array $orderBy
-	 * @return \miBadger\Query\Query the given query after adding the given order by conditions.
-	 */
-	private function getSearchQueryOrderBy($query, $orderBy)
-	{
-		foreach ($orderBy as $key => $value) {
-			$query->orderBy($key, $value);
-		}
-
-		return $query;
-	}
-
-	/**
-	 * Returns the given query after adding the given limit and offset conditions.
-	 *
-	 * @param \miBadger\Query\Query $query
-	 * @param int $limit
-	 * @param int $offset
-	 * @return \miBadger\Query\Query the given query after adding the given limit and offset conditions.
-	 */
-	private function getSearchQueryLimit($query, $limit, $offset)
-	{
-		if ($limit > -1) {
-			$query->limit($limit);
-			$query->offset($offset);
-		}
-
-		return $query;
-	}
-
-	/**
-	 * Returns the PDO.
-	 *
-	 * @return \PDO the PDO.
-	 */
-	public function getPdo()
-	{
-		return $this->pdo;
-	}
-
-	/**
-	 * Set the PDO.
-	 *
-	 * @param \PDO $pdo
-	 * @return $this
-	 */
-	protected function setPdo($pdo)
-	{
-		$this->pdo = $pdo;
-
-		return $this;
-	}
-
-	/**
-	 * Returns the ID.
-	 *
-	 * @return null|int The ID.
-	 */
-	public function getId()
-	{
-		return $this->id;
-	}
-
-	/**
-	 * Set the ID.
-	 *
-	 * @param int $id
-	 * @return $this
-	 */
-	protected function setId($id)
-	{
-		$this->id = $id;
-
-		return $this;
-	}
-
-	/**
-	 * Returns the active record table.
-	 *
-	 * @return string the active record table name.
-	 */
-	abstract protected function getActiveRecordTable();
-
-	/**
-	 * Returns the active record columns.
-	 *
-	 * @return array the active record columns.
-	 */
-	abstract protected function getActiveRecordTableDefinition();
+        return sprintf($template, $childTable, $childColumn, $parentTable, $parentColumn);
+    }
+
+    /**
+     * Iterates over the specified constraints in the table definition, 
+     * 		and applies these to the database.
+     */
+    public function createTableConstraints()
+    {
+        // Iterate over columns, check whether "relation" field exists, if so create constraint
+        foreach ($this->tableDefinition as $colName => $definition) {
+            if (isset($definition['relation']) && $definition['relation'] instanceof AbstractActiveRecord) {
+                // Forge new relation
+                $target = $definition['relation'];
+                $constraintSql = $this->buildConstraint($target->getActiveRecordTable(), 'id', $this->getActiveRecordTable(), $colName);
+
+                $this->pdo->query($constraintSql);
+            }
+        }
+    }
+
+    /**
+     * Returns the name -> variable mapping for the table definition.
+     * @return Array The mapping
+     */
+    protected function getActiveRecordColumns()
+    {
+        $bindings = [];
+        foreach ($this->tableDefinition as $colName => $definition) {
+
+            // Ignore the id column (key) when inserting or updating
+            if ($colName == self::COLUMN_NAME_ID) {
+                continue;
+            }
+
+            $bindings[$colName] = &$definition['value'];
+        }
+        return $bindings;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function create()
+    {
+        foreach ($this->registeredCreateHooks as $colName => $fn) {
+            // @TODO: Would it be better to pass the Query to the function?
+            $fn();
+        }
+
+        try {
+            (new Query($this->getPdo(), $this->getActiveRecordTable()))
+                ->insert($this->getActiveRecordColumns())
+                ->execute();
+
+            $this->setId(intval($this->getPdo()->lastInsertId()));
+        } catch (\PDOException $e) {
+            throw new ActiveRecordException($e->getMessage(), 0, $e);
+        }
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function read($id)
+    {
+        foreach ($this->registeredReadHooks as $colName => $fn) {
+            // @TODO: Would it be better to pass the Query to the function?
+            $fn();
+        }
+
+        try {
+            $row = (new Query($this->getPdo(), $this->getActiveRecordTable()))
+                ->select()
+                ->where('id', '=', $id)
+                ->execute()
+                ->fetch();
+
+            if ($row === false) {
+                throw new ActiveRecordException(sprintf('Can not read the non-existent active record entry %d from the `%s` table.', $id, $this->getActiveRecordTable()));
+            }
+
+            $this->fill($row)->setId($id);
+        } catch (\PDOException $e) {
+            throw new ActiveRecordException($e->getMessage(), 0, $e);
+        }
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function update()
+    {
+        foreach ($this->registeredUpdateHooks as $colName => $fn) {
+            // @TODO: Would it be better to pass the Query to the function?
+            $fn();
+        }
+
+        try {
+            (new Query($this->getPdo(), $this->getActiveRecordTable()))
+                ->update($this->getActiveRecordColumns())
+                ->where('id', '=', $this->getId())
+                ->execute();
+        } catch (\PDOException $e) {
+            throw new ActiveRecordException($e->getMessage(), 0, $e);
+        }
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function delete()
+    {
+        foreach ($this->registeredDeleteHooks as $colName => $fn) {
+            // @TODO: Would it be better to pass the Query to the function?
+            $fn();
+        }
+
+        try {
+            (new Query($this->getPdo(), $this->getActiveRecordTable()))
+                ->delete()
+                ->where('id', '=', $this->getId())
+                ->execute();
+
+            $this->setId(null);
+        } catch (\PDOException $e) {
+            throw new ActiveRecordException($e->getMessage(), 0, $e);
+        }
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function sync()
+    {
+        if (!$this->exists()) {
+            return $this->create();
+        }
+
+        return $this->update();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function exists()
+    {
+        return $this->getId() !== null;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fill(array $attributes)
+    {
+        $columns = $this->getActiveRecordColumns();
+        $columns['id'] = &$this->id;
+
+        foreach ($attributes as $key => $value) {
+            if (array_key_exists($key, $columns)) {
+                $columns[$key] = $value;
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function searchOne(array $where = [], array $orderBy = [])
+    {
+        try {
+            $row = $this->getSearchQueryResult($where, $orderBy, 1)->fetch();
+
+            if ($row === false) {
+                throw new ActiveRecordException(sprintf('Can not search one non-existent entry from the `%s` table.', $this->getActiveRecordTable()));
+            }
+
+            return $this->fill($row)->setId($row['id']);
+        } catch (\PDOException $e) {
+            throw new ActiveRecordException($e->getMessage(), 0, $e);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function search(array $where = [], array $orderBy = [], $limit = -1, $offset = 0)
+    {
+        try {
+            $queryResult = $this->getSearchQueryResult($where, $orderBy, $limit, $offset);
+            $result = [];
+
+            foreach ($queryResult as $row) {
+                $new = clone $this;
+
+                $result[] = $new->fill($row)->setId($row['id']);
+            }
+
+            return $result;
+        } catch (\PDOException $e) {
+            throw new ActiveRecordException($e->getMessage(), 0, $e);
+        }
+    }
+
+    /**
+     * Returns the search query result with the given where, order by, limit and offset clauses.
+     *
+     * @param array $where = []
+     * @param array $orderBy = []
+     * @param int $limit = -1
+     * @param int $offset = 0
+     * @return \miBadger\Query\QueryResult the search query result with the given where, order by, limit and offset clauses.
+     */
+    private function getSearchQueryResult(array $where = [], array $orderBy = [], $limit = -1, $offset = 0)
+    {
+        $query = (new Query($this->getPdo(), $this->getActiveRecordTable()))
+            ->select();
+
+        $this->getSearchQueryWhere($query, $where);
+        $this->getSearchQueryOrderBy($query, $orderBy);
+        $this->getSearchQueryLimit($query, $limit, $offset);
+
+        // Ignore all trait modifiers for which a where clause was specified
+        $registeredSearchHooks = $this->registeredSearchHooks;
+        foreach ($where as $index => $clause) {
+            $colName = $clause[0];
+            unset($registeredSearchHooks[$colName]);
+        }
+
+        // Allow traits to modify the query
+        foreach ($registeredSearchHooks as $column => $searchFunction) {
+            $searchFunction($query);
+        }
+
+        return $query->execute();
+    }
+
+    /**
+     * Returns the given query after adding the given where conditions.
+     *
+     * @param \miBadger\Query\Query $query
+     * @param array $where
+     * @return \miBadger\Query\Query the given query after adding the given where conditions.
+     */
+    private function getSearchQueryWhere($query, $where)
+    {
+        foreach ($where as $key => $value) {
+            $query->where($value[0], $value[1], $value[2]);
+        }
+
+        return $query;
+    }
+
+    /**
+     * Returns the given query after adding the given order by conditions.
+     *
+     * @param \miBadger\Query\Query $query
+     * @param array $orderBy
+     * @return \miBadger\Query\Query the given query after adding the given order by conditions.
+     */
+    private function getSearchQueryOrderBy($query, $orderBy)
+    {
+        foreach ($orderBy as $key => $value) {
+            $query->orderBy($key, $value);
+        }
+
+        return $query;
+    }
+
+    /**
+     * Returns the given query after adding the given limit and offset conditions.
+     *
+     * @param \miBadger\Query\Query $query
+     * @param int $limit
+     * @param int $offset
+     * @return \miBadger\Query\Query the given query after adding the given limit and offset conditions.
+     */
+    private function getSearchQueryLimit($query, $limit, $offset)
+    {
+        if ($limit > -1) {
+            $query->limit($limit);
+            $query->offset($offset);
+        }
+
+        return $query;
+    }
+
+    /**
+     * Returns the PDO.
+     *
+     * @return \PDO the PDO.
+     */
+    public function getPdo()
+    {
+        return $this->pdo;
+    }
+
+    /**
+     * Set the PDO.
+     *
+     * @param \PDO $pdo
+     * @return $this
+     */
+    protected function setPdo($pdo)
+    {
+        $this->pdo = $pdo;
+
+        return $this;
+    }
+
+    /**
+     * Returns the ID.
+     *
+     * @return null|int The ID.
+     */
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    /**
+     * Set the ID.
+     *
+     * @param int $id
+     * @return $this
+     */
+    protected function setId($id)
+    {
+        $this->id = $id;
+
+        return $this;
+    }
+
+    /**
+     * Returns the active record table.
+     *
+     * @return string the active record table name.
+     */
+    abstract protected function getActiveRecordTable();
+
+    /**
+     * Returns the active record columns.
+     *
+     * @return array the active record columns.
+     */
+    abstract protected function getActiveRecordTableDefinition();
 }

Spacing +2 added lines, -2 removed lines

@@ -265,7 +265,7 @@ 
 		}
 
 		if ($default !== NULL) {
-			$stmnt .= ' DEFAULT ' . $default . ' ';
+			$stmnt .= ' DEFAULT '.$default.' ';
 		}
 
 		if ($properties & ColumnProperty::AUTO_INCREMENT) {
@@ -335,7 +335,7 @@ 
 		// Sort table (first column is id, the remaining are alphabetically sorted)
 		$columnStatements = $this->sortColumnStatements($columnStatements);
 
-		$sql = 'CREATE TABLE ' . $this->getActiveRecordTable() . ' ';
+		$sql = 'CREATE TABLE '.$this->getActiveRecordTable().' ';
 		$sql .= "(\n";
 		$sql .= implode(",\n", $columnStatements);
 		$sql .= "\n);";

src/Traits/Datefields.php

Indentation +99 added lines, -99 removed lines

@@ -10,106 +10,106 @@
 
 trait Datefields
 {
-	/** @var string The timestamp representing the moment this record was created */
-	protected $created;
-
-	/** @var string The timestamp representing the moment this record was last updated */
-	protected $lastModified;
-
-	/**
-	 * this method is required to be called in the constructor for each class that uses this trait. 
-	 * It adds the datefields to the table definition and registers the callback hooks
-	 */
-	protected function initDatefields()
-	{
-		$this->extendTableDefinition(TRAIT_DATEFIELDS_CREATED, [
-			'value' => &$this->created,
-			'validate' => null,
-			'type' => 'DATETIME',
-			'default' => 'CURRENT_TIMESTAMP',
-			'properties' => ColumnProperty::NOT_NULL | ColumnProperty::IMMUTABLE
-		]);
-
-		$this->extendTableDefinition(TRAIT_DATEFIELDS_LAST_MODIFIED, [
-			'value' => &$this->lastModified,
-			'validate' => null,
-			'type' => 'DATETIME',
-			'default' => 'CURRENT_TIMESTAMP',
-			'properties' => ColumnProperty::NOT_NULL | ColumnProperty::IMMUTABLE
-		]);
+    /** @var string The timestamp representing the moment this record was created */
+    protected $created;
+
+    /** @var string The timestamp representing the moment this record was last updated */
+    protected $lastModified;
+
+    /**
+     * this method is required to be called in the constructor for each class that uses this trait. 
+     * It adds the datefields to the table definition and registers the callback hooks
+     */
+    protected function initDatefields()
+    {
+        $this->extendTableDefinition(TRAIT_DATEFIELDS_CREATED, [
+            'value' => &$this->created,
+            'validate' => null,
+            'type' => 'DATETIME',
+            'default' => 'CURRENT_TIMESTAMP',
+            'properties' => ColumnProperty::NOT_NULL | ColumnProperty::IMMUTABLE
+        ]);
+
+        $this->extendTableDefinition(TRAIT_DATEFIELDS_LAST_MODIFIED, [
+            'value' => &$this->lastModified,
+            'validate' => null,
+            'type' => 'DATETIME',
+            'default' => 'CURRENT_TIMESTAMP',
+            'properties' => ColumnProperty::NOT_NULL | ColumnProperty::IMMUTABLE
+        ]);
 		
-		$this->registerUpdateHook(TRAIT_DATEFIELDS_LAST_MODIFIED, 'DatefieldsUpdateHook');
-		$this->registerCreateHook(TRAIT_DATEFIELDS_LAST_MODIFIED, 'DatefieldsCreateHook');
-
-		$this->created = null;
-		$this->lastModified = null;
-	}
-
-	/**
-	 * The hook that gets called to set the timestamp whenever a new record is created
-	 */
-	protected function DatefieldsCreateHook()
-	{
-		// @TODO: Should this be split up to seperate hooks for "last_modified" and "created" for consistency?
-		$this->created = (new \DateTime('now'))->format('Y-m-d H:i:s');
-		$this->lastModified = (new \DateTime('now'))->format('Y-m-d H:i:s');
-	}
-
-	/**
-	 * The hook that gets called to set the timestamp whenever a record gets updated
-	 */
-	protected function DatefieldsUpdateHook()
-	{
-		$this->lastModified = (new \DateTime('now'))->format('Y-m-d H:i:s');
-	}
-
-	/**
-	 * Returns the timestamp of last update for this record
-	 * @return \DateTime
-	 */
-	public function getLastModifiedDate()
-	{
-		return new \DateTime($this->lastModified);
-	}
-
-	/**
-	 * Returns the timestamp of when this record was created
-	 * @return \DateTime
-	 */
-	public function getCreationDate()
-	{
-		return new \DateTime($this->created);
-	}
-
-	/**
-	 * @return void
-	 */
-	abstract protected function extendTableDefinition($columnName, $definition);
+        $this->registerUpdateHook(TRAIT_DATEFIELDS_LAST_MODIFIED, 'DatefieldsUpdateHook');
+        $this->registerCreateHook(TRAIT_DATEFIELDS_LAST_MODIFIED, 'DatefieldsCreateHook');
+
+        $this->created = null;
+        $this->lastModified = null;
+    }
+
+    /**
+     * The hook that gets called to set the timestamp whenever a new record is created
+     */
+    protected function DatefieldsCreateHook()
+    {
+        // @TODO: Should this be split up to seperate hooks for "last_modified" and "created" for consistency?
+        $this->created = (new \DateTime('now'))->format('Y-m-d H:i:s');
+        $this->lastModified = (new \DateTime('now'))->format('Y-m-d H:i:s');
+    }
+
+    /**
+     * The hook that gets called to set the timestamp whenever a record gets updated
+     */
+    protected function DatefieldsUpdateHook()
+    {
+        $this->lastModified = (new \DateTime('now'))->format('Y-m-d H:i:s');
+    }
+
+    /**
+     * Returns the timestamp of last update for this record
+     * @return \DateTime
+     */
+    public function getLastModifiedDate()
+    {
+        return new \DateTime($this->lastModified);
+    }
+
+    /**
+     * Returns the timestamp of when this record was created
+     * @return \DateTime
+     */
+    public function getCreationDate()
+    {
+        return new \DateTime($this->created);
+    }
+
+    /**
+     * @return void
+     */
+    abstract protected function extendTableDefinition($columnName, $definition);
 	
-	/**
-	 * @return void
-	 */
-	abstract protected function registerSearchHook($columnName, $fn);
-
-	/**
-	 * @return void
-	 */
-	abstract protected function registerDeleteHook($columnName, $fn);
-
-	/**
-	 * @return void
-	 */
-	abstract protected function registerUpdateHook($columnName, $fn);
-
-	/**
-	 * @return void
-	 */
-	abstract protected function registerReadHook($columnName, $fn);
-
-	/**
-	 * @return void
-	 */
-	abstract protected function registerCreateHook($columnName, $fn);
+    /**
+     * @return void
+     */
+    abstract protected function registerSearchHook($columnName, $fn);
+
+    /**
+     * @return void
+     */
+    abstract protected function registerDeleteHook($columnName, $fn);
+
+    /**
+     * @return void
+     */
+    abstract protected function registerUpdateHook($columnName, $fn);
+
+    /**
+     * @return void
+     */
+    abstract protected function registerReadHook($columnName, $fn);
+
+    /**
+     * @return void
+     */
+    abstract protected function registerCreateHook($columnName, $fn);
 }
 
-	
\ No newline at end of file
+    
\ No newline at end of file

src/Traits/AutoApi.php

Indentation +307 added lines, -307 removed lines

@@ -8,327 +8,327 @@
 
 trait AutoApi
 {
-	/* =======================================================================
+    /* =======================================================================
 	 * ===================== Automatic API Support ===========================
 	 * ======================================================================= */
 
-	/** @var array A map of column name to functions that hook the insert function */
-	protected $registeredCreateHooks;
+    /** @var array A map of column name to functions that hook the insert function */
+    protected $registeredCreateHooks;
 
-	/** @var array A map of column name to functions that hook the read function */
-	protected $registeredReadHooks;
+    /** @var array A map of column name to functions that hook the read function */
+    protected $registeredReadHooks;
 
-	/** @var array A map of column name to functions that hook the update function */
-	protected $registeredUpdateHooks;
+    /** @var array A map of column name to functions that hook the update function */
+    protected $registeredUpdateHooks;
 
-	/** @var array A map of column name to functions that hook the update function */
-	protected $registeredDeleteHooks;	
+    /** @var array A map of column name to functions that hook the update function */
+    protected $registeredDeleteHooks;	
 
-	/** @var array A map of column name to functions that hook the search function */
-	protected $registeredSearchHooks;
+    /** @var array A map of column name to functions that hook the search function */
+    protected $registeredSearchHooks;
 
-	/** @var array A list of table column definitions */
-	protected $tableDefinition;
+    /** @var array A list of table column definitions */
+    protected $tableDefinition;
 
-	public function apiSearch($inputs, $fieldWhitelist)
-	{
-		// @TODO: How to handle this case?
-		// => Default parameter names for searching? (limit, pagination, sort order etc)
-		//		Find default names for this and store in class
-		// => Limited search parameters? (We don't want to be able to search on a password field for example)
-	}
+    public function apiSearch($inputs, $fieldWhitelist)
+    {
+        // @TODO: How to handle this case?
+        // => Default parameter names for searching? (limit, pagination, sort order etc)
+        //		Find default names for this and store in class
+        // => Limited search parameters? (We don't want to be able to search on a password field for example)
+    }
 
-	public function toArray($fieldWhitelist)
-	{
-		$output = [];
-		foreach ($this->tableDefinition as $colName => $definition) {
-			if (in_array($colName, $fieldWhitelist)) {
-				$output[$colName] = $definition['value'];
-			}
-		}
+    public function toArray($fieldWhitelist)
+    {
+        $output = [];
+        foreach ($this->tableDefinition as $colName => $definition) {
+            if (in_array($colName, $fieldWhitelist)) {
+                $output[$colName] = $definition['value'];
+            }
+        }
 
-		return $output;
-	}
+        return $output;
+    }
 
-	public function apiRead($id, $fieldWhitelist)
-	{
-		$this->read($id);
-		return $this->toArray($fieldWhitelist);
-	}
+    public function apiRead($id, $fieldWhitelist)
+    {
+        $this->read($id);
+        return $this->toArray($fieldWhitelist);
+    }
 
-	/* =============================================================
+    /* =============================================================
 	 * ===================== Constraint validation =================
 	 * ============================================================= */
 
-	/**
-	 * Copy all table variables between two instances
-	 */
-	private function syncInstances($to, $from)
-	{
-		foreach ($to->tableDefinition as $colName => $definition) {
-			$definition['value'] = $from->tableDefinition[$colName]['value'];
-		}
-	}
-
-	private function filterInputColumns($input, $whitelist)
-	{
-		$filteredInput = $input;
-		foreach ($input as $colName => $value) {
-			if (!in_array($colName, $whitelist)) {
-				unset($filteredInput[$colName]);
-			}
-		}
-		return $filteredInput;
-	}
-
-	private function validateExcessKeys($input)
-	{
-		$errors = [];
-		foreach ($input as $colName => $value) {
-			if (!array_key_exists($colName, $this->tableDefinition)) {
-				$errors[$colName] = "Unknown input field";
-				continue;
-			}
-		}
-		return $errors;
-	}
-
-	private function validateImmutableColumns($input)
-	{
-		$errors = [];
-		foreach ($this->tableDefinition as $colName => $definition) {
-			$property = $definition['properties'] ?? null;
-			if (array_key_exists($colName, $input)
-				&& $property & ColumnProperty::IMMUTABLE) {
-				$errors[$colName] = "Field cannot be changed";
-			}
-		}
-		return $errors;
-	}
-
-	private function validateInputValues($input)
-	{
-		$errors = [];
-		foreach ($this->tableDefinition as $colName => $definition) {
-			// Validation check 1: If validate function is present
-			if (array_key_exists($colName, $input) 
-				&& is_callable($definition['validate'] ?? null)) {
-				$inputValue = $input[$colName];
-
-				// If validation function fails
-				[$status, $message] = $definition['validate']($inputValue);
-				if (!$status) {
-					$errors[$colName] = $message;
-				}	
-			}
-
-			// Validation check 2: If relation column, check whether entity exists
-			$properties = $definition['properties'] ?? null;
-			if (isset($definition['relation'])
-				&& ($properties & ColumnProperty::NOT_NULL)) {
-				$instance = clone $definition['relation'];
-				try {
-					$instance->read($input[$colName] ?? null);
-				} catch (ActiveRecordException $e) {
-					$errors[$colName] = "Entity for this value doesn't exist";
-				}
-			}
-		}
-		return $errors;
-	}
-
-	/**
-	 * This function is only used for API Update calls (direct getter/setter functions are unconstrained)
-	 */
-	private function validateMissingKeys()
-	{
-		$errors = [];
-
-		foreach ($this->tableDefinition as $colName => $colDefinition) {
-			$default = $colDefinition['default'] ?? null;
-			$properties = $colDefinition['properties'] ?? null;
-			$value = $colDefinition['value'];
-
-			// If nullable and default not set => null
-			// If nullable and default null => default (null)
-			// If nullable and default set => default (value)
-
-			// if not nullable and default not set => error
-			// if not nullable and default null => error
-			// if not nullable and default st => default (value)
-			// => if not nullable and default null and value not set => error message in this method
-			if ($properties & ColumnProperty::NOT_NULL
-				&& $default === null
-				&& !($properties & ColumnProperty::AUTO_INCREMENT)
-				// && !array_key_exists($colName, $input)
-				&& $value === null) {
-				$errors[$colName] = sprintf("The required field \"%s\" is missing", $colName);
-			}
-		}
-
-		return $errors;
-	}
-
-	/**
-	 * Copies the values for entries in the input with matching variable names in the record definition
-	 * @param Array $input The input data to be loaded into $this record
-	 */
-	private function loadData($input)
-	{
-		foreach ($this->tableDefinition as $colName => $definition) {
-			if (array_key_exists($colName, $input)) {
-				$definition['value'] = $input[$colName];
-			}
-		}
-	}
-
-	/**
-	 * @param Array $input Associative array of input values
-	 * @param Array $fieldWhitelist array of column names that are allowed to be filled by the input array 
-	 * @return Array Array containing the set of optional errors (associative array) and an optional array representation (associative)
-	 * 					of the modified data.
-	 */
-	public function apiCreate($input, $fieldWhitelist)
-	{
-		// Clone $this to new instance (for restoring if validation goes wrong)
-		$transaction = clone $this;
-		$errors = [];
-
-		// Filter out all non-whitelisted input values
-		$input = $this->filterInputColumns($input, $fieldWhitelist);
-
-		// Validate excess keys
-		$errors += $transaction->validateExcessKeys($input);
-
-		// Validate input values (using validation function)
-		$errors += $transaction->validateInputValues($input);
-
-		// "Copy" data into transaction
-		$transaction->loadData($input);
-
-		// Run create hooks
-		foreach ($this->registeredCreateHooks as $colName => $fn) {
-			$fn();
-		}
-
-		// Validate missing keys
-		$errors += $transaction->validateMissingKeys();
-
-		// If no errors, commit the pending data
-		if (empty($errors)) {
-			$this->syncInstances($this, $transaction);
-
-			try {
-				(new Query($this->getPdo(), $this->getActiveRecordTable()))
-					->insert($this->getActiveRecordColumns())
-					->execute();
-
-				$this->setId(intval($this->getPdo()->lastInsertId()));
-			} catch (\PDOException $e) {
-				// @TODO: Potentially filter and store mysql messages (where possible) in error messages
-				throw new ActiveRecordException($e->getMessage(), 0, $e);
-			}
-
-			return [null, $this->toArray($fieldWhitelist)];
-		} else {
-			return [$errors, null];
-		}
-	}
-
-	/**
-	 * @param Array $input Associative array of input values
-	 * @param Array $fieldWhitelist array of column names that are allowed to be filled by the input array 
-	 * @return Array Array containing the set of optional errors (associative array) and an optional array representation (associative)
-	 * 					of the modified data.
-	 */
-	public function apiUpdate($input, $fieldWhitelist)
-	{
-		$transaction = clone $this;
-		$errors = [];
-
-		// Filter out all non-whitelisted input values
-		$input = $this->filterInputColumns($input, $fieldWhitelist);
-
-		// Check for excess keys
-		$errors += $transaction->validateExcessKeys($input);
-
-		// Check for immutable keys
-		$errors += $transaction->validateImmutableColumns($input);
-
-		// Validate input values (using validation function)
-		$errors += $transaction->validateInputValues($input);
-
-		// "Copy" data into transaction
-		$transaction->loadData($input);
-
-		// Run create hooks
-		foreach ($this->registeredUpdateHooks as $colName => $fn) {
-			$fn();
-		}
-
-		// Validate missing keys
-		$errors += $transaction->validateMissingKeys();
-
-		// Update database
-		if (empty($errors)) {
-			$this->syncInstances($this, $transaction);
-
-			try {
-				(new Query($this->getPdo(), $this->getActiveRecordTable()))
-					->update($this->getActiveRecordColumns())
-					->where('id', '=', $this->getId())
-					->execute();
-			} catch (\PDOException $e) {
-				throw new ActiveRecordException($e->getMessage(), 0, $e);
-			}
-
-			return [null, $this->toArray($fieldWhitelist)];
-		} else {
-			return [$errors, null];
-		}
-	}
-
-	/**
-	 * Returns this active record after reading the attributes from the entry with the given identifier.
-	 *
-	 * @param mixed $id
-	 * @return $this
-	 * @throws ActiveRecordException on failure.
-	 */
-	abstract public function read($id);
-
-	/**
-	 * Returns the PDO.
-	 *
-	 * @return \PDO the PDO.
-	 */
-	abstract public function getPdo();
-
-	/**
-	 * Set the ID.
-	 *
-	 * @param int $id
-	 * @return $this
-	 */
-	abstract protected function setId($id);
-
-	/**
-	 * Returns the ID.
-	 *
-	 * @return null|int The ID.
-	 */
-	abstract protected function getId();
-
-	/**
-	 * Returns the active record table.
-	 *
-	 * @return string the active record table name.
-	 */
-	abstract protected function getActiveRecordTable();
-
-	/**
-	 * Returns the name -> variable mapping for the table definition.
-	 * @return Array The mapping
-	 */
-	abstract protected function getActiveRecordColumns();
+    /**
+     * Copy all table variables between two instances
+     */
+    private function syncInstances($to, $from)
+    {
+        foreach ($to->tableDefinition as $colName => $definition) {
+            $definition['value'] = $from->tableDefinition[$colName]['value'];
+        }
+    }
+
+    private function filterInputColumns($input, $whitelist)
+    {
+        $filteredInput = $input;
+        foreach ($input as $colName => $value) {
+            if (!in_array($colName, $whitelist)) {
+                unset($filteredInput[$colName]);
+            }
+        }
+        return $filteredInput;
+    }
+
+    private function validateExcessKeys($input)
+    {
+        $errors = [];
+        foreach ($input as $colName => $value) {
+            if (!array_key_exists($colName, $this->tableDefinition)) {
+                $errors[$colName] = "Unknown input field";
+                continue;
+            }
+        }
+        return $errors;
+    }
+
+    private function validateImmutableColumns($input)
+    {
+        $errors = [];
+        foreach ($this->tableDefinition as $colName => $definition) {
+            $property = $definition['properties'] ?? null;
+            if (array_key_exists($colName, $input)
+                && $property & ColumnProperty::IMMUTABLE) {
+                $errors[$colName] = "Field cannot be changed";
+            }
+        }
+        return $errors;
+    }
+
+    private function validateInputValues($input)
+    {
+        $errors = [];
+        foreach ($this->tableDefinition as $colName => $definition) {
+            // Validation check 1: If validate function is present
+            if (array_key_exists($colName, $input) 
+                && is_callable($definition['validate'] ?? null)) {
+                $inputValue = $input[$colName];
+
+                // If validation function fails
+                [$status, $message] = $definition['validate']($inputValue);
+                if (!$status) {
+                    $errors[$colName] = $message;
+                }	
+            }
+
+            // Validation check 2: If relation column, check whether entity exists
+            $properties = $definition['properties'] ?? null;
+            if (isset($definition['relation'])
+                && ($properties & ColumnProperty::NOT_NULL)) {
+                $instance = clone $definition['relation'];
+                try {
+                    $instance->read($input[$colName] ?? null);
+                } catch (ActiveRecordException $e) {
+                    $errors[$colName] = "Entity for this value doesn't exist";
+                }
+            }
+        }
+        return $errors;
+    }
+
+    /**
+     * This function is only used for API Update calls (direct getter/setter functions are unconstrained)
+     */
+    private function validateMissingKeys()
+    {
+        $errors = [];
+
+        foreach ($this->tableDefinition as $colName => $colDefinition) {
+            $default = $colDefinition['default'] ?? null;
+            $properties = $colDefinition['properties'] ?? null;
+            $value = $colDefinition['value'];
+
+            // If nullable and default not set => null
+            // If nullable and default null => default (null)
+            // If nullable and default set => default (value)
+
+            // if not nullable and default not set => error
+            // if not nullable and default null => error
+            // if not nullable and default st => default (value)
+            // => if not nullable and default null and value not set => error message in this method
+            if ($properties & ColumnProperty::NOT_NULL
+                && $default === null
+                && !($properties & ColumnProperty::AUTO_INCREMENT)
+                // && !array_key_exists($colName, $input)
+                && $value === null) {
+                $errors[$colName] = sprintf("The required field \"%s\" is missing", $colName);
+            }
+        }
+
+        return $errors;
+    }
+
+    /**
+     * Copies the values for entries in the input with matching variable names in the record definition
+     * @param Array $input The input data to be loaded into $this record
+     */
+    private function loadData($input)
+    {
+        foreach ($this->tableDefinition as $colName => $definition) {
+            if (array_key_exists($colName, $input)) {
+                $definition['value'] = $input[$colName];
+            }
+        }
+    }
+
+    /**
+     * @param Array $input Associative array of input values
+     * @param Array $fieldWhitelist array of column names that are allowed to be filled by the input array 
+     * @return Array Array containing the set of optional errors (associative array) and an optional array representation (associative)
+     * 					of the modified data.
+     */
+    public function apiCreate($input, $fieldWhitelist)
+    {
+        // Clone $this to new instance (for restoring if validation goes wrong)
+        $transaction = clone $this;
+        $errors = [];
+
+        // Filter out all non-whitelisted input values
+        $input = $this->filterInputColumns($input, $fieldWhitelist);
+
+        // Validate excess keys
+        $errors += $transaction->validateExcessKeys($input);
+
+        // Validate input values (using validation function)
+        $errors += $transaction->validateInputValues($input);
+
+        // "Copy" data into transaction
+        $transaction->loadData($input);
+
+        // Run create hooks
+        foreach ($this->registeredCreateHooks as $colName => $fn) {
+            $fn();
+        }
+
+        // Validate missing keys
+        $errors += $transaction->validateMissingKeys();
+
+        // If no errors, commit the pending data
+        if (empty($errors)) {
+            $this->syncInstances($this, $transaction);
+
+            try {
+                (new Query($this->getPdo(), $this->getActiveRecordTable()))
+                    ->insert($this->getActiveRecordColumns())
+                    ->execute();
+
+                $this->setId(intval($this->getPdo()->lastInsertId()));
+            } catch (\PDOException $e) {
+                // @TODO: Potentially filter and store mysql messages (where possible) in error messages
+                throw new ActiveRecordException($e->getMessage(), 0, $e);
+            }
+
+            return [null, $this->toArray($fieldWhitelist)];
+        } else {
+            return [$errors, null];
+        }
+    }
+
+    /**
+     * @param Array $input Associative array of input values
+     * @param Array $fieldWhitelist array of column names that are allowed to be filled by the input array 
+     * @return Array Array containing the set of optional errors (associative array) and an optional array representation (associative)
+     * 					of the modified data.
+     */
+    public function apiUpdate($input, $fieldWhitelist)
+    {
+        $transaction = clone $this;
+        $errors = [];
+
+        // Filter out all non-whitelisted input values
+        $input = $this->filterInputColumns($input, $fieldWhitelist);
+
+        // Check for excess keys
+        $errors += $transaction->validateExcessKeys($input);
+
+        // Check for immutable keys
+        $errors += $transaction->validateImmutableColumns($input);
+
+        // Validate input values (using validation function)
+        $errors += $transaction->validateInputValues($input);
+
+        // "Copy" data into transaction
+        $transaction->loadData($input);
+
+        // Run create hooks
+        foreach ($this->registeredUpdateHooks as $colName => $fn) {
+            $fn();
+        }
+
+        // Validate missing keys
+        $errors += $transaction->validateMissingKeys();
+
+        // Update database
+        if (empty($errors)) {
+            $this->syncInstances($this, $transaction);
+
+            try {
+                (new Query($this->getPdo(), $this->getActiveRecordTable()))
+                    ->update($this->getActiveRecordColumns())
+                    ->where('id', '=', $this->getId())
+                    ->execute();
+            } catch (\PDOException $e) {
+                throw new ActiveRecordException($e->getMessage(), 0, $e);
+            }
+
+            return [null, $this->toArray($fieldWhitelist)];
+        } else {
+            return [$errors, null];
+        }
+    }
+
+    /**
+     * Returns this active record after reading the attributes from the entry with the given identifier.
+     *
+     * @param mixed $id
+     * @return $this
+     * @throws ActiveRecordException on failure.
+     */
+    abstract public function read($id);
+
+    /**
+     * Returns the PDO.
+     *
+     * @return \PDO the PDO.
+     */
+    abstract public function getPdo();
+
+    /**
+     * Set the ID.
+     *
+     * @param int $id
+     * @return $this
+     */
+    abstract protected function setId($id);
+
+    /**
+     * Returns the ID.
+     *
+     * @return null|int The ID.
+     */
+    abstract protected function getId();
+
+    /**
+     * Returns the active record table.
+     *
+     * @return string the active record table name.
+     */
+    abstract protected function getActiveRecordTable();
+
+    /**
+     * Returns the name -> variable mapping for the table definition.
+     * @return Array The mapping
+     */
+    abstract protected function getActiveRecordColumns();
 }