टेक्स्ट प्रतिनिधित्व में हेक्स को दशमलव संख्या में कनवर्ट करें

गतिशील SQL के बिना तरीके

text . में हेक्स नंबरों से कोई कास्ट नहीं है एक संख्यात्मक प्रकार का प्रतिनिधित्व, लेकिन हम bit(n) . का उपयोग कर सकते हैं रास्ते के रूप में। अदस्तावेजीकृत . हैं बिट स्ट्रिंग्स से कास्ट करता है (bit(n) ) पूर्णांक प्रकार के लिए (int2 , int4 , int8 ) - आंतरिक प्रतिनिधित्व बाइनरी संगत है। टॉम लेन का हवाला देते हुए:

यह बिट-टाइप इनपुट कनवर्टर के कुछ अनियंत्रित व्यवहार पर निर्भर है, लेकिन मुझे यह उम्मीद करने का कोई कारण नहीं दिखता कि यह टूट जाएगा। एक संभावित रूप से बड़ा मुद्दा यह है कि इसके लिए पीजी> =8.3 की आवश्यकता होती है क्योंकि इससे पहले थोड़ा सा टेक्स्ट नहीं डाला गया था।

integer अधिकतम के लिए 8 हेक्स अंक

8 हेक्स अंकों तक को bit(32) . में बदला जा सकता है और फिर integer . के लिए बाध्य किया गया (मानक 4-बाइट पूर्णांक):

SELECT ('x' || lpad(hex, 8, '0'))::bit(32)::int AS int_val
FROM  (
   VALUES
      ('1'::text)
    , ('f')
    , ('100')
    , ('7fffffff')
    , ('80000000')     -- overflow into negative number
    , ('deadbeef')
    , ('ffffffff')
    , ('ffffffff123')  -- too long
   ) AS t(hex);

   int_val
------------
          1
         15
        256
 2147483647
-2147483648
 -559038737
         -1

Postgres एक हस्ताक्षरित पूर्णांक प्रकार का उपयोग करता है, इसलिए हेक्स संख्या ऊपर '7fffffff' ऋणात्मक पूर्णांक . में अतिप्रवाह संख्याएं। यह अभी भी एक मान्य, अद्वितीय प्रतिनिधित्व है लेकिन अर्थ फरक है। अगर यह मायने रखता है, तो bigint पर स्विच करें; नीचे देखें।

8 से अधिक हेक्स अंकों के लिए कम से कम महत्वपूर्ण वर्ण (दाईं ओर से अधिक) छोटा हो जाते हैं ।

4 बिट एक बिट स्ट्रिंग में 1 हेक्स अंक को सांकेतिक शब्दों में बदलना . ज्ञात लंबाई के हेक्स नंबर संबंधित bit(n) . पर डाले जा सकते हैं सीधे। वैकल्पिक रूप से, अज्ञात लंबाई . के पैड हेक्स नंबर अग्रणी शून्य के साथ (0 ) जैसा दिखाया गया है और bit(32) . पर डाला गया है . उदाहरण 7 हेक्स अंकों और int . के साथ या 8 अंक और bigint :

SELECT ('x'|| 'deafbee')::bit(28)::int
     , ('x'|| 'deadbeef')::bit(32)::bigint;

  int4     | int8
-----------+------------
 233503726 | 3735928559

bigint अधिकतम के लिए 16 हेक्स अंक

16 हेक्स अंकों तक को bit(64) . में बदला जा सकता है और फिर bigint . के लिए ज़बरदस्ती किया (int8 , 8-बाइट पूर्णांक) - ऊपरी आधे हिस्से में फिर से ऋणात्मक संख्याओं में अतिप्रवाह:

SELECT ('x' || lpad(hex, 16, '0'))::bit(64)::bigint AS int8_val
FROM  (
   VALUES
      ('ff'::text)
    , ('7fffffff')
    , ('80000000')
    , ('deadbeef')
    , ('7fffffffffffffff')
    , ('8000000000000000')     -- overflow into negative number
    , ('ffffffffffffffff')
    , ('ffffffffffffffff123')  -- too long
   ) t(hex);

       int8_val
---------------------
                 255
          2147483647
          2147483648
          3735928559
 9223372036854775807
-9223372036854775808
                  -1
                  -1

uuid अधिकतम के लिए 32 हेक्स अंक

पोस्टग्रेज uuid डेटा प्रकार संख्यात्मक प्रकार नहीं है . लेकिन यह 32 हेक्स अंकों तक स्टोर करने के लिए मानक पोस्टग्रेस में सबसे कुशल प्रकार है, केवल 16 बाइट्स स्टोरेज पर कब्जा कर रहा है। एक प्रत्यक्ष कलाकार . है text . से करने के लिए uuid (bit(n) . की कोई आवश्यकता नहीं है वेपॉइंट के रूप में), लेकिन बिल्कुल 32 हेक्स अंक आवश्यक हैं।

SELECT lpad(hex, 32, '0')::uuid AS uuid_val
FROM  (
   VALUES ('ff'::text)
        , ('deadbeef')
        , ('ffffffffffffffff')
        , ('ffffffffffffffffffffffffffffffff')
        , ('ffffffffffffffffffffffffffffffff123') -- too long
   ) t(hex);

              uuid_val
--------------------------------------
 00000000-0000-0000-0000-0000000000ff
 00000000-0000-0000-0000-0000deadbeef
 00000000-0000-0000-ffff-ffffffffffff
 ffffffff-ffff-ffff-ffff-ffffffffffff
 ffffffff-ffff-ffff-ffff-ffffffffffff

जैसा कि आप देख सकते हैं, मानक आउटपुट UUID के लिए विशिष्ट विभाजकों के साथ हेक्स अंकों की एक स्ट्रिंग है।

md5 हैश

यह md5 हैश को स्टोर करने के लिए विशेष रूप से उपयोगी है :

SELECT md5('Store hash for long string, maybe for index?')::uuid AS md5_hash;

           md5_hash
--------------------------------------
 02e10e94-e895-616e-8e23-bb7f8025da42

देखें:

• MD5 फ़ील्ड के लिए इष्टतम डेटा प्रकार क्या है?