php - varios - usar archivo txt como base de datos




Bases de datos de archivos planos (8)

¿Cuáles son las mejores prácticas para crear estructuras de bases de datos de archivos planos en PHP?

Hay muchos marcos de archivos planos PHP más maduros que intento implementar sintaxis de consulta tipo SQL que es exagerada para mis propósitos en la mayoría de los casos. (Simplemente usaría una base de datos en ese punto).

¿Hay algún truco elegante para obtener un buen rendimiento y características con una pequeña sobrecarga de código?


Aquí está el código que usamos para Lilina:

<?php
/**
 * Handler for persistent data files
 *
 * @author Ryan McCue <[email protected]>
 * @package Lilina
 * @version 1.0
 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
 */

/**
 * Handler for persistent data files
 *
 * @package Lilina
 */
class DataHandler {
    /**
     * Directory to store data.
     *
     * @since 1.0
     *
     * @var string
     */
    protected $directory;

    /**
     * Constructor, duh.
     *
     * @since 1.0
     * @uses $directory Holds the data directory, which the constructor sets.
     *
     * @param string $directory 
     */
    public function __construct($directory = null) {
        if ($directory === null)
            $directory = get_data_dir();

        if (substr($directory, -1) != '/')
            $directory .= '/';

        $this->directory = (string) $directory;
    }

    /**
     * Prepares filename and content for saving
     *
     * @since 1.0
     * @uses $directory
     * @uses put()
     *
     * @param string $filename Filename to save to
     * @param string $content Content to save to cache
     */
    public function save($filename, $content) {
        $file = $this->directory . $filename;

        if(!$this->put($file, $content)) {
            trigger_error(get_class($this) . " error: Couldn't write to $file", E_USER_WARNING);
            return false;
        }

        return true;
    }

    /**
     * Saves data to file
     *
     * @since 1.0
     * @uses $directory
     *
     * @param string $file Filename to save to
     * @param string $data Data to save into $file
     */
    protected function put($file, $data, $mode = false) {
        if(file_exists($file) && file_get_contents($file) === $data) {
            touch($file);
            return true;
        }

        if(!$fp = @fopen($file, 'wb')) {
            return false;
        }

        fwrite($fp, $data);
        fclose($fp);

        $this->chmod($file, $mode);
        return true;

    }

    /**
     * Change the file permissions
     *
     * @since 1.0
     *
     * @param string $file Absolute path to file
     * @param integer $mode Octal mode
     */
    protected function chmod($file, $mode = false){
        if(!$mode)
            $mode = 0644;
        return @chmod($file, $mode);
    }

    /**
     * Returns the content of the cached file if it is still valid
     *
     * @since 1.0
     * @uses $directory
     * @uses check() Check if cache file is still valid
     *
     * @param string $id Unique ID for content type, used to distinguish between different caches
     * @return null|string Content of the cached file if valid, otherwise null
     */
    public function load($filename) {
        return $this->get($this->directory . $filename);
    }

    /**
     * Returns the content of the file
     *
     * @since 1.0
     * @uses $directory
     * @uses check() Check if file is valid
     *
     * @param string $id Filename to load data from
     * @return bool|string Content of the file if valid, otherwise null
     */
    protected function get($filename) {
        if(!$this->check($filename))
            return null;

        return file_get_contents($filename);
    }

    /**
     * Check a file for validity
     *
     * Basically just a fancy alias for file_exists(), made primarily to be
     * overriden.
     *
     * @since 1.0
     * @uses $directory
     *
     * @param string $id Unique ID for content type, used to distinguish between different caches
     * @return bool False if the cache doesn't exist or is invalid, otherwise true
     */
    protected function check($filename){
        return file_exists($filename);
    }

    /**
     * Delete a file
     *
     * @param string $filename Unique ID
     */
    public function delete($filename) {
        return unlink($this->directory . $filename);
    }
}

?>

Almacena cada entrada como un archivo separado, que encontramos lo suficientemente eficiente para su uso (no se cargan datos innecesarios y es más rápido guardarlos).


Bueno, ¿cuál es la naturaleza de las bases de datos planas? ¿Son grandes o pequeños? ¿Son simples matrices con matrices en ellas? si es algo simple, diga perfiles de usuario creados como tales:

$user = array("name" => "dubayou", 
              "age" => 20,
              "websites" => array("dubayou.com","willwharton.com","codecream.com"),
              "and_one" => "more");

y para guardar o actualizar el registro db para ese usuario.

$dir = "../userdata/";  //make sure to put it bellow what the server can reach.
file_put_contents($dir.$user['name'],serialize($user));

y cargar el registro para el usuario

function &get_user($name){
    return unserialize(file_get_contents("../userdata/".$name));
}

pero nuevamente, esta implementación variará según la aplicación y la naturaleza de la base de datos que necesita.


En mi opinión, el uso de una "Base de datos de archivos planos" en el sentido de lo que quiere decir (y la respuesta que ha aceptado) no es necesariamente la mejor manera de hacer las cosas. En primer lugar, usar serialize() y unserialize() puede causar dolores de cabeza GRANDES si alguien ingresa y edita el archivo (de hecho, puede poner código arbitrario en su "base de datos" para que se ejecute cada vez).

Personalmente, diría: ¿por qué no mirar hacia el futuro? Ha habido tantas veces que he tenido problemas porque he estado creando mis propios archivos "propietarios", y el proyecto ha explotado hasta el punto de que necesita una base de datos, y estoy pensando "ya sabes, ojalá Escribí esto para comenzar con una base de datos ", porque la refactorización del código requiere demasiado tiempo y esfuerzo.

De esto, aprendí que mi aplicación de prueba futura para que cuando crezca no tenga que ir y pasar días refactorizando es el camino a seguir. ¿Cómo hago esto?

SQLite. Funciona como una base de datos, usa SQL, y es bastante fácil cambiarlo a mySQL (¡especialmente si está usando clases abstractas para la manipulación de la base de datos como lo hago yo!)

De hecho, especialmente con el método de "respuesta aceptada", puede reducir drásticamente el uso de memoria de su aplicación (no tiene que cargar todos los "REGISTROS" en PHP)


Este es inspirador como una solución práctica:
https://github.com/mhgolkar/FlatFire
Utiliza múltiples estrategias para manejar datos ...
[Copiado del archivo Léame]

Libre o estructurado o mixto

- STRUCTURED
Regular (table, row, column) format.
[DATABASE]
/   \
TX  TableY
    \_____________________________
    |ROW_0 Colum_0 Colum_1 Colum_2|
    |ROW_1 Colum_0 Colum_1 Colum_2|
    |_____________________________|
- FREE
More creative data storing. You can store data in any structure you want for each (free) element, its similar to storing an array with a unique "Id".
[DATABASE]
/   \
EX  ElementY (ID)
    \________________
    |Field_0 Value_0 |
    |Field_1 Value_1 |
    |Field_2 Value_2 |
    |________________|
recall [ID]: get_free("ElementY") --> array([Field_0]=>Value_0,[Field_1]=>Value_1...
- MIXD (Mixed)
Mixed databases can store both free elements and tables.If you add a table to a free db or a free element to a structured db, flat fire will automatically convert FREE or SRCT to MIXD database.
[DATABASE]
/   \
EX  TY

Puede considerar SQLite . Es casi tan simple como los archivos planos, pero obtienes un motor SQL para realizar consultas. Funciona bien con PHP también.


Si desea un resultado legible para humanos, también puede usar este tipo de archivo:

ofaurax|27|male|something|
another|24|unknown||
...

De esta manera, solo tiene un archivo, puede depurarlo (y corregirlo manualmente) fácilmente, puede agregar campos más tarde (al final de cada línea) y el código PHP es simple (para cada línea, dividido según |).

Sin embargo, el inconveniente es que debe analizar todo el archivo para buscar algo (si tiene millones de entradas, no está bien) y debe manejar el separador en los datos (por ejemplo, si el nick es WaR | ordz).


Simplemente señalando un problema potencial con una base de datos de archivos planos con este tipo de sistema:

data|some text|more data

row 2 data|bla hbalh|more data

... etc.

El problema es que los datos de la celda contienen un "|" o un "\ n", entonces los datos se perderán. A veces sería más fácil dividir por combinaciones de letras que la mayoría de la gente no usaría.

Por ejemplo:

Divisor de columna: #$% (Shift+345)

Separador de filas: ^&* (Shift+678)

Archivo de texto: test data#$%blah blah#$%^&*new row#$%new row data 2

Luego use: explode("#$%", $data); use foreach, the explode again to separate columns explode("#$%", $data); use foreach, the explode again to separate columns

O cualquier cosa en este sentido. Además, podría agregar que las bases de datos de archivos planos son buenas para los sistemas con pequeñas cantidades de datos (es decir, menos de 20 filas), pero se convierten en enormes cerdos de memoria para bases de datos más grandes.


Un marco que estoy considerando sería para una plataforma de blogs. Dado que casi cualquier vista posible de datos que desearía se ordenaría por fecha, estaba pensando en esta estructura:

Un directorio por nodo de contenido:

./content/YYYYMMDDHHMMSS/

Subdirectorios de cada nodo incluyendo

/tags  
/authors  
/comments  

Además de archivos de texto simples en el directorio de nodos para contenido pre y post renderizado y similares.

Esto permitiría que una simple llamada glob() PHP (y probablemente una inversión de la matriz de resultados) consulte sobre casi cualquier cosa dentro de la estructura de contenido:

glob("content/*/tags/funny");  

Volvería caminos incluyendo todos los artículos etiquetados "gracioso".







flat-file