क्या रेल्स कॉलम के प्रकार के लिए प्रलेखन है?


181

मैं इस पृष्ठ पर पाई जाने वाली सरल प्रकार की सूची से अधिक खोज रहा हूं :

: प्राथमिक_की: स्ट्रिंग,: पाठ,: पूर्णांक,: नाव,: दशमलव,: तिथि:, समय, समय: तिथि:: द्विआधारी: बूलियन

लेकिन क्या कोई दस्तावेज है जो वास्तव में इन क्षेत्रों को परिभाषित करता है ?

विशेष रूप से:

  • बीच क्या अंतर है :stringऔर :text?
  • बीच :floatऔर :decimal?
  • और :time, की विशिष्ट विशेषताएं क्या हैं ?:timestamp:datetime

क्या इन प्रकार की बारीकियों को कहीं भी प्रलेखित किया गया है?

संपादित करें: डीबी-प्लेटफॉर्म कार्यान्वयन के अंक उस प्रश्न के लिए अप्रासंगिक हैं जो मैं पूछने की कोशिश कर रहा हूं। यदि, कहते हैं, :datetimeरेल प्रलेखन में एक निर्धारित उद्देश्य नहीं है, तो db- अडैप्टर-लेखक क्या इसी अनुरूप प्रकार का चयन करते हैं?


1
उन प्रकार के क्या हैं, मेरी पसंद के शब्दों, चीजों को कहा जाता है? जैसे, क्या वे क्षेत्र या गुण हैं या क्या हैं। मैं इसके अलावा और चीजों को खोज रहा था और मुझे इसके अलावा कोई और नहीं मिल रहा था। इसलिए, मैं भविष्य के संदर्भ के लिए सोच रहा था। :string:text
l1zZY

2
@ l1zZY, ​​आप जिस शब्द की तलाश कर रहे हैं वह "डेटा प्रकार" है।
thatpaintingelephant 18

जवाबों:


397

व्यक्तिगत अनुभव से निर्मित दिशानिर्देश:

  • स्ट्रिंग :
    • 255 वर्णों तक (DBMS पर निर्भर करता है)
    • छोटे पाठ फ़ील्ड (नाम, ईमेल आदि) के लिए उपयोग करें
  • पाठ :
    • असीमित लंबाई (DBMS पर निर्भर करता है)
    • टिप्पणियों, ब्लॉग पोस्टों, आदि के लिए उपयोग करें। अंगूठे का सामान्य नियम: यदि यह टेक्सएरिया के माध्यम से कैप्चर किया गया है, तो टेक्स्ट का उपयोग करें। टेक्स्टफील्ड के उपयोग से इनपुट के लिए, स्ट्रिंग का उपयोग करें।
  • पूर्णांक :
    • पूर्ण संख्या
  • फ्लोट :
    • दशमलव संख्या अस्थायी बिंदु परिशुद्धता के साथ संग्रहीत
    • परिशुद्धता तय हो गई है, जो कुछ गणनाओं के लिए समस्याग्रस्त हो सकती है; आम तौर पर गलत राउंडिंग के कारण गणित के संचालन के लिए अच्छा नहीं है।
  • दशमलव :
    • दशमलव संख्या सटीकता के साथ संग्रहीत होती है जो आपकी गणना द्वारा आवश्यक के अनुसार भिन्न होती है; गणित के लिए इनका उपयोग करें जिन्हें सटीक होना चाहिए
    • उदाहरण के लिए इस पोस्ट को देखें और फ़्लोट्स और दशमलव के बीच के अंतर पर गहराई से व्याख्या करें।
  • बूलियन :
    • सच्ची / झूठी विशेषताओं को स्टोर करने के लिए उपयोग करें (अर्थात ऐसी चीजें जिनके केवल दो राज्य हैं, जैसे / बंद)
  • बाइनरी :
    • छवियों, फिल्मों, और अन्य फ़ाइलों को उनके मूल, कच्चे स्वरूप में डेटा को ब्लूबस कहा जाता है
  • :प्राथमिक कुंजी
    • यह डेटाटाइप एक प्लेसहोल्डर है जो रेल को आपकी पसंद के डेटाबेस ( serial primary keyपोस्टगॉक्सीक्यूएल में) की आवश्यकता वाले प्राथमिक कुंजी डेटा टाइप में अनुवाद करता है। इसका उपयोग कुछ जटिल है और अनुशंसित नहीं है।
    • अपने स्वयं के क्षेत्रों में प्राथमिक कुंजी कार्यक्षमता का अनुकरण करने के बजाय मॉडल और माइग्रेशन बाधाओं (जैसे validates_uniqueness_ofऔर विकल्प के add_indexसाथ :unique => true) का उपयोग करें।
  • तारीख :
    • केवल एक दिनांक (वर्ष, माह, दिन) को संग्रहीत करता है
  • समय :
    • स्टोर केवल एक समय (घंटे, मिनट, सेकंड)
  • दिनांक समय :
    • स्टोर तारीख और समय दोनों
  • समय-चिह्न
    • स्टोर तारीख और समय दोनों
    • नोट: रेल के प्रयोजनों के लिए, टाइमस्टैम्प और डेटटाइम दोनों का मतलब एक ही बात है (तारीख और समय दोनों को स्टोर करने के लिए दोनों प्रकार का उपयोग करें)। टीएल के लिए; डीआर वर्णन क्यों दोनों मौजूद हैं, नीचे पैराग्राफ पढ़ें।

ये प्रकार हैं जिनके बारे में भ्रम अक्सर मौजूद होते हैं; आशा है कि ये आपकी मदद करेगा। मैं वास्तव में नहीं जानता कि इन के बारे में आधिकारिक दस्तावेज क्यों नहीं है। इसके अलावा, मुझे लगता है कि आपके द्वारा संदर्भित इन डेटाबेस एडाप्टरों को उन्हीं लोगों द्वारा लिखा गया था, जिन्होंने रेल लिखी थी, इसलिए जब उन्हें एडेप्टर लिख रहे थे, तब शायद उन्हें जाने के लिए किसी दस्तावेज की आवश्यकता नहीं थी। उम्मीद है की यह मदद करेगा!

ध्यान दें: दोनों की उपस्थिति :DateTimeऔर :Timestamp, जो मैं पा सकता हूं, वह ज्यादातर डेटाबेस सिस्टम के साथ संगतता के लिए रेल द्वारा शामिल है। उदाहरण के लिए, MySQL के TIMESTAMPडेटाटाइप को यूनिक्स टाइमस्टैम्प के रूप में संग्रहीत किया जाता है। इसकी वैध सीमा 1970 से 2038 तक जाती है, और समय को सेकंड की संख्या के रूप में संग्रहीत किया जाता है क्योंकि पिछले युग के है, जो माना जाता है कि मानक है, लेकिन व्यवहार में व्यवस्था करने के लिए प्रणाली से अलग कर सकते हैं। यह मानते हुए कि डेटाबेस में सापेक्ष समय अच्छी बात नहीं थी, MySQL ने बाद में पेश किया कि और डेटापाइप को पीछे की संगतता के लिए बनाए रखा गया था। अन्य डेटाबेस सिस्टम इसी तरह के प्रस्तावों से गुजरे। रेल ने माना कि कई मानक मौजूद थे, और दोनों को इंटरफेस प्रदान किया। हालाँकि, Rails ActiveRecord दोनों UTC तारीखों को MySql के स्टोर में डिफॉल्ट करता है , इसलिए यह Rails प्रोग्रामर्स के लिए कोई कार्यात्मक अंतर नहीं करता है। ये मौजूद हैं ताकि उपयोगकर्ता जो चाहेंDATETIME डेटाटाइप , जो आकार, वृद्धि की कीमत पर वर्ष, माह, दिन, घंटे, मिनट और सेकंड में हर अंक को संग्रहीत करता है। TIMESTAMP:Timestamp:DateTimeDATETIMEदोनों के बीच अंतर करने के लिए ऐसा कर सकते हैं। (अधिक गहराई से स्पष्टीकरण के लिए, यह SO उत्तर देखें )।


21
यह एक भयानक राइटअप है, @aguazales। यह एक बहुत बड़ा निरीक्षण जैसा लगता है कि रेल दस्तावेज में ऐसा कुछ नहीं है।
बर्चचेयर

धन्यवाद :) और मैं पूरी तरह से सहमत हूं, ActiveRecord और इसके डेटाटाइप्स रेल के लिए बहुत महत्वपूर्ण हैं, आइडीके क्यों यह मानक प्रलेखन नहीं है।
अगुआजेल्स

2
पाठ हमेशा असीमित लंबाई नहीं है - MySQL में यह लगभग 16kb तक सीमित है। अगर आपको 16kb से अधिक की आवश्यकता है तो मेडीमेटेक्ट और लॉन्गटैक्स डेटाबेस प्रकार हैं।
Haegin

3
यह एक अच्छा स्रोत रेल माइग्रेशन डेटा प्रकार - MySql - Postgresql - SQLite भी है । मुझे पता है कि यह डेटाबेस विशिष्ट है, लेकिन रेल के प्रकारों को समझते हुए वास्तविक कार्यान्वयन जानना अभी भी उपयोगी है।
नैट

1
मैं 100% निश्चित नहीं हो सकता, लेकिन मुझे लगता है कि नैट के संसाधन को यहां पुनर्प्रकाशित किया गया था ।
अगुआजेल्स

10

रेल मास्टर शाखा स्रोत कोड से मैंने पाया:

सार mysql_adcape

#activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

  NATIVE_DATABASE_TYPES = {
    primary_key: "bigint auto_increment PRIMARY KEY",
    string:      { name: "varchar", limit: 255 },
    text:        { name: "text", limit: 65535 },
    integer:     { name: "int", limit: 4 },
    float:       { name: "float" },
    decimal:     { name: "decimal" },
    datetime:    { name: "datetime" },
    timestamp:   { name: "timestamp" },
    time:        { name: "time" },
    date:        { name: "date" },
    binary:      { name: "blob", limit: 65535 },
    boolean:     { name: "tinyint", limit: 1 },
    json:        { name: "json" },
  }

  # Maps logical Rails types to MySQL-specific data types.
  def type_to_sql(type, limit = nil, precision = nil, scale = nil, unsigned = nil)
    sql = case type.to_s
    when 'integer'
      integer_to_sql(limit)
    when 'text'
      text_to_sql(limit)
    when 'blob'
      binary_to_sql(limit)
    when 'binary'
      if (0..0xfff) === limit
        "varbinary(#{limit})"
      else
        binary_to_sql(limit)
      end
    else
      super(type, limit, precision, scale)
    end

    sql << ' unsigned' if unsigned && type != :primary_key
    sql
  end    

# and integer ...

  def integer_to_sql(limit) # :nodoc:
    case limit
    when 1; 'tinyint'
    when 2; 'smallint'
    when 3; 'mediumint'
    when nil, 4; 'int'
    when 5..8; 'bigint'
    else raise(ActiveRecordError, "No integer type has byte size #{limit}")
    end
  end

 # and text ..

  def text_to_sql(limit) # :nodoc:
    case limit
    when 0..0xff;               'tinytext'
    when nil, 0x100..0xffff;    'text'
    when 0x10000..0xffffff;     'mediumtext'
    when 0x1000000..0xffffffff; 'longtext'
    else raise(ActiveRecordError, "No text type has byte length #{limit}")
    end
  end

# and binary ...

    def binary_to_sql(limit) # :nodoc:
      case limit
      when 0..0xff;               "tinyblob"
      when nil, 0x100..0xffff;    "blob"
      when 0x10000..0xffffff;     "mediumblob"
      when 0x1000000..0xffffffff; "longblob"
      else raise(ActiveRecordError, "No binary type has byte length #{limit}")
      end
    end

superमें type_to_sqlविधि

#activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
  def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
    type = type.to_sym if type
    if native = native_database_types[type]
      column_type_sql = (native.is_a?(Hash) ? native[:name] : native).dup

      if type == :decimal # ignore limit, use precision and scale
        scale ||= native[:scale]

        if precision ||= native[:precision]
          if scale
            column_type_sql << "(#{precision},#{scale})"
          else
            column_type_sql << "(#{precision})"
          end
        elsif scale
          raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale is specified"
        end

      elsif [:datetime, :time].include?(type) && precision ||= native[:precision]
        if (0..6) === precision
          column_type_sql << "(#{precision})"
        else
          raise(ActiveRecordError, "No #{native[:name]} type has precision of #{precision}. The allowed range of precision is from 0 to 6")
        end
      elsif (type != :primary_key) && (limit ||= native.is_a?(Hash) && native[:limit])
        column_type_sql << "(#{limit})"
      end

      column_type_sql
    else
      type.to_s
    end
  end
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.