CodeIgniter Filebase.php - File-base database

<?php
defined('BASEPATH') OR exit('No direct script access allowed');

/**
 * CodeIgniter Filebase Class
 *
 *  HOW TO USE - see at the bottom of the file.
 *
 * @package     CodeIgniter
 * @subpackage  Third Party
 * @category    File-based database engine
 * @author  Kader Bouyakoub <bkader@mail.com>
 * @link    https://github.com/bkader/filebase
 * @link    http://www.bkader.com/
 */

// Make sure the DIRECTORY_SEPARATOR is defined
defined('DS') OR define('DS', DIRECTORY_SEPARATOR);

class Filebase
{
    /**
     * @var string - path to data folder
     */
    protected $path = NULL;

    /**
     * @var string - main database name
     */
    protected $database = NULL;

    /**
     * @var string - table name set when class is called
     */
    protected $table = NULL;

    /**
     * @var string - realpath to the data folder
     */
    protected $data_dir = NULL;

    /**
     * @var string - realpath to table folder
     */
    protected $table_dir = NULL;

    /**
     * @var array - array of ALL tables' indices
     */
    protected $indices = array();

    /**
     * @var boolean - turn on/off safe delete
     */
    protected $safe_delete = FALSE;

    /**
     * @var array - array of fields with unique values.
     */
    protected $unique_fields = array();

    /**
     * Constructor:
     * We start by settings our path, database, table, data_dir and table_dir
     * @access  public
     * @param   array   $config     array of class config.
     * @param   string  $database   the database name
     */
    public function __construct($config = array(), $database = 'main')
    {
        // We start by setting real path to data folder.
        $this->path = realpath(($config['path'] !== NULL) ? $config['path'] : './').DS;

        // We set our database
        $this->db   = $database;

        // Set path to data folder and create it if it does snot exist.
        $this->data_dir = $this->path.$this->db.DS;

        // Create all needed folder
        $this->_create_datafolder();
        $this->_create_database();

        // Make sure our table is set and not NULL so we can create
        // our table's folder where files will be stored.
        $this->table = $config['table'];
        if ($this->table !== NULL)
        {
            $this->table_dir = $this->data_dir.$this->table.DS;
        }
        if ($this->table_dir !== NULL)
        {
            $this->_create_folder($this->table_dir);
        }

        // Check if our safe delete is turned on.
        if (isset($config['safe_delete']))
        {
            $this->safe_delete = (bool) $config['safe_delete'];
        }

        // Are there any unique fields?
        if (isset($config['unique_fields']) && is_array($config['unique_fields']))
        {
            $this->unique_fields = array_merge(
                $this->unique_fields,
                $config['unique_fields']
            );
        }

        // List all indices to be used to call files but also
        // to keep track of records count.
        $this->indices = $this->_list_indices();
    }

    /*
    |======================================================================
    | READERS
    |======================================================================
    */

    /**
     * Get the row where the value matches that of the key and return the value of the other key
     *
     * @param   string  $col    the column to get
     * @param   string  $key    the key whose value to match
     * @param   string  $val    the value to match
     * @param   array   $table  the array to get from
     *
     * @return array
     */
    public function get($col, $key, $val, $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $rows = $this->all($table))
        {
            foreach ($rows as $row)
            {
                if ($row[$key] === $val && $row[$col])
                {
                    return $row[$col];
                    break;
                }
            }
        }
        return FALSE;
    }

    /**
     * Returns an array of selected columns for all rows
     * @access  public
     * @param   array   $cols   columns to get
     * @param   string  $table  table name
     * @return  array
     */
    public function select($cols = array(), $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $rows = $this->all($table))
        {
            $_result = array();
            $_values = array();
            if ($cols === array())
            {
                foreach ($rows as $row)
                {
                    foreach (array_keys($row) as $c)
                    {
                        $_values[$c] = $row[$c];
                    }
                    if ($_values)
                    {
                        $_result[] = $_values;
                    }
                    $_values = array();
                }
            }
            else
            {
                foreach ($rows as $row)
                {
                    foreach ((array) $cols as $c)
                    {
                        if ($row[$c])
                            $_values[$c] = $row[$c];
                    }
                    if ($_values)
                    {
                        $_result[] = $_values;
                    }
                    $_values = array();
                }
            }
            return $_result;
        }
        return FALSE;
    }

    /**
     * Get columns from records in which key's value is part of an array of value
     * @access  public
     * @param   array   $cols   columns to get
     * @param   string  $key    key to look for the value
     * @param   array   $values array of value to be compared to
     * @return  array
     */
    public function where_in($cols = array(), $key, $values = array(), $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $rows = $this->all($table))
        {
            $_result = array();
            $_values = array();
            if ($cols === array())
            {
                foreach ($rows as $row)
                {
                    if (in_array($row[$key], $values))
                    {
                        foreach (array_keys($row) as $c)
                        {
                            $_values[$c] = $row[$c];
                        }
                        $_result[] = $_values;
                        $_values = array();
                    }
                }
            }
            else
            {
                foreach ($rows as $row)
                {
                    if (in_array($row[$key], $values))
                    {
                        foreach ((array) $cols as $c)
                        {
                            $_values[$c] = $row[$c];
                        }
                        $_result[] = $_values;
                        $_values = array();
                    }
                }
            }
            return $_result;
        }
        return FALSE;
    }

    /**
     * Get columns from records in which key's value is NOT part of an array of value
     * @access  public
     * @param   array   $cols   columns to get
     * @param   string  $key    key to look for the value
     * @param   array   $values array of value to be compared to
     * @return  array
     */
    public function where_not_in($cols = array(), $key, $values = array(), $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $rows = $this->all($table))
        {
            $_result = array();
            $_values = array();
            if ($cols === array())
            {
                foreach ($rows as $row)
                {
                    if ( ! in_array($row[$key], $values))
                    {
                        foreach (array_keys($row) as $c)
                        {
                            $_values[$c] = $row[$c];
                        }
                        $_result[] = $_values;
                        $_values = array();
                    }
                }
            }
            else
            {
                foreach ($rows as $row)
                {
                    if ( ! in_array($row[$key], $values))
                    {
                        foreach ((array) $cols as $c)
                        {
                            $_values[$c] = $row[$c];
                        }
                        $_result[] = $_values;
                        $_values = array();
                    }
                }
            }
            return $_result;
        }
        return FALSE;
    }

    /**
     * Matches keys and values bases on a regular expression
     * @param  array $cols  the columns to return
     * @param  string $key   the key to check
     * @param  string $regex the regular expression to match
     * @param  string $table table to execute the search on
     * @return array
     */
    public function like($cols, $key, $regex, $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $rows = $this->all($table))
        {
            $_result = array();
            $_values = array();
            if ($cols === array())
            {
                foreach ($rows as $row)
                {
                    if (preg_match($regex, $row[$key]))
                    {
                        foreach (array_keys($row) as $c)
                        {
                            $_values[$c] = $row[$c];
                        }
                        $_result[] = $_values;
                        $_values = array();
                    }
                }
            }
            else
            {
                foreach ($rows as $row)
                {
                    if (preg_match($regex, $row[$key]))
                    {
                        foreach ((array) $cols as $c)
                        {
                            $_values[$c] = $row[$c];
                        }
                        $_result[] = $_values;
                        $_values = array();
                    }
                }
            }
            return $_result;
        }
        return FALSE;
    }

    /**
     * Matches keys and values bases on a regular expression
     * @param  array $cols  the columns to return
     * @param  string $key   the key to check
     * @param  string $regex the regular expression to match
     * @param  string $table table to execute the search on
     * @return array
     */
    public function not_like($cols, $key, $regex, $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $rows = $this->all($table))
        {
            $_result = array();
            $_values = array();
            if ($cols === array())
            {
                foreach ($rows as $row)
                {
                    if ( ! preg_match($regex, $row[$key]))
                    {
                        foreach (array_keys($row) as $c)
                        {
                            $_values[$c] = $row[$c];
                        }
                        $_result[] = $_values;
                        $_values = array();
                    }
                }
            }
            else
            {
                foreach ($rows as $row)
                {
                    if ( ! preg_match($regex, $row[$key]))
                    {
                        foreach ((array) $cols as $c)
                        {
                            $_values[$c] = $row[$c];
                        }
                        $_result[] = $_values;
                        $_values = array();
                    }
                }
            }
            return $_result;
        }
        return FALSE;
    }

    /**
     * Retrieves a single row by its ID
     * @access  public
     * @param   string  $id     ID of the row to retrieve
     * @param   string  $table
     * @return  array
     */
    public function find($id, $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and in_array(md5($id), $this->indices))
        {
            $content = file_get_contents($this->table_dir.md5($id).'.dat');
            return $this->_unserialize($content);
        }
        return NULL;
    }

    /**
     * Retrieves multiple rows by conditions
     * @access  public
     * @param   mixed   $field  field name or array of WHERE
     * @param   mixed
     * @param   string  $table
     * @return  array
     */
    public function find_one($field, $match = NULL, $table = NULL)
    {
        $table or $table = $this->table;
        if($rows = $this->_read_files($table))
        {
            $where = (is_array($field) and $match === NULL) ? $field : array($field => $match);
            if ($indices = $this->_search_array($rows, $where))
            {
                return $rows[$indices[0]];
            }
            return NULL;
        }
        return NULL;
    }

    /**
     * Retrieves multiple or all rows inside a table
     * @access  public
     * @param   array   $where      array of WHERE statements
     * @param   string  $table
     * @return  array
     */
    // public function find_all($where = array(), $table = NULL)
    public function find_all($field, $match = NULL, $table = NULL)
    {
        $table or $table = $this->table;
        if ($rows = $this->_read_files($table))
        {
            $where = (is_array($field) AND $match === NULL)
                    ? $field : array($field => $match);
            $found = array();
            if ($indices = $this->_search_array($rows, $where))
            {
                foreach ($indices as $index)
                {
                    $found[] = $rows[$index];
                }
            }
            return $found;
        }
        return NULL;
    }

    /**
     * Alias of the method above but it takes only the table nam
     * so it would retrieve ALL records.
     * @access  public
     * @param   array   $where  array of WHERE statements
     * @param   string  $table  table name
     * @return  array
     */
    public function all($table = NULL)
    {
        return $this->find_all(array(), NULL, $table);
    }

    /*
    |======================================================================
    | CRUD INTERFACE
    |======================================================================
    */

    /**
     * Insert new record into table
     * @access  public
     * @param   array   $data       array of key=>value
     * @param   string  $table  table name
     * @return  boolean
     */
    public function insert($data, $table = NULL)
    {
        // Make sure to use a table, otherwise return FALSE
        $table or $table = $this->table;
        if ($this->table !== NULL)
        {
            // Prepare our default
            $default = array();

            // Loop through all our records and append to $default
            foreach($data as $key => $val)
            {
                // Make sure there is no duplicate entry!
                if (in_array($key, $this->unique_fields)
                    && $this->get($key, $key, $val))
                {
                    throw new Exception("Duplicate entry '{$val}' for key '{$key}'.");
                    break;
                }
                // Loop through and set our data
                $default[$key] = $val;
            }

            // Generate new UUID and add it to the $data array
            $guid = $this->_generate_guid();

            // Add both id and sid to $default.
            $default = array_merge(
                array(  'id' => $guid,
                        'sid' => $this->_shorten_guid($guid)),
                $default
            );

            // Make sure to insert our created_at and created_by in case it is not set
            $default['created_at'] = @$default['created_at'] ?: time();
            $default['created_by'] = @$default['created_by'] ?: NULL;

            // This is the first time the file is created! So, we set our
            // update fields and make them empty.
            $default['updated_at'] = 0;
            $default['updated_by'] = NULL;

            // Create safe delete fields if safe delete is turned on
            if ($this->safe_delete === TRUE)
            {
                $default['deleted']    = FALSE;
                $default['deleted_at'] = 0;
                $default['deleted_by'] = NULL;
            }

            // Prepare out file to store, put content into file and
            // return a simple the newly inserted ID.
            $file = $this->table_dir.md5($guid).'.dat';
            file_put_contents($file, $this->_serialize($default));
            return $guid;
        }
        return FALSE;
    }

    /**
     * Updates an existing row by its ID
     * @access  public
     * @param   string  $id     ID of the row to update
     * @param   array   $data   array of SET statements
     * @param   string  $table
     * @return  boolean
     */
    public function update($id, array $data, $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $row = $this->find($id))
        {
            foreach($data as $key => $val)
            {
                // Are there any duplicate entries?
                if (in_array($key, $this->unique_fields)
                    && $this->get($key, $key, $val))
                {
                    throw new Exception("Duplicate entry '{$val}' for key '{$key}'.");
                    break;
                }

                $row[$key] = $val;
                if (isset($data['updated_at']))
                {
                    $row['updated_at'] = time();
                }
                else
                {
                    $row['updated_at'] = time();
                }
            }

            $file = $this->data_dir.$table.DS.md5($row['id']).'.dat';

            return (file_put_contents($file, $this->_serialize($row))) ? TRUE : FALSE;
        }
        return FALSE;
    }

    /**
     * Updates multiple or all rows
     * @access  public
     * @param   array   $data   array of SET statements
     * @param   array   $where  array of WHERE statements
     * @param   string  $table
     * @return  boolean
     */
    public function update_all(array $data, $where = array(), $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $rows = $this->find_all($where, NULL, $table))
        {
            foreach($rows as $row)
            {
                $this->update($row['id'], $data, $table);
            }
            return TRUE;
        }
        return FALSE;
    }

    /**
     * Deletes a single existing row by its ID
     * @access  public
     * @param   string  $id     ID of the row to delete
     * @param   string  $table
     * @return  boolean
     */
    public function delete($id, $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $row = $this->find($id, $table))
        {
            if ($this->safe_delete === TRUE or isset($row['deleted']))
            {
                return $this->update($id, array(
                    'deleted'    => TRUE,
                    'deleted_at' => time(),
                ), $table);
            }
            else
            {
                return $this->remove($id, $table);
            }
        }
        return FALSE;
    }

    /**
     * Deletes multiple or all rows by conditions
     * @access  public
     * @param   array   $where  array of WHERE statements
     * @param   string  $table
     * @return  boolean
     */
    public function delete_all($where = array(), $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $rows = $this->find_all($where, NULL, $table))
        {
            foreach($rows as $row)
            {
                $this->delete($row['id']);
            }
            return TRUE;
        }
        return FALSE;
    }

    /**
     * Completely removes a single row bypassing soft delete
     * @access  public
     * @param   string  $id     ID of the row to delete
     * @param   string  $table
     * @return  boolean
     */
    public function remove($id, $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $row = $this->find($id, $table))
        {
            @unlink($this->table_dir.md5($row['id']).'.dat');
            clearstatcache();
            return TRUE;
        }
        return FALSE;
    }

    /**
     * Completely remove multiple or all rows bypassing soft delete
     * @access  public
     * @param   array   $where  array of where statements
     * @param   string  $table
     * @return  boolean
     */
    public function remove_all($where = array(), $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $rows = $this->find_all($where, NULL, $table))
        {
            foreach($rows as $row)
            {
                $this->remove($row['id'], $table);
            }
            clearstatcache();
            return TRUE;
        }
        return FALSE;
    }

    /**
     * This empties the table folder
     * NOTE: This is an alias of the method above
     * @access  public
     * @param   none
     * @return  boolean
     */
    public function truncate($table = NULL)
    {
        $table or $table = $this->table;
        return ($table !== NULL) ? $this->remove_all() : FALSE;
    }

    /*
    |======================================================================
    | UTILITIES
    |======================================================================
    */

    /**
     * Checks whether the given key/value pair exists
     *
     * @param string $key       the key
     * @param string $val       the value
     * @param array  $table     the array to work on
     *
     * @return boolean whether the pair exists
     */
    public function exists($key, $val, $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL and $rows = $thi->all($table))
        {
            $_result = FALSE;
            foreach ($rows as $row)
            {
                if ($row[$key] === $val)
                {
                    $_result = TRUE;
                }
            }
            return $_result;
        }
        return FALSE;
    }

    /**
     * Counts the number of items per column or for all columns
     *
     * @param string $col the column name to count. No input counts all columns.
     * @param string  $table  table to use
     *
     * @return int the number of rows containing that column.
     */
    public function count($col, $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL)
        {
            is_array($col) or $col = (array) $col;
            return count($this->select($col, $table));
        }
        return 0;
    }

    /**
     * Gets the first item of a column
     *
     * @param   string  $col    the column to look at
     * @param   string  $table  the table name
     *
     * @return mixed the first item in the column
     */
    public function first($col = array(), $table = NULL)
    {
        $table or $table = $this->table;
        return ($table !== NULL)
                ? $this->select((array) $col, $table)[0]
                : FALSE;
    }

    /**
     * Gets the last item in a column
     *
     * @param   string  $col    the name of the column to look at
     * @param   string  $table  the array to work on
     *
     * @return mixed the last item in the column
     */
    public function last($col, $table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL)
        {
            $_values = $this->select((array) $col, $table);
            return end($_values)[$col];
        }
        return FALSE;
    }

    /*
    |======================================================================
    | PRIVATE METHODS
    |======================================================================
    */

    /**
     * Searches inside an array
     * @access  protected
     * @param   array       $array
     * @param   array       $where
     */
    protected function _search_array(array $array, array $where)
    {
        $found = FALSE;
        foreach ($array as $aKey => $aVal)
        {
            $coincidences = 0;
            foreach ($where as $pKey => $pVal)
            {
                if (array_key_exists($pKey, $aVal) && $aVal[$pKey] == $pVal)
                {
                    $coincidences++;
                }
            }
            if ($coincidences == count($where))
            {
                $found[] = $aKey;
            }
        }

        return $found;
    }

    /**
     * Reads all files inside table folder
     * @access  protected
     * @param   string  $table
     * @return  array
     */
    protected function _read_files($table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL)
        {
            $rows = array();
            foreach (glob($this->table_dir.'*.dat') as $row)
            {
                $content = file_get_contents($row);
                $rows[] = $this->_unserialize($content);
            }
            return $rows;
        }
        return NULL;
    }

    // ------------------------------------------------------------------------

    /**
     * Creates a new folder in a specified path
     * @access  protected
     * @param   string  $path   folder to create
     * @return  boolean
     */
    protected function _create_folder($path = NULL)
    {
        if ($path !== NULL)
        {
            // Create data folder if it does not already exist.
            if ( ! is_dir($path))
            {
                // Create the data folder
                if ( ! mkdir($path, 0777, TRUE))
                {
                    throw new Exception("Could not create data folder. Permission Denied!");
                }
            }

            // Write our protection index.php if does not exists
            if ( ! file_exists($path.'index.php'))
            {
                $this->_create_index($path);
            }
        }
        return FALSE;
    }

    /**
     * Creates data folder if it does not exit.
     * @access  protected
     * @param   string  $path   path to data folder
     * @return  boolean
     */
    protected function _create_datafolder($path = NULL)
    {
        $path or $path = $this->path;
        return ($path !== NULL)
                ? $this->_create_folder($path)
                : FALSE;
    }

    /**
     * Creates database folder
     * @access  protected
     * @param   string  $path   path to database folder
     * @return boolean
     */
    protected function _create_database($database = NULL)
    {
        $database or $database = $this->database;
        return ($this->database !== NULL) ?
                $this->_create_folder($this->data_dir)
                : FALSE;
    }

    /**
     * Create the index.php protection file
     * @access  protected
     * @param   string $path path where the create the file
     * @return  void
     */
    protected function _create_index($path)
    {
        $o = umask(0);
        file_put_contents(
            $path.'index.php',
            '<?php'."\n".'die("No direct script access allowed.");'."\n"
        );
        umask($o);
    }

    // ------------------------------------------------------------------------

    /**
     * Returns an array of all IDs
     * @access  protected
     * @param   string  $table  table's name
     * @return  array
     */
    protected function _list_indices($table = NULL)
    {
        $table or $table = $this->table;
        if ($table !== NULL)
        {
            $indices = array();
            foreach (glob($this->table_dir.'*.dat') as $row)
            {
                $indices[] = str_replace('.dat', '', basename($row));
            }
            return $indices;
        }
        return FALSE;
    }

    /**
     * Generates a fresh new GUID
     * @access  protected
     * @param   none
     * @return  string
     */
    protected function _generate_guid($striped = FALSE)
    {
        $guid = '%04x%04x-%04x-%04x-%04x-%04x%04x%04x';
        if ($striped === TRUE)
            $guid = '%04x%04x%04x%04x%04x%04x%04x%04x';

        return vsprintf($guid, array(
            mt_rand(0, 0xffff), mt_rand(0, 0xffff),
            mt_rand(0, 0xffff),
            mt_rand(0, 0x0fff) | 0x4000,
            mt_rand(0, 0x3fff) | 0x8000,
            mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff),
        ));
    }

    /**
     * Generates a new shortened URL for a specific GUID
     * @access  protected
     * @param   string  $id     id to shorten
     * @return  string  $sid    shortened id
     */
    protected function _shorten_guid($guid = NULL)
    {
        if ($guid !== NULL and $this->table !== NULL)
        {
            do {
                $sid = $this->random_string();
                return $sid;
            } while ( ! $this->find_one('sid', $sid));
        }
        return FALSE;
    }

    /**
     * Generate random string
     * @access  public
     * @param   string  string to use to generate a random one
     * @return  string
     */
    public function random_string($str = NULL)
    {
        is_array($str) or $str = (array) $str;
        ! empty($str) or $str = array(uniqid(), session_id());
        for ($i=0; $i < count(array($str)); $i++)
        {
            $str = hash('crc32b', $str[$i]."-".$i);
        }
        return $str;

    }

    // ------------------------------------------------------------------------

    /**
     * Serializes an array
     * @access  protected
     * @param   array   $data   array of data to serialize
     * @return  string  serialized $data
     */
    protected function _serialize(array $data = array())
    {
        // Now we serialize and prepare our data!
        // 1. Try to use igbinary_serialize/igbinary_unserialize
        // 2. Try to use bson_encode/bson_decode (MongoDB)
        // 3. If none of the above found, we use json_encode/json_decode
        // 4. If none of the functions are available
        //    we use php serialize/unserialize

        if (function_exists('igbinary_serialize'))
            return igbinary_serialize($data);
        elseif (function_exists('bson_encode'))
            return bson_encode($data);
        elseif (function_exists('json_encode'))
            return json_encode($data);
        else
            return serialize($data);
    }

    /**
     * Unerializes a string into an array
     * @access  protected
     * @param   string  $str    the string to unserialize
     * @return  array   serialized string
     */
    protected function _unserialize($str = '')
    {
        if (function_exists('igbinary_unserialize'))
            $array = igbinary_unserialize($str);
        elseif (function_exists('bson_decode'))
            $array = bson_decode($str);
        elseif (function_exists('json_decode'))
            $array = json_decode($str);
        else
            $array = unserialize($str);

        // Because functions above, except php serialize, return
        // objects instead of array, we convert them into arrays.
        return (array) $array;
    }
}

// What is Filebase.php?
// ---------------------
// This class allows you to use CodeIgniter without any database server. It brings a homemade file-based, serverless database mechanism.

// How it works?
// -------------
// Once use, "Filebase" will automatically create a folder with the database name you provide. If you do not provide any, the database name "main" will be used.

// Each library using this class will have (preferably) its own table, which means, its own folder.

// Each record will be stored as a serialized array using in-order:
// 1. igbinary_serialize() and igbinary_unserialize() if they exist (Look for php_igbinary extension).
// 2. bson_encode() and bson_decode() if they exist (php_mongo extension).
// 3. json_encode() and json_decode()

// How to install?
// ---------------
// 1. Put the php files "Filebase.php" anywhere you want as long as you will correctly include.

// 2. Create a library (CodeIgniter) and include Filebase like so:
// require APPPATH.'third_party/Filebase/Filebase.php';
// (assuming that it is inside third_party folder)

// 3. In library's constructor you can put:

// - already declared $table -
// $this->table = new Filebase(array(
//     'path'        => $dbpath,
//     'table'       => $tablename,
//     'safe_delete' => TRUE/FALSE
// ), $database);
// - $dbpath: path to your writable database folder.
// - $tablename: library's table name.
// - safe_delete: whether to delete OR hide records.
// - $database : your database name (default: main)
//
// Once done, you can use the $table object like so:
// 1. $this->table->insert($data) where $data is the array to insert
// 2. $this->table->update($id, $data) & $this->table->update_all($data, $where)
// 3. $this->table->delete($id), ...->delete_all($where)
// ... etc

/* End of file Filebase.php */
/* Location: ./application/third_party/Filebase/Filebase.php */