Bases de datos de archivos planos [cerrado]

StackOverflow https://stackoverflow.com/questions/85

  •  08-06-2019
  •  | 
  •  

Pregunta

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

Muchos de los marcos de archivos planos PHP más maduros que veo intentan implementar una sintaxis de consulta similar a SQL, que es exagerada para mis propósitos en la mayoría de los casos (solo usaría una base de datos en ese momento).

¿Existen trucos elegantes para obtener un buen rendimiento y funciones con una pequeña sobrecarga de código?

¿Fue útil?

Solución

Bueno, ¿cuál es la naturaleza de las bases de datos planas?¿Son grandes o pequeños?¿Son matrices simples 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 de base de datos 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 para 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.

Otros consejos

Podrías considerar SQLite.Es casi tan simple como los archivos planos, pero obtienes un motor SQL para realizar consultas.Él funciona bien con PHP también.

En mi opinión, utilizar una "base de datos de archivos planos" en el sentido que usted quiere decir (y la respuesta que ha aceptado) no es necesariamente la mejor manera de hacer las cosas.En primer lugar, utilizando serialize() y unserialize() puede causar GRANDES dolores de cabeza si alguien ingresa y edita el archivo (de hecho, pueden poner código arbitrario en su "base de datos" para ejecutarlo 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 en que necesita una base de datos, y estoy pensando "ya sabes, desearía Para empezar, escribí esto para una base de datos", porque la refactorización del código requiere demasiado tiempo y esfuerzo.

De esto aprendí que preparar mi aplicación para el futuro para que cuando crezca no tenga que pasar días refactorizando es la forma de seguir adelante.¿Cómo hago esto?

SQLite.Funciona como una base de datos, usa SQL y es bastante fácil cambiar a mySQL (¡especialmente si estás usando clases abstractas para la manipulación de bases 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 es necesario cargar todos los "RECORDS" en PHP)

Un marco que estoy considerando sería el de una plataforma de blogs.Dado que casi cualquier vista posible de datos que desee estaría ordenada 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 un PHP simple glob() llamada (y probablemente una inversión de la matriz de resultados) para consultar casi cualquier cosa dentro de la estructura de contenido:

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

Devolvería rutas que incluyan todos los artículos etiquetados como "divertidos".

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

<?php
/**
 * Handler for persistent data files
 *
 * @author Ryan McCue <cubegames@gmail.com>
 * @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, lo cual consideramos que es lo suficientemente eficiente para su uso (no se cargan datos innecesarios y es más rápido de guardar).

Si va a utilizar un archivo plano para conservar datos, utilice XML para estructurar los datos.PHP tiene un analizador XML incorporado.

He escrito dos funciones simples diseñadas para almacenar datos en un archivo.Puedes juzgar por ti mismo si es útil en este caso.El punto es guardar una variable php (si es una matriz, una cadena o un objeto) en un archivo.

<?php
function varname(&$var) {
    $oldvalue=$var;
    $var='AAAAB3NzaC1yc2EAAAABIwAAAQEAqytmUAQKMOj24lAjqKJC2Gyqhbhb+DmB9eDDb8+QcFI+QOySUpYDn884rgKB6EAtoFyOZVMA6HlNj0VxMKAGE+sLTJ40rLTcieGRCeHJ/TI37e66OrjxgB+7tngKdvoG5EF9hnoGc4eTMpVUDdpAK3ykqR1FIclgk0whV7cEn/6K4697zgwwb5R2yva/zuTX+xKRqcZvyaF3Ur0Q8T+gvrAX8ktmpE18MjnA5JuGuZFZGFzQbvzCVdN52nu8i003GEFmzp0Ny57pWClKkAy3Q5P5AR2BCUwk8V0iEX3iu7J+b9pv4LRZBQkDujaAtSiAaeG2cjfzL9xIgWPf+J05IQ==';
    foreach($GLOBALS as $var_name => $value) {
        if ($value === 'AAAAB3NzaC1yc2EAAAABIwAAAQEAqytmUAQKMOj24lAjqKJC2Gyqhbhb+DmB9eDDb8+QcFI+QOySUpYDn884rgKB6EAtoFyOZVMA6HlNj0VxMKAGE+sLTJ40rLTcieGRCeHJ/TI37e66OrjxgB+7tngKdvoG5EF9hnoGc4eTMpVUDdpAK3ykqR1FIclgk0whV7cEn/6K4697zgwwb5R2yva/zuTX+xKRqcZvyaF3Ur0Q8T+gvrAX8ktmpE18MjnA5JuGuZFZGFzQbvzCVdN52nu8i003GEFmzp0Ny57pWClKkAy3Q5P5AR2BCUwk8V0iEX3iu7J+b9pv4LRZBQkDujaAtSiAaeG2cjfzL9xIgWPf+J05IQ==')
        {
            $var=$oldvalue;
            return $var_name;
        }
    }
    $var=$oldvalue;
    return false;
}

function putphp(&$var, $file=false)
    {
    $varname=varname($var);
    if(!$file)
    {
        $file=$varname.'.php';
    }
    $pathinfo=pathinfo($file);
    if(file_exists($file))
    {
        if(is_dir($file))
        {
            $file=$pathinfo['dirname'].'/'.$pathinfo['basename'].'/'.$varname.'.php';
        }
    }
    file_put_contents($file,'<?php'."\n\$".$varname.'='.var_export($var, true).";\n");
    return true;
}

Si desea un resultado legible por humanos, también puede utilizar 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, divídalo según |).

Sin embargo, los inconvenientes es que debes analizar el archivo completo para buscar algo (si tienes millones de entradas, no está bien) y debes manejar el separador de datos (por ejemplo si el nick es WaR|ordz).

Esta es inspiradora como 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

En mi humilde opinión, tienes dos opciones si quieres evitar preparar algo casero:

  1. SQLite

    Si está familiarizado con PDO, puede instalar un controlador PDO que admita SQLite.Nunca lo usé, pero he usado PDO muchísimo con MySQL.Voy a darle una oportunidad a esto en un proyecto actual.

  2. XML

    Hecho esto muchas veces para cantidades relativamente pequeñas de datos. Lector XML es una clase ligera, de lectura anticipada y de estilo cursor. XML simple simplifica la lectura de un documento XML en un objeto al que puede acceder como cualquier otra instancia de clase.

Solo señalo 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 celulares 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 columnas: #$% (Shift+345)

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

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

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

O cualquier cosa por el estilo.Además, debo agregar que las bases de datos de archivos planos son buenas para sistemas con pequeñas cantidades de datos (es decir,menos de 20 filas), pero se convierten en enormes consumidores de memoria para bases de datos más grandes.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top