php फ्लैट फ़ाइल डेटाबेस



sql database (10)

PHP में फ्लैट फ़ाइल डेटाबेस संरचनाओं को बनाने के आसपास सबसे अच्छा अभ्यास क्या हैं? अधिकतर परिपक्व PHP फ्लैट फ़ाइल ढांचे में मैं एसक्यूएल-जैसी क्वेरी सिंटैक्स को लागू करने का प्रयास करता हूं, जो ज्यादातर मामलों में मेरे उद्देश्यों के लिए शीर्ष पर है (मैं उस बिंदु पर केवल डेटाबेस का उपयोग करता हूं)।

क्या इस समस्या को पहली जगह पर ले जाकर एक छोटे कोड ओवरहेड के साथ अच्छे प्रदर्शन और सुविधाओं को पाने के लिए वहां कोई सुरुचिपूर्ण चाल है?


Answer #1

इस प्रकार के सिस्टम के साथ एक फ्लैट फ़ाइल डेटाबेस के साथ एक संभावित समस्या को इंगित करना:

data|some text|more data

row 2 data|bla hbalh|more data

...आदि

समस्या यह है कि सेल डेटा में "|" होता है या एक "\ n" तो डेटा खो जाएगा। कभी-कभी उन अक्षरों के संयोजन से विभाजित करना आसान होता है जो अधिकांश लोग उपयोग नहीं करेंगे।

उदाहरण के लिए:

कॉलम स्प्लिटर: #$% (Shift+345)

पंक्ति splitter: ^&* (Shift+678)

पाठ फ़ाइल: test data#$%blah blah#$%^&*new row#$%new row data 2

फिर उपयोग करें: explode("#$%", $data); use foreach, the explode again to separate columns explode("#$%", $data); use foreach, the explode again to separate columns

या इन लाइनों के साथ कुछ भी। साथ ही, मैं जोड़ सकता हूं कि फ्लैट फ़ाइल डेटाबेस छोटे मात्रा में डेटा (यानी 20 पंक्तियों से कम) वाले सिस्टम के लिए अच्छे हैं, लेकिन बड़े डेटाबेस के लिए बड़ी मेमोरी होग बन जाते हैं।


Answer #2

मैंने फ़ाइल में डेटा स्टोर करने के लिए डिज़ाइन किए गए दो सरल फ़ंक्शन लिखे हैं। यदि आप इस मामले में उपयोगी हैं तो आप अपने लिए न्याय कर सकते हैं। बिंदु एक फ़ाइल में एक php वैरिएबल को सहेजना है (यदि यह या तो एक सरणी या ऑब्जेक्ट है)।

<?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;
}

Answer #3

खैर, फ्लैट डेटाबेस की प्रकृति क्या है। क्या वे बड़े या छोटे हैं। क्या यह उन सरणी के साथ सरल सरणी है? यदि यह कुछ सरल कहता है तो उपयोगकर्ता प्रोफाइल इस प्रकार बनाया गया है:

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

और उस उपयोगकर्ता के लिए डीबी रिकॉर्ड को सहेजने या अपडेट करने के लिए।

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

और उपयोगकर्ता के लिए रिकॉर्ड लोड करने के लिए

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

लेकिन फिर यह कार्यान्वयन आपको आवश्यक डेटाबेस के आवेदन और प्रकृति पर अलग-अलग होगा।


Answer #4

यदि आप मानव-पठनीय परिणाम चाहते हैं, तो आप इस प्रकार की फ़ाइल का भी उपयोग कर सकते हैं:

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

इस तरह, आपके पास केवल एक फ़ाइल है, आप इसे आसानी से डीबग कर सकते हैं (और मैन्युअल रूप से ठीक कर सकते हैं), आप बाद में फ़ील्ड (प्रत्येक पंक्ति के अंत में) जोड़ सकते हैं और PHP कोड सरल है (प्रत्येक पंक्ति के लिए, के अनुसार विभाजित करें |)।

हालांकि, दोष यह है कि आपको पूरी फ़ाइल को कुछ खोजने के लिए पार्स करना चाहिए (यदि आपके पास लाखों प्रविष्टियां हैं, तो यह ठीक नहीं है) और आपको डेटा में विभाजक को संभालना चाहिए (उदाहरण के लिए यदि निक वाईआर | ordz है)।


Answer #5

यह एक व्यावहारिक समाधान के रूप में प्रेरणादायक है:
https://github.com/mhgolkar/FlatFire
यह डेटा को संभालने के लिए कई रणनीतियों का उपयोग करता है ...
[रीडेमे फ़ाइल से कॉपी]

नि: शुल्क या संरचित या मिश्रित

- 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

Answer #6

मेरी राय में, अर्थ में "फ़्लैट फ़ाइल डेटाबेस" का उपयोग करके आप अर्थ (और आपके द्वारा स्वीकार किए गए उत्तर) को चीजों के बारे में जाने का सबसे अच्छा तरीका नहीं है। सबसे पहले, serialize() और unserialize() उपयोग कर प्रमुख सिरदर्द का कारण बन सकता है अगर कोई फ़ाइल में प्रवेश करता है और संपादित करता है (वास्तव में, वे आपके "डेटाबेस" में हर बार चलाने के लिए मनमाना कोड डाल सकते हैं।)

निजी तौर पर, मैं कहूंगा - भविष्य को क्यों न देखें? ऐसे कई बार हुए हैं जिनके पास मुझे समस्याएं थीं क्योंकि मैं अपनी खुद की "स्वामित्व" फाइलें बना रहा हूं, और परियोजना उस बिंदु पर विस्फोट हो गई है जहां इसे डेटाबेस की आवश्यकता है, और मैं सोच रहा हूं "आप जानते हैं, मेरी इच्छा है मैं इसे डेटाबेस के लिए शुरू करने के लिए लिखा था "- क्योंकि कोड का रिफैक्टरिंग बहुत अधिक समय और प्रयास करता है।

इससे मैंने सीखा है कि भविष्य में मेरे आवेदन का सबूत है ताकि जब यह बड़ा हो जाए तो मुझे आगे बढ़ने और दिन को फिर से काम करने का समय नहीं जाना पड़ेगा। मैं यह कैसे करु?

SQLite। यह डेटाबेस के रूप में काम करता है, एसक्यूएल का उपयोग करता है, और mySQL पर बदलने के लिए बहुत आसान है (espscially अगर आप डेटाबेस मैनिपुलेशन के लिए सारणी कक्षाओं का उपयोग कर रहे हैं जैसे मैं करता हूं!)

वास्तव में, "स्वीकार्य उत्तर" विधि के साथ espscially, यह आपके ऐप के स्मृति उपयोग में भारी कटौती कर सकते हैं (आपको सभी "रिकॉर्ड" को PHP में लोड करने की आवश्यकता नहीं है)


Answer #7

आईएमएचओ, यदि आप होमब्रीविंग से बचना चाहते हैं तो आपके पास दो विकल्प हैं:

  1. SQLite

    यदि आप पीडीओ से परिचित हैं, तो आप एक पीडीओ ड्राइवर स्थापित कर सकते हैं जो SQLite का समर्थन करता है। इसका कभी भी इस्तेमाल नहीं किया, लेकिन मैंने पीडीओ का उपयोग माईएसक्यूएल के साथ एक टन किया है। मैं इसे एक मौजूदा परियोजना पर एक शॉट देने जा रहा हूं।

  2. एक्सएमएल

    अपेक्षाकृत कम मात्रा में डेटा के लिए यह कई बार किया गया। XMLReader एक हल्का, रीड-फॉरवर्ड, कर्सर-स्टाइल क्लास है। SimpleXML किसी ऑब्जेक्ट में किसी XML दस्तावेज़ को पढ़ने में आसान बनाता है जिसे आप किसी अन्य क्लास इंस्टेंस की तरह एक्सेस कर सकते हैं।


Answer #8

एक फ्रेमवर्क जो मैं विचार कर रहा हूं वह ब्लॉगिंग प्लेटफ़ॉर्म के लिए होगा। चूंकि डेटा के बारे में किसी भी संभावित दृश्य के बारे में आप चाहते हैं कि तिथि के अनुसार क्रमबद्ध किया जाए, मैं इस संरचना के बारे में सोच रहा था:

प्रति सामग्री नोड में एक निर्देशिका:

./content/YYYYMMDDHHMMSS/

प्रत्येक नोड के उपनिर्देशिका सहित

/tags  
/authors  
/comments  

पूर्व-और बाद में प्रस्तुत सामग्री और इसी तरह के लिए नोड निर्देशिका में सरल पाठ फ़ाइलों के साथ-साथ।

सामग्री संरचना के भीतर बस कुछ भी पूछने के लिए यह एक साधारण PHP glob() कॉल (और संभवतः परिणाम सरणी का एक उलटा glob() अनुमति देगा:

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

"हास्यास्पद" टैग किए गए सभी लेखों सहित पथ वापस कर देंगे।


Answer #9

यहां कोड है जिसे हम लिलिना के लिए उपयोग करते हैं:

<?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);
    }
}

?>

यह प्रत्येक प्रविष्टि को एक अलग फ़ाइल के रूप में संग्रहीत करता है, जिसे हमने पाया है उपयोग के लिए पर्याप्त कुशल है (कोई अनियंत्रित डेटा लोड नहीं होता है और यह सहेजने में तेज़ है)।


Answer #10

यह सच है। serialize() इसके लिए भी बहुत उपयोगी हो सकता है।

मुझे लगता है कि एक व्यावहारिक प्रणाली के साथ आने की चाल जटिलता के साथ खुद को मारने के बिना डेटा नोड्स को इंडेक्स करने का कोई तरीका ढूंढ रही है।





flat-file