gin0115 / pixie-wpdb

static-loader-creator.php

Indentation +224 added lines, -224 removed lines

@@ -25,161 +25,161 @@ 
 
 class StaticLoaderCreator
 {
-    /** @var string[] Array of file names */
-    protected array $files = [];
-
-    /** @var array<int, array{class:string|null, ns:string|null, interface:string|null, trait:string|null, file:string}> Classes */
-    protected array $classes = [];
-
-    /** @var string Path to the SRC directory. */
-    protected $routePath;
-
-    public function __construct()
-    {
-        $this->routePath = __DIR__ . DIRECTORY_SEPARATOR . 'src';
-    }
-
-    /**
-     * Static initialiser
-     *
-     * @return void
-     */
-    public static function run(): void
-    {
-        $instance = new self();
-        $instance->getFiles();
-        $instance->getClassNames();
-        $instance->writeLoader();
-    }
-
-    /**
-     * Get all filenames excluding the loader.
-     *
-     * @return void
-     */
-    public function getFiles(): void
-    {
-        $rii = new RecursiveIteratorIterator(
-            new RecursiveDirectoryIterator($this->routePath)
-        );
-
-        foreach ($rii as $file) {
-            if ($file->isDir() || $file->getPathname() === $this->routePath . DIRECTORY_SEPARATOR . 'loader.php') {
-                continue;
-            }
-
-            $this->files[] = $file->getPathname();
-        }
-    }
-
-    /**
-     * Compiles the list of classnames with file paths.
-     *
-     * @return void
-     */
-    public function getClassNames(): void
-    {
-        foreach ($this->files as $file) {
-            $classData['class'] = $this->getObjectTypeFromFile($file, T_CLASS);
-            $classData['trait'] = $this->getObjectTypeFromFile($file, T_TRAIT);
-            $classData['interface'] = $this->getObjectTypeFromFile($file, T_INTERFACE);
-            $classData['ns'] = $this->getNamespace($file);
-            $classData['file'] = str_replace($this->routePath, '', $file);
-            $this->classes[] = $classData;
-        }
-
-        // Set all classes to be required last, allow traits to load first.
-        uasort($this->classes, function ($file1, $file2) {
-            return is_null($file1['class']) ? -1 : 1;
-        });
-    }
-
-    /**
-     * Gets the namespace from a file.
-     *
-     * @see https://stackoverflow.com/questions/7153000/get-class-name-from-file/44654073
-     * @param string $file
-     * @return string|null
-     * @throws \Exception If file not found or empty.
-     */
-    public function getNamespace(string $file): ?string
-    {
-        $src = file_get_contents($file);
-
-        if (false === $src) {
-            throw new \Exception("Could not read contents of {$file}", 1);
-        }
-
-        $tokens = token_get_all($src);
-        $count = count($tokens);
-        $i = 0;
-        $namespace = '';
-        $namespace_ok = false;
-        while ($i < $count) {
-            $token = $tokens[$i];
-            if (is_array($token) && $token[0] === T_NAMESPACE) {
-                // Found namespace declaration
-                while (++$i < $count) {
-                    if ($tokens[$i] === ';') {
-                        $namespace_ok = true;
-                        $namespace = trim($namespace);
-                        break;
-                    }
-                    $namespace .= is_array($tokens[$i]) ? $tokens[$i][1] : $tokens[$i];
-                }
-                break;
-            }
-            $i++;
-        }
-        if (!$namespace_ok) {
-            return null;
-        } else {
-            return $namespace;
-        }
-    }
-
-    /**
-     * get the class name form file path using token
-     *
-     * @see https://stackoverflow.com/questions/7153000/get-class-name-from-file/44654073
-     * @param string $file
-     * @param int $type
-     * @return string|null
-     */
-    protected function getObjectTypeFromFile(string $file, int $type = T_CLASS): ?string
-    {
-        $src = file_get_contents($file);
-
-        if (false === $src) {
-            throw new \Exception("Could not read contents of {$file}", 1);
-        }
-
-        $classes = array();
-        $tokens = token_get_all($src);
-        $count = count($tokens);
-        for ($i = 2; $i < $count; $i++) {
-            if (
-                $tokens[$i - 2][0] == $type
-                && $tokens[$i - 1][0] == T_WHITESPACE
-                && $tokens[$i][0] == T_STRING
-            ) {
-                $class_name = $tokens[$i][1];
-                $classes[] = $class_name;
-            }
-        }
-
-        return array_key_exists(0, $classes) ? $classes[0] : null;
-    }
-
-    /**
-     * Writes the loader.php file.
-     *
-     * @return void
-     */
-    public function writeLoader(): void
-    {
-        $newLine = PHP_EOL;
-        $header = "<?php{$newLine}{$newLine}{$newLine}
+	/** @var string[] Array of file names */
+	protected array $files = [];
+
+	/** @var array<int, array{class:string|null, ns:string|null, interface:string|null, trait:string|null, file:string}> Classes */
+	protected array $classes = [];
+
+	/** @var string Path to the SRC directory. */
+	protected $routePath;
+
+	public function __construct()
+	{
+		$this->routePath = __DIR__ . DIRECTORY_SEPARATOR . 'src';
+	}
+
+	/**
+	 * Static initialiser
+	 *
+	 * @return void
+	 */
+	public static function run(): void
+	{
+		$instance = new self();
+		$instance->getFiles();
+		$instance->getClassNames();
+		$instance->writeLoader();
+	}
+
+	/**
+	 * Get all filenames excluding the loader.
+	 *
+	 * @return void
+	 */
+	public function getFiles(): void
+	{
+		$rii = new RecursiveIteratorIterator(
+			new RecursiveDirectoryIterator($this->routePath)
+		);
+
+		foreach ($rii as $file) {
+			if ($file->isDir() || $file->getPathname() === $this->routePath . DIRECTORY_SEPARATOR . 'loader.php') {
+				continue;
+			}
+
+			$this->files[] = $file->getPathname();
+		}
+	}
+
+	/**
+	 * Compiles the list of classnames with file paths.
+	 *
+	 * @return void
+	 */
+	public function getClassNames(): void
+	{
+		foreach ($this->files as $file) {
+			$classData['class'] = $this->getObjectTypeFromFile($file, T_CLASS);
+			$classData['trait'] = $this->getObjectTypeFromFile($file, T_TRAIT);
+			$classData['interface'] = $this->getObjectTypeFromFile($file, T_INTERFACE);
+			$classData['ns'] = $this->getNamespace($file);
+			$classData['file'] = str_replace($this->routePath, '', $file);
+			$this->classes[] = $classData;
+		}
+
+		// Set all classes to be required last, allow traits to load first.
+		uasort($this->classes, function ($file1, $file2) {
+			return is_null($file1['class']) ? -1 : 1;
+		});
+	}
+
+	/**
+	 * Gets the namespace from a file.
+	 *
+	 * @see https://stackoverflow.com/questions/7153000/get-class-name-from-file/44654073
+	 * @param string $file
+	 * @return string|null
+	 * @throws \Exception If file not found or empty.
+	 */
+	public function getNamespace(string $file): ?string
+	{
+		$src = file_get_contents($file);
+
+		if (false === $src) {
+			throw new \Exception("Could not read contents of {$file}", 1);
+		}
+
+		$tokens = token_get_all($src);
+		$count = count($tokens);
+		$i = 0;
+		$namespace = '';
+		$namespace_ok = false;
+		while ($i < $count) {
+			$token = $tokens[$i];
+			if (is_array($token) && $token[0] === T_NAMESPACE) {
+				// Found namespace declaration
+				while (++$i < $count) {
+					if ($tokens[$i] === ';') {
+						$namespace_ok = true;
+						$namespace = trim($namespace);
+						break;
+					}
+					$namespace .= is_array($tokens[$i]) ? $tokens[$i][1] : $tokens[$i];
+				}
+				break;
+			}
+			$i++;
+		}
+		if (!$namespace_ok) {
+			return null;
+		} else {
+			return $namespace;
+		}
+	}
+
+	/**
+	 * get the class name form file path using token
+	 *
+	 * @see https://stackoverflow.com/questions/7153000/get-class-name-from-file/44654073
+	 * @param string $file
+	 * @param int $type
+	 * @return string|null
+	 */
+	protected function getObjectTypeFromFile(string $file, int $type = T_CLASS): ?string
+	{
+		$src = file_get_contents($file);
+
+		if (false === $src) {
+			throw new \Exception("Could not read contents of {$file}", 1);
+		}
+
+		$classes = array();
+		$tokens = token_get_all($src);
+		$count = count($tokens);
+		for ($i = 2; $i < $count; $i++) {
+			if (
+				$tokens[$i - 2][0] == $type
+				&& $tokens[$i - 1][0] == T_WHITESPACE
+				&& $tokens[$i][0] == T_STRING
+			) {
+				$class_name = $tokens[$i][1];
+				$classes[] = $class_name;
+			}
+		}
+
+		return array_key_exists(0, $classes) ? $classes[0] : null;
+	}
+
+	/**
+	 * Writes the loader.php file.
+	 *
+	 * @return void
+	 */
+	public function writeLoader(): void
+	{
+		$newLine = PHP_EOL;
+		$header = "<?php{$newLine}{$newLine}{$newLine}
 /**
  * Pixie WPDB Static Loader
  *
@@ -205,77 +205,77 @@ 
 
 // Generated code start...";
 
-        $contents = array_map(function ($file, $class) {
-             return sprintf(
-                 "if (!%s(%s::class)) {
+		$contents = array_map(function ($file, $class) {
+			 return sprintf(
+				 "if (!%s(%s::class)) {
     require_once __DIR__ . '%s';
 }",
-                 $this->getMethodFromToken($class),
-                 $this->getFullTokenName($class),
-                 $class['file']
-             );
-        }, array_keys($this->classes), $this->classes);
-
-        $footer = sprintf("// CREATED ON %s", date('D jS F Y', time()));
-
-        $file = __DIR__ . DIRECTORY_SEPARATOR . 'src' . DIRECTORY_SEPARATOR . 'loader.php';
-        touch($file);
-
-        file_put_contents(
-            $file,
-            join(PHP_EOL, [
-                $header,
-                join(PHP_EOL, $contents),
-                $footer, ''
-            ])
-        );
-    }
-
-    /**
-     * Gets the *_exists() method based on the token type.
-     *
-     * @param array{class:string|null, ns:string|null, interface:string|null, trait:string|null, file:string} $token
-     * @return string
-     */
-    public function getMethodFromToken(array $token): string
-    {
-        switch (true) {
-            case ! is_null($token['trait']):
-                return 'trait_exists';
-
-            case ! is_null($token['interface']):
-                return 'interface_exists';
-
-            default:
-                return 'class_exists';
-        }
-    }
-
-    /**
-     * Returns the full (namespaced) token name
-     *
-     * @param array{class:string|null, ns:string|null, interface:string|null, trait:string|null, file:string} $token
-     * @return string
-     */
-    public function getFullTokenName(array $token): string
-    {
-        switch (true) {
-            case ! array_key_exists('ns', $token):
-                return '';
-
-            case ! is_null($token['trait']):
-                return $token['ns'] . '\\' . $token['trait'];
-
-            case ! is_null($token['interface']):
-                return $token['ns'] . '\\' . $token['interface'];
-
-            case ! is_null($token['class']):
-                return $token['ns'] . '\\' . $token['class'];
-
-            default:
-                return '';
-        }
-    }
+				 $this->getMethodFromToken($class),
+				 $this->getFullTokenName($class),
+				 $class['file']
+			 );
+		}, array_keys($this->classes), $this->classes);
+
+		$footer = sprintf("// CREATED ON %s", date('D jS F Y', time()));
+
+		$file = __DIR__ . DIRECTORY_SEPARATOR . 'src' . DIRECTORY_SEPARATOR . 'loader.php';
+		touch($file);
+
+		file_put_contents(
+			$file,
+			join(PHP_EOL, [
+				$header,
+				join(PHP_EOL, $contents),
+				$footer, ''
+			])
+		);
+	}
+
+	/**
+	 * Gets the *_exists() method based on the token type.
+	 *
+	 * @param array{class:string|null, ns:string|null, interface:string|null, trait:string|null, file:string} $token
+	 * @return string
+	 */
+	public function getMethodFromToken(array $token): string
+	{
+		switch (true) {
+			case ! is_null($token['trait']):
+				return 'trait_exists';
+
+			case ! is_null($token['interface']):
+				return 'interface_exists';
+
+			default:
+				return 'class_exists';
+		}
+	}
+
+	/**
+	 * Returns the full (namespaced) token name
+	 *
+	 * @param array{class:string|null, ns:string|null, interface:string|null, trait:string|null, file:string} $token
+	 * @return string
+	 */
+	public function getFullTokenName(array $token): string
+	{
+		switch (true) {
+			case ! array_key_exists('ns', $token):
+				return '';
+
+			case ! is_null($token['trait']):
+				return $token['ns'] . '\\' . $token['trait'];
+
+			case ! is_null($token['interface']):
+				return $token['ns'] . '\\' . $token['interface'];
+
+			case ! is_null($token['class']):
+				return $token['ns'] . '\\' . $token['class'];
+
+			default:
+				return '';
+		}
+	}
 }
 
 StaticLoaderCreator::run();

Spacing +9 added lines, -9 removed lines

@@ -36,7 +36,7 @@ 
 
     public function __construct()
     {
-        $this->routePath = __DIR__ . DIRECTORY_SEPARATOR . 'src';
+        $this->routePath = __DIR__.DIRECTORY_SEPARATOR.'src';
     }
 
     /**
@@ -64,7 +64,7 @@ 
         );
 
         foreach ($rii as $file) {
-            if ($file->isDir() || $file->getPathname() === $this->routePath . DIRECTORY_SEPARATOR . 'loader.php') {
+            if ($file->isDir() || $file->getPathname() === $this->routePath.DIRECTORY_SEPARATOR.'loader.php') {
                 continue;
             }
 
@@ -89,7 +89,7 @@ 
         }
 
         // Set all classes to be required last, allow traits to load first.
-        uasort($this->classes, function ($file1, $file2) {
+        uasort($this->classes, function($file1, $file2) {
             return is_null($file1['class']) ? -1 : 1;
         });
     }
@@ -131,7 +131,7 @@ 
             }
             $i++;
         }
-        if (!$namespace_ok) {
+        if ( ! $namespace_ok) {
             return null;
         } else {
             return $namespace;
@@ -205,7 +205,7 @@ 
 
 // Generated code start...";
 
-        $contents = array_map(function ($file, $class) {
+        $contents = array_map(function($file, $class) {
              return sprintf(
                  "if (!%s(%s::class)) {
     require_once __DIR__ . '%s';
@@ -218,7 +218,7 @@ 
 
         $footer = sprintf("// CREATED ON %s", date('D jS F Y', time()));
 
-        $file = __DIR__ . DIRECTORY_SEPARATOR . 'src' . DIRECTORY_SEPARATOR . 'loader.php';
+        $file = __DIR__.DIRECTORY_SEPARATOR.'src'.DIRECTORY_SEPARATOR.'loader.php';
         touch($file);
 
         file_put_contents(
@@ -264,13 +264,13 @@ 
                 return '';
 
             case ! is_null($token['trait']):
-                return $token['ns'] . '\\' . $token['trait'];
+                return $token['ns'].'\\'.$token['trait'];
 
             case ! is_null($token['interface']):
-                return $token['ns'] . '\\' . $token['interface'];
+                return $token['ns'].'\\'.$token['interface'];
 
             case ! is_null($token['class']):
-                return $token['ns'] . '\\' . $token['class'];
+                return $token['ns'].'\\'.$token['class'];
 
             default:
                 return '';

src/QueryBuilder/JsonQueryBuilder.php

Indentation +444 added lines, -444 removed lines

@@ -4,448 +4,448 @@
 
 class JsonQueryBuilder extends QueryBuilderHandler
 {
-    /**
-    * @param string|Raw $column The database column which holds the JSON value
-    * @param string|Raw|string[] $nodes The json key/index to search
-    * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-    * @param mixed|null $value
-    * @return static
-    */
-    public function whereJson($column, $nodes, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (3 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-
-        return $this->whereJsonHandler($column, $nodes, $operator, $value, 'AND');
-    }
-
-    /**
-     * @param string|Raw $column The database column which holds the JSON value
-     * @param string|Raw|string[] $nodes The json key/index to search
-     * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-     * @param mixed|null $value
-     * @return static
-     */
-    public function whereNotJson($column, $nodes, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (3 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-
-        return $this->whereJsonHandler($column, $nodes, $operator, $value, 'AND NOT');
-    }
-
-    /**
-    * @param string|Raw $column The database column which holds the JSON value
-    * @param string|Raw|string[] $nodes The json key/index to search
-    * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-    * @param mixed|null $value
-    * @return static
-    */
-    public function orWhereJson($column, $nodes, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (3 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-
-        return $this->whereJsonHandler($column, $nodes, $operator, $value, 'OR');
-    }
-
-    /**
-    * @param string|Raw $column The database column which holds the JSON value
-    * @param string|Raw|string[] $nodes The json key/index to search
-    * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-    * @param mixed|null $value
-    * @return static
-    */
-    public function orWhereNotJson($column, $nodes, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (3 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-
-        return $this->whereJsonHandler($column, $nodes, $operator, $value, 'OR NOT');
-    }
-
-    /**
-    * @param string|Raw $column The database column which holds the JSON value
-    * @param string|Raw|string[] $nodes The json key/index to search
-    * @param mixed[] $values
-    * @return static
-    */
-    public function whereInJson($column, $nodes, $values): self
-    {
-        return $this->whereJsonHandler($column, $nodes, 'IN', $values, 'AND');
-    }
-
-    /**
-    * @param string|Raw $column The database column which holds the JSON value
-    * @param string|Raw|string[] $nodes The json key/index to search
-    * @param mixed[] $values
-    * @return static
-    */
-    public function whereNotInJson($column, $nodes, $values): self
-    {
-        return $this->whereJsonHandler($column, $nodes, 'NOT IN', $values, 'AND');
-    }
-
-    /**
-    * @param string|Raw $column The database column which holds the JSON value
-    * @param string|Raw|string[] $nodes The json key/index to search
-    * @param mixed[] $values
-    * @return static
-    */
-    public function orWhereInJson($column, $nodes, $values): self
-    {
-        return $this->whereJsonHandler($column, $nodes, 'IN', $values, 'OR');
-    }
-
-    /**
-    * @param string|Raw $column The database column which holds the JSON value
-    * @param string|Raw|string[] $nodes The json key/index to search
-    * @param mixed[] $values
-    * @return static
-    */
-    public function orWhereNotInJson($column, $nodes, $values): self
-    {
-        return $this->whereJsonHandler($column, $nodes, 'NOT IN', $values, 'OR');
-    }
-
-    /**
-     * @param string|Raw $column
-    * @param string|Raw|string[] $nodes The json key/index to search
-     * @param mixed $valueFrom
-     * @param mixed $valueTo
-     *
-     * @return static
-     */
-    public function whereBetweenJson($column, $nodes, $valueFrom, $valueTo): self
-    {
-        return $this->whereJsonHandler($column, $nodes, 'BETWEEN', [$valueFrom, $valueTo], 'AND');
-    }
-
-    /**
-     * @param string|Raw $column
-    * @param string|Raw|string[] $nodes The json key/index to search
-     * @param mixed $valueFrom
-     * @param mixed $valueTo
-     *
-     * @return static
-     */
-    public function orWhereBetweenJson($column, $nodes, $valueFrom, $valueTo): self
-    {
-        return $this->whereJsonHandler($column, $nodes, 'BETWEEN', [$valueFrom, $valueTo], 'OR');
-    }
-
-    /**
-    * @param string|Raw $column The database column which holds the JSON value
-    * @param string|Raw|string[] $nodes The json key/index to search
-    * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-    * @param mixed|null $value
-    * @return static
-    */
-    public function whereDayJson($column, $nodes, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (3 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-        return $this->whereFunctionCallJsonHandler($column, $nodes, 'DAY', $operator, $value);
-    }
-
-    /**
-    * @param string|Raw $column The database column which holds the JSON value
-    * @param string|Raw|string[] $nodes The json key/index to search
-    * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-    * @param mixed|null $value
-    * @return static
-    */
-    public function whereMonthJson($column, $nodes, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (3 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-        return $this->whereFunctionCallJsonHandler($column, $nodes, 'MONTH', $operator, $value);
-    }
-
-    /**
-    * @param string|Raw $column The database column which holds the JSON value
-    * @param string|Raw|string[] $nodes The json key/index to search
-    * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-    * @param mixed|null $value
-    * @return static
-    */
-    public function whereYearJson($column, $nodes, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (3 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-        return $this->whereFunctionCallJsonHandler($column, $nodes, 'YEAR', $operator, $value);
-    }
-
-    /**
-    * @param string|Raw $column The database column which holds the JSON value
-    * @param string|Raw|string[] $nodes The json key/index to search
-    * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-    * @param mixed|null $value
-    * @return static
-    */
-    public function whereDateJson($column, $nodes, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (3 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-        return $this->whereFunctionCallJsonHandler($column, $nodes, 'DATE', $operator, $value);
-    }
-
-    /**
-     * Maps a function call for a JSON where condition
-     *
-     * @param string|Raw $column
-     * @param string|Raw|string[] $nodes
-     * @param string $function
-     * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-     * @param mixed|null $value
-     * @return static
-     */
-    protected function whereFunctionCallJsonHandler($column, $nodes, $function, $operator, $value): self
-    {
-        // Handle potential raw values.
-        if ($column instanceof Raw) {
-            $column = $this->adapterInstance->parseRaw($column);
-        }
-        if ($nodes instanceof Raw) {
-            $nodes = $this->adapterInstance->parseRaw($nodes);
-        }
-
-        return $this->whereFunctionCallHandler(
-            $this->jsonHandler->jsonExpressionFactory()->extractAndUnquote($column, $nodes),
-            $function,
-            $operator,
-            $value
-        );
-    }
-
-    /**
-    * @param string|Raw $column The database column which holds the JSON value
-    * @param string|Raw|string[] $nodes The json key/index to search
-    * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-    * @param mixed|null $value
-    * @param string $joiner
-    * @return static
-    */
-    protected function whereJsonHandler($column, $nodes, $operator = null, $value = null, string $joiner = 'AND'): self
-    {
-        // Handle potential raw values.
-        if ($column instanceof Raw) {
-            $column = $this->adapterInstance->parseRaw($column);
-        }
-        if ($nodes instanceof Raw) {
-            $nodes = $this->adapterInstance->parseRaw($nodes);
-        }
-
-        return $this->whereHandler(
-            $this->jsonHandler->jsonExpressionFactory()->extractAndUnquote($column, $nodes),
-            $operator,
-            $value,
-            $joiner
-        );
-    }
-
-    /**
-     * @param string|Raw $table
-     * @param string|Raw $leftColumn
-     * @param string|Raw|string[]|null $leftNodes The json key/index to search
-     * @param string $operator
-     * @param string|Raw $rightColumn
-     * @param string|Raw|string[]|null $rightNodes
-     * @param string $type
-     *
-     * @return static
-     */
-    public function joinJson(
-        $table,
-        $leftColumn,
-        $leftNodes,
-        string $operator,
-        $rightColumn,
-        $rightNodes,
-        $type = 'inner'
-    ): self {
-        // Convert key if json
-        if (null !== $rightNodes) {
-            $rightColumn = $this->jsonHandler->jsonExpressionFactory()->extractAndUnquote($rightColumn, $rightNodes);
-        }
-
-        // Convert key if json
-        if (null !== $leftNodes) {
-            $leftColumn = $this->jsonHandler->jsonExpressionFactory()->extractAndUnquote($leftColumn, $leftNodes);
-        }
-
-        return $this->join($table, $leftColumn, $operator, $rightColumn, $type);
-    }
-
-    /**
-     * @param string|Raw $table
-     * @param string|Raw $leftColumn
-     * @param string|Raw|string[]|null $leftNodes The json key/index to search
-     * @param string $operator
-     * @param string|Raw $rightColumn
-     * @param string|Raw|string[]|null $rightNodes
-     *
-     * @return static
-     */
-    public function leftJoinJson(
-        $table,
-        $leftColumn,
-        $leftNodes,
-        string $operator,
-        $rightColumn,
-        $rightNodes
-    ): self {
-        return $this->joinJson(
-            $table,
-            $leftColumn,
-            $leftNodes,
-            $operator,
-            $rightColumn,
-            $rightNodes,
-            'left'
-        );
-    }
-
-    /**
-     * @param string|Raw $table
-     * @param string|Raw $leftColumn
-     * @param string|Raw|string[]|null $leftNodes The json key/index to search
-     * @param string $operator
-     * @param string|Raw $rightColumn
-     * @param string|Raw|string[]|null $rightNodes
-     *
-     * @return static
-     */
-    public function rightJoinJson(
-        $table,
-        $leftColumn,
-        $leftNodes,
-        string $operator,
-        $rightColumn,
-        $rightNodes
-    ): self {
-        return $this->joinJson(
-            $table,
-            $leftColumn,
-            $leftNodes,
-            $operator,
-            $rightColumn,
-            $rightNodes,
-            'right'
-        );
-    }
-
-    /**
-     * @param string|Raw $table
-     * @param string|Raw $leftColumn
-     * @param string|Raw|string[]|null $leftNodes The json key/index to search
-     * @param string $operator
-     * @param string|Raw $rightColumn
-     * @param string|Raw|string[]|null $rightNodes
-     *
-     * @return static
-     */
-    public function outerJoinJson(
-        $table,
-        $leftColumn,
-        $leftNodes,
-        string $operator,
-        $rightColumn,
-        $rightNodes
-    ): self {
-        return $this->joinJson(
-            $table,
-            $leftColumn,
-            $leftNodes,
-            $operator,
-            $rightColumn,
-            $rightNodes,
-            'FULL OUTER'
-        );
-    }
-
-    /**
-     * @param string|Raw $table
-     * @param string|Raw $leftColumn
-     * @param string|Raw|string[]|null $leftNodes The json key/index to search
-     * @param string $operator
-     * @param string|Raw $rightColumn
-     * @param string|Raw|string[]|null $rightNodes
-     *
-     * @return static
-     */
-    public function crossJoinJson(
-        $table,
-        $leftColumn,
-        $leftNodes,
-        string $operator,
-        $rightColumn,
-        $rightNodes
-    ): self {
-        return $this->joinJson(
-            $table,
-            $leftColumn,
-            $leftNodes,
-            $operator,
-            $rightColumn,
-            $rightNodes,
-            'cross'
-        );
-    }
-
-
-
-    // JSON
-
-    /**
-     * @param string|Raw $column The database column which holds the JSON value
-     * @param string|Raw|string[] $nodes The json key/index to search
-     * @param string|null $alias The alias used to define the value in results, if not defined will use json_{$nodes}
-     * @return static
-     */
-    public function selectJson($column, $nodes, ?string $alias = null): self
-    {
-        // Handle potential raw values.
-        if ($column instanceof Raw) {
-            $column = $this->adapterInstance->parseRaw($column);
-        }
-        if ($nodes instanceof Raw) {
-            $nodes = $this->adapterInstance->parseRaw($nodes);
-        }
-
-        // If deeply nested jsonKey.
-        if (is_array($nodes)) {
-            $nodes = \implode('.', $nodes);
-        }
-
-        // Add any possible prefixes to the key
-        $column = $this->addTablePrefix($column, true);
-
-        $alias = null === $alias ? "json_{$nodes}" : $alias;
-        return  $this->select(new Raw("JSON_UNQUOTE(JSON_EXTRACT({$column}, \"$.{$nodes}\")) as {$alias}"));
-    }
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return static
+	 */
+	public function whereJson($column, $nodes, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (3 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+
+		return $this->whereJsonHandler($column, $nodes, $operator, $value, 'AND');
+	}
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return static
+	 */
+	public function whereNotJson($column, $nodes, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (3 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+
+		return $this->whereJsonHandler($column, $nodes, $operator, $value, 'AND NOT');
+	}
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return static
+	 */
+	public function orWhereJson($column, $nodes, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (3 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+
+		return $this->whereJsonHandler($column, $nodes, $operator, $value, 'OR');
+	}
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return static
+	 */
+	public function orWhereNotJson($column, $nodes, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (3 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+
+		return $this->whereJsonHandler($column, $nodes, $operator, $value, 'OR NOT');
+	}
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param mixed[] $values
+	 * @return static
+	 */
+	public function whereInJson($column, $nodes, $values): self
+	{
+		return $this->whereJsonHandler($column, $nodes, 'IN', $values, 'AND');
+	}
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param mixed[] $values
+	 * @return static
+	 */
+	public function whereNotInJson($column, $nodes, $values): self
+	{
+		return $this->whereJsonHandler($column, $nodes, 'NOT IN', $values, 'AND');
+	}
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param mixed[] $values
+	 * @return static
+	 */
+	public function orWhereInJson($column, $nodes, $values): self
+	{
+		return $this->whereJsonHandler($column, $nodes, 'IN', $values, 'OR');
+	}
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param mixed[] $values
+	 * @return static
+	 */
+	public function orWhereNotInJson($column, $nodes, $values): self
+	{
+		return $this->whereJsonHandler($column, $nodes, 'NOT IN', $values, 'OR');
+	}
+
+	/**
+	 * @param string|Raw $column
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param mixed $valueFrom
+	 * @param mixed $valueTo
+	 *
+	 * @return static
+	 */
+	public function whereBetweenJson($column, $nodes, $valueFrom, $valueTo): self
+	{
+		return $this->whereJsonHandler($column, $nodes, 'BETWEEN', [$valueFrom, $valueTo], 'AND');
+	}
+
+	/**
+	 * @param string|Raw $column
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param mixed $valueFrom
+	 * @param mixed $valueTo
+	 *
+	 * @return static
+	 */
+	public function orWhereBetweenJson($column, $nodes, $valueFrom, $valueTo): self
+	{
+		return $this->whereJsonHandler($column, $nodes, 'BETWEEN', [$valueFrom, $valueTo], 'OR');
+	}
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return static
+	 */
+	public function whereDayJson($column, $nodes, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (3 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+		return $this->whereFunctionCallJsonHandler($column, $nodes, 'DAY', $operator, $value);
+	}
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return static
+	 */
+	public function whereMonthJson($column, $nodes, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (3 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+		return $this->whereFunctionCallJsonHandler($column, $nodes, 'MONTH', $operator, $value);
+	}
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return static
+	 */
+	public function whereYearJson($column, $nodes, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (3 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+		return $this->whereFunctionCallJsonHandler($column, $nodes, 'YEAR', $operator, $value);
+	}
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return static
+	 */
+	public function whereDateJson($column, $nodes, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (3 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+		return $this->whereFunctionCallJsonHandler($column, $nodes, 'DATE', $operator, $value);
+	}
+
+	/**
+	 * Maps a function call for a JSON where condition
+	 *
+	 * @param string|Raw $column
+	 * @param string|Raw|string[] $nodes
+	 * @param string $function
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return static
+	 */
+	protected function whereFunctionCallJsonHandler($column, $nodes, $function, $operator, $value): self
+	{
+		// Handle potential raw values.
+		if ($column instanceof Raw) {
+			$column = $this->adapterInstance->parseRaw($column);
+		}
+		if ($nodes instanceof Raw) {
+			$nodes = $this->adapterInstance->parseRaw($nodes);
+		}
+
+		return $this->whereFunctionCallHandler(
+			$this->jsonHandler->jsonExpressionFactory()->extractAndUnquote($column, $nodes),
+			$function,
+			$operator,
+			$value
+		);
+	}
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @param string $joiner
+	 * @return static
+	 */
+	protected function whereJsonHandler($column, $nodes, $operator = null, $value = null, string $joiner = 'AND'): self
+	{
+		// Handle potential raw values.
+		if ($column instanceof Raw) {
+			$column = $this->adapterInstance->parseRaw($column);
+		}
+		if ($nodes instanceof Raw) {
+			$nodes = $this->adapterInstance->parseRaw($nodes);
+		}
+
+		return $this->whereHandler(
+			$this->jsonHandler->jsonExpressionFactory()->extractAndUnquote($column, $nodes),
+			$operator,
+			$value,
+			$joiner
+		);
+	}
+
+	/**
+	 * @param string|Raw $table
+	 * @param string|Raw $leftColumn
+	 * @param string|Raw|string[]|null $leftNodes The json key/index to search
+	 * @param string $operator
+	 * @param string|Raw $rightColumn
+	 * @param string|Raw|string[]|null $rightNodes
+	 * @param string $type
+	 *
+	 * @return static
+	 */
+	public function joinJson(
+		$table,
+		$leftColumn,
+		$leftNodes,
+		string $operator,
+		$rightColumn,
+		$rightNodes,
+		$type = 'inner'
+	): self {
+		// Convert key if json
+		if (null !== $rightNodes) {
+			$rightColumn = $this->jsonHandler->jsonExpressionFactory()->extractAndUnquote($rightColumn, $rightNodes);
+		}
+
+		// Convert key if json
+		if (null !== $leftNodes) {
+			$leftColumn = $this->jsonHandler->jsonExpressionFactory()->extractAndUnquote($leftColumn, $leftNodes);
+		}
+
+		return $this->join($table, $leftColumn, $operator, $rightColumn, $type);
+	}
+
+	/**
+	 * @param string|Raw $table
+	 * @param string|Raw $leftColumn
+	 * @param string|Raw|string[]|null $leftNodes The json key/index to search
+	 * @param string $operator
+	 * @param string|Raw $rightColumn
+	 * @param string|Raw|string[]|null $rightNodes
+	 *
+	 * @return static
+	 */
+	public function leftJoinJson(
+		$table,
+		$leftColumn,
+		$leftNodes,
+		string $operator,
+		$rightColumn,
+		$rightNodes
+	): self {
+		return $this->joinJson(
+			$table,
+			$leftColumn,
+			$leftNodes,
+			$operator,
+			$rightColumn,
+			$rightNodes,
+			'left'
+		);
+	}
+
+	/**
+	 * @param string|Raw $table
+	 * @param string|Raw $leftColumn
+	 * @param string|Raw|string[]|null $leftNodes The json key/index to search
+	 * @param string $operator
+	 * @param string|Raw $rightColumn
+	 * @param string|Raw|string[]|null $rightNodes
+	 *
+	 * @return static
+	 */
+	public function rightJoinJson(
+		$table,
+		$leftColumn,
+		$leftNodes,
+		string $operator,
+		$rightColumn,
+		$rightNodes
+	): self {
+		return $this->joinJson(
+			$table,
+			$leftColumn,
+			$leftNodes,
+			$operator,
+			$rightColumn,
+			$rightNodes,
+			'right'
+		);
+	}
+
+	/**
+	 * @param string|Raw $table
+	 * @param string|Raw $leftColumn
+	 * @param string|Raw|string[]|null $leftNodes The json key/index to search
+	 * @param string $operator
+	 * @param string|Raw $rightColumn
+	 * @param string|Raw|string[]|null $rightNodes
+	 *
+	 * @return static
+	 */
+	public function outerJoinJson(
+		$table,
+		$leftColumn,
+		$leftNodes,
+		string $operator,
+		$rightColumn,
+		$rightNodes
+	): self {
+		return $this->joinJson(
+			$table,
+			$leftColumn,
+			$leftNodes,
+			$operator,
+			$rightColumn,
+			$rightNodes,
+			'FULL OUTER'
+		);
+	}
+
+	/**
+	 * @param string|Raw $table
+	 * @param string|Raw $leftColumn
+	 * @param string|Raw|string[]|null $leftNodes The json key/index to search
+	 * @param string $operator
+	 * @param string|Raw $rightColumn
+	 * @param string|Raw|string[]|null $rightNodes
+	 *
+	 * @return static
+	 */
+	public function crossJoinJson(
+		$table,
+		$leftColumn,
+		$leftNodes,
+		string $operator,
+		$rightColumn,
+		$rightNodes
+	): self {
+		return $this->joinJson(
+			$table,
+			$leftColumn,
+			$leftNodes,
+			$operator,
+			$rightColumn,
+			$rightNodes,
+			'cross'
+		);
+	}
+
+
+
+	// JSON
+
+	/**
+	 * @param string|Raw $column The database column which holds the JSON value
+	 * @param string|Raw|string[] $nodes The json key/index to search
+	 * @param string|null $alias The alias used to define the value in results, if not defined will use json_{$nodes}
+	 * @return static
+	 */
+	public function selectJson($column, $nodes, ?string $alias = null): self
+	{
+		// Handle potential raw values.
+		if ($column instanceof Raw) {
+			$column = $this->adapterInstance->parseRaw($column);
+		}
+		if ($nodes instanceof Raw) {
+			$nodes = $this->adapterInstance->parseRaw($nodes);
+		}
+
+		// If deeply nested jsonKey.
+		if (is_array($nodes)) {
+			$nodes = \implode('.', $nodes);
+		}
+
+		// Add any possible prefixes to the key
+		$column = $this->addTablePrefix($column, true);
+
+		$alias = null === $alias ? "json_{$nodes}" : $alias;
+		return  $this->select(new Raw("JSON_UNQUOTE(JSON_EXTRACT({$column}, \"$.{$nodes}\")) as {$alias}"));
+	}
 }

src/QueryBuilder/QueryBuilderHandler.php

Indentation +1494 added lines, -1494 removed lines

@@ -24,1498 +24,1498 @@
 
 class QueryBuilderHandler implements HasConnection
 {
-    /**
-     * @method add
-     */
-    use TablePrefixer;
-
-    /**
-     * @var \Viocon\Container
-     */
-    protected $container;
-
-    /**
-     * @var Connection
-     */
-    protected $connection;
-
-    /**
-     * @var array<string, mixed[]|mixed>
-     */
-    protected $statements = [];
-
-    /**
-     * @var wpdb
-     */
-    protected $dbInstance;
-
-    /**
-     * @var string|string[]|null
-     */
-    protected $sqlStatement = null;
-
-    /**
-     * @var string|null
-     */
-    protected $tablePrefix = null;
-
-    /**
-     * @var WPDBAdapter
-     */
-    protected $adapterInstance;
-
-    /**
-     * The mode to return results as.
-     * Accepts WPDB constants or class names.
-     *
-     * @var string
-     */
-    protected $fetchMode;
-
-    /**
-     * Custom args used to construct models for hydrator
-     *
-     * @var array<int, mixed>|null
-     */
-    protected $hydratorConstructorArgs;
-
-    /**
-     * Handler for Json Selectors
-     *
-     * @var JsonHandler
-     */
-    protected $jsonHandler;
-
-    /**
-     * @param \Pixie\Connection|null $connection
-     * @param string $fetchMode
-     * @param mixed[] $hydratorConstructorArgs
-     *
-     * @throws Exception if no connection passed and not previously established
-     */
-    final public function __construct(
-        Connection $connection = null,
-        string $fetchMode = \OBJECT,
-        ?array $hydratorConstructorArgs = null
-    ) {
-        if (is_null($connection)) {
-            // throws if connection not already established.
-            $connection = Connection::getStoredConnection();
-        }
-
-        // Set all dependencies from connection.
-        $this->connection = $connection;
-        $this->container  = $this->connection->getContainer();
-        $this->dbInstance = $this->connection->getDbInstance();
-        $this->setAdapterConfig($this->connection->getAdapterConfig());
-
-        // Set up optional hydration details.
-        $this->setFetchMode($fetchMode);
-        $this->hydratorConstructorArgs = $hydratorConstructorArgs;
-
-        // Query builder adapter instance
-        $this->adapterInstance = $this->container->build(
-            WPDBAdapter::class,
-            [$this->connection]
-        );
-
-        // Setup JSON Selector handler.
-        $this->jsonHandler = new JsonHandler($connection);
-    }
-
-    /**
-     * Sets the config for WPDB
-     *
-     * @param array<string, mixed> $adapterConfig
-     *
-     * @return void
-     */
-    protected function setAdapterConfig(array $adapterConfig): void
-    {
-        if (isset($adapterConfig[Connection::PREFIX])) {
-            $this->tablePrefix = $adapterConfig[Connection::PREFIX];
-        }
-    }
-
-    /**
-     * Fetch query results as object of specified type
-     *
-     * @param string $className
-     * @param array<int, mixed> $constructorArgs
-     * @return static
-     */
-    public function asObject($className, $constructorArgs = array()): self
-    {
-        return $this->setFetchMode($className, $constructorArgs);
-    }
-
-    /**
-     * Set the fetch mode
-     *
-     * @param string $mode
-     * @param array<int, mixed>|null $constructorArgs
-     *
-     * @return static
-     */
-    public function setFetchMode(string $mode, ?array $constructorArgs = null): self
-    {
-        $this->fetchMode               = $mode;
-        $this->hydratorConstructorArgs = $constructorArgs;
-
-        return $this;
-    }
-
-    /**
-     * @param Connection|null $connection
-     *
-     * @return static
-     *
-     * @throws Exception
-     */
-    public function newQuery(Connection $connection = null): self
-    {
-        if (is_null($connection)) {
-            $connection = $this->connection;
-        }
-
-        $newQuery = $this->constructCurrentBuilderClass($connection);
-        $newQuery->setFetchMode($this->getFetchMode(), $this->hydratorConstructorArgs);
-
-        return $newQuery;
-    }
-
-    /**
-     * Returns a new instance of the current, with the passed connection.
-     *
-     * @param \Pixie\Connection $connection
-     *
-     * @return static
-     */
-    protected function constructCurrentBuilderClass(Connection $connection): self
-    {
-        return new static($connection);
-    }
-
-    /**
-     * Interpolates a query
-     *
-     * @param string $query
-     * @param array<mixed> $bindings
-     * @return string
-     */
-    public function interpolateQuery(string $query, array $bindings = []): string
-    {
-        return $this->adapterInstance->interpolateQuery($query, $bindings);
-    }
-
-    /**
-     * @param string           $sql
-     * @param array<int,mixed> $bindings
-     *
-     * @return static
-     */
-    public function query($sql, $bindings = []): self
-    {
-        list($this->sqlStatement) = $this->statement($sql, $bindings);
-
-        return $this;
-    }
-
-    /**
-     * @param string           $sql
-     * @param array<int,mixed> $bindings
-     *
-     * @return array{0:string, 1:float}
-     */
-    public function statement(string $sql, $bindings = []): array
-    {
-        $start        = microtime(true);
-        $sqlStatement = empty($bindings) ? $sql : $this->interpolateQuery($sql, $bindings);
-
-        if (!is_string($sqlStatement)) {
-            throw new Exception('Could not interpolate query', 1);
-        }
-
-        return [$sqlStatement, microtime(true) - $start];
-    }
-
-    /**
-     * Get all rows
-     *
-     * @return array<mixed,mixed>|null
-     *
-     * @throws Exception
-     */
-    public function get()
-    {
-        $eventResult = $this->fireEvents('before-select');
-        if (!is_null($eventResult)) {
-            return $eventResult;
-        }
-        $executionTime = 0;
-        if (is_null($this->sqlStatement)) {
-            $queryObject = $this->getQuery('select');
-            $statement   = $this->statement(
-                $queryObject->getSql(),
-                $queryObject->getBindings()
-            );
-
-            $this->sqlStatement = $statement[0];
-            $executionTime      = $statement[1];
-        }
-
-        $start  = microtime(true);
-        $result = $this->dbInstance()->get_results(
-            is_array($this->sqlStatement) ? (end($this->sqlStatement) ?: '') : $this->sqlStatement,
-            // If we are using the hydrator, return as OBJECT and let the hydrator map the correct model.
-            $this->useHydrator() ? OBJECT : $this->getFetchMode()
-        );
-        $executionTime += microtime(true) - $start;
-        $this->sqlStatement = null;
-
-        // Ensure we have an array of results.
-        if (!is_array($result) && null !== $result) {
-            $result = [$result];
-        }
-
-        // Maybe hydrate the results.
-        if (null !== $result && $this->useHydrator()) {
-            $result = $this->getHydrator()->fromMany($result);
-        }
-
-        $this->fireEvents('after-select', $result, $executionTime);
-
-        return $result;
-    }
-
-    /**
-     * Returns a populated instance of the Hydrator.
-     *
-     * @return Hydrator
-     */
-    protected function getHydrator(): Hydrator /* @phpstan-ignore-line */
-    {
-        $hydrator = new Hydrator($this->getFetchMode(), $this->hydratorConstructorArgs ?? []); /* @phpstan-ignore-line */
-
-        return $hydrator;
-    }
-
-    /**
-     * Checks if the results should be mapped via the hydrator
-     *
-     * @return bool
-     */
-    protected function useHydrator(): bool
-    {
-        return !in_array($this->getFetchMode(), [\ARRAY_A, \ARRAY_N, \OBJECT, \OBJECT_K]);
-    }
-
-    /**
-     * Find all matching a simple where condition.
-     *
-     * Shortcut of ->where('key','=','value')->limit(1)->get();
-     *
-     * @return \stdClass\array<mixed,mixed>|object|null Can return any object using hydrator
-     */
-    public function first()
-    {
-        $this->limit(1);
-        $result = $this->get();
-
-        return empty($result) ? null : $result[0];
-    }
-
-    /**
-     * Find all matching a simple where condition.
-     *
-     * Shortcut of ->where('key','=','value')->get();
-     *
-     * @param string $fieldName
-     * @param mixed $value
-     *
-     * @return array<mixed,mixed>|null Can return any object using hydrator
-     */
-    public function findAll($fieldName, $value)
-    {
-        $this->where($fieldName, '=', $value);
-
-        return $this->get();
-    }
-
-    /**
-     * @param string $fieldName
-     * @param mixed $value
-     *
-     * @return \stdClass\array<mixed,mixed>|object|null Can return any object using hydrator
-     */
-    public function find($value, $fieldName = 'id')
-    {
-        $this->where($fieldName, '=', $value);
-
-        return $this->first();
-    }
-
-    /**
-     * @param string $fieldName
-     * @param mixed $value
-     *
-     * @return \stdClass\array<mixed,mixed>|object Can return any object using hydrator
-     * @throws Exception If fails to find
-     */
-    public function findOrFail($value, $fieldName = 'id')
-    {
-        $result = $this->find($value, $fieldName);
-        if (null === $result) {
-            throw new Exception("Failed to find {$fieldName}={$value}", 1);
-        }
-        return $result;
-    }
-
-    /**
-     * Used to handle all aggregation method.
-     *
-     * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
-     *
-     * @param string $type
-     * @param string|Raw $field
-     *
-     * @return float
-     */
-    protected function aggregate(string $type, $field = '*'): float
-    {
-        // Parse a raw expression.
-        if ($field instanceof Raw) {
-            $field = $this->adapterInstance->parseRaw($field);
-        }
-
-        // Potentialy cast field from JSON
-        if ($this->jsonHandler->isJsonSelector($field)) {
-            $field = $this->jsonHandler->extractAndUnquoteFromJsonSelector($field);
-        }
-
-        // Verify that field exists
-        if ('*' !== $field && true === isset($this->statements['selects']) && false === \in_array($field, $this->statements['selects'], true)) {
-            throw new \Exception(sprintf('Failed %s query - the column %s hasn\'t been selected in the query.', $type, $field));
-        }
-
-
-        if (false === isset($this->statements['tables'])) {
-            throw new Exception('No table selected');
-        }
-
-        $count = $this
-            ->table($this->subQuery($this, 'count'))
-            ->select([$this->raw(sprintf('%s(%s) AS field', strtoupper($type), $field))])
-            ->first();
-
-        return true === isset($count->field) ? (float)$count->field : 0;
-    }
-
-    /**
-     * Get count of all the rows for the current query
-     *
-     * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
-     *
-     * @param string|Raw $field
-     *
-     * @return int
-     *
-     * @throws Exception
-     */
-    public function count($field = '*'): int
-    {
-        return (int)$this->aggregate('count', $field);
-    }
-
-    /**
-     * Get the sum for a field in the current query
-     *
-     * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
-     *
-     * @param string|Raw $field
-     *
-     * @return float
-     *
-     * @throws Exception
-     */
-    public function sum($field): float
-    {
-        return $this->aggregate('sum', $field);
-    }
-
-    /**
-     * Get the average for a field in the current query
-     *
-     * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
-     *
-     * @param string|Raw $field
-     *
-     * @return float
-     *
-     * @throws Exception
-     */
-    public function average($field): float
-    {
-        return $this->aggregate('avg', $field);
-    }
-
-    /**
-     * Get the minimum for a field in the current query
-     *
-     * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
-     *
-     * @param string|Raw $field
-     *
-     * @return float
-     *
-     * @throws Exception
-     */
-    public function min($field): float
-    {
-        return $this->aggregate('min', $field);
-    }
-
-    /**
-     * Get the maximum for a field in the current query
-     *
-     * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
-     *
-     * @param string|Raw $field
-     *
-     * @return float
-     *
-     * @throws Exception
-     */
-    public function max($field): float
-    {
-        return $this->aggregate('max', $field);
-    }
-
-    /**
-     * @param string $type
-     * @param bool|array<mixed, mixed> $dataToBePassed
-     *
-     * @return mixed
-     *
-     * @throws Exception
-     */
-    public function getQuery(string $type = 'select', $dataToBePassed = [])
-    {
-        $allowedTypes = ['select', 'insert', 'insertignore', 'replace', 'delete', 'update', 'criteriaonly'];
-        if (!in_array(strtolower($type), $allowedTypes)) {
-            throw new Exception($type . ' is not a known type.', 2);
-        }
-
-        $queryArr = $this->adapterInstance->$type($this->statements, $dataToBePassed);
-
-        return $this->container->build(
-            QueryObject::class,
-            [$queryArr['sql'], $queryArr['bindings'], $this->dbInstance]
-        );
-    }
-
-    /**
-     * @param QueryBuilderHandler $queryBuilder
-     * @param string|null $alias
-     *
-     * @return Raw
-     */
-    public function subQuery(QueryBuilderHandler $queryBuilder, ?string $alias = null)
-    {
-        $sql = '(' . $queryBuilder->getQuery()->getRawSql() . ')';
-        if (is_string($alias) && 0 !== mb_strlen($alias)) {
-            $sql = $sql . ' as ' . $alias;
-        }
-
-        return $queryBuilder->raw($sql);
-    }
-
-    /**
-     * Handles the various insert operations based on the type.
-     *
-     * @param array<int|string, mixed|mixed[]> $data
-     * @param string $type
-     *
-     * @return int|int[]|mixed|null can return a single row id, array of row ids, null (for failed) or any other value short circuited from event
-     */
-    private function doInsert(array $data, string $type)
-    {
-        $eventResult = $this->fireEvents('before-insert');
-        if (!is_null($eventResult)) {
-            return $eventResult;
-        }
-
-        // If first value is not an array () not a batch insert)
-        if (!is_array(current($data))) {
-            $queryObject = $this->getQuery($type, $data);
-
-            list($preparedQuery, $executionTime) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
-            $this->dbInstance->get_results($preparedQuery);
-
-            // Check we have a result.
-            $return = 1 === $this->dbInstance->rows_affected ? $this->dbInstance->insert_id : null;
-        } else {
-            // Its a batch insert
-            $return        = [];
-            $executionTime = 0;
-            foreach ($data as $subData) {
-                $queryObject = $this->getQuery($type, $subData);
-
-                list($preparedQuery, $time) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
-                $this->dbInstance->get_results($preparedQuery);
-                $executionTime += $time;
-
-                if (1 === $this->dbInstance->rows_affected) {
-                    $return[] = $this->dbInstance->insert_id;
-                }
-            }
-        }
-
-        $this->fireEvents('after-insert', $return, $executionTime);
-
-        return $return;
-    }
-
-    /**
-     * @param array<int|string, mixed|mixed[]> $data either key=>value array for single or array of arrays for bulk
-     *
-     * @return int|int[]|mixed|null can return a single row id, array of row ids, null (for failed) or any other value short circuited from event
-     */
-    public function insert($data)
-    {
-        return $this->doInsert($data, 'insert');
-    }
-
-    /**
-     *
-     * @param array<int|string, mixed|mixed[]> $data either key=>value array for single or array of arrays for bulk
-     *
-     * @return int|int[]|mixed|null can return a single row id, array of row ids, null (for failed) or any other value short circuited from event
-     */
-    public function insertIgnore($data)
-    {
-        return $this->doInsert($data, 'insertignore');
-    }
-
-    /**
-     *
-     * @param array<int|string, mixed|mixed[]> $data either key=>value array for single or array of arrays for bulk
-     *
-     * @return int|int[]|mixed|null can return a single row id, array of row ids, null (for failed) or any other value short circuited from event
-     */
-    public function replace($data)
-    {
-        return $this->doInsert($data, 'replace');
-    }
-
-    /**
-     * @param array<string, mixed> $data
-     *
-     * @return int|null
-     */
-    public function update($data)
-    {
-        $eventResult = $this->fireEvents('before-update');
-        if (!is_null($eventResult)) {
-            return $eventResult;
-        }
-        $queryObject                         = $this->getQuery('update', $data);
-        $r = $this->statement($queryObject->getSql(), $queryObject->getBindings());
-        list($preparedQuery, $executionTime) = $r;
-        $this->dbInstance()->get_results($preparedQuery);
-        $this->fireEvents('after-update', $queryObject, $executionTime);
-
-        return 0 !== $this->dbInstance()->rows_affected
-            ? $this->dbInstance()->rows_affected
-            : null;
-    }
-
-    /**
-     * @param array<string, mixed> $data
-     *
-     * @return int|null will return row id for insert and bool for success/fail on update
-     */
-    public function updateOrInsert($data)
-    {
-        if ($this->first()) {
-            return $this->update($data);
-        }
-
-        return $this->insert($data);
-    }
-
-    /**
-     * @param array<string, mixed> $data
-     *
-     * @return static
-     */
-    public function onDuplicateKeyUpdate($data)
-    {
-        $this->addStatement('onduplicate', $data);
-
-        return $this;
-    }
-
-    /**
-     * @return mixed number of rows effected or shortcircuited response
-     */
-    public function delete()
-    {
-        $eventResult = $this->fireEvents('before-delete');
-        if (!is_null($eventResult)) {
-            return $eventResult;
-        }
-
-        $queryObject = $this->getQuery('delete');
-
-        list($preparedQuery, $executionTime) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
-        $this->dbInstance()->get_results($preparedQuery);
-        $this->fireEvents('after-delete', $queryObject, $executionTime);
-
-        return $this->dbInstance()->rows_affected;
-    }
-
-    /**
-     * @param string|Raw ...$tables Single table or array of tables
-     *
-     * @return static
-     *
-     * @throws Exception
-     */
-    public function table(...$tables)
-    {
-        $instance =  $this->constructCurrentBuilderClass($this->connection);
-        $this->setFetchMode($this->getFetchMode(), $this->hydratorConstructorArgs);
-        $tables = $this->addTablePrefix($tables, false);
-        $instance->addStatement('tables', $tables);
-
-        return $instance;
-    }
-
-    /**
-     * @param string|Raw ...$tables Single table or array of tables
-     *
-     * @return static
-     */
-    public function from(...$tables): self
-    {
-        $tables = $this->addTablePrefix($tables, false);
-        $this->addStatement('tables', $tables);
-
-        return $this;
-    }
-
-    /**
-     * @param string|string[]|Raw[]|array<string, string> $fields
-     *
-     * @return static
-     */
-    public function select($fields): self
-    {
-        if (!is_array($fields)) {
-            $fields = func_get_args();
-        }
-
-        foreach ($fields as $field => $alias) {
-            // If we have a JSON expression
-            if ($this->jsonHandler->isJsonSelector($field)) {
-                $field = $this->jsonHandler->extractAndUnquoteFromJsonSelector($field);
-            }
-
-            // If no alias passed, but field is for JSON. thrown an exception.
-            if (is_numeric($field) && is_string($alias) && $this->jsonHandler->isJsonSelector($alias)) {
-                throw new Exception("An alias must be used if you wish to select from JSON Object", 1);
-            }
-
-            // Treat each array as a single table, to retain order added
-            $field = is_numeric($field)
-                ? $field = $alias // If single colum
-                : $field = [$field => $alias]; // Has alias
-
-            $field = $this->addTablePrefix($field);
-            $this->addStatement('selects', $field);
-        }
-
-        return $this;
-    }
-
-    /**
-     * @param string|string[]|Raw[]|array<string, string> $fields
-     *
-     * @return static
-     */
-    public function selectDistinct($fields)
-    {
-        $this->select($fields);
-        $this->addStatement('distinct', true);
-
-        return $this;
-    }
-
-    /**
-     * @param string|string[] $field either the single field or an array of fields
-     *
-     * @return static
-     */
-    public function groupBy($field): self
-    {
-        $field = $this->addTablePrefix($field);
-        $this->addStatement('groupBys', $field);
-
-        return $this;
-    }
-
-    /**
-     * @param string|array<string|int, mixed> $fields
-     * @param string          $defaultDirection
-     *
-     * @return static
-     */
-    public function orderBy($fields, string $defaultDirection = 'ASC'): self
-    {
-        if (!is_array($fields)) {
-            $fields = [$fields];
-        }
-
-        foreach ($fields as $key => $value) {
-            $field = $key;
-            $type  = $value;
-            if (is_int($key)) {
-                $field = $value;
-                $type  = $defaultDirection;
-            }
-
-            if ($this->jsonHandler->isJsonSelector($field)) {
-                $field = $this->jsonHandler->extractAndUnquoteFromJsonSelector($field);
-            }
-
-            if (!$field instanceof Raw) {
-                $field = $this->addTablePrefix($field);
-            }
-            $this->statements['orderBys'][] = compact('field', 'type');
-        }
-
-        return $this;
-    }
-
-    /**
-     * @param string|Raw $key The database column which holds the JSON value
-     * @param string|Raw|string[] $jsonKey The json key/index to search
-     * @param string $defaultDirection
-     * @return static
-     */
-    public function orderByJson($key, $jsonKey, string $defaultDirection = 'ASC'): self
-    {
-        $key = $this->jsonHandler->jsonExpressionFactory()->extractAndUnquote($key, $jsonKey);
-        return $this->orderBy($key, $defaultDirection);
-    }
-
-    /**
-     * @param int $limit
-     *
-     * @return static
-     */
-    public function limit(int $limit): self
-    {
-        $this->statements['limit'] = $limit;
-
-        return $this;
-    }
-
-    /**
-     * @param int $offset
-     *
-     * @return static
-     */
-    public function offset(int $offset): self
-    {
-        $this->statements['offset'] = $offset;
-
-        return $this;
-    }
-
-    /**
-     * @param string|string[]|Raw|Raw[]       $key
-     * @param string $operator
-     * @param mixed $value
-     * @param string $joiner
-     *
-     * @return static
-     */
-    public function having($key, string $operator, $value, string $joiner = 'AND')
-    {
-        $key                           = $this->addTablePrefix($key);
-        $this->statements['havings'][] = compact('key', 'operator', 'value', 'joiner');
-
-        return $this;
-    }
-
-    /**
-     * @param string|string[]|Raw|Raw[]       $key
-     * @param string $operator
-     * @param mixed $value
-     *
-     * @return static
-     */
-    public function orHaving($key, $operator, $value)
-    {
-        return $this->having($key, $operator, $value, 'OR');
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-     * @param mixed|null $value
-     *
-     * @return static
-     */
-    public function where($key, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (2 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-
-        return $this->whereHandler($key, $operator, $value);
-    }
-
-    /**
-     * @param string|Raw|\Closure(QueryBuilderHandler):void $key
-     * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-     * @param mixed|null $value
-     *
-     * @return static
-     */
-    public function orWhere($key, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (2 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-
-        return $this->whereHandler($key, $operator, $value, 'OR');
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-     * @param mixed|null $value
-     *
-     * @return static
-     */
-    public function whereNot($key, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (2 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-
-        return $this->whereHandler($key, $operator, $value, 'AND NOT');
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-     * @param mixed|null $value
-     *
-     * @return static
-     */
-    public function orWhereNot($key, $operator = null, $value = null)
-    {
-        // If two params are given then assume operator is =
-        if (2 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-
-        return $this->whereHandler($key, $operator, $value, 'OR NOT');
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param mixed[]|string|Raw $values
-     *
-     * @return static
-     */
-    public function whereIn($key, $values): self
-    {
-        return $this->whereHandler($key, 'IN', $values, 'AND');
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param mixed[]|string|Raw $values
-     *
-     * @return static
-     */
-    public function whereNotIn($key, $values): self
-    {
-        return $this->whereHandler($key, 'NOT IN', $values, 'AND');
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param mixed[]|string|Raw $values
-     *
-     * @return static
-     */
-    public function orWhereIn($key, $values): self
-    {
-        return $this->whereHandler($key, 'IN', $values, 'OR');
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param mixed[]|string|Raw $values
-     *
-     * @return static
-     */
-    public function orWhereNotIn($key, $values): self
-    {
-        return $this->whereHandler($key, 'NOT IN', $values, 'OR');
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param mixed $valueFrom
-     * @param mixed $valueTo
-     *
-     * @return static
-     */
-    public function whereBetween($key, $valueFrom, $valueTo): self
-    {
-        return $this->whereHandler($key, 'BETWEEN', [$valueFrom, $valueTo], 'AND');
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param mixed $valueFrom
-     * @param mixed $valueTo
-     *
-     * @return static
-     */
-    public function orWhereBetween($key, $valueFrom, $valueTo): self
-    {
-        return $this->whereHandler($key, 'BETWEEN', [$valueFrom, $valueTo], 'OR');
-    }
-
-    /**
-     * Handles all function call based where conditions
-     *
-     * @param string|Raw $key
-     * @param string $function
-     * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-     * @param mixed|null $value
-     * @return static
-     */
-    protected function whereFunctionCallHandler($key, $function, $operator, $value): self
-    {
-        $key = \sprintf('%s(%s)', $function, $this->addTablePrefix($key));
-        return $this->where($key, $operator, $value);
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-     * @param mixed|null $value
-     * @return self
-     */
-    public function whereMonth($key, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (2 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-        return $this->whereFunctionCallHandler($key, 'MONTH', $operator, $value);
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-     * @param mixed|null $value
-     * @return self
-     */
-    public function whereDay($key, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (2 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-        return $this->whereFunctionCallHandler($key, 'DAY', $operator, $value);
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-     * @param mixed|null $value
-     * @return self
-     */
-    public function whereYear($key, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (2 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-        return $this->whereFunctionCallHandler($key, 'YEAR', $operator, $value);
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
-     * @param mixed|null $value
-     * @return self
-     */
-    public function whereDate($key, $operator = null, $value = null): self
-    {
-        // If two params are given then assume operator is =
-        if (2 === func_num_args()) {
-            $value    = $operator;
-            $operator = '=';
-        }
-        return $this->whereFunctionCallHandler($key, 'DATE', $operator, $value);
-    }
-
-    /**
-     * @param string|Raw $key
-     *
-     * @return static
-     */
-    public function whereNull($key): self
-    {
-        return $this->whereNullHandler($key);
-    }
-
-    /**
-     * @param string|Raw $key
-     *
-     * @return static
-     */
-    public function whereNotNull($key): self
-    {
-        return $this->whereNullHandler($key, 'NOT');
-    }
-
-    /**
-     * @param string|Raw $key
-     *
-     * @return static
-     */
-    public function orWhereNull($key): self
-    {
-        return $this->whereNullHandler($key, '', 'or');
-    }
-
-    /**
-     * @param string|Raw $key
-     *
-     * @return static
-     */
-    public function orWhereNotNull($key): self
-    {
-        return $this->whereNullHandler($key, 'NOT', 'or');
-    }
-
-    /**
-     * @param string|Raw $key
-     * @param string $prefix
-     * @param string $operator
-     *
-     * @return static
-     */
-    protected function whereNullHandler($key, string $prefix = '', $operator = ''): self
-    {
-        $prefix = 0 === mb_strlen($prefix) ? '' : " {$prefix}";
-
-        if ($key instanceof Raw) {
-            $key = $this->adapterInstance->parseRaw($key);
-        }
-
-        $key = $this->addTablePrefix($key);
-        if ($key instanceof Closure) {
-            throw new Exception('Key used for whereNull condition must be a string or raw exrpession.', 1);
-        }
-
-        return $this->{$operator . 'Where'}($this->raw("{$key} IS{$prefix} NULL"));
-    }
-
-
-    /**
-     * Runs a transaction
-     *
-     * @param \Closure(Transaction):void $callback
-     *
-     * @return static
-     */
-    public function transaction(Closure $callback): self
-    {
-        try {
-            // Begin the transaction
-            $this->dbInstance->query('START TRANSACTION');
-
-            // Get the Transaction class
-            $transaction = $this->container->build(Transaction::class, [$this->connection]);
-
-            $this->handleTransactionCall($callback, $transaction);
-
-            // If no errors have been thrown or the transaction wasn't completed within
-            $this->dbInstance->query('COMMIT');
-
-            return $this;
-        } catch (TransactionHaltException $e) {
-            // Commit or rollback behavior has been handled in the closure, so exit
-            return $this;
-        } catch (\Exception $e) {
-            // something happened, rollback changes
-            $this->dbInstance->query('ROLLBACK');
-
-            return $this;
-        }
-    }
-
-    /**
-     * Handles the transaction call.
-     * Catches any WPDB Errors (printed)
-     *
-     * @param Closure    $callback
-     * @param Transaction $transaction
-     *
-     * @return void
-     * @throws Exception
-     */
-    protected function handleTransactionCall(Closure $callback, Transaction $transaction): void
-    {
-        try {
-            ob_start();
-            $callback($transaction);
-            $output = ob_get_clean() ?: '';
-        } catch (Throwable $th) {
-            ob_end_clean();
-            throw $th;
-        }
-
-        // If we caught an error, throw an exception.
-        if (0 !== mb_strlen($output)) {
-            throw new Exception($output);
-        }
-    }
-
-    /*************************************************************************/
-    /*************************************************************************/
-    /*************************************************************************/
-    /**                              JOIN JOIN                              **/
-    /**                                 JOIN                                **/
-    /**                              JOIN JOIN                              **/
-    /*************************************************************************/
-    /*************************************************************************/
-    /*************************************************************************/
-
-    /**
-     * @param string|Raw $table
-     * @param string|Raw|Closure $key
-     * @param string|null $operator
-     * @param mixed $value
-     * @param string $type
-     *
-     * @return static
-     */
-    public function join($table, $key, ?string $operator = null, $value = null, $type = 'inner')
-    {
-        // Potentially cast key from JSON
-        if ($this->jsonHandler->isJsonSelector($key)) {
-            /** @var string $key */
-            $key = $this->jsonHandler->extractAndUnquoteFromJsonSelector($key); /** @phpstan-ignore-line */
-        }
-
-        // Potentially cast value from json
-        if ($this->jsonHandler->isJsonSelector($value)) {
-            /** @var string $value */
-            $value = $this->jsonHandler->extractAndUnquoteFromJsonSelector($value);
-        }
-
-        if (!$key instanceof Closure) {
-            $key = function ($joinBuilder) use ($key, $operator, $value) {
-                $joinBuilder->on($key, $operator, $value);
-            };
-        }
-
-        // Build a new JoinBuilder class, keep it by reference so any changes made
-        // in the closure should reflect here
-        $joinBuilder = $this->container->build(JoinBuilder::class, [$this->connection]);
-        $joinBuilder = &$joinBuilder;
-        // Call the closure with our new joinBuilder object
-        $key($joinBuilder);
-        $table = $this->addTablePrefix($table, false);
-        // Get the criteria only query from the joinBuilder object
-        $this->statements['joins'][] = compact('type', 'table', 'joinBuilder');
-        return $this;
-    }
-
-    /**
-     * @param string|Raw $table
-     * @param string|Raw|Closure $key
-     * @param string|null $operator
-     * @param mixed $value
-     *
-     * @return static
-     */
-    public function leftJoin($table, $key, $operator = null, $value = null)
-    {
-        return $this->join($table, $key, $operator, $value, 'left');
-    }
-
-    /**
-     * @param string|Raw $table
-     * @param string|Raw|Closure $key
-     * @param string|null $operator
-     * @param mixed $value
-     *
-     * @return static
-     */
-    public function rightJoin($table, $key, $operator = null, $value = null)
-    {
-        return $this->join($table, $key, $operator, $value, 'right');
-    }
-
-    /**
-     * @param string|Raw $table
-     * @param string|Raw|Closure $key
-     * @param string|null $operator
-     * @param mixed $value
-     *
-     * @return static
-     */
-    public function innerJoin($table, $key, $operator = null, $value = null)
-    {
-        return $this->join($table, $key, $operator, $value, 'inner');
-    }
-
-    /**
-     * @param string|Raw $table
-     * @param string|Raw|Closure $key
-     * @param string|null $operator
-     * @param mixed $value
-     *
-     * @return static
-     */
-    public function crossJoin($table, $key, $operator = null, $value = null)
-    {
-        return $this->join($table, $key, $operator, $value, 'cross');
-    }
-
-    /**
-     * @param string|Raw $table
-     * @param string|Raw|Closure $key
-     * @param string|null $operator
-     * @param mixed $value
-     *
-     * @return static
-     */
-    public function outerJoin($table, $key, $operator = null, $value = null)
-    {
-        return $this->join($table, $key, $operator, $value, 'full outer');
-    }
-
-    /**
-     * Shortcut to join 2 tables on the same key name with equals
-     *
-     * @param string $table
-     * @param string $key
-     * @param string $type
-     * @return self
-     * @throws Exception If base table is set as more than 1 or 0
-     */
-    public function joinUsing(string $table, string $key, string $type = 'INNER'): self
-    {
-        if (!array_key_exists('tables', $this->statements) || count($this->statements['tables']) !== 1) {
-            throw new Exception("JoinUsing can only be used with a single table set as the base of the query", 1);
-        }
-        $baseTable = end($this->statements['tables']);
-
-        // Potentialy cast key from JSON
-        if ($this->jsonHandler->isJsonSelector($key)) {
-            $key = $this->jsonHandler->extractAndUnquoteFromJsonSelector($key);
-        }
-
-        $remoteKey = $table = $this->addTablePrefix("{$table}.{$key}", true);
-        $localKey = $table = $this->addTablePrefix("{$baseTable}.{$key}", true);
-        return $this->join($table, $remoteKey, '=', $localKey, $type);
-    }
-
-    /**
-     * Add a raw query
-     *
-     * @param string|Raw $value
-     * @param mixed|mixed[] $bindings
-     *
-     * @return Raw
-     */
-    public function raw($value, $bindings = []): Raw
-    {
-        return new Raw($value, $bindings);
-    }
-
-    /**
-     * Return wpdb instance
-     *
-     * @return wpdb
-     */
-    public function dbInstance(): wpdb
-    {
-        return $this->dbInstance;
-    }
-
-    /**
-     * @param Connection $connection
-     *
-     * @return static
-     */
-    public function setConnection(Connection $connection): self
-    {
-        $this->connection = $connection;
-
-        return $this;
-    }
-
-    /**
-     * @return Connection
-     */
-    public function getConnection(): Connection
-    {
-        return $this->connection;
-    }
-
-    /**
-     * @param string|Raw|Closure $key
-     * @param string|null      $operator
-     * @param mixed|null       $value
-     * @param string $joiner
-     *
-     * @return static
-     */
-    protected function whereHandler($key, $operator = null, $value = null, $joiner = 'AND')
-    {
-        $key = $this->addTablePrefix($key);
-        if ($key instanceof Raw) {
-            $key = $this->adapterInstance->parseRaw($key);
-        }
-
-        if ($this->jsonHandler->isJsonSelector($key)) {
-            $key = $this->jsonHandler->extractAndUnquoteFromJsonSelector($key);
-        }
-
-        $this->statements['wheres'][] = compact('key', 'operator', 'value', 'joiner');
-        return $this;
-    }
-
-
-
-    /**
-     * @param string $key
-     * @param mixed|mixed[]|bool $value
-     *
-     * @return void
-     */
-    protected function addStatement($key, $value)
-    {
-        if (!is_array($value)) {
-            $value = [$value];
-        }
-
-        if (!array_key_exists($key, $this->statements)) {
-            $this->statements[$key] = $value;
-        } else {
-            $this->statements[$key] = array_merge($this->statements[$key], $value);
-        }
-    }
-
-    /**
-     * @param string $event
-     * @param string|Raw $table
-     *
-     * @return callable|null
-     */
-    public function getEvent(string $event, $table = ':any'): ?callable
-    {
-        return $this->connection->getEventHandler()->getEvent($event, $table);
-    }
-
-    /**
-     * @param string $event
-     * @param string|Raw $table
-     * @param Closure $action
-     *
-     * @return void
-     */
-    public function registerEvent($event, $table, Closure $action): void
-    {
-        $table = $table ?: ':any';
-
-        if (':any' != $table) {
-            $table = $this->addTablePrefix($table, false);
-        }
-
-        $this->connection->getEventHandler()->registerEvent($event, $table, $action);
-    }
-
-    /**
-     * @param string $event
-     * @param string|Raw $table
-     *
-     * @return void
-     */
-    public function removeEvent(string $event, $table = ':any')
-    {
-        if (':any' != $table) {
-            $table = $this->addTablePrefix($table, false);
-        }
-
-        $this->connection->getEventHandler()->removeEvent($event, $table);
-    }
-
-    /**
-     * @param string $event
-     *
-     * @return mixed
-     */
-    public function fireEvents(string $event)
-    {
-        $params = func_get_args(); // @todo Replace this with an easier to read alteratnive
-        array_unshift($params, $this);
-
-        return call_user_func_array([$this->connection->getEventHandler(), 'fireEvents'], $params);
-    }
-
-    /**
-     * @return array<string, mixed[]>
-     */
-    public function getStatements()
-    {
-        return $this->statements;
-    }
-
-    /**
-     * @return string will return WPDB Fetch mode
-     */
-    public function getFetchMode()
-    {
-        return null !== $this->fetchMode
-            ? $this->fetchMode
-            : \OBJECT;
-    }
-
-    /**
-     * Returns an NEW instance of the JSON builder populated with the same connection and hydrator details.
-     *
-     * @return JsonQueryBuilder
-     */
-    public function jsonBuilder(): JsonQueryBuilder
-    {
-        return new JsonQueryBuilder($this->getConnection(), $this->getFetchMode(), $this->hydratorConstructorArgs);
-    }
+	/**
+	 * @method add
+	 */
+	use TablePrefixer;
+
+	/**
+	 * @var \Viocon\Container
+	 */
+	protected $container;
+
+	/**
+	 * @var Connection
+	 */
+	protected $connection;
+
+	/**
+	 * @var array<string, mixed[]|mixed>
+	 */
+	protected $statements = [];
+
+	/**
+	 * @var wpdb
+	 */
+	protected $dbInstance;
+
+	/**
+	 * @var string|string[]|null
+	 */
+	protected $sqlStatement = null;
+
+	/**
+	 * @var string|null
+	 */
+	protected $tablePrefix = null;
+
+	/**
+	 * @var WPDBAdapter
+	 */
+	protected $adapterInstance;
+
+	/**
+	 * The mode to return results as.
+	 * Accepts WPDB constants or class names.
+	 *
+	 * @var string
+	 */
+	protected $fetchMode;
+
+	/**
+	 * Custom args used to construct models for hydrator
+	 *
+	 * @var array<int, mixed>|null
+	 */
+	protected $hydratorConstructorArgs;
+
+	/**
+	 * Handler for Json Selectors
+	 *
+	 * @var JsonHandler
+	 */
+	protected $jsonHandler;
+
+	/**
+	 * @param \Pixie\Connection|null $connection
+	 * @param string $fetchMode
+	 * @param mixed[] $hydratorConstructorArgs
+	 *
+	 * @throws Exception if no connection passed and not previously established
+	 */
+	final public function __construct(
+		Connection $connection = null,
+		string $fetchMode = \OBJECT,
+		?array $hydratorConstructorArgs = null
+	) {
+		if (is_null($connection)) {
+			// throws if connection not already established.
+			$connection = Connection::getStoredConnection();
+		}
+
+		// Set all dependencies from connection.
+		$this->connection = $connection;
+		$this->container  = $this->connection->getContainer();
+		$this->dbInstance = $this->connection->getDbInstance();
+		$this->setAdapterConfig($this->connection->getAdapterConfig());
+
+		// Set up optional hydration details.
+		$this->setFetchMode($fetchMode);
+		$this->hydratorConstructorArgs = $hydratorConstructorArgs;
+
+		// Query builder adapter instance
+		$this->adapterInstance = $this->container->build(
+			WPDBAdapter::class,
+			[$this->connection]
+		);
+
+		// Setup JSON Selector handler.
+		$this->jsonHandler = new JsonHandler($connection);
+	}
+
+	/**
+	 * Sets the config for WPDB
+	 *
+	 * @param array<string, mixed> $adapterConfig
+	 *
+	 * @return void
+	 */
+	protected function setAdapterConfig(array $adapterConfig): void
+	{
+		if (isset($adapterConfig[Connection::PREFIX])) {
+			$this->tablePrefix = $adapterConfig[Connection::PREFIX];
+		}
+	}
+
+	/**
+	 * Fetch query results as object of specified type
+	 *
+	 * @param string $className
+	 * @param array<int, mixed> $constructorArgs
+	 * @return static
+	 */
+	public function asObject($className, $constructorArgs = array()): self
+	{
+		return $this->setFetchMode($className, $constructorArgs);
+	}
+
+	/**
+	 * Set the fetch mode
+	 *
+	 * @param string $mode
+	 * @param array<int, mixed>|null $constructorArgs
+	 *
+	 * @return static
+	 */
+	public function setFetchMode(string $mode, ?array $constructorArgs = null): self
+	{
+		$this->fetchMode               = $mode;
+		$this->hydratorConstructorArgs = $constructorArgs;
+
+		return $this;
+	}
+
+	/**
+	 * @param Connection|null $connection
+	 *
+	 * @return static
+	 *
+	 * @throws Exception
+	 */
+	public function newQuery(Connection $connection = null): self
+	{
+		if (is_null($connection)) {
+			$connection = $this->connection;
+		}
+
+		$newQuery = $this->constructCurrentBuilderClass($connection);
+		$newQuery->setFetchMode($this->getFetchMode(), $this->hydratorConstructorArgs);
+
+		return $newQuery;
+	}
+
+	/**
+	 * Returns a new instance of the current, with the passed connection.
+	 *
+	 * @param \Pixie\Connection $connection
+	 *
+	 * @return static
+	 */
+	protected function constructCurrentBuilderClass(Connection $connection): self
+	{
+		return new static($connection);
+	}
+
+	/**
+	 * Interpolates a query
+	 *
+	 * @param string $query
+	 * @param array<mixed> $bindings
+	 * @return string
+	 */
+	public function interpolateQuery(string $query, array $bindings = []): string
+	{
+		return $this->adapterInstance->interpolateQuery($query, $bindings);
+	}
+
+	/**
+	 * @param string           $sql
+	 * @param array<int,mixed> $bindings
+	 *
+	 * @return static
+	 */
+	public function query($sql, $bindings = []): self
+	{
+		list($this->sqlStatement) = $this->statement($sql, $bindings);
+
+		return $this;
+	}
+
+	/**
+	 * @param string           $sql
+	 * @param array<int,mixed> $bindings
+	 *
+	 * @return array{0:string, 1:float}
+	 */
+	public function statement(string $sql, $bindings = []): array
+	{
+		$start        = microtime(true);
+		$sqlStatement = empty($bindings) ? $sql : $this->interpolateQuery($sql, $bindings);
+
+		if (!is_string($sqlStatement)) {
+			throw new Exception('Could not interpolate query', 1);
+		}
+
+		return [$sqlStatement, microtime(true) - $start];
+	}
+
+	/**
+	 * Get all rows
+	 *
+	 * @return array<mixed,mixed>|null
+	 *
+	 * @throws Exception
+	 */
+	public function get()
+	{
+		$eventResult = $this->fireEvents('before-select');
+		if (!is_null($eventResult)) {
+			return $eventResult;
+		}
+		$executionTime = 0;
+		if (is_null($this->sqlStatement)) {
+			$queryObject = $this->getQuery('select');
+			$statement   = $this->statement(
+				$queryObject->getSql(),
+				$queryObject->getBindings()
+			);
+
+			$this->sqlStatement = $statement[0];
+			$executionTime      = $statement[1];
+		}
+
+		$start  = microtime(true);
+		$result = $this->dbInstance()->get_results(
+			is_array($this->sqlStatement) ? (end($this->sqlStatement) ?: '') : $this->sqlStatement,
+			// If we are using the hydrator, return as OBJECT and let the hydrator map the correct model.
+			$this->useHydrator() ? OBJECT : $this->getFetchMode()
+		);
+		$executionTime += microtime(true) - $start;
+		$this->sqlStatement = null;
+
+		// Ensure we have an array of results.
+		if (!is_array($result) && null !== $result) {
+			$result = [$result];
+		}
+
+		// Maybe hydrate the results.
+		if (null !== $result && $this->useHydrator()) {
+			$result = $this->getHydrator()->fromMany($result);
+		}
+
+		$this->fireEvents('after-select', $result, $executionTime);
+
+		return $result;
+	}
+
+	/**
+	 * Returns a populated instance of the Hydrator.
+	 *
+	 * @return Hydrator
+	 */
+	protected function getHydrator(): Hydrator /* @phpstan-ignore-line */
+	{
+		$hydrator = new Hydrator($this->getFetchMode(), $this->hydratorConstructorArgs ?? []); /* @phpstan-ignore-line */
+
+		return $hydrator;
+	}
+
+	/**
+	 * Checks if the results should be mapped via the hydrator
+	 *
+	 * @return bool
+	 */
+	protected function useHydrator(): bool
+	{
+		return !in_array($this->getFetchMode(), [\ARRAY_A, \ARRAY_N, \OBJECT, \OBJECT_K]);
+	}
+
+	/**
+	 * Find all matching a simple where condition.
+	 *
+	 * Shortcut of ->where('key','=','value')->limit(1)->get();
+	 *
+	 * @return \stdClass\array<mixed,mixed>|object|null Can return any object using hydrator
+	 */
+	public function first()
+	{
+		$this->limit(1);
+		$result = $this->get();
+
+		return empty($result) ? null : $result[0];
+	}
+
+	/**
+	 * Find all matching a simple where condition.
+	 *
+	 * Shortcut of ->where('key','=','value')->get();
+	 *
+	 * @param string $fieldName
+	 * @param mixed $value
+	 *
+	 * @return array<mixed,mixed>|null Can return any object using hydrator
+	 */
+	public function findAll($fieldName, $value)
+	{
+		$this->where($fieldName, '=', $value);
+
+		return $this->get();
+	}
+
+	/**
+	 * @param string $fieldName
+	 * @param mixed $value
+	 *
+	 * @return \stdClass\array<mixed,mixed>|object|null Can return any object using hydrator
+	 */
+	public function find($value, $fieldName = 'id')
+	{
+		$this->where($fieldName, '=', $value);
+
+		return $this->first();
+	}
+
+	/**
+	 * @param string $fieldName
+	 * @param mixed $value
+	 *
+	 * @return \stdClass\array<mixed,mixed>|object Can return any object using hydrator
+	 * @throws Exception If fails to find
+	 */
+	public function findOrFail($value, $fieldName = 'id')
+	{
+		$result = $this->find($value, $fieldName);
+		if (null === $result) {
+			throw new Exception("Failed to find {$fieldName}={$value}", 1);
+		}
+		return $result;
+	}
+
+	/**
+	 * Used to handle all aggregation method.
+	 *
+	 * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
+	 *
+	 * @param string $type
+	 * @param string|Raw $field
+	 *
+	 * @return float
+	 */
+	protected function aggregate(string $type, $field = '*'): float
+	{
+		// Parse a raw expression.
+		if ($field instanceof Raw) {
+			$field = $this->adapterInstance->parseRaw($field);
+		}
+
+		// Potentialy cast field from JSON
+		if ($this->jsonHandler->isJsonSelector($field)) {
+			$field = $this->jsonHandler->extractAndUnquoteFromJsonSelector($field);
+		}
+
+		// Verify that field exists
+		if ('*' !== $field && true === isset($this->statements['selects']) && false === \in_array($field, $this->statements['selects'], true)) {
+			throw new \Exception(sprintf('Failed %s query - the column %s hasn\'t been selected in the query.', $type, $field));
+		}
+
+
+		if (false === isset($this->statements['tables'])) {
+			throw new Exception('No table selected');
+		}
+
+		$count = $this
+			->table($this->subQuery($this, 'count'))
+			->select([$this->raw(sprintf('%s(%s) AS field', strtoupper($type), $field))])
+			->first();
+
+		return true === isset($count->field) ? (float)$count->field : 0;
+	}
+
+	/**
+	 * Get count of all the rows for the current query
+	 *
+	 * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
+	 *
+	 * @param string|Raw $field
+	 *
+	 * @return int
+	 *
+	 * @throws Exception
+	 */
+	public function count($field = '*'): int
+	{
+		return (int)$this->aggregate('count', $field);
+	}
+
+	/**
+	 * Get the sum for a field in the current query
+	 *
+	 * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
+	 *
+	 * @param string|Raw $field
+	 *
+	 * @return float
+	 *
+	 * @throws Exception
+	 */
+	public function sum($field): float
+	{
+		return $this->aggregate('sum', $field);
+	}
+
+	/**
+	 * Get the average for a field in the current query
+	 *
+	 * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
+	 *
+	 * @param string|Raw $field
+	 *
+	 * @return float
+	 *
+	 * @throws Exception
+	 */
+	public function average($field): float
+	{
+		return $this->aggregate('avg', $field);
+	}
+
+	/**
+	 * Get the minimum for a field in the current query
+	 *
+	 * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
+	 *
+	 * @param string|Raw $field
+	 *
+	 * @return float
+	 *
+	 * @throws Exception
+	 */
+	public function min($field): float
+	{
+		return $this->aggregate('min', $field);
+	}
+
+	/**
+	 * Get the maximum for a field in the current query
+	 *
+	 * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
+	 *
+	 * @param string|Raw $field
+	 *
+	 * @return float
+	 *
+	 * @throws Exception
+	 */
+	public function max($field): float
+	{
+		return $this->aggregate('max', $field);
+	}
+
+	/**
+	 * @param string $type
+	 * @param bool|array<mixed, mixed> $dataToBePassed
+	 *
+	 * @return mixed
+	 *
+	 * @throws Exception
+	 */
+	public function getQuery(string $type = 'select', $dataToBePassed = [])
+	{
+		$allowedTypes = ['select', 'insert', 'insertignore', 'replace', 'delete', 'update', 'criteriaonly'];
+		if (!in_array(strtolower($type), $allowedTypes)) {
+			throw new Exception($type . ' is not a known type.', 2);
+		}
+
+		$queryArr = $this->adapterInstance->$type($this->statements, $dataToBePassed);
+
+		return $this->container->build(
+			QueryObject::class,
+			[$queryArr['sql'], $queryArr['bindings'], $this->dbInstance]
+		);
+	}
+
+	/**
+	 * @param QueryBuilderHandler $queryBuilder
+	 * @param string|null $alias
+	 *
+	 * @return Raw
+	 */
+	public function subQuery(QueryBuilderHandler $queryBuilder, ?string $alias = null)
+	{
+		$sql = '(' . $queryBuilder->getQuery()->getRawSql() . ')';
+		if (is_string($alias) && 0 !== mb_strlen($alias)) {
+			$sql = $sql . ' as ' . $alias;
+		}
+
+		return $queryBuilder->raw($sql);
+	}
+
+	/**
+	 * Handles the various insert operations based on the type.
+	 *
+	 * @param array<int|string, mixed|mixed[]> $data
+	 * @param string $type
+	 *
+	 * @return int|int[]|mixed|null can return a single row id, array of row ids, null (for failed) or any other value short circuited from event
+	 */
+	private function doInsert(array $data, string $type)
+	{
+		$eventResult = $this->fireEvents('before-insert');
+		if (!is_null($eventResult)) {
+			return $eventResult;
+		}
+
+		// If first value is not an array () not a batch insert)
+		if (!is_array(current($data))) {
+			$queryObject = $this->getQuery($type, $data);
+
+			list($preparedQuery, $executionTime) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
+			$this->dbInstance->get_results($preparedQuery);
+
+			// Check we have a result.
+			$return = 1 === $this->dbInstance->rows_affected ? $this->dbInstance->insert_id : null;
+		} else {
+			// Its a batch insert
+			$return        = [];
+			$executionTime = 0;
+			foreach ($data as $subData) {
+				$queryObject = $this->getQuery($type, $subData);
+
+				list($preparedQuery, $time) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
+				$this->dbInstance->get_results($preparedQuery);
+				$executionTime += $time;
+
+				if (1 === $this->dbInstance->rows_affected) {
+					$return[] = $this->dbInstance->insert_id;
+				}
+			}
+		}
+
+		$this->fireEvents('after-insert', $return, $executionTime);
+
+		return $return;
+	}
+
+	/**
+	 * @param array<int|string, mixed|mixed[]> $data either key=>value array for single or array of arrays for bulk
+	 *
+	 * @return int|int[]|mixed|null can return a single row id, array of row ids, null (for failed) or any other value short circuited from event
+	 */
+	public function insert($data)
+	{
+		return $this->doInsert($data, 'insert');
+	}
+
+	/**
+	 *
+	 * @param array<int|string, mixed|mixed[]> $data either key=>value array for single or array of arrays for bulk
+	 *
+	 * @return int|int[]|mixed|null can return a single row id, array of row ids, null (for failed) or any other value short circuited from event
+	 */
+	public function insertIgnore($data)
+	{
+		return $this->doInsert($data, 'insertignore');
+	}
+
+	/**
+	 *
+	 * @param array<int|string, mixed|mixed[]> $data either key=>value array for single or array of arrays for bulk
+	 *
+	 * @return int|int[]|mixed|null can return a single row id, array of row ids, null (for failed) or any other value short circuited from event
+	 */
+	public function replace($data)
+	{
+		return $this->doInsert($data, 'replace');
+	}
+
+	/**
+	 * @param array<string, mixed> $data
+	 *
+	 * @return int|null
+	 */
+	public function update($data)
+	{
+		$eventResult = $this->fireEvents('before-update');
+		if (!is_null($eventResult)) {
+			return $eventResult;
+		}
+		$queryObject                         = $this->getQuery('update', $data);
+		$r = $this->statement($queryObject->getSql(), $queryObject->getBindings());
+		list($preparedQuery, $executionTime) = $r;
+		$this->dbInstance()->get_results($preparedQuery);
+		$this->fireEvents('after-update', $queryObject, $executionTime);
+
+		return 0 !== $this->dbInstance()->rows_affected
+			? $this->dbInstance()->rows_affected
+			: null;
+	}
+
+	/**
+	 * @param array<string, mixed> $data
+	 *
+	 * @return int|null will return row id for insert and bool for success/fail on update
+	 */
+	public function updateOrInsert($data)
+	{
+		if ($this->first()) {
+			return $this->update($data);
+		}
+
+		return $this->insert($data);
+	}
+
+	/**
+	 * @param array<string, mixed> $data
+	 *
+	 * @return static
+	 */
+	public function onDuplicateKeyUpdate($data)
+	{
+		$this->addStatement('onduplicate', $data);
+
+		return $this;
+	}
+
+	/**
+	 * @return mixed number of rows effected or shortcircuited response
+	 */
+	public function delete()
+	{
+		$eventResult = $this->fireEvents('before-delete');
+		if (!is_null($eventResult)) {
+			return $eventResult;
+		}
+
+		$queryObject = $this->getQuery('delete');
+
+		list($preparedQuery, $executionTime) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
+		$this->dbInstance()->get_results($preparedQuery);
+		$this->fireEvents('after-delete', $queryObject, $executionTime);
+
+		return $this->dbInstance()->rows_affected;
+	}
+
+	/**
+	 * @param string|Raw ...$tables Single table or array of tables
+	 *
+	 * @return static
+	 *
+	 * @throws Exception
+	 */
+	public function table(...$tables)
+	{
+		$instance =  $this->constructCurrentBuilderClass($this->connection);
+		$this->setFetchMode($this->getFetchMode(), $this->hydratorConstructorArgs);
+		$tables = $this->addTablePrefix($tables, false);
+		$instance->addStatement('tables', $tables);
+
+		return $instance;
+	}
+
+	/**
+	 * @param string|Raw ...$tables Single table or array of tables
+	 *
+	 * @return static
+	 */
+	public function from(...$tables): self
+	{
+		$tables = $this->addTablePrefix($tables, false);
+		$this->addStatement('tables', $tables);
+
+		return $this;
+	}
+
+	/**
+	 * @param string|string[]|Raw[]|array<string, string> $fields
+	 *
+	 * @return static
+	 */
+	public function select($fields): self
+	{
+		if (!is_array($fields)) {
+			$fields = func_get_args();
+		}
+
+		foreach ($fields as $field => $alias) {
+			// If we have a JSON expression
+			if ($this->jsonHandler->isJsonSelector($field)) {
+				$field = $this->jsonHandler->extractAndUnquoteFromJsonSelector($field);
+			}
+
+			// If no alias passed, but field is for JSON. thrown an exception.
+			if (is_numeric($field) && is_string($alias) && $this->jsonHandler->isJsonSelector($alias)) {
+				throw new Exception("An alias must be used if you wish to select from JSON Object", 1);
+			}
+
+			// Treat each array as a single table, to retain order added
+			$field = is_numeric($field)
+				? $field = $alias // If single colum
+				: $field = [$field => $alias]; // Has alias
+
+			$field = $this->addTablePrefix($field);
+			$this->addStatement('selects', $field);
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param string|string[]|Raw[]|array<string, string> $fields
+	 *
+	 * @return static
+	 */
+	public function selectDistinct($fields)
+	{
+		$this->select($fields);
+		$this->addStatement('distinct', true);
+
+		return $this;
+	}
+
+	/**
+	 * @param string|string[] $field either the single field or an array of fields
+	 *
+	 * @return static
+	 */
+	public function groupBy($field): self
+	{
+		$field = $this->addTablePrefix($field);
+		$this->addStatement('groupBys', $field);
+
+		return $this;
+	}
+
+	/**
+	 * @param string|array<string|int, mixed> $fields
+	 * @param string          $defaultDirection
+	 *
+	 * @return static
+	 */
+	public function orderBy($fields, string $defaultDirection = 'ASC'): self
+	{
+		if (!is_array($fields)) {
+			$fields = [$fields];
+		}
+
+		foreach ($fields as $key => $value) {
+			$field = $key;
+			$type  = $value;
+			if (is_int($key)) {
+				$field = $value;
+				$type  = $defaultDirection;
+			}
+
+			if ($this->jsonHandler->isJsonSelector($field)) {
+				$field = $this->jsonHandler->extractAndUnquoteFromJsonSelector($field);
+			}
+
+			if (!$field instanceof Raw) {
+				$field = $this->addTablePrefix($field);
+			}
+			$this->statements['orderBys'][] = compact('field', 'type');
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param string|Raw $key The database column which holds the JSON value
+	 * @param string|Raw|string[] $jsonKey The json key/index to search
+	 * @param string $defaultDirection
+	 * @return static
+	 */
+	public function orderByJson($key, $jsonKey, string $defaultDirection = 'ASC'): self
+	{
+		$key = $this->jsonHandler->jsonExpressionFactory()->extractAndUnquote($key, $jsonKey);
+		return $this->orderBy($key, $defaultDirection);
+	}
+
+	/**
+	 * @param int $limit
+	 *
+	 * @return static
+	 */
+	public function limit(int $limit): self
+	{
+		$this->statements['limit'] = $limit;
+
+		return $this;
+	}
+
+	/**
+	 * @param int $offset
+	 *
+	 * @return static
+	 */
+	public function offset(int $offset): self
+	{
+		$this->statements['offset'] = $offset;
+
+		return $this;
+	}
+
+	/**
+	 * @param string|string[]|Raw|Raw[]       $key
+	 * @param string $operator
+	 * @param mixed $value
+	 * @param string $joiner
+	 *
+	 * @return static
+	 */
+	public function having($key, string $operator, $value, string $joiner = 'AND')
+	{
+		$key                           = $this->addTablePrefix($key);
+		$this->statements['havings'][] = compact('key', 'operator', 'value', 'joiner');
+
+		return $this;
+	}
+
+	/**
+	 * @param string|string[]|Raw|Raw[]       $key
+	 * @param string $operator
+	 * @param mixed $value
+	 *
+	 * @return static
+	 */
+	public function orHaving($key, $operator, $value)
+	{
+		return $this->having($key, $operator, $value, 'OR');
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 *
+	 * @return static
+	 */
+	public function where($key, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (2 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+
+		return $this->whereHandler($key, $operator, $value);
+	}
+
+	/**
+	 * @param string|Raw|\Closure(QueryBuilderHandler):void $key
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 *
+	 * @return static
+	 */
+	public function orWhere($key, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (2 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+
+		return $this->whereHandler($key, $operator, $value, 'OR');
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 *
+	 * @return static
+	 */
+	public function whereNot($key, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (2 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+
+		return $this->whereHandler($key, $operator, $value, 'AND NOT');
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 *
+	 * @return static
+	 */
+	public function orWhereNot($key, $operator = null, $value = null)
+	{
+		// If two params are given then assume operator is =
+		if (2 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+
+		return $this->whereHandler($key, $operator, $value, 'OR NOT');
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param mixed[]|string|Raw $values
+	 *
+	 * @return static
+	 */
+	public function whereIn($key, $values): self
+	{
+		return $this->whereHandler($key, 'IN', $values, 'AND');
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param mixed[]|string|Raw $values
+	 *
+	 * @return static
+	 */
+	public function whereNotIn($key, $values): self
+	{
+		return $this->whereHandler($key, 'NOT IN', $values, 'AND');
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param mixed[]|string|Raw $values
+	 *
+	 * @return static
+	 */
+	public function orWhereIn($key, $values): self
+	{
+		return $this->whereHandler($key, 'IN', $values, 'OR');
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param mixed[]|string|Raw $values
+	 *
+	 * @return static
+	 */
+	public function orWhereNotIn($key, $values): self
+	{
+		return $this->whereHandler($key, 'NOT IN', $values, 'OR');
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param mixed $valueFrom
+	 * @param mixed $valueTo
+	 *
+	 * @return static
+	 */
+	public function whereBetween($key, $valueFrom, $valueTo): self
+	{
+		return $this->whereHandler($key, 'BETWEEN', [$valueFrom, $valueTo], 'AND');
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param mixed $valueFrom
+	 * @param mixed $valueTo
+	 *
+	 * @return static
+	 */
+	public function orWhereBetween($key, $valueFrom, $valueTo): self
+	{
+		return $this->whereHandler($key, 'BETWEEN', [$valueFrom, $valueTo], 'OR');
+	}
+
+	/**
+	 * Handles all function call based where conditions
+	 *
+	 * @param string|Raw $key
+	 * @param string $function
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return static
+	 */
+	protected function whereFunctionCallHandler($key, $function, $operator, $value): self
+	{
+		$key = \sprintf('%s(%s)', $function, $this->addTablePrefix($key));
+		return $this->where($key, $operator, $value);
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return self
+	 */
+	public function whereMonth($key, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (2 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+		return $this->whereFunctionCallHandler($key, 'MONTH', $operator, $value);
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return self
+	 */
+	public function whereDay($key, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (2 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+		return $this->whereFunctionCallHandler($key, 'DAY', $operator, $value);
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return self
+	 */
+	public function whereYear($key, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (2 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+		return $this->whereFunctionCallHandler($key, 'YEAR', $operator, $value);
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param string|mixed|null $operator Can be used as value, if 3rd arg not passed
+	 * @param mixed|null $value
+	 * @return self
+	 */
+	public function whereDate($key, $operator = null, $value = null): self
+	{
+		// If two params are given then assume operator is =
+		if (2 === func_num_args()) {
+			$value    = $operator;
+			$operator = '=';
+		}
+		return $this->whereFunctionCallHandler($key, 'DATE', $operator, $value);
+	}
+
+	/**
+	 * @param string|Raw $key
+	 *
+	 * @return static
+	 */
+	public function whereNull($key): self
+	{
+		return $this->whereNullHandler($key);
+	}
+
+	/**
+	 * @param string|Raw $key
+	 *
+	 * @return static
+	 */
+	public function whereNotNull($key): self
+	{
+		return $this->whereNullHandler($key, 'NOT');
+	}
+
+	/**
+	 * @param string|Raw $key
+	 *
+	 * @return static
+	 */
+	public function orWhereNull($key): self
+	{
+		return $this->whereNullHandler($key, '', 'or');
+	}
+
+	/**
+	 * @param string|Raw $key
+	 *
+	 * @return static
+	 */
+	public function orWhereNotNull($key): self
+	{
+		return $this->whereNullHandler($key, 'NOT', 'or');
+	}
+
+	/**
+	 * @param string|Raw $key
+	 * @param string $prefix
+	 * @param string $operator
+	 *
+	 * @return static
+	 */
+	protected function whereNullHandler($key, string $prefix = '', $operator = ''): self
+	{
+		$prefix = 0 === mb_strlen($prefix) ? '' : " {$prefix}";
+
+		if ($key instanceof Raw) {
+			$key = $this->adapterInstance->parseRaw($key);
+		}
+
+		$key = $this->addTablePrefix($key);
+		if ($key instanceof Closure) {
+			throw new Exception('Key used for whereNull condition must be a string or raw exrpession.', 1);
+		}
+
+		return $this->{$operator . 'Where'}($this->raw("{$key} IS{$prefix} NULL"));
+	}
+
+
+	/**
+	 * Runs a transaction
+	 *
+	 * @param \Closure(Transaction):void $callback
+	 *
+	 * @return static
+	 */
+	public function transaction(Closure $callback): self
+	{
+		try {
+			// Begin the transaction
+			$this->dbInstance->query('START TRANSACTION');
+
+			// Get the Transaction class
+			$transaction = $this->container->build(Transaction::class, [$this->connection]);
+
+			$this->handleTransactionCall($callback, $transaction);
+
+			// If no errors have been thrown or the transaction wasn't completed within
+			$this->dbInstance->query('COMMIT');
+
+			return $this;
+		} catch (TransactionHaltException $e) {
+			// Commit or rollback behavior has been handled in the closure, so exit
+			return $this;
+		} catch (\Exception $e) {
+			// something happened, rollback changes
+			$this->dbInstance->query('ROLLBACK');
+
+			return $this;
+		}
+	}
+
+	/**
+	 * Handles the transaction call.
+	 * Catches any WPDB Errors (printed)
+	 *
+	 * @param Closure    $callback
+	 * @param Transaction $transaction
+	 *
+	 * @return void
+	 * @throws Exception
+	 */
+	protected function handleTransactionCall(Closure $callback, Transaction $transaction): void
+	{
+		try {
+			ob_start();
+			$callback($transaction);
+			$output = ob_get_clean() ?: '';
+		} catch (Throwable $th) {
+			ob_end_clean();
+			throw $th;
+		}
+
+		// If we caught an error, throw an exception.
+		if (0 !== mb_strlen($output)) {
+			throw new Exception($output);
+		}
+	}
+
+	/*************************************************************************/
+	/*************************************************************************/
+	/*************************************************************************/
+	/**                              JOIN JOIN                              **/
+	/**                                 JOIN                                **/
+	/**                              JOIN JOIN                              **/
+	/*************************************************************************/
+	/*************************************************************************/
+	/*************************************************************************/
+
+	/**
+	 * @param string|Raw $table
+	 * @param string|Raw|Closure $key
+	 * @param string|null $operator
+	 * @param mixed $value
+	 * @param string $type
+	 *
+	 * @return static
+	 */
+	public function join($table, $key, ?string $operator = null, $value = null, $type = 'inner')
+	{
+		// Potentially cast key from JSON
+		if ($this->jsonHandler->isJsonSelector($key)) {
+			/** @var string $key */
+			$key = $this->jsonHandler->extractAndUnquoteFromJsonSelector($key); /** @phpstan-ignore-line */
+		}
+
+		// Potentially cast value from json
+		if ($this->jsonHandler->isJsonSelector($value)) {
+			/** @var string $value */
+			$value = $this->jsonHandler->extractAndUnquoteFromJsonSelector($value);
+		}
+
+		if (!$key instanceof Closure) {
+			$key = function ($joinBuilder) use ($key, $operator, $value) {
+				$joinBuilder->on($key, $operator, $value);
+			};
+		}
+
+		// Build a new JoinBuilder class, keep it by reference so any changes made
+		// in the closure should reflect here
+		$joinBuilder = $this->container->build(JoinBuilder::class, [$this->connection]);
+		$joinBuilder = &$joinBuilder;
+		// Call the closure with our new joinBuilder object
+		$key($joinBuilder);
+		$table = $this->addTablePrefix($table, false);
+		// Get the criteria only query from the joinBuilder object
+		$this->statements['joins'][] = compact('type', 'table', 'joinBuilder');
+		return $this;
+	}
+
+	/**
+	 * @param string|Raw $table
+	 * @param string|Raw|Closure $key
+	 * @param string|null $operator
+	 * @param mixed $value
+	 *
+	 * @return static
+	 */
+	public function leftJoin($table, $key, $operator = null, $value = null)
+	{
+		return $this->join($table, $key, $operator, $value, 'left');
+	}
+
+	/**
+	 * @param string|Raw $table
+	 * @param string|Raw|Closure $key
+	 * @param string|null $operator
+	 * @param mixed $value
+	 *
+	 * @return static
+	 */
+	public function rightJoin($table, $key, $operator = null, $value = null)
+	{
+		return $this->join($table, $key, $operator, $value, 'right');
+	}
+
+	/**
+	 * @param string|Raw $table
+	 * @param string|Raw|Closure $key
+	 * @param string|null $operator
+	 * @param mixed $value
+	 *
+	 * @return static
+	 */
+	public function innerJoin($table, $key, $operator = null, $value = null)
+	{
+		return $this->join($table, $key, $operator, $value, 'inner');
+	}
+
+	/**
+	 * @param string|Raw $table
+	 * @param string|Raw|Closure $key
+	 * @param string|null $operator
+	 * @param mixed $value
+	 *
+	 * @return static
+	 */
+	public function crossJoin($table, $key, $operator = null, $value = null)
+	{
+		return $this->join($table, $key, $operator, $value, 'cross');
+	}
+
+	/**
+	 * @param string|Raw $table
+	 * @param string|Raw|Closure $key
+	 * @param string|null $operator
+	 * @param mixed $value
+	 *
+	 * @return static
+	 */
+	public function outerJoin($table, $key, $operator = null, $value = null)
+	{
+		return $this->join($table, $key, $operator, $value, 'full outer');
+	}
+
+	/**
+	 * Shortcut to join 2 tables on the same key name with equals
+	 *
+	 * @param string $table
+	 * @param string $key
+	 * @param string $type
+	 * @return self
+	 * @throws Exception If base table is set as more than 1 or 0
+	 */
+	public function joinUsing(string $table, string $key, string $type = 'INNER'): self
+	{
+		if (!array_key_exists('tables', $this->statements) || count($this->statements['tables']) !== 1) {
+			throw new Exception("JoinUsing can only be used with a single table set as the base of the query", 1);
+		}
+		$baseTable = end($this->statements['tables']);
+
+		// Potentialy cast key from JSON
+		if ($this->jsonHandler->isJsonSelector($key)) {
+			$key = $this->jsonHandler->extractAndUnquoteFromJsonSelector($key);
+		}
+
+		$remoteKey = $table = $this->addTablePrefix("{$table}.{$key}", true);
+		$localKey = $table = $this->addTablePrefix("{$baseTable}.{$key}", true);
+		return $this->join($table, $remoteKey, '=', $localKey, $type);
+	}
+
+	/**
+	 * Add a raw query
+	 *
+	 * @param string|Raw $value
+	 * @param mixed|mixed[] $bindings
+	 *
+	 * @return Raw
+	 */
+	public function raw($value, $bindings = []): Raw
+	{
+		return new Raw($value, $bindings);
+	}
+
+	/**
+	 * Return wpdb instance
+	 *
+	 * @return wpdb
+	 */
+	public function dbInstance(): wpdb
+	{
+		return $this->dbInstance;
+	}
+
+	/**
+	 * @param Connection $connection
+	 *
+	 * @return static
+	 */
+	public function setConnection(Connection $connection): self
+	{
+		$this->connection = $connection;
+
+		return $this;
+	}
+
+	/**
+	 * @return Connection
+	 */
+	public function getConnection(): Connection
+	{
+		return $this->connection;
+	}
+
+	/**
+	 * @param string|Raw|Closure $key
+	 * @param string|null      $operator
+	 * @param mixed|null       $value
+	 * @param string $joiner
+	 *
+	 * @return static
+	 */
+	protected function whereHandler($key, $operator = null, $value = null, $joiner = 'AND')
+	{
+		$key = $this->addTablePrefix($key);
+		if ($key instanceof Raw) {
+			$key = $this->adapterInstance->parseRaw($key);
+		}
+
+		if ($this->jsonHandler->isJsonSelector($key)) {
+			$key = $this->jsonHandler->extractAndUnquoteFromJsonSelector($key);
+		}
+
+		$this->statements['wheres'][] = compact('key', 'operator', 'value', 'joiner');
+		return $this;
+	}
+
+
+
+	/**
+	 * @param string $key
+	 * @param mixed|mixed[]|bool $value
+	 *
+	 * @return void
+	 */
+	protected function addStatement($key, $value)
+	{
+		if (!is_array($value)) {
+			$value = [$value];
+		}
+
+		if (!array_key_exists($key, $this->statements)) {
+			$this->statements[$key] = $value;
+		} else {
+			$this->statements[$key] = array_merge($this->statements[$key], $value);
+		}
+	}
+
+	/**
+	 * @param string $event
+	 * @param string|Raw $table
+	 *
+	 * @return callable|null
+	 */
+	public function getEvent(string $event, $table = ':any'): ?callable
+	{
+		return $this->connection->getEventHandler()->getEvent($event, $table);
+	}
+
+	/**
+	 * @param string $event
+	 * @param string|Raw $table
+	 * @param Closure $action
+	 *
+	 * @return void
+	 */
+	public function registerEvent($event, $table, Closure $action): void
+	{
+		$table = $table ?: ':any';
+
+		if (':any' != $table) {
+			$table = $this->addTablePrefix($table, false);
+		}
+
+		$this->connection->getEventHandler()->registerEvent($event, $table, $action);
+	}
+
+	/**
+	 * @param string $event
+	 * @param string|Raw $table
+	 *
+	 * @return void
+	 */
+	public function removeEvent(string $event, $table = ':any')
+	{
+		if (':any' != $table) {
+			$table = $this->addTablePrefix($table, false);
+		}
+
+		$this->connection->getEventHandler()->removeEvent($event, $table);
+	}
+
+	/**
+	 * @param string $event
+	 *
+	 * @return mixed
+	 */
+	public function fireEvents(string $event)
+	{
+		$params = func_get_args(); // @todo Replace this with an easier to read alteratnive
+		array_unshift($params, $this);
+
+		return call_user_func_array([$this->connection->getEventHandler(), 'fireEvents'], $params);
+	}
+
+	/**
+	 * @return array<string, mixed[]>
+	 */
+	public function getStatements()
+	{
+		return $this->statements;
+	}
+
+	/**
+	 * @return string will return WPDB Fetch mode
+	 */
+	public function getFetchMode()
+	{
+		return null !== $this->fetchMode
+			? $this->fetchMode
+			: \OBJECT;
+	}
+
+	/**
+	 * Returns an NEW instance of the JSON builder populated with the same connection and hydrator details.
+	 *
+	 * @return JsonQueryBuilder
+	 */
+	public function jsonBuilder(): JsonQueryBuilder
+	{
+		return new JsonQueryBuilder($this->getConnection(), $this->getFetchMode(), $this->hydratorConstructorArgs);
+	}
 }

Spacing +24 added lines, -24 removed lines

@@ -232,7 +232,7 @@ 
         $start        = microtime(true);
         $sqlStatement = empty($bindings) ? $sql : $this->interpolateQuery($sql, $bindings);
 
-        if (!is_string($sqlStatement)) {
+        if ( ! is_string($sqlStatement)) {
             throw new Exception('Could not interpolate query', 1);
         }
 
@@ -249,7 +249,7 @@ 
     public function get()
     {
         $eventResult = $this->fireEvents('before-select');
-        if (!is_null($eventResult)) {
+        if ( ! is_null($eventResult)) {
             return $eventResult;
         }
         $executionTime = 0;
@@ -274,7 +274,7 @@ 
         $this->sqlStatement = null;
 
         // Ensure we have an array of results.
-        if (!is_array($result) && null !== $result) {
+        if ( ! is_array($result) && null !== $result) {
             $result = [$result];
         }
 
@@ -307,7 +307,7 @@ 
      */
     protected function useHydrator(): bool
     {
-        return !in_array($this->getFetchMode(), [\ARRAY_A, \ARRAY_N, \OBJECT, \OBJECT_K]);
+        return ! in_array($this->getFetchMode(), [\ARRAY_A, \ARRAY_N, \OBJECT, \OBJECT_K]);
     }
 
     /**
@@ -408,7 +408,7 @@ 
             ->select([$this->raw(sprintf('%s(%s) AS field', strtoupper($type), $field))])
             ->first();
 
-        return true === isset($count->field) ? (float)$count->field : 0;
+        return true === isset($count->field) ? (float) $count->field : 0;
     }
 
     /**
@@ -424,7 +424,7 @@ 
      */
     public function count($field = '*'): int
     {
-        return (int)$this->aggregate('count', $field);
+        return (int) $this->aggregate('count', $field);
     }
 
     /**
@@ -502,8 +502,8 @@ 
     public function getQuery(string $type = 'select', $dataToBePassed = [])
     {
         $allowedTypes = ['select', 'insert', 'insertignore', 'replace', 'delete', 'update', 'criteriaonly'];
-        if (!in_array(strtolower($type), $allowedTypes)) {
-            throw new Exception($type . ' is not a known type.', 2);
+        if ( ! in_array(strtolower($type), $allowedTypes)) {
+            throw new Exception($type.' is not a known type.', 2);
         }
 
         $queryArr = $this->adapterInstance->$type($this->statements, $dataToBePassed);
@@ -522,9 +522,9 @@ 
      */
     public function subQuery(QueryBuilderHandler $queryBuilder, ?string $alias = null)
     {
-        $sql = '(' . $queryBuilder->getQuery()->getRawSql() . ')';
+        $sql = '('.$queryBuilder->getQuery()->getRawSql().')';
         if (is_string($alias) && 0 !== mb_strlen($alias)) {
-            $sql = $sql . ' as ' . $alias;
+            $sql = $sql.' as '.$alias;
         }
 
         return $queryBuilder->raw($sql);
@@ -541,12 +541,12 @@ 
     private function doInsert(array $data, string $type)
     {
         $eventResult = $this->fireEvents('before-insert');
-        if (!is_null($eventResult)) {
+        if ( ! is_null($eventResult)) {
             return $eventResult;
         }
 
         // If first value is not an array () not a batch insert)
-        if (!is_array(current($data))) {
+        if ( ! is_array(current($data))) {
             $queryObject = $this->getQuery($type, $data);
 
             list($preparedQuery, $executionTime) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
@@ -616,7 +616,7 @@ 
     public function update($data)
     {
         $eventResult = $this->fireEvents('before-update');
-        if (!is_null($eventResult)) {
+        if ( ! is_null($eventResult)) {
             return $eventResult;
         }
         $queryObject                         = $this->getQuery('update', $data);
@@ -662,7 +662,7 @@ 
     public function delete()
     {
         $eventResult = $this->fireEvents('before-delete');
-        if (!is_null($eventResult)) {
+        if ( ! is_null($eventResult)) {
             return $eventResult;
         }
 
@@ -684,7 +684,7 @@ 
      */
     public function table(...$tables)
     {
-        $instance =  $this->constructCurrentBuilderClass($this->connection);
+        $instance = $this->constructCurrentBuilderClass($this->connection);
         $this->setFetchMode($this->getFetchMode(), $this->hydratorConstructorArgs);
         $tables = $this->addTablePrefix($tables, false);
         $instance->addStatement('tables', $tables);
@@ -712,7 +712,7 @@ 
      */
     public function select($fields): self
     {
-        if (!is_array($fields)) {
+        if ( ! is_array($fields)) {
             $fields = func_get_args();
         }
 
@@ -773,7 +773,7 @@ 
      */
     public function orderBy($fields, string $defaultDirection = 'ASC'): self
     {
-        if (!is_array($fields)) {
+        if ( ! is_array($fields)) {
             $fields = [$fields];
         }
 
@@ -789,7 +789,7 @@ 
                 $field = $this->jsonHandler->extractAndUnquoteFromJsonSelector($field);
             }
 
-            if (!$field instanceof Raw) {
+            if ( ! $field instanceof Raw) {
                 $field = $this->addTablePrefix($field);
             }
             $this->statements['orderBys'][] = compact('field', 'type');
@@ -1141,7 +1141,7 @@ 
             throw new Exception('Key used for whereNull condition must be a string or raw exrpession.', 1);
         }
 
-        return $this->{$operator . 'Where'}($this->raw("{$key} IS{$prefix} NULL"));
+        return $this->{$operator.'Where'}($this->raw("{$key} IS{$prefix} NULL"));
     }
 
 
@@ -1238,8 +1238,8 @@ 
             $value = $this->jsonHandler->extractAndUnquoteFromJsonSelector($value);
         }
 
-        if (!$key instanceof Closure) {
-            $key = function ($joinBuilder) use ($key, $operator, $value) {
+        if ( ! $key instanceof Closure) {
+            $key = function($joinBuilder) use ($key, $operator, $value) {
                 $joinBuilder->on($key, $operator, $value);
             };
         }
@@ -1332,7 +1332,7 @@ 
      */
     public function joinUsing(string $table, string $key, string $type = 'INNER'): self
     {
-        if (!array_key_exists('tables', $this->statements) || count($this->statements['tables']) !== 1) {
+        if ( ! array_key_exists('tables', $this->statements) || count($this->statements['tables']) !== 1) {
             throw new Exception("JoinUsing can only be used with a single table set as the base of the query", 1);
         }
         $baseTable = end($this->statements['tables']);
@@ -1423,11 +1423,11 @@ 
      */
     protected function addStatement($key, $value)
     {
-        if (!is_array($value)) {
+        if ( ! is_array($value)) {
             $value = [$value];
         }
 
-        if (!array_key_exists($key, $this->statements)) {
+        if ( ! array_key_exists($key, $this->statements)) {
             $this->statements[$key] = $value;
         } else {
             $this->statements[$key] = array_merge($this->statements[$key], $value);

src/JSON/JsonSelectorHandler.php

Indentation +70 added lines, -70 removed lines

@@ -9,84 +9,84 @@
 
 class JsonSelectorHandler implements HasConnection
 {
-    use TablePrefixer;
+	use TablePrefixer;
 
-    /** @var Connection */
-    protected $connection;
+	/** @var Connection */
+	protected $connection;
 
-    public function __construct(Connection $connection)
-    {
-        $this->connection = $connection;
-    }
+	public function __construct(Connection $connection)
+	{
+		$this->connection = $connection;
+	}
 
-    /**
-     * Returns the current connection instance.
-     *
-     * @return connection
-     */
-    public function getConnection(): Connection
-    {
-        return $this->connection;
-    }
+	/**
+	 * Returns the current connection instance.
+	 *
+	 * @return connection
+	 */
+	public function getConnection(): Connection
+	{
+		return $this->connection;
+	}
 
-    /**
-     * Checks if the passed expression is for JSON
-     * this->denotes->json
-     *
-     * @param string $expression
-     * @return bool
-     */
-    public function isJsonSelector($expression): bool
-    {
-        return is_string($expression)
-        && 2 <= count(array_diff(explode('->', $expression), array("")));
-    }
+	/**
+	 * Checks if the passed expression is for JSON
+	 * this->denotes->json
+	 *
+	 * @param string $expression
+	 * @return bool
+	 */
+	public function isJsonSelector($expression): bool
+	{
+		return is_string($expression)
+		&& 2 <= count(array_diff(explode('->', $expression), array("")));
+	}
 
-    /**
-    * Gets the column name form a potential array
-    *
-    * @param string $expression
-    * @return string
-    * @throws Exception If invalid JSON Selector string passed.
-    */
-    public function getColumn(string $expression): string
-    {
-        return $this->toJsonSelector($expression)->getColumn();
-    }
+	/**
+	 * Gets the column name form a potential array
+	 *
+	 * @param string $expression
+	 * @return string
+	 * @throws Exception If invalid JSON Selector string passed.
+	 */
+	public function getColumn(string $expression): string
+	{
+		return $this->toJsonSelector($expression)->getColumn();
+	}
 
-    /**
-     * Gets all JSON object keys while removing the column name.
-     *
-     * @param string $expression
-     * @return string[]
-     * @throws Exception If invalid JSON Selector string passed.
-     */
-    public function getNodes(string $expression): array
-    {
-        return $this->toJsonSelector($expression)->getNodes();
-    }
+	/**
+	 * Gets all JSON object keys while removing the column name.
+	 *
+	 * @param string $expression
+	 * @return string[]
+	 * @throws Exception If invalid JSON Selector string passed.
+	 */
+	public function getNodes(string $expression): array
+	{
+		return $this->toJsonSelector($expression)->getNodes();
+	}
 
-    /**
-     * Casts a valid JSON selector to a JsonSelector object.
-     *
-     * @param string $expression
-     * @return JsonSelector
-     * @throws Exception If invalid JSON Selector string passed.
-     */
-    public function toJsonSelector(string $expression): JsonSelector
-    {
-        if (! $this->isJsonSelector($expression)) {
-            throw new Exception('JSON expression must contain at least 2 values, the table column and at least 1 node.', 1);
-        }
+	/**
+	 * Casts a valid JSON selector to a JsonSelector object.
+	 *
+	 * @param string $expression
+	 * @return JsonSelector
+	 * @throws Exception If invalid JSON Selector string passed.
+	 */
+	public function toJsonSelector(string $expression): JsonSelector
+	{
+		if (! $this->isJsonSelector($expression)) {
+			throw new Exception('JSON expression must contain at least 2 values, the table column and at least 1 node.', 1);
+		}
 
-        /** @var string[] Check done above. */
-        $parts = array_diff(explode('->', $expression), array(""));
+		/** @var string[] Check done above. */
+		$parts = array_diff(explode('->', $expression), array(""));
 
-        /** @var string */
-        $column = array_shift($parts);
-        /** @var string[] */
-        $nodes = $parts;
+		/** @var string */
+		$column = array_shift($parts);
+		/** @var string[] */
+		$nodes = $parts;
 
-        return new JsonSelector($column, $nodes);
-    }
+		return new JsonSelector($column, $nodes);
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -75,7 +75,7 @@
      */
     public function toJsonSelector(string $expression): JsonSelector
     {
-        if (! $this->isJsonSelector($expression)) {
+        if ( ! $this->isJsonSelector($expression)) {
             throw new Exception('JSON expression must contain at least 2 values, the table column and at least 1 node.', 1);
         }
 

src/JSON/JsonExpressionFactory.php

Indentation +51 added lines, -51 removed lines

@@ -9,65 +9,65 @@
 
 class JsonExpressionFactory
 {
-    use TablePrefixer;
+	use TablePrefixer;
 
-    /** @var Connection */
-    protected $connection;
+	/** @var Connection */
+	protected $connection;
 
-    public function __construct(Connection $connection)
-    {
-        $this->connection = $connection;
-    }
+	public function __construct(Connection $connection)
+	{
+		$this->connection = $connection;
+	}
 
-    /**
-     * Returns the current connection instance.
-     *
-     * @return connection
-     */
-    public function getConnection(): Connection
-    {
-        return $this->connection;
-    }
+	/**
+	 * Returns the current connection instance.
+	 *
+	 * @return connection
+	 */
+	public function getConnection(): Connection
+	{
+		return $this->connection;
+	}
 
-    /**
-     * Normalises the values passed as nodes
-     *
-     * @param mixed $nodes
-     * @return string
-     */
-    protected function normaliseNodes($nodes): string
-    {
-        // If its not an array, cast.
-        if (!is_array($nodes)) {
-            $nodes = [$nodes];
-        }
+	/**
+	 * Normalises the values passed as nodes
+	 *
+	 * @param mixed $nodes
+	 * @return string
+	 */
+	protected function normaliseNodes($nodes): string
+	{
+		// If its not an array, cast.
+		if (!is_array($nodes)) {
+			$nodes = [$nodes];
+		}
 
-        // Remove all none string.
-        $nodes = array_filter($nodes, function ($node): bool {
-            return is_string($node);
-        });
+		// Remove all none string.
+		$nodes = array_filter($nodes, function ($node): bool {
+			return is_string($node);
+		});
 
-        // If we have no nodes, throw.
-        if (count($nodes) === 0) {
-            throw new Exception("Only strings values may be passed as nodes.");
-        }
+		// If we have no nodes, throw.
+		if (count($nodes) === 0) {
+			throw new Exception("Only strings values may be passed as nodes.");
+		}
 
-        return \implode('.', $nodes);
-    }
+		return \implode('.', $nodes);
+	}
 
-    /**
-     * @param string          $column  The database column which holds the JSON value
-     * @param string|string[] $nodes   The json key/index to search
-     * @return \Pixie\QueryBuilder\Raw
-     */
-    public function extractAndUnquote(string $column, $nodes): Raw
-    {
-        // Normalise nodes.
-        $nodes = $this->normaliseNodes($nodes);
+	/**
+	 * @param string          $column  The database column which holds the JSON value
+	 * @param string|string[] $nodes   The json key/index to search
+	 * @return \Pixie\QueryBuilder\Raw
+	 */
+	public function extractAndUnquote(string $column, $nodes): Raw
+	{
+		// Normalise nodes.
+		$nodes = $this->normaliseNodes($nodes);
 
-        // Add any possible prefixes to the key
-        $column = $this->addTablePrefix($column, true);
+		// Add any possible prefixes to the key
+		$column = $this->addTablePrefix($column, true);
 
-        return new Raw("JSON_UNQUOTE(JSON_EXTRACT({$column}, \"$.{$nodes}\"))");
-    }
+		return new Raw("JSON_UNQUOTE(JSON_EXTRACT({$column}, \"$.{$nodes}\"))");
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -38,12 +38,12 @@
     protected function normaliseNodes($nodes): string
     {
         // If its not an array, cast.
-        if (!is_array($nodes)) {
+        if ( ! is_array($nodes)) {
             $nodes = [$nodes];
         }
 
         // Remove all none string.
-        $nodes = array_filter($nodes, function ($node): bool {
+        $nodes = array_filter($nodes, function($node): bool {
             return is_string($node);
         });
 

src/loader.php

Indentation +21 added lines, -21 removed lines

@@ -27,66 +27,66 @@
 
 // Generated code start...
 if (!trait_exists(Pixie\QueryBuilder\TablePrefixer::class)) {
-    require_once __DIR__ . '/QueryBuilder/TablePrefixer.php';
+	require_once __DIR__ . '/QueryBuilder/TablePrefixer.php';
 }
 if (!interface_exists(Pixie\HasConnection::class)) {
-    require_once __DIR__ . '/HasConnection.php';
+	require_once __DIR__ . '/HasConnection.php';
 }
 if (!class_exists(Pixie\Binding::class)) {
-    require_once __DIR__ . '/Binding.php';
+	require_once __DIR__ . '/Binding.php';
 }
 if (!class_exists(Pixie\QueryBuilder\QueryBuilderHandler::class)) {
-    require_once __DIR__ . '/QueryBuilder/QueryBuilderHandler.php';
+	require_once __DIR__ . '/QueryBuilder/QueryBuilderHandler.php';
 }
 if (!class_exists(Pixie\QueryBuilder\Transaction::class)) {
-    require_once __DIR__ . '/QueryBuilder/Transaction.php';
+	require_once __DIR__ . '/QueryBuilder/Transaction.php';
 }
 if (!class_exists(Pixie\QueryBuilder\Raw::class)) {
-    require_once __DIR__ . '/QueryBuilder/Raw.php';
+	require_once __DIR__ . '/QueryBuilder/Raw.php';
 }
 if (!class_exists(Pixie\JSON\JsonHandler::class)) {
-    require_once __DIR__ . '/JSON/JsonHandler.php';
+	require_once __DIR__ . '/JSON/JsonHandler.php';
 }
 if (!class_exists(Pixie\EventHandler::class)) {
-    require_once __DIR__ . '/EventHandler.php';
+	require_once __DIR__ . '/EventHandler.php';
 }
 if (!class_exists(Pixie\QueryBuilder\QueryObject::class)) {
-    require_once __DIR__ . '/QueryBuilder/QueryObject.php';
+	require_once __DIR__ . '/QueryBuilder/QueryObject.php';
 }
 if (!class_exists(Pixie\QueryBuilder\JoinBuilder::class)) {
-    require_once __DIR__ . '/QueryBuilder/JoinBuilder.php';
+	require_once __DIR__ . '/QueryBuilder/JoinBuilder.php';
 }
 if (!class_exists(Pixie\QueryBuilder\NestedCriteria::class)) {
-    require_once __DIR__ . '/QueryBuilder/NestedCriteria.php';
+	require_once __DIR__ . '/QueryBuilder/NestedCriteria.php';
 }
 if (!class_exists(Pixie\JSON\JsonSelectorHandler::class)) {
-    require_once __DIR__ . '/JSON/JsonSelectorHandler.php';
+	require_once __DIR__ . '/JSON/JsonSelectorHandler.php';
 }
 if (!class_exists(Pixie\JSON\JsonSelector::class)) {
-    require_once __DIR__ . '/JSON/JsonSelector.php';
+	require_once __DIR__ . '/JSON/JsonSelector.php';
 }
 if (!class_exists(Pixie\Connection::class)) {
-    require_once __DIR__ . '/Connection.php';
+	require_once __DIR__ . '/Connection.php';
 }
 if (!class_exists(Pixie\QueryBuilder\JsonQueryBuilder::class)) {
-    require_once __DIR__ . '/QueryBuilder/JsonQueryBuilder.php';
+	require_once __DIR__ . '/QueryBuilder/JsonQueryBuilder.php';
 }
 if (!class_exists(Pixie\Hydration\Hydrator::class)) {
-    require_once __DIR__ . '/Hydration/Hydrator.php';
+	require_once __DIR__ . '/Hydration/Hydrator.php';
 }
 if (!class_exists(Pixie\QueryBuilder\WPDBAdapter::class)) {
-    require_once __DIR__ . '/QueryBuilder/WPDBAdapter.php';
+	require_once __DIR__ . '/QueryBuilder/WPDBAdapter.php';
 }
 if (!class_exists(Pixie\Exception::class)) {
-    require_once __DIR__ . '/Exception.php';
+	require_once __DIR__ . '/Exception.php';
 }
 if (!class_exists(Pixie\QueryBuilder\TransactionHaltException::class)) {
-    require_once __DIR__ . '/QueryBuilder/TransactionHaltException.php';
+	require_once __DIR__ . '/QueryBuilder/TransactionHaltException.php';
 }
 if (!class_exists(Pixie\AliasFacade::class)) {
-    require_once __DIR__ . '/AliasFacade.php';
+	require_once __DIR__ . '/AliasFacade.php';
 }
 if (!class_exists(Pixie\JSON\JsonExpressionFactory::class)) {
-    require_once __DIR__ . '/JSON/JsonExpressionFactory.php';
+	require_once __DIR__ . '/JSON/JsonExpressionFactory.php';
 }
 // CREATED ON Fri 4th February 2022

Spacing +42 added lines, -42 removed lines

@@ -26,67 +26,67 @@
  */
 
 // Generated code start...
-if (!trait_exists(Pixie\QueryBuilder\TablePrefixer::class)) {
-    require_once __DIR__ . '/QueryBuilder/TablePrefixer.php';
+if ( ! trait_exists(Pixie\QueryBuilder\TablePrefixer::class)) {
+    require_once __DIR__.'/QueryBuilder/TablePrefixer.php';
 }
-if (!interface_exists(Pixie\HasConnection::class)) {
-    require_once __DIR__ . '/HasConnection.php';
+if ( ! interface_exists(Pixie\HasConnection::class)) {
+    require_once __DIR__.'/HasConnection.php';
 }
-if (!class_exists(Pixie\Binding::class)) {
-    require_once __DIR__ . '/Binding.php';
+if ( ! class_exists(Pixie\Binding::class)) {
+    require_once __DIR__.'/Binding.php';
 }
-if (!class_exists(Pixie\QueryBuilder\QueryBuilderHandler::class)) {
-    require_once __DIR__ . '/QueryBuilder/QueryBuilderHandler.php';
+if ( ! class_exists(Pixie\QueryBuilder\QueryBuilderHandler::class)) {
+    require_once __DIR__.'/QueryBuilder/QueryBuilderHandler.php';
 }
-if (!class_exists(Pixie\QueryBuilder\Transaction::class)) {
-    require_once __DIR__ . '/QueryBuilder/Transaction.php';
+if ( ! class_exists(Pixie\QueryBuilder\Transaction::class)) {
+    require_once __DIR__.'/QueryBuilder/Transaction.php';
 }
-if (!class_exists(Pixie\QueryBuilder\Raw::class)) {
-    require_once __DIR__ . '/QueryBuilder/Raw.php';
+if ( ! class_exists(Pixie\QueryBuilder\Raw::class)) {
+    require_once __DIR__.'/QueryBuilder/Raw.php';
 }
-if (!class_exists(Pixie\JSON\JsonHandler::class)) {
-    require_once __DIR__ . '/JSON/JsonHandler.php';
+if ( ! class_exists(Pixie\JSON\JsonHandler::class)) {
+    require_once __DIR__.'/JSON/JsonHandler.php';
 }
-if (!class_exists(Pixie\EventHandler::class)) {
-    require_once __DIR__ . '/EventHandler.php';
+if ( ! class_exists(Pixie\EventHandler::class)) {
+    require_once __DIR__.'/EventHandler.php';
 }
-if (!class_exists(Pixie\QueryBuilder\QueryObject::class)) {
-    require_once __DIR__ . '/QueryBuilder/QueryObject.php';
+if ( ! class_exists(Pixie\QueryBuilder\QueryObject::class)) {
+    require_once __DIR__.'/QueryBuilder/QueryObject.php';
 }
-if (!class_exists(Pixie\QueryBuilder\JoinBuilder::class)) {
-    require_once __DIR__ . '/QueryBuilder/JoinBuilder.php';
+if ( ! class_exists(Pixie\QueryBuilder\JoinBuilder::class)) {
+    require_once __DIR__.'/QueryBuilder/JoinBuilder.php';
 }
-if (!class_exists(Pixie\QueryBuilder\NestedCriteria::class)) {
-    require_once __DIR__ . '/QueryBuilder/NestedCriteria.php';
+if ( ! class_exists(Pixie\QueryBuilder\NestedCriteria::class)) {
+    require_once __DIR__.'/QueryBuilder/NestedCriteria.php';
 }
-if (!class_exists(Pixie\JSON\JsonSelectorHandler::class)) {
-    require_once __DIR__ . '/JSON/JsonSelectorHandler.php';
+if ( ! class_exists(Pixie\JSON\JsonSelectorHandler::class)) {
+    require_once __DIR__.'/JSON/JsonSelectorHandler.php';
 }
-if (!class_exists(Pixie\JSON\JsonSelector::class)) {
-    require_once __DIR__ . '/JSON/JsonSelector.php';
+if ( ! class_exists(Pixie\JSON\JsonSelector::class)) {
+    require_once __DIR__.'/JSON/JsonSelector.php';
 }
-if (!class_exists(Pixie\Connection::class)) {
-    require_once __DIR__ . '/Connection.php';
+if ( ! class_exists(Pixie\Connection::class)) {
+    require_once __DIR__.'/Connection.php';
 }
-if (!class_exists(Pixie\QueryBuilder\JsonQueryBuilder::class)) {
-    require_once __DIR__ . '/QueryBuilder/JsonQueryBuilder.php';
+if ( ! class_exists(Pixie\QueryBuilder\JsonQueryBuilder::class)) {
+    require_once __DIR__.'/QueryBuilder/JsonQueryBuilder.php';
 }
-if (!class_exists(Pixie\Hydration\Hydrator::class)) {
-    require_once __DIR__ . '/Hydration/Hydrator.php';
+if ( ! class_exists(Pixie\Hydration\Hydrator::class)) {
+    require_once __DIR__.'/Hydration/Hydrator.php';
 }
-if (!class_exists(Pixie\QueryBuilder\WPDBAdapter::class)) {
-    require_once __DIR__ . '/QueryBuilder/WPDBAdapter.php';
+if ( ! class_exists(Pixie\QueryBuilder\WPDBAdapter::class)) {
+    require_once __DIR__.'/QueryBuilder/WPDBAdapter.php';
 }
-if (!class_exists(Pixie\Exception::class)) {
-    require_once __DIR__ . '/Exception.php';
+if ( ! class_exists(Pixie\Exception::class)) {
+    require_once __DIR__.'/Exception.php';
 }
-if (!class_exists(Pixie\QueryBuilder\TransactionHaltException::class)) {
-    require_once __DIR__ . '/QueryBuilder/TransactionHaltException.php';
+if ( ! class_exists(Pixie\QueryBuilder\TransactionHaltException::class)) {
+    require_once __DIR__.'/QueryBuilder/TransactionHaltException.php';
 }
-if (!class_exists(Pixie\AliasFacade::class)) {
-    require_once __DIR__ . '/AliasFacade.php';
+if ( ! class_exists(Pixie\AliasFacade::class)) {
+    require_once __DIR__.'/AliasFacade.php';
 }
-if (!class_exists(Pixie\JSON\JsonExpressionFactory::class)) {
-    require_once __DIR__ . '/JSON/JsonExpressionFactory.php';
+if ( ! class_exists(Pixie\JSON\JsonExpressionFactory::class)) {
+    require_once __DIR__.'/JSON/JsonExpressionFactory.php';
 }
 // CREATED ON Fri 4th February 2022

src/Event.php

Indentation +9 added lines, -9 removed lines

@@ -27,13 +27,13 @@
 
 class Event
 {
-    /** Events */
-    public const BEFORE_SELECT = 'before-select';
-    public const AFTER_SELECT = 'after-select';
-    public const BEFORE_INSERT = 'before-insert';
-    public const AFTER_INSERT = 'after-insert';
-    public const BEFORE_UPDATE = 'before-update';
-    public const AFTER_UPDATE = 'after-update';
-    public const BEFORE_DELETE = 'before-delete';
-    public const AFTER_DELETE = 'after-delete';
+	/** Events */
+	public const BEFORE_SELECT = 'before-select';
+	public const AFTER_SELECT = 'after-select';
+	public const BEFORE_INSERT = 'before-insert';
+	public const AFTER_INSERT = 'after-insert';
+	public const BEFORE_UPDATE = 'before-update';
+	public const AFTER_UPDATE = 'after-update';
+	public const BEFORE_DELETE = 'before-delete';
+	public const AFTER_DELETE = 'after-delete';
 }