added composer support

Author: daveismynamecom

LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Daveismyname
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -4,49 +4,36 @@ This PDO wrapper, is a collection of crud methods for working with a database th
 
 ## Install
 
-To install place this class into the project folder and include the class, then set the db credentials. Finally create an instance of the classes by calling it's get method.
+Using composer include the repository by typing the following into a terminal
 
-This wrapper makes use of a single database connection further connections attempts will reuse the already open connections, if not already connected.
-
-````php
-include('database.php');
+```
+composer require daveismyname/pdo-wrapper
+```
 
-//db properties
-define('DB_TYPE','mysql');
-define('DB_HOST','localhost');
-define('DB_USER','username');
-define('DB_PASS','password');
-define('DB_NAME','database name');
+Set the db credentials. Finally create an instance of the classes by calling it's get method.
 
-// make a connection to mysql here
-$db = Database::get();
-````
+This wrapper makes use of a single database connection further connections attempts will reuse the already open connections, if not already connected.
 
-To make a connection to another database pass an array containing the following:
+```php
+use Daveismyname\PdoWrapper\Database;
 
-````
-$db = Database::get(array(
-	'type' => 'mysql',
-	'host' => 'localhost',
-	'name' => 'dbname',
-	'user' => 'dbusername'
-	'pass' => 'password'
-));
-````
+// make a connection to mysql here
+$db = Database::get($username, $password, $database, $host = 'localhost', $type = 'mysql');
+```
 
 # Usage examples
 
 ## Select:
 
-````php
+```php
 $db->select("column FROM table");
-````
+```
 
 To select data based on user data instead of passing the data to the query directly use a prepared statement, this is safer and stops any attempt at sql injections.
 
-````php
+```php
 $db->select("username FROM members WHERE memberID = :id and email = :email", array(':id' => 1, ':email' => 'someone@domain.com'));
-````
+```
 
 The above query will return the username from the members table where the memberID and email match. The memberID and email is passed seperartly in an array.
 
@@ -56,67 +43,67 @@ Data returned from the query will be returns as an object this can be changed by
 
 To use the object loop through it, a typical example:
 
-````php
+```php
 $rows = $db->select("firstName, lastName FROM members ORDER BY firstName, lastName");
 foreach ($rows as $row) {
     echo "<p>$row->firstName $row->lastName</p>";
 }
-````
+```
 
-## Select Signle Record:
+## Select Single Record:
 
 Using find() will return only a single result. Like select it accepts params being passed in an array as a second argument.
 
-````php
+```php
 $db->find("column FROM table where id=:id", [':id' => 23]);
-````
+```
 
 # Raw
 
 A raw query is a query that is not ran through a prepared statement and will execute the query passed directly. Useful when creating a table.
 
-````php
+```php
 $db->raw("CREATE TABLE IF NOT EXISTS members (
   memberID INT(11) NOT NULL AUTO_INCREMENT,
   firstName VARCHAR(255) NOT NULL,
   lastnName VARCHAR(255) NOT NULL,
   email VARCHAR(255) NOT NULL,
   PRIMARY KEY (memberID))"
 );
-````
+```
 
 ## Insert
 
 Data is inserted by calling the insert method it expects the table name followed by an array of key and values to insert in to the database.
 
-````php
+```php
 $data = array(
     'firstName' => 'Joe',
     'lastnName' => 'Smith',
     'email' => 'someone@domain.com'
 );
 $db->insert('members', $data);
-````
+```
 
 The insert automatically returns the last inserted id by returning 'lastInsertId' to collect the id:
 
-````php
+```php
 $id = $db->insert('members', $data);
-````
+```
 
 ## Updating
 
 To update an existing record the update method is called. This method expects the table, array of data to update and a second array containing the where condition.
 
-````php
+```php
 $data = array(
     'firstName' => 'Joe',
     'lastnName' => 'Smith',
     'email' => 'someone@domain.com'
 );
 $where = array('memberID' => 2);
 $db->update('members', $data, $where);
-````
+```
 Or:
 
 ```php
@@ -137,37 +124,46 @@ $db->update('members', $update['data'], $update['where']);
 
 To delete records call the delete method. This method expects the table name and an array of the where condition.
 
-````php
+```php
 $where = array('memberID' => 2);
 $db->delete('members', $where);
-````
+```
 
 This will delete a single record to set the limit pass a third parameters containing the number to limit to, or to remove the limit pass null as a third param.
 
-````php
+```php
 $db->delete('members', $where, 10);  //delete 10 records matcing the where
 $db->delete('members', $where, null); //delete all records matching the where
 ```
 
+## Delete multiple IN
+
+To delete multiple records where ids are in a specific column, this uses WHERE id IN (4,5,6)
+
+```php
+$db->deleteByIds('users', 'id', '4,5,6');
+```
+
 ## Truncate
 
 To empty a table of all contents call the truncate method. Passing only the table name.
 
-````php
+```php
 $db->truncate('members');
-````
+```
 
 
 ## Count
 
 To count records call the count method. This method expects the table name and column name (optional).
 
-````php
+```php
 $db->count('members');
-````
+```
 
 If table has no column `id`
-````
+
+```php
 $db->count('members', 'member_id');
-````
+```
 

composer.json

@@ -0,0 +1,22 @@
+{
+    "name": "daveismyname/pdo-wrapper",
+    "description": "A crud wrapper for PDO",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "David Carr",
+            "email": "dave@daveismyname.com",
+            "homepage": "http://daveismyname.blog",
+            "role": "Developer"
+        }
+    ],
+    "require": {
+        "php": ">=7.2"
+    },
+    "autoload": {
+        "psr-4": {
+            "Daveismyname\\PdoWrapper\\": "/src"
+        }
+    },
+    "minimum-stability": "dev"
+}

database.php src/Database.phpdatabase.php renamed to src/Database.php

@@ -1,45 +1,32 @@
 <?php
+namespace Daveismyname\PdoWrapper;
+
+use PDO;
 
 class Database extends PDO
 {
     /**
      * @var array Array of saved databases for reusing
      */
-    protected static $instances = array();
+    protected static $instances = [];
 
     /**
      * Static method get
      *
      * @param  array $group
-     * @return \helpers\database
+     * @return database
      */
-    public static function get($group = false)
+    public static function get(string $username, string $password, string $database, string $host = 'localhost', string $type = 'mysql')
     {
-        // Determining if exists or it's not empty, then use default group defined in config
-        $group = !$group ? array (
-            'type' => DB_TYPE,
-            'host' => DB_HOST,
-            'name' => DB_NAME,
-            'user' => DB_USER,
-            'pass' => DB_PASS
-        ) : $group;
-
-        // Group information
-        $type = $group['type'];
-        $host = $group['host'];
-        $name = $group['name'];
-        $user = $group['user'];
-        $pass = $group['pass'];
-
-        // ID for database based on the group information
-        $id = "$type.$host.$name.$user.$pass";
+        // ID for database based on the credentials
+        $id = "$type.$host.$database.$username.$password";
 
         // Checking if the same
         if (isset(self::$instances[$id])) {
             return self::$instances[$id];
         }
 
-        $instance = new Database("$type:host=$host;dbname=$name;charset=utf8", $user, $pass);
+        $instance = new Database("$type:host=$host;dbname=$database;charset=utf8", $username, $password);
         $instance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 
         // Setting Database into $instances to avoid duplication
@@ -69,7 +56,7 @@ public function raw($sql)
      * @param  string $single    when set will return only 1 record
      * @return array            returns an array of records
      */
-    public function select($sql, $array = array(), $fetchMode = PDO::FETCH_OBJ, $class = '', $single = null)
+    public function select($sql, $array = [], $fetchMode = PDO::FETCH_OBJ, $class = '', $single = null)
     {
          // Append select if it isn't appended.
         if (strtolower(substr($sql, 0, 7)) !== 'select ') {
@@ -102,7 +89,7 @@ public function select($sql, $array = array(), $fetchMode = PDO::FETCH_OBJ, $cla
      * @param  string $class     class name
      * @return array            returns a single record
      */
-    public function find($sql, $array = array(), $fetchMode = PDO::FETCH_OBJ, $class = '')
+    public function find($sql, $array = [], $fetchMode = PDO::FETCH_OBJ, $class = '')
     {
         return $this->select($sql, $array, $fetchMode, $class, true);
     }
@@ -221,6 +208,13 @@ public function delete($table, $where, $limit = 1)
         return $stmt->rowCount();
     }
 
+    public function deleteByIds(string $table, string $column, string $ids)
+    {
+        $stmt = $this->prepare("DELETE FROM $table WHERE $column IN ($ids)");
+        $stmt->execute();
+        return $stmt->rowCount();        
+    }
+
     /**
      * truncate table
      * @param  string $table table name