Initial Commit

.gitignore

@@ -0,0 +1 @@
+.idea

README.md

@@ -0,0 +1,6 @@
+<h1>Simple DBAL</h1>
+Ein Simpler Database Abstraction Layer der eine rudimentäre funktionalität bietet.
+Dieser DBAL ermöglicht es Datenbank Queries zu erzeugen ohne SQL Code direkt im eigenen Code zu schreiben.
+
+<br /><br />
+Eine genaue erklärung wird hier noch folgen ^^

composer.json

@@ -0,0 +1,21 @@
+{
+    "name": "scavenger/simple-dbal",
+    "version": "0.2.0",
+    "description": "A Simple Database Abstraction Layer with a few simple Classes to prevent writing raw SQL in your Code",
+    "type": "library",
+    "authors": [
+        {
+            "name": "Marcel Voelkel",
+            "email": "m.voelkel@scav-media.com"
+        }
+    ],
+    "minimum-stability": "dev",
+    "require": {
+        "php": ">=7.1"
+    },
+    "autoload": {
+        "psr-0": {
+            "SimpleDBAL": "src/"
+        }
+    }
+}

src/Database.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace SimpleDBAL;
+
+use PDO;
+use PDOException;
+
+class Database extends PDO {
+    private $db;
+
+    private $stmt;
+
+    /**
+     * Database constructor.
+     * @param array $config
+     */
+    public function __construct($config)
+    {
+        $dsn = $config['dbext']. ":host=".$config['dbhost'].";dbname=".$config['dbname'].";charset=".$config['dbchar'];
+
+        try {
+             parent::__construct($dsn, $config['dbuser'], $config['dbpass']);
+        } catch (PDOException $e) {
+            print($e);
+        }
+    }
+}

src/QueryBuilder.php

@@ -0,0 +1,275 @@
+<?php
+
+namespace SimpleDBAL;
+
+
+class QueryBuilder
+{
+
+    private $db;
+
+    private $select = [];
+
+    private $table = null;
+
+    private $values = [];
+
+    private $where = [];
+
+    private $orderBy = [];
+
+    private $join = [];
+
+    private $paramters = [];
+
+    private $groupBy = null;
+
+    private $qType;
+
+    public const IS_SELECT = 1;
+    public const IS_INSERT = 2;
+    public const IS_UPDATE = 3;
+    public const IS_DELETE = 4;
+    public const IS_TRUNCATE = 5;
+
+    public function __construct(Database $db)
+    {
+        $this->db = $db;
+    }
+
+    public function Execute($fetchArray = false)
+    {
+        echo var_dump(SQLBuilder::Build($this));
+        $query = $this->db->prepare(SQLBuilder::Build($this));
+        if ($this->paramters) {
+            foreach ($this->paramters as $paraKey => $paraValue) {
+                $query->bindValue($paraKey, $paraValue);
+            }
+        }
+        $query->execute();
+            if ($query->rowCount() > 1 || $fetchArray == true) {
+                return $query->fetchAll($this->db::FETCH_ASSOC);
+            } else {
+                return $query->fetch($this->db::FETCH_ASSOC);
+            }
+    }
+
+    public function Reset()
+    {
+        $this->select = [];
+        $this->table = null;
+        $this->values = [];
+        $this->where = [];
+        $this->orderBy = [];
+        $this->join = [];
+        $this->paramters = [];
+        $this->groupBy = null;
+    }
+
+    /**
+     * Nötig für ein SELECT Query. Speichert in einem Array die benötigten Felder des SQL Statements
+     * @param mixed ...$select
+     * @return QueryBuilder
+     */
+    public function Select(...$select): QueryBuilder
+    {
+        foreach ($select as $item)
+            $this->select[] = $item;
+        $this->qType = self::IS_SELECT;
+        return $this;
+    }
+
+    /**
+     * Nötig für ein UPDATE Query. Speichert in einem Array die benötigten Felder des SQL Statements
+     * @param array $update
+     * @return QueryBuilder
+     */
+    public function Update(array $update): QueryBuilder
+    {
+        $this->select = $update;
+        $this->qType = self::IS_UPDATE;
+        return $this;
+    }
+
+    /**
+     * Nötig für einen INSERT Query. Speichert in einem Array die nötigen felder des SQL Statements
+     * @param array $insert
+     * @return QueryBuilder
+     */
+    public function Insert(array $insert): QueryBuilder
+    {
+        $this->select = $insert;
+        $this->qType = self::IS_INSERT;
+        return $this;
+    }
+
+    /**
+     * Nötig für ein DELETE Query.
+     * @return QueryBuilder
+     */
+    public function Delete(): QueryBuilder
+    {
+        $this->qType = self::IS_DELETE;
+        return $this;
+    }
+
+    public function Truncate(): QueryBuilder
+    {
+        $this->qType = self::IS_TRUNCATE;
+        return $this;
+    }
+
+    /**
+     * Nötig um die Tabelle der Datenbank auszuwählen die benötigt wird
+     * @param string $table
+     * @return QueryBuilder
+     */
+    public function Table(string $table): QueryBuilder
+    {
+        $this->table = $table;
+        return $this;
+    }
+
+    public function InsertValues(array $insertValues): QueryBuilder
+    {
+        $this->values = $insertValues;
+        return $this;
+    }
+
+    /**
+     * Nötig wenn man auf eine andere Tabelle Joinen möchte. Speichert
+     * Die nötigen Angaben in einem Array welches vom SQLBuilder verarbeitet wird.
+     * @param $joinType
+     * @param mixed ...$jArgs Following order: joinTable, joinColumn, originTable, originColumn
+     * @return QueryBuilder
+     */
+    public function Join($joinType, ...$jArgs): QueryBuilder
+    {
+        $this->join[$joinType] = $jArgs;
+        return $this;
+    }
+
+    /**
+     * Nötig für SET Angaben im UPDATE Segment eines SQL Statements.
+     * Nutzt das Select-Array, da während eines UPDATE keine SELECT Angaben getätigt werden
+     * @param $column
+     * @param $value
+     * @return QueryBuilder
+     */
+    public function Set(string $column, $value): QueryBuilder
+    {
+        $this->select[$column] = $value;
+        return $this;
+    }
+
+    /**
+     * Nötig für WHERE Teil des SQL Statements. Speichert die Angaben in dem Array $this->where für weitere Verarbeitung
+     * @param $column
+     * @param $value
+     * @param string $operator
+     * @return QueryBuilder
+     */
+    public function Where($column, $value, $operator = "="): QueryBuilder
+    {
+        $this->where[] = (new QueryFilter($column, $value))->setOperator($operator);
+        return $this;
+    }
+
+    /**
+     * Angabe nach welchen Spalten sortiert werden soll
+     * @param $order
+     * @param bool $desc
+     * @return QueryBuilder
+     */
+    public function OrderBy($order, bool $desc = false): QueryBuilder
+    {
+        if (is_array($order)) {
+            foreach ($order as $column => $desc) {
+                if (is_bool($desc))
+                    $this->orderBy[$column] = $desc;
+                else
+                    $this->orderBy[$desc] = false;
+            }
+        } else {
+            $this->orderBy[$order] = $desc;
+        }
+        return $this;
+    }
+
+    public function GroupBy($value)
+    {
+        $this->groupBy = $value;
+        return $this;
+    }
+
+    public function setParameter($param, $value)
+    {
+        $this->paramters[$param] = $value;
+        return $this;
+    }
+
+    /**
+     * @return array
+     */
+    public function getSelect(): array
+    {
+        return $this->select;
+    }
+
+    /**
+     * @return null
+     */
+    public function getTable()
+    {
+        return $this->table;
+    }
+
+    /**
+     * @return array
+     */
+    public function getValues(): array
+    {
+        return $this->values;
+    }
+
+    /**
+     * @return array
+     */
+    public function getWhere(): array
+    {
+        return $this->where;
+    }
+
+    /**
+     * @return array
+     */
+    public function getJoin(): array
+    {
+        return $this->join;
+    }
+
+    /**
+     * @return array
+     */
+    public function getOrderBy(): array
+    {
+        return $this->orderBy;
+    }
+
+    /**
+     * @return string
+     */
+    public function getGroupBy()
+    {
+        return $this->groupBy;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getQType()
+    {
+        return $this->qType;
+    }
+
+}

src/QueryFilter.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace SimpleDBAL;
+
+class QueryFilter {
+
+    private $column;
+    private $value;
+    private $operator = "=";
+
+    public function __construct(string $column, $value)
+    {
+        $this->column = $column;
+        $this->value = $value;
+    }
+
+    public function setOperator(string $operator): QueryFilter
+    {
+        $this->operator = $operator;
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getOperator(): string
+    {
+        return $this->operator;
+    }
+
+    /**
+     * @return string
+     */
+    public function getColumn(): string
+    {
+        return $this->column;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+
+}

src/SQLBuilder.php

@@ -0,0 +1,210 @@
+<?php
+
+namespace SimpleDBAL;
+
+
+abstract class SQLBuilder
+{
+
+    private static function Quote($value, string $quote = "'")
+    {
+        if(strpos($value, "COUNT") !== false && strpos($value, "`") === false || $value == "NOW()") {
+            $output = $value;
+        } else {
+            $output = (is_numeric($value) ? $value : ($value[0] == ":" && !strpos($value, "`") ? $value : $quote . $value . $quote));
+        }
+        return $output;
+    }
+
+    public static function Build(QueryBuilder $query)
+    {
+        switch ($query->getQType()) {
+            case QueryBuilder::IS_SELECT:
+                return self::GenerateSelect($query);
+                break;
+            case QueryBuilder::IS_UPDATE:
+                return self::GenerateUpdate($query);
+                break;
+            case QueryBuilder::IS_INSERT:
+                return self::GenerateInsert($query);
+                break;
+            case QueryBuilder::IS_TRUNCATE:
+                return self::GenerateTruncate($query);
+                break;
+            case QueryBuilder::IS_DELETE:
+                return self::GenerateDelete($query);
+                break;
+
+        }
+    }
+
+
+    /**
+     * Generiert einen mit Kommata getrennten String
+     * @param array $list
+     * @param string $quote
+     * @return string
+     */
+    private static function generateListItems(array $list, string $quote = "'")
+    {
+        $out = "";
+        foreach ($list as $item)
+            $out .= self::Quote($item, $quote) . ", ";
+
+        return rtrim($out, ", ");
+    }
+
+    /**
+     * Erzeugt eine Liste aus Schlüsseln und Werten
+     * @param array $list
+     * @param string $operator
+     * @param string $seperator
+     * @return string
+     */
+    private static function KeyValues(array $list, string $operator = " = ", string $seperator = ", ")
+    {
+        $out = "";
+        foreach ($list as $key => $value)
+            $out .= self::Quote($key, "`") . $operator . self::Quote($value, "'");
+
+        return rtrim($out, $seperator);
+    }
+
+    /**
+     * Erzeugt einen gültigen String für eine SELECT-Ausgabe eines SQL Statements
+     * @param array $columns
+     * @return string
+     */
+    private static function SelectConstruct(array $columns): string
+    {
+        return (count($columns) > 0) ? self::generateListItems($columns, "`") : "*";
+    }
+
+    private static function InsertConstruct(array $columns): string
+    {
+        return (count($columns) > 0) ? self::generateListItems($columns, "`") : "";
+    }
+
+    private static function ValueConstruct(array $values): string
+    {
+        return self::generateListItems($values);
+    }
+
+    private static function JoinConstruct(array $joins): string
+    {
+        $outJoin = "";
+        foreach ($joins as $key => $value)
+            $outJoin .= $key . " JOIN " . $value[0] . " ON `" . $value[0] . "`.`" . $value[1] . "` = `" . $value[2] . "`.`" . $value[3] . "`";
+
+        return $outJoin;
+    }
+
+    /**
+     * Erzeugt einen gültigen String für eine WHERE-Ausgabe eines SQL Statements
+     * @param array $where
+     * @return string
+     */
+    private static function WhereConstruct(array $where): string
+    {
+        if (count($where) === 0)
+            return "";
+
+        $out = "";
+        foreach ($where as $item) {
+            if($item->getOperator() == "BETWEEN") {
+                $values = explode("#", $item->getValue());
+                $out .= "`".$item->getColumn()."` ". $item->getOperator(). " " . self::Quote($values[0], "") ." AND ". self::Quote($values[1], "") ." AND ";
+            }
+            else {
+                $out .= "`" . $item->getColumn() . "` " . $item->getOperator() . " " . self::Quote($item->getValue()) . " AND ";
+            }
+        }
+
+        return rtrim($out, " AND ");
+    }
+
+    /**
+     * Erzeugt das ORDER BY anhand eines Arrays das die Spaltennahmen als Array-Schlüssel und den boolischen Wert als Value enthält
+     * True = Descending; False = Ascending;
+     * @param array $orderBy
+     * @return string
+     */
+    private static function OrderByConstruct(array $orderBy): string
+    {
+        if (count($orderBy) === 0)
+            return "";
+
+        $orderCols = [];
+        foreach ($orderBy as $cols => $order)
+            $orderCols[] = "`{$cols}`" . ($order === true ? " DESC" : "");
+
+        return " ORDER BY " . self::generateListItems($orderCols, "");
+    }
+
+    /**
+     * Erzeugt den GROUP BY Part des SQL Statements
+     * @param $groupBy
+     * @return string
+     */
+    private static function GroupByConstruct($groupBy): string
+    {
+        return " GROUP BY " . $groupBy;
+    }
+
+    /**
+     * Erzeugt ein SELECT Statement welches mit JOINs, WHEREs, GROUP BYs und ORDER BYs erstellt wird
+     * @param QueryBuilder $query
+     * @return string
+     */
+    private static function GenerateSelect(QueryBuilder $query): string
+    {
+        return "SELECT " . self::SelectConstruct($query->getSelect()) . " FROM " . $query->getTable() .
+            (!empty($query->getJoin()) ? " " . self::JoinConstruct($query->getJoin()) : "") .
+            (!empty($query->getWhere()) ? " WHERE " . self::WhereConstruct($query->getWhere()) : "") .
+            (!empty($query->getGroupBy()) ? self::GroupByConstruct($query->getGroupBy()) : "") .
+            (!empty($query->getOrderBy()) ? self::OrderByConstruct($query->getOrderBy()) : "");
+    }
+
+    /**
+     * Erzeugt ein UPDATE Statement
+     * @param QueryBuilder $query
+     * @return string
+     */
+    private static function GenerateUpdate(QueryBuilder $query): string
+    {
+        return "UPDATE " . $query->getTable() . " SET " . self::KeyValues($query->getSelect(), " = ", ",") .
+            " WHERE " . self::WhereConstruct($query->getWhere());
+    }
+
+    /**
+     * Erzeugt ein INSERT INTO Statement
+     * @param QueryBuilder $query
+     * @return string
+     */
+    private static function GenerateInsert(QueryBuilder $query): string
+    {
+        return "INSERT INTO " . $query->getTable() . " (" . self::InsertConstruct($query->getSelect()) . ") VALUES (" . self::ValueConstruct($query->getValues()) . ")";
+    }
+
+    /**
+     * Erzeugt ein TRUNCATE TABLE Statement
+     * @param QueryBuilder $query
+     * @return string
+     */
+    private function GenerateTruncate(QueryBuilder $query): string
+    {
+        return "TRUNCATE TABLE ".$query->getTable();
+    }
+
+    /**
+     * Erzeugt ein DELETE FROM Statement
+     * @param QueryBuilder $query
+     * @return string
+     */
+    private function GenerateDelete(QueryBuilder $query): string
+    {
+        return "DELETE FROM ". $query->getTable() . " WHERE " . self::WhereConstruct($query->getWhere());
+    }
+
+
+}