Sima file adatbázisok

szavazat
101

Melyek a legjobb gyakorlatok készítésével sima file adatbázis szerkezetek PHP-ben?

Sok az érettebb PHP sima file keretek látok ott megpróbálja végrehajtani az SQL-hez hasonló lekérdezéssel szintaxist, ami fölött én célokra a legtöbb esetben (én csak használni egy adatbázis ezen a ponton).

Vannak olyan elegáns trükköket odakinn, hogy jó teljesítmény és funkciók egy kis kódot fölött?

A kérdést 01/08/2008 15:19
a forrás felhasználó
Más nyelveken...                            


12 válasz

szavazat
68

Nos, mi a természete a lakás adatbázisok. Ők nagy vagy kicsi. Ez egyszerű tömbök tömbök őket? ha valami egyszerű mondani userprofiles épült ilyen:

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

és menteni, vagy frissíteni a db rekordot az adott felhasználó.

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

és betölteni a rekordot a felhasználó számára

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

de ez megint végrehajtása változik alkalmazásáról szóló és a természet az adatbázis van szüksége.

Válaszolt 01/08/2008 18:45
a forrás felhasználó

szavazat
46

Lehet, hogy úgy SQLite . Ez majdnem olyan egyszerű, mint sima fájlok, de nem kap egy SQL motort lekérdezésére. Ez jól működik a PHP is.

Válaszolt 09/08/2008 00:00
a forrás felhasználó

szavazat
20

Véleményem szerint egy „lapos Fájl Adatbázis” abban az értelemben, amit azt jelenti (és a válasz, amit elfogadott) nem neccesarily a legjobb módja annak, hogy megy a dolog. Először is, a serialize()és unserialize()okozhat fejfájást MAJOR ha valaki bejut és szerkeszti a fájlt (tudják, sőt, fel arbritrary kódot a „adatbázis” kell futtatni minden alkalommal.)

Személy szerint azt mondanám, hogy - miért nem néz a jövőbe? Voltak olyan sokszor, hogy már volt kérdés, mert én már létre saját „tulajdonosi” fájlokat, és a projekt felrobbant egy pont, ahol szükség van egy adatbázis, és azt gondolom: „Tudod, bárcsak írtam ezt egy adatbázisban kell kezdeni”-, mert a refactoring a kód vesz túl sok időt és erőfeszítést igényel.

Ebből megtanultam, hogy jövőbeli próbanyomat a kérelmemet, hogy amikor nagyobb lesz nem kell menni, és napokig újraírás a módja, hogy menjen előre. Hogyan tudom ezt megtenni?

SQLite. Úgy működik, mint egy adatbázist, az SQL és elég könnyű áttérni mySQL (espescially ha használja a kitermelt osztályok adatbázis módosítás, mint én!)

Tény, espescially az „elfogadott válasz” 's módszer képes jelentősen csökkenteni a memória használat az alkalmazás (nem kell betölteni a »rekordot« a PHP)

Válaszolt 21/09/2008 19:21
a forrás felhasználó

szavazat
15

Ez igaz. serialize()is elég hasznos, hogy is.

Azt hiszem, a trükk, hogy jön egy életképes rendszert találni valamilyen módon az index adatok csomópontok megölése nélkül magát a komplexitást.

Válaszolt 01/08/2008 15:58
a forrás felhasználó

szavazat
11

Egy keret gondolkodom lenne egy blog platform. Mivel majdnem minden lehetséges adatnézetet amit szeretne lenne, dátum szerint rendezve, gondolkodtam ezen szerkezete:

Egy könyvtár tartalomtulajdonosonként csomópont:

./content/YYYYMMDDHHMMSS/

Alkönyvtárakat minden csomópont beleértve

/tags  
/authors  
/comments  

Csakúgy, mint az egyszerű szöveges fájlokat a csomópont előtti és utáni megjelenítési tartalmát és hasonlók.

Ez lehetővé tenné egy egyszerű PHP glob()hívás (és valószínűleg a fordítottja az eredmény tömb), hogy a lekérdezés csak a semmit a tartalom felépítése:

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

Visszatér utak, beleértve az összes cikket tagged „vicces”.

Válaszolt 01/08/2008 15:26
a forrás felhasználó

szavazat
8

Itt a kód amit használunk 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);
    }
}

?>

Ez tárolja minden bejegyzés egy külön fájlban, amit találtam elég hatékony felhasználásra (nincs felesleges adatok betöltése és ez gyorsabb menteni).

Válaszolt 28/10/2008 11:45
a forrás felhasználó

szavazat
8

Ha megy, hogy egy sima file megmaradnak az adatok, XML strukturálása az adatokat. A PHP a beépített XML elemző .

Válaszolt 18/09/2008 07:40
a forrás felhasználó

szavazat
7

Írtam két egyszerű funkciókat célja, hogy tárolja az adatokat egy fájlba. Meg tudja ítélni magad, ha ez hasznos ebben az esetben. A lényeg az, hogy mentse a php változó (ha ez sem egy tömb egy karakterlánc vagy objektum) egy fájlba.

<?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;
}
Válaszolt 19/12/2012 21:48
a forrás felhasználó

szavazat
6

Ez egy inspiráló praktikus megoldás:
https://github.com/mhgolkar/FlatFire
használ több stratégiák adatkezelés ...
[Másolt Readme File]

Szabad vagy strukturált vagy vegyes

- 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
Válaszolt 02/05/2013 14:57
a forrás felhasználó

szavazat
6

IMHO, akkor két lehetősége van, ha el akarjuk kerülni homebrewing valamit:

  1. SQLite

    Ha még nem ismeri, OEM, akkor telepíteni egy OEM-illesztőprogram, amely támogatja SQLite. Soha nem használt, de én használtam egy csomó OEM MySQL. Megyek, hogy ez egy lövés egy aktuális projekt.

  2. XML

    Kész ez sokszor viszonylag kis mennyiségű adat. XMLReader egy könnyű, olvasható előre, kurzor-style class. SimpleXML egyszerűvé teszi, hogy olvassa el az XML dokumentumot egy objektum érheti, mint bármely más osztály példányát.

Válaszolt 02/12/2012 16:49
a forrás felhasználó

szavazat
6

Ha azt szeretnénk, olvasható eredményt, akkor is használja ezt a fájltípust:

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

Ily módon, ha csak egy fájl, akkor debug meg (és kézzel kell kijavítani) könnyen, akkor mezőket később (a végén minden vonal) és a PHP kód egyszerű (soronként, osztható szerint |).

Azonban a hátránya az, hogy meg kell elemezni a teljes fájlt keresni valamit (ha van több millió bejegyzést, ez nem jó), és meg kell kezelni a szeparátor az adatok (például, ha a nick háború | ordz).

Válaszolt 18/09/2008 08:51
a forrás felhasználó

szavazat
4

Csak rámutatva egy potenciális problémát egy sima fájl adatbázis az ilyen típusú rendszer:

data|some text|more data

row 2 data|bla hbalh|more data

...stb

A probléma az, hogy a cella adatokat tartalmaz „|” vagy „\ n”, akkor az adatok elvesznek. Néha könnyebb lenne megosztani a betűkombinációk hogy a legtöbb ember nem használja.

Például:

Oszlop splitter: #$% (Shift+345)

Row splitter: ^&* (Shift+678)

Szöveges fájl: test data#$%blah blah#$%^&*new row#$%new row data 2

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

Vagy bármi ezen vonalak mentén. Azt is hozzátenném, hogy a sima file adatbázisok jók rendszerek kis mennyiségű adat (pl. Kevesebb, mint 20 sor), de lesz hatalmas memória sertés a nagyobb adatbázisok.

Válaszolt 04/01/2013 01:14
a forrás felhasználó

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