Redshift

Question

मैं एक मेज बनाने रहा Amazon Redshift में निम्न आदेश का उपयोग कर अमेज़न में अत्यंत छोटे मूल्यों भंडारण:

CREATE TABLE asmt.incorrect_question_pairs_unique 
    AS 
    SELECT question1, 
      question2, 
      occurrences, 
      occurrences::float/SUM(occurrences) OVER() AS prob_q1_q2 
    FROM (SELECT question1, 
       question2, 
       SUM(occurrences) AS occurrences 
      FROM asmt.incorrect_question_pairs 
      GROUP BY question1, 
        question2 
      HAVING SUM(occurrences) >= 50) 

मैं करने के लिए स्तंभ prob_q1_q2 चाहते हैं:

CREATE TABLE asmt.incorrect_question_pairs_unique 
AS 
SELECT question1, 
     question2, 
     occurrences, 
     occurrences/(SUM(occurrences)::FLOAT) OVER() AS prob_q1_q2 
FROM (SELECT question1, 
      question2, 
      SUM(occurrences) AS occurrences 
     FROM asmt.incorrect_question_pairs 
     GROUP BY question1, 
       question2 
     HAVING SUM(occurrences) >= 50) 

मैं भी एक वैकल्पिक करने की कोशिश की float कॉलम बनें, यही कारण है कि मैं denominator/numerator को float में परिवर्तित कर रहा हूं। लेकिन परिणामी तालिका में, मुझे उस कॉलम में सभी शून्य मिलते हैं।

मैं यह इंगित करना चाहता हूं कि SUM(occurrences) लगभग 10 Billion होगा, इसलिए कॉलम prob_q1_q2 में बहुत कम मूल्य होंगे। Amazon Redshift में ऐसे छोटे मानों को स्टोर करने का कोई तरीका है?

मैं कैसे सुनिश्चित कर सकता हूं कि कॉलम में सभी मान गैर-शून्य float हैं?

किसी भी मदद की सराहना की जाएगी।

Answer 1

विधि 1 - मैं एक ही समस्या पड़ा है! मेरे मामले में यह पंक्तियों में से लाख थी इसलिए मैंने 10000 तक परिणाम बढ़ाया।
जब भी मैं उस कॉलम से मूल्यों का चयन करना चाहता था, तो मैं इसे चुनने के लिए चुनिंदा कथन में 10000 से विभाजित करूंगा।
मुझे पता है कि यह सही समाधान नहीं है बल्कि मेरे लिए काम करता है।

METHOD 2 - मैंने न्यूमेरिक (12,6) डेटाटाइप के साथ एक नमूना तालिका बनाई और जब मैंने आपके जैसा परिणाम सेट आयात किया, तो मैं 6 दशमलव परिशुद्धता तक फ्लोट मान देख सकता हूं।

मुझे लगता है, जब आप तालिका आदेश के रूप में बनाने का उपयोग रूपांतरण काम नहीं करता है, तो आप डेटाप्रकार जो परिणाम एक निश्चित सटीक स्तर पर संग्रहित किया जा करने के लिए सेट को लागू करता है को निर्दिष्ट तालिका बनाने के लिए की जरूरत है।
इसकी विषमता! एक ही चयन कैसे करता है 0.00 लेकिन जब लागू कॉलम के साथ तालिका में डाला जाता है, तो यह 0.00333 देता है।

यदि मैंने एक बुरा धारणा की है तो कृपया टिप्पणी करें और मैं अपना जवाब दोबारा कर दूंगा।

Answer 2

प्रयास करें:

select cast(num1 as float)/cast(num2 as float);

यह आपको 2 दशमलव स्थानों (डिफ़ॉल्ट रूप से) तक परिणाम देगा, लेकिन अपने प्रसंस्करण समय में से कुछ लेता है। कुछ और करना दशमलव भाग को गोल-बंद कर देगा।

Answer 3

Patthebug,

आप एक तरह से बहुत कम संख्या जो अमेज़न Redshift की फ्लोट प्रकार में संग्रहीत नहीं किया जा सकता हो रही हो सकता है। इसके बजाय DECIMAL का उपयोग करने का प्रयास करें, कोई तरीका नहीं है कि यह आपके मान को स्टोर नहीं कर सकता है यह 128 बिट चर है।

जिस तरह से यह काम करता है वह निम्न है, यदि मूल्य बहुत बड़ा है या आपके मामले में बहुत छोटा है और यह आपके प्रकार के अधिकतम/न्यूनतम मान से अधिक है तो अंतिम अंक छंटनी की जाती हैं और फिर नया (छंटनी) मान संग्रहीत किया जाता है अपने प्रकार के चर/कॉलम में। जब यह एक बड़ा मूल्य ट्रिम कर रहा है तो आप लगभग कुछ भी नहीं कह सकते हैं कि आप 20 बिलियन डॉलर में से 20 सेंट ट्रिम कर रहे हैं, आपको ज्यादा नुकसान नहीं होगा। लेकिन आपके मामले में जब संख्या बहुत छोटी होती है तो आप (फी ए प्रकार 5 अंकों तक स्टोर कर सकते हैं और आप एक चर/कॉलम में 0.00000 9 का मान स्टोर करना चाहते हैं) के अंतिम अंक को ट्रिम करते समय सबकुछ खो सकते हैं। इस प्रकार का। आपका मान इस प्रकार के फिट नहीं हो सकता है, इसलिए यह पिछले 2 अंकों से छंटनी की जा सकती है, इसलिए यह फिट हो सकती है और आपको 0.0000 का नया मान प्राप्त होता है)

तो यदि आपने मेरे विचारों का पालन किया तो बस :: फ्लोट बदल रहा है करने के लिए :: दशमलव को अपनी समस्या को ठीक करना चाहिए। पीएस दशमलव को इसके आकार को निर्दिष्ट करने की आवश्यकता हो सकती है f.e. दशमलव (127.100)

Answer 4

You can have up to 38 digits in a DECIMAL/NUMERIC column with of 37 digits of scale.

CREATE TEMP TABLE precision_test (test NUMERIC(38,37)) DISTSTYLE ALL 
; 
INSERT INTO precision_test 
SELECT CAST(0.0000000000000000000000000000000000001 AS NUMERIC(38,37)) test 
; 
SELECT * FROM precision_test 
; 
--Returns 0.0000000000000000000000000000000000001