Prostý databázový soubor

hlasů
101

Jaké jsou nejlepší postupy kolem vytváření plochý soubor databázové struktury v PHP?

Mnoho z více zralých PHP plochou rámců souborů vidím tam pokusí zavést syntaxi dotazu formulovaného podobně jako SQL, který je přes vrchol pro mé účely ve většině případů (Jen bych použít databázi v tomto bodě).

Existují nějaké elegantní triky tam venku, jak získat dobrý výkon a funkce s malým kódem nad hlavou?

Položena 01/08/2008 v 15:19
zdroj uživatelem
V jiných jazycích...                            


12 odpovědí

hlasů
68

Dobře, jaká je povaha plochých databází. Jsou to velké nebo malé. Je to jednoduché pole s poli v nich? pokud její něco jednoduchého říci userprofiles postavené takto:

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

a ukládat nebo aktualizovat záznam db pro daného uživatele.

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

a nahrát záznam pro uživatele

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

ale zase to realizace se bude lišit o uplatňování a povaze databáze, kterou potřebujete.

Odpovězeno 01/08/2008 v 18:45
zdroj uživatelem

hlasů
46

Dalo by se uvažovat o SQLite . Je to skoro stejně jednoduché jako obyčejných souborů, ale vy dostanete SQL engine pro dotazování. To funguje dobře s PHP taky.

Odpovězeno 09/08/2008 v 00:00
zdroj uživatelem

hlasů
20

Podle mého názoru, pomocí „prostý databázový soubor“ v tom smyslu, že jste znamenat (a odpovědí, které jste přijal) není neccesarily nejlepší způsob, jak jít o věci. Za prvé, použití serialize()a unserialize()může způsobit velké bolesti hlavy, když někdo dostane dovnitř a upraví soubor (mohou ve skutečnosti dát arbritrary kód do vašich „databáze“ má být spuštěn pokaždé).

Osobně bych řekl - proč ne hledět do budoucnosti? Tam byli tolikrát, že jsem měl problémy, protože jsem byl vytváří své vlastní „proprietární“ soubory a projekt rozložený do bodu, kdy to potřebuje databázi, a myslím „víte, přeji napsal jsem to pro databázi, jak začít s“- protože refactoring kódu trvá příliš mnoho času a úsilí.

Z toho jsem se dozvěděl, že budoucí kontroly pravopisu svou žádost tak, že když se dostane větší nemám jít a strávit dny refaktoring je způsob, jak jít kupředu. Jak to mám udělat?

SQLite. Působí jako databáze, používá SQL, a je docela snadné přejít na MySQL (espescially Pokud používáte abstrahované třídy pro manipulaci s databází jako já!)

Ve skutečnosti espescially s „Přijímání odpověď“ 's metodou, může výrazně snížit využití paměti aplikace (nemáte načíst všechny ‚záznamy‘ v PHP)

Odpovězeno 21/09/2008 v 19:21
zdroj uživatelem

hlasů
15

To je pravda. serialize()může být docela užitečné pro to stejně.

Myslím, že trik, jak přijít s životaschopným systémem je najít nějaký způsob, jak indexovat datových uzlů bez sebevraždu s složitosti.

Odpovězeno 01/08/2008 v 15:58
zdroj uživatelem

hlasů
11

Jeden rámec Zvažuji bude pro blogování platformy. Vzhledem k tomu, téměř každý možný vzhledem k údajům, bude podle data byste chtěli, přemýšlel jsem o této struktuře:

Každou lokalizaci jeden podadresář obsahu uzlu:

./content/YYYYMMDDHHMMSS/

Podaresářích každém uzlu, včetně

/tags  
/authors  
/comments  

Stejně jako jednoduché textové soubory v adresáři uzlu pro pre- a post-vykreslení obsahu a podobně.

To by umožnilo jednoduchou PHP glob()volání (a pravděpodobně obrácení pole result) dotazovat na cokoliv v rámci struktury obsahu:

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

Vrátí cesty včetně všech výrobků označených „legrační“.

Odpovězeno 01/08/2008 v 15:26
zdroj uživatelem

hlasů
8

Zde je kód použijeme pro 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);
    }
}

?>

Ukládá každou položku jako samostatný soubor, který jsme našli, je dostatečně efektivní pro použití (ne nepotřebných dat je načten a je to rychlejší zachránit).

Odpovězeno 28/10/2008 v 11:45
zdroj uživatelem

hlasů
8

Pokud se chystáte použít plochý soubor přetrvávat dat pomocí XML strukturovat data. PHP má vestavěný analyzátor XML .

Odpovězeno 18/09/2008 v 07:40
zdroj uživatelem

hlasů
7

Napsal jsem dvě jednoduché funkce určené k ukládání dat do souboru. Posuďte sami, zda je to užitečné v tomto případě. Jde o to, zachránit php proměnné (pokud je to buď pole řetězec nebo objekt) do souboru.

<?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;
}
Odpovězeno 19/12/2012 v 21:48
zdroj uživatelem

hlasů
6

Tohle je inspirující jako praktické řešení:
https://github.com/mhgolkar/FlatFire
používá několik strategií pro práci s daty ...
[Kopírované z souboru readme]

Volný nebo strukturovaný nebo Mixed

- 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
Odpovězeno 02/05/2013 v 14:57
zdroj uživatelem

hlasů
6

IMHO, máte dvě možnosti, pokud chcete, aby se zabránilo homebrewing něco:

  1. SQLite

    Pokud jste obeznámeni s chráněným označením původu, můžete nainstalovat ovladač PDO, který podporuje SQLite. Nikdy nepoužíval, ale jsem použil CHOP tuny s MySQL. Chystám se dát to výstřel na aktuální projekt.

  2. XML

    Udělal to mnohokrát pro relativně malé množství dat. XMLReader je lehký, má-forward, třída kurzor stylu. SimpleXML usnadňuje čtení dokumentu XML do objektu, který můžete přistupovat stejně jako všechny ostatní instance třídy.

Odpovězeno 02/12/2012 v 16:49
zdroj uživatelem

hlasů
6

Pokud chcete, aby výsledek čitelný, můžete také použít tento typ souboru:

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

Tímto způsobem, máte jen jeden soubor, můžete jej odladit (a ručně opravit) snadno, můžete později přidat pole (na konci každého řádku) a PHP kód je jednoduchý (pro každý řádek, rozdělí podle |).

Nicméně, nevýhody je, že byste měli analyzovat celý soubor hledat něco, co (pokud máte miliony vstupu, není to v pořádku), a vy byste měli zvládnout oddělovač v datech (například v případě, že nick je válka | ordz).

Odpovězeno 18/09/2008 v 08:51
zdroj uživatelem

hlasů
4

Jen poukazuje na potenciální problém s plochý soubor databáze s tímto typem systému:

data|some text|more data

row 2 data|bla hbalh|more data

...atd

Problém je v tom, že data buňka obsahuje „|“ nebo „\ n“, pak dojde ke ztrátě dat. Někdy, že by bylo jednodušší rozdělit kombinacemi písmen, které by většina lidí nepoužívají.

Například:

dělicí kolony: #$% (Shift+345)

Row polen: ^&* (Shift+678)

Textový soubor: test data#$%blah blah#$%^&*new row#$%new row data 2

Pak použijte: explode("#$%", $data); use foreach, the explode again to separate columns

Nebo něco podél těchto linek. Také mohu dodat, že prostý databázový soubor, jsou vhodné pro systémy s malým množstvím dat (tj. Méně než 20 řádků), ale stávají obrovské paměti prasata u větších databází.

Odpovězeno 04/01/2013 v 01:14
zdroj uživatelem

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more