रेल में पोस्टग्रेएसक्यूएल की बड़ी वस्तुओं को मॉडलिंग करना

यदि ActiveRecord का उपयोग कर रहा है जो इसके एडेप्टर में से एक के साथ रेल के साथ आता है, तो डेटाबेस प्रकार का रेल या रूबी प्रकार का एकमात्र औपचारिक मानचित्रण होता है जो आमतौर पर NATIVE_DATABASE_TYPES में परिभाषित किया जाता है। एडेप्टर में स्थिर जो इसके native_database_types . के माध्यम से लौटाया जाता है तरीका। रेल 3.2.x में PostgreSQL के लिए, जो कि ActiveRecord::ConnectionAdapters::PostgreSQLAdapter में है जो यहां है। . तो, उस एडेप्टर के लिए, रेल में "बाइनरी" प्रकार पीजी में "बाइटा" प्रकार के लिए मैप करता है। कुछ प्रकारों के लिए, आप उस डेटाबेस प्रकार को ओवरराइड कर सकते हैं जिसे वह activerecord-native_db_types_override नामक रत्न का उपयोग करने के लिए मैप करता है। ए> . लेकिन, हम बड़ी वस्तुओं का उपयोग करना चाहते हैं, इसलिए...

माइग्रेशन

जैसा कि जिम डेविल ने टिप्पणियों में उल्लेख किया है, आप तालिका में कस्टम टाइप किए गए कॉलम को निर्दिष्ट कर सकते हैं जैसे:

t.column :some_oid, 'blob_oid', :null => false

यदि आपको और भी अधिक करने की आवश्यकता है जो गैर-मानक है, तो आप execute("SQL GOES HERE;") का भी उपयोग कर सकते हैं सीधे SQL का उपयोग करके तालिका बनाने के लिए। और, यदि आपके पास मौजूदा लीगेसी स्कीमा या SQL परिवर्तन हैं जो माइग्रेशन के बाहर किए गए हैं, तो structure.sql (config.active_record.schema_format = :sql का उपयोग करने पर विचार करें। config/application.rb में विकल्प और फिर करें:rake db:structure:dump )।

बड़ी वस्तुएं पढ़ें/लिखें/लंबाई जांचें/हटाएं

स्पष्ट करने के लिए कुछ संशोधनों के साथ कॉपी किया गया, आदि। .rb">https://github.com/diogob/carrierwave-postgresql/blob/v0.1.0/lib/carrierwave/storage/postgresql_lo.rb :

अपडेट किया गया :हमें lo_read/lo_write/lo_lseek से पहले शुरुआत करने की आवश्यकता नहीं है और सुनिश्चित ब्लॉक में lo_close करते हैं क्योंकि प्रति PG दस्तावेज़ीकरण "लेन-देन के अंत में खुले रहने वाले किसी भी बड़े ऑब्जेक्ट डिस्क्रिप्टर को स्वचालित रूप से बंद कर दिया जाएगा।" (उस जानकारी के लिए डियोगो को धन्यवाद)

    require 'pg'

    ...

    def read
      (...).transaction do
        lo = connection.lo_open(identifier)
        content = connection.lo_read(lo, file_length)
        connection.lo_close(lo)
        content
      end
    end

    def write(file)
      (...).transaction do
        lo = connection.lo_open(identifier, ::PG::INV_WRITE)
        size = connection.lo_write(lo, file.read)
        connection.lo_close(lo)
        size
      end
    end

    def delete
      connection.lo_unlink(identifier)
    end

    def file_length
      (...).transaction do
        lo = connection.lo_open(identifier)
        size = connection.lo_lseek(lo, 0, 2)
        connection.lo_close(lo)
        size
      end
    end

connection के बजाय , मॉडल या आधार से कच्चे कनेक्शन का उपयोग करें, उदा। ActiveRecord::Base.connection.raw_connection (देखें यह )।

(...).transaction मॉडल या आधार पर लेन-देन बुला रहा है, उदा। ActiveRecord::Base.transaction (देखें यह )।

identifier वह ओड है जिसे आपको या तो पास/सेट करने की आवश्यकता है या केवल connection.lo_creat करने से प्राप्त करना है ।

अन्य उदाहरण/जानकारी:

उत्तरार्द्ध और कुछ जवाब यहां सुझाव है कि आप डीबी से अलग बड़ी फाइलों के भंडारण पर विचार करना चाहेंगे, उदा। ताकि आप क्लाउड स्टोरेज का इस्तेमाल कर सकें। लेकिन, अगर केवल पथ/आईडी को बाहरी फ़ाइलों में संग्रहीत करते हैं जो नहीं . हैं डीबी द्वारा प्रबंधित, आप एसीआईडी संगति खो देते हैं (एक या अधिक डीबी रिकॉर्ड एक या अधिक फाइलों को इंगित कर सकते हैं जो वहां नहीं हैं या एक या अधिक फाइलें मौजूद हो सकती हैं जिनके पास डेटाबेस में एक या अधिक संबंधित रिकॉर्ड नहीं हैं)। फ़ाइल सिस्टम पर फ़ाइलों को संग्रहीत करने के लिए एक और तर्क यह है कि आप फ़ाइलों को स्ट्रीम कर सकते हैं, लेकिन पीजी बड़ी ऑब्जेक्ट फाइल सिस्टम पर फाइलों को एक तरह से पोस्टग्रेज द्वारा प्रबंधित करती है ताकि दोनों एसीआईडी संगति सुनिश्चित कर सकें और स्ट्रीमिंग की अनुमति दे सकें (जो आप सामान्य बीएलओबी के साथ नहीं कर सकते हैं) / रेल बाइनरी प्रकार)। तो, यह सिर्फ निर्भर करता है; कुछ पथ संदर्भों का उपयोग करके अलग भंडारण में भंडारण करना एक बेहतर विकल्प पाते हैं, और कुछ बड़ी वस्तुओं के माध्यम से एसीआईडी संगति पसंद करते हैं।

आसान तरीका

बस CarrierWave का उपयोग करें और carrierwave-postgresql ।