एकाधिक तालिकाओं की पूछताछ करते समय कुल कार्यों का सटीक रूप से उपयोग कैसे करें?

Question

मैं एक कठिन समय चल रहा है की तुलना में मैं एक प्रश्न है कि कुल कार्य शामिल हैं, कई टेबल, और सही संख्या में परिणाम प्रश्नों लिखने और मैं कुछ मदद मिल सकती है उम्मीद कर रहा उम्मीद करेंगे।

SQL Fiddle

श्रेणी तालिका उदाहरण

श्रेणी मैं क्या पर रिपोर्ट करने की आवश्यकता है:

|----|-----------| 
| id | name  | 
|----|-----------| 
| 1 | furniture | 
| 2 | music  | 
| 3 | kitchen | 
| 4 | adventure | 
|----|-----------| 

उत्पाद तालिका उदाहरण

उत्पाद तालिका उदाहरण:

+०१२३५१६४१०६१

|-----|----------------|-------------| 
| id | name   | category_id | 
|-----|----------------|-------------| 
| 101 | couch   | 1   | 
| 102 | chair   | 1   | 
| 103 | drum   | 2   | 
| 104 | flute   | 2   | 
| 105 | pot   | 3   | 
| 106 | pan   | 3   | 
| 107 | kitchen sink | 3   | 
| 108 | unicorn saddle | 4   | 
| 109 | unicorn shoes | 4   | 
| 110 | horse shampoo | 4   | 
|-----|----------------|-------------| 

गतिविधि तालिका उदाहरण

विचारों डेटा हम (श्रेणी के द्वारा) योग करने के लिए चाहते हैं गतिविधि तालिका में पाया:

|----|------------|-------| 
| id | product_id | views | 
|----|------------|-------| 
| 1 | 101  | 1000 | 
| 2 | 102  | 2000 | 
| 3 | 103  | 3000 | 
| 4 | 104  | 4000 | 
| 5 | 105  | 5000 | 
| 6 | 106  | 6000 | 
| 7 | 107  | 7000 | 
| 8 | 108  | 8000 | 
| 9 | 109  | 9000 | 
| 10 | 110  | 10000 | 
|----|------------|-------| 

बिक्री तालिका उदाहरण

बिक्री तालिका कि हम औसत बिक्री (फिर श्रेणी के अनुसार) पूछना चाहते हैं। ध्यान दें कि विक्रेता_आईडी महत्वपूर्ण है क्योंकि एक ही उत्पाद कई विक्रेताओं द्वारा किया जा सकता है। मैं विक्रेता तालिका छोड़ रहा हूं क्योंकि इस प्रश्न के लिए इसकी आवश्यकता नहीं है (हम केवल बाद के उदाहरणों में विक्रेता आईडी का उपयोग कर पूछ सकते हैं)।

|----|------------|-----------|--------| 
| id | product_id | vendor_id | amount | 
|----|------------|-----------|--------| 
| 1 | 101  | 1   | 1000 | 
| 2 | 102  | 1   | 900 | 
| 3 | 103  | 1   | 2000 | 
| 4 | 105  | 1   | 3000 | 
| 5 | 107  | 1   | 5000 | 
| 6 | 101  | 2   | 600 | 
| 7 | 103  | 2   | 7000 | 
| 8 | 105  | 2   | 8000 | 
| 9 | 107  | 2   | 1000 | 
| 10 | 108  | 1   | 500 | 
| 11 | 109  | 1   | 600 | 
| 12 | 108  | 2   | 400 | 
| 13 | 109  | 2   | 500 | 
|----|------------|-----------|--------| 

वांछित आउटपुट

नीचे वांछित आउटपुट है:

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

|-----------|----------------|-----------|---------------|-------------------------------|-------------------------| 
| category | count_products | sum_views | average_sales | sum_views_where_sales_=>_1000 | sum_views_sales_<_1000 | 
|-----------|----------------|-----------|---------------|-------------------------------|-------------------------| 
| adventure | 3    | 27000  | 500   | 0        | 27000     | 
| furniture | 2    | 3000  | 833   | 0        | 3000     | 
| kitchen | 3    | 18000  | 3000   | 6000       | 12000     | 
| music  | 2    | 7000  | 5000   | 7000       | 0      | 
|-----------|----------------|-----------|---------------|-------------------------------|-------------------------| 

क्वेरी की वर्तमान स्थिति

पहले उत्पादों और विचारों पर एक सटीक गणना प्राप्त करने के लिए:

SELECT cat.name AS category, 
     count(distinct p.name) AS product, 
     sum(a.views) AS views 
    FROM 
     category AS cat, 
     product AS p, 
     activity AS a 
    WHERE 
     cat.id=p.category_id 
    AND 
     p.id=a.product_id 
    GROUP BY 
     category; 

sidenote: मैं नहीं करने के लिए प्यार होता है में विशिष्ट उपयोग करने के लिए उपरोक्त क्वेरी। यहां कोई भी विचार बहुत अच्छा होगा।

सटीक परिणाम श्रेणी के द्वारा देखा गया प्रदर्शित:

|-----------|---------|-------| 
| category | product | views | 
|-----------|---------|-------| 
| Adventure | 3  | 27000 | 
| Furniture | 2  | 3000 | 
| Kitchen | 3  | 18000 | 
| Music  | 2  | 7000 | 
|-----------|---------|-------| 

सब कुछ अच्छा लग रहा है जब तक मैं अन्य तालिकाओं के लिए शामिल होने शुरू:

SELECT cat.name AS category, 
     count(distinct p.name) AS product, 
     sum(a.views) AS views, 
     round(avg(s.amount)) AS sales_amount 
    FROM 
     category AS cat, 
     product AS p, 
     activity AS a, 
     sales AS s 
    WHERE 
     cat.id=p.category_id 
    AND 
     p.id=a.product_id 
    AND 
     p.id=s.product_id 
    AND 
     s.vendor_id=1 
    GROUP BY 
     category; 

समस्या आउटपुट

|-----------|---------|-------|------------------| 
| category | product | views | avg_sales_amount | 
|-----------|---------|-------|------------------| 
| Adventure | 2  | 17000 | 550    | 
| Furniture | 2  | 3000 | 950    | 
| Kitchen | 2  | 12000 | 4000    | 
| Music  | 1  | 3000 | 2000    | 
|-----------|---------|-------|------------------| 

जैसा कि आप देख सकते हैं कि मैं वांछित आउटपुट से आगे बढ़ रहा हूं जब मैं औसत बिक्री राशि प्राप्त करने के लिए विक्रेता_आईडी द्वारा पूछताछ शुरू करता हूं। विशिष्ट होने के लिए, उत्पाद कॉलम का परिणाम अब सही मात्रा में उत्पादों में नहीं होता है क्योंकि सभी विक्रेताओं में s.vendor_id = 1 फ़िल्टर को कठिन बनाने वाले सभी समान उत्पाद नहीं होते हैं। मुझे में इन रिपोर्टों को विक्रेता द्वारा फ़िल्टर करने के लिए उपयोग करना होगा, जबकि अभी भी दृश्य फ़ील्ड पर सटीक रकम प्राप्त हो रही है।

मैंने बाएं जॉइन का उपयोग करके उपर्युक्त प्रश्नों का प्रयास किया है लेकिन अभी भी असुरक्षित परिणामों के साथ समाप्त होता है और यह सुनिश्चित नहीं करता कि क्या होने की आवश्यकता है, संभवतः किसी प्रकार की उप-क्वेरी?

Answer 1

आपकी रिपोर्ट आवश्यकता आश्चर्यजनक रूप से जटिल है। हो सकता है कि आप इस परियोजना में चले गए हों कि यह सोचने से कहीं अधिक सरल है।

यह एक ऐसा मामला है जहां आप स्वतंत्र रूप से सारणीबद्ध उपायों (विचारों और बिक्री) के आधार पर सारांशों पर रिपोर्टिंग कर रहे हैं।

इसलिए, आपको कुल सबक्वायरीज़ से शुरू करने की आवश्यकता है जो दो विस्तृत माप तालिकाओं में शामिल हों।यह एक ऐसी सवाल है। यह आपको श्रेणी के आधार पर देखता है। http://sqlfiddle.com/#!9/02f4b6/31/0

    SELECT c.id category_id, SUM(a.views) views 
        FROM activity a 
        JOIN product p ON a.product_id = p.id 
        JOIN category c ON p.category_id = c.id 
        GROUP BY c.id 

यह ऐसी अन्य क्वेरी है। यह आपको श्रेणी के आधार पर बिक्री करता है। http://sqlfiddle.com/#!9/02f4b6/32/0

    SELECT c.id category_id, 
          SUM(s.amount) total_sales, 
          AVG(s.amount) avg_sales 
        FROM sales s 
        JOIN product p ON s.product_id = p.id 
        JOIN category c ON p.category_id = c.id 
        GROUP BY c.id 

अगला आपको श्रेणी के अनुसार उत्पादों की गिनती की आवश्यकता है। सौभाग्य से प्रत्येक उत्पाद केवल एक श्रेणी में हो सकता है। http://sqlfiddle.com/#!9/02f4b6/42/0

    SELECT c.id category_id, 
          COUNT(*) products 
        FROM product p 
        JOIN category c ON p.category_id = c.id 
        GROUP BY c.id 

अब, इन वस्तुओं को एक साथ शामिल करना आवश्यक है। category तालिका और LEFT JOIN के साथ अन्य तीनों के साथ शुरू करें। http://sqlfiddle.com/#!9/02f4b6/51/0

SELECT c.name, aggproducts.products, 
     aggviews.views, aggsales.avg_sales, 
     aggsales.total_sales 
    FROM category c 
    LEFT JOIN (
        SELECT c.id category_id, SUM(a.views) views 
        FROM activity a 
        JOIN product p ON a.product_id = p.id 
        JOIN category c ON p.category_id = c.id 
        GROUP BY c.id 
     ) aggviews ON c.id = aggviews.category_id 
    LEFT JOIN (
        SELECT c.id category_id, 
          SUM(s.amount) total_sales, 
          AVG(s.amount) avg_sales 
        FROM sales s 
        JOIN product p ON s.product_id = p.id 
        JOIN category c ON p.category_id = c.id 
        GROUP BY c.id 
     ) aggsales ON c.id = aggsales.category_id 
    LEFT JOIN (
        SELECT c.id category_id, 
          COUNT(*) products 
        FROM product p 
        JOIN category c ON p.category_id = c.id 
        GROUP BY c.id 
     ) aggproducts ON c.id = aggproducts.category_id 

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

फिर आप श्रेणी तालिका में उन कुल सबक्विरी LEFT JOIN। सामान्य JOIN का उपयोग न करें क्योंकि यदि कुल उपकुंजी में से कोई भी विशेष श्रेणी गुम हो तो परिणाम से पंक्तियों को दबाएगा।

ध्यान दें कि आप इन सबक्विरी का उपयोग कर रहे हैं जैसे कि वे टेबल थे। सबक्वायरीज़ से प्रश्न बनाने की क्षमता संरचित क्वेरी भाषा में संरचित रखती है।

वे मूल बातें हैं। अब आपको उन सशर्त रकम के लिए एक और कुल सबक्वायरी की आवश्यकता है। मैं तुम्हें वह छोड़ने जा रहा हूँ।

Answer 2

निम्नलिखित प्रयास करें ...

SELECT Category.name AS category, 
     COUNT(*) AS count_Product, 
     SUM(views) AS sum_views, 
     ROUND(COALESCE(SUM(sumAmount)/SUM(countAmounts), 0)) AS average_sales, 
     SUM(whereGreater) AS 'sum_views_where_sales_=>_1000', 
     SUM(whereLesser) AS 'sum_views_sales_<_1000' 
FROM Category 
JOIN Product ON Category.id = Product.category_id 
JOIN Activity ON Product.id = Activity.product_id 
LEFT JOIN (SELECT product_id AS product_id, 
        SUM(amount) AS sumAmount, 
        COUNT(*) AS countAmounts 
      FROM Sales 
      GROUP BY product_id 
    ) sumCountAmountFinder ON Product.id = sumCountAmountFinder.product_id 
JOIN (SELECT Activity.product_id AS product_id, 
       SUM(CASE WHEN COALESCE(meanAmount, 0) >= 1000 THEN views ELSE 0 END) AS whereGreater, 
       SUM(CASE WHEN COALESCE(meanAmount, 0) < 1000 THEN views ELSE 0 END) AS whereLesser 
     FROM Activity 
     LEFT JOIN (SELECT product_id AS product_id, 
          SUM(amount)/COUNT(*) AS meanAmount 
        FROM Sales 
        GROUP BY product_id 
       ) AS meanAmountFinder ON Activity.product_id = meanAmountFinder.product_id 
     GROUP BY Activity.product_id 
    ) sumWhereFinder ON Product.id = sumWhereFinder.product_id 
GROUP BY Category.name; 

अनुमान

कि Category में एक रिकॉर्ड हमेशा Product में कम से कम एक रिकॉर्ड इसके साथ जुड़े होगा।

कि Product में प्रत्येक रिकॉर्ड Activity में एक समान रिकॉर्ड होगा।

स्पष्टीकरण

मेरे बयान, एक INNER JOINCategory और Product के बीच प्रदर्शन को प्रभावी ढंग से हमें एक Category के साथ जुड़े Products की एक सूची देकर शुरू होता है।

एक INNER JOIN प्रभावी रूप से अपने इसी Product रिकॉर्ड करने के लिए views क्षेत्र के प्रत्येक मान जोड़कर, Activity और इसके बाद के संस्करण में शामिल हो गए डाटासेट के बीच किया जाता है।

निम्नलिखित सबक्वेरी तो Sales में प्रत्येक product_id के लिए amount की कुल और प्रत्येक product_id के लिए अभिलेखों की संख्या निर्धारित करने के लिए प्रयोग किया जाता है। LEFT JOIN तब Product और उपकुंजी से प्रभावी रूप से उपरोक्त डेटासेट में प्रत्येक रिकॉर्ड को अपने संबंधित Product में जोड़कर प्रभावी ढंग से जोड़ता है। LEFT JOIN का उपयोग INNER JOIN के बजाय किया गया था क्योंकि Product के सभी रिकॉर्ड Sales में संबंधित रिकॉर्ड होंगे और हम उस अनुपस्थिति के आधार पर Product से किसी भी रिकॉर्ड की इच्छा नहीं रखते हैं।

SELECT product_id AS product_id, 
     SUM(amount) AS sumAmount, 
     COUNT(*) AS countAmounts 
FROM Sales 
GROUP BY product_id 

एक और सबक्वेरी (इस प्रकार) तो Sales में प्रत्येक product_id के लिए amount का मतलब औसत की गणना करने के लिए प्रयोग किया जाता है।

SELECT product_id AS product_id, 
     SUM(amount)/COUNT(*) AS meanAmount 
FROM Sales 
GROUP BY product_id 

एक LEFT JOIN तो Activity और सबक्वेरी के परिणामों के बीच किया जाता है। प्रत्येक product_id के लिए amount का औसत औसत 1000 से तुलना किया गया है और के views के संबंधित मान को उचित फ़ील्ड में रखा गया है, 0 दूसरे में रखा जा रहा है। यदि product_id का मान Sales में कोई संबंधित रिकॉर्ड नहीं है, तो 0 दोनों फ़ील्ड में स्थित है। परिणामी मूल उपकुंजी (जो निम्नानुसार) द्वारा उत्पादित परिणामस्वरूप उपर्युक्त डेटासेट में शामिल हो जाते हैं।

SELECT Activity.product_id AS product_id, 
     SUM(CASE WHEN COALESCE(meanAmount, 0) >= 1000 THEN views ELSE 0 END) AS whereGreater, 
     SUM(CASE WHEN COALESCE(meanAmount, 0) < 1000 THEN views ELSE 0 END) AS whereLesser 
FROM Activity 
LEFT JOIN (SELECT product_id AS product_id, 
        SUM(amount)/COUNT(*) AS meanAmount 
      FROM Sales 
      GROUP BY product_id 
     ) AS meanAmountFinder ON Activity.product_id = meanAmountFinder.product_id 
GROUP BY Activity.product_id 

के साथ अपने अंतिम में शामिल हो गए डाटासेट अब गठन, रिकॉर्ड तो Category.name के अपने मूल्य के आधार पर वर्गीकृत किया जाता है। प्रत्येक समूह का मूल्य Category.name और उसके संबंधित समेकित मूल्यों की गणना और वापसी की जाती है।

परीक्षण

मेरे बयान निम्नलिखित कोड का उपयोग कर बनाया एक नमूना डेटाबेस के खिलाफ परीक्षण किया गया था ...

CREATE TABLE Category 
(
    id  INT, 
    name VARCHAR(50) 
); 
INSERT INTO Category (id, 
         name) 
VALUES (1, 'furniture'), 
     (2, 'music'), 
     (3, 'kitchen'), 
     (4, 'adventure'); 
CREATE TABLE Product 
(
    id   INT, 
    name   VARCHAR(50), 
    category_id INT 
); 
INSERT INTO Product (id, 
         name, 
         category_id) 
VALUES (101, 'couch',   1), 
     (102, 'chair',   1), 
     (103, 'drum',   2), 
     (104, 'flute',   2), 
     (105, 'pot',   3), 
     (106, 'pan',   3), 
     (107, 'kitchen sink', 3), 
     (108, 'unicorn saddle', 4), 
     (109, 'unicorn shoes', 4), 
     (110, 'horse shampoo', 4); 
CREATE TABLE Activity 
(
    id   INT, 
    product_id INT, 
    views  INT 
); 
INSERT INTO Activity (id, 
         product_id, 
         views) 
VALUES (1, 101, 1000 ), 
     (2, 102, 2000 ), 
     (3, 103, 3000 ), 
     (4, 104, 4000 ), 
     (5, 105, 5000 ), 
     (6, 106, 6000 ), 
     (7, 107, 7000 ), 
     (8, 108, 8000 ), 
     (9, 109, 9000 ), 
     (10, 110, 10000); 
CREATE TABLE Sales 
(
    id   INT, 
    product_id INT, 
    vendor_id INT, 
    amount  INT 
); 
INSERT INTO Sales (id, 
        product_id, 
        vendor_id, 
        amount) 
VALUES (1, 101, 1, 1000), 
     (2, 102, 1, 900 ), 
     (3, 103, 1, 2000), 
     (4, 105, 1, 3000), 
     (5, 107, 1, 5000), 
     (6, 101, 2, 600 ), 
     (7, 103, 2, 7000), 
     (8, 105, 2, 8000), 
     (9, 107, 2, 1000), 
     (10, 108, 1, 500 ), 
     (11, 109, 1, 600 ), 
     (12, 108, 2, 400 ), 
     (13, 109, 2, 500); 

आप कोई प्रश्न या टिप्पणी है, तो एक टिप्पणी पोस्ट करने के लिए संकोच न करें तदनुसार।

अतिरिक्त पठन

https://dev.mysql.com/doc/refman/5.7/en/case.html

https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html#function_coalesce (MySQL के COALESCE() समारोह पर)

https://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html#function_count (MySQL की 'गिनती पर() `में समेकित फ़ंक्शन)

(MySQL के CASE बयान पर) https://www.w3schools.com/sql/sql_join.asp (क्षैतिजके विभिन्न प्रकारों पर एसक्यूएल मेंके)

https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html#function_round (MySQL के ROUND() समारोह पर)

https://dev.mysql.com/doc/refman/5.7/en/select.html (MySQL के SELECT बयान पर)

https://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html#function_sum (MySQL के SUM() समेकित फ़ंक्शन पर)

परिशिष्ट

यदि मेरी दोनों धारणाएं गलत हैं, तो कृपया निम्नलिखित कोड आज़माएं ...

SELECT Category.name AS category, 
     COUNT(*) AS count_Product, 
     COALESCE(SUM(views), '') AS sum_views, 
     COALESCE(ROUND(SUM(sumAmount)/SUM(countAmounts), '')) AS average_sales, 
     COALESCE(SUM(whereGreater), '') AS 'sum_views_where_sales_=>_1000', 
     COALESCE(SUM(whereLesser), '') AS 'sum_views_sales_<_1000' 
FROM Category 
LEFT JOIN Product ON Category.id = Product.category_id 
LEFT JOIN Activity ON Product.id = Activity.product_id 
LEFT JOIN (SELECT product_id AS product_id, 
        SUM(amount) AS sumAmount, 
        COUNT(*) AS countAmounts 
      FROM Sales 
      GROUP BY product_id 
    ) sumCountAmountFinder ON Product.id = sumCountAmountFinder.product_id 
LEFT JOIN (SELECT Activity.product_id AS product_id, 
        SUM(CASE WHEN COALESCE(meanAmount, 0) >= 1000 THEN views ELSE 0 END) AS whereGreater, 
        SUM(CASE WHEN COALESCE(meanAmount, 0) < 1000 THEN views ELSE 0 END) AS whereLesser 
      FROM Activity 
      LEFT JOIN (SELECT product_id AS product_id, 
           SUM(amount)/COUNT(*) AS meanAmount 
         FROM Sales 
         GROUP BY product_id 
        ) AS meanAmountFinder ON Activity.product_id = meanAmountFinder.product_id 
      GROUP BY Activity.product_id 
     ) sumWhereFinder ON Product.id = sumWhereFinder.product_id 
GROUP BY Category.name; 

Answer 3

आपके पास आउटपुट में आने वाले अंतिम तालिका आउटपुट की गणना करने में कई गलतियां हैं।

मुझे यह समझाया गया है कि तुम क्या मतलब है मेज पर कोशिश करते हैं और इस परिणाम है:

SELECT 
    (`cat`.`name`) AS `category`, 
    COUNT(`p`.`name`) AS `productsInGroup`, 
    SUM(`a`.`views`) AS `viewsOnGroup`, 
    SUM(`s`.`amount`)/SUM(`salesCnt`) AS `average_sales`, 
    IF(SUM(`s`.`amount`)/SUM(`salesCnt`) >= 1000, SUM(`a`.`views`) - SUM(IF(`s`.`salesCnt` IS NULL, `a`.`views`, 0)), 0) AS `sum_views_where_sales_>=_1000`, 
    IF(SUM(`s`.`amount`)/SUM(`salesCnt`) < 1000, SUM(`a`.`views`) , SUM(IF(`s`.`salesCnt` IS NULL, `a`.`views`, 0))) AS `sum_views_where_sales_<_1000` 
FROM 
    `product` AS `p` 

INNER JOIN 
    `category` AS `cat` 
    ON `cat`.`id` = `p`.`category_id` 
LEFT JOIN 
    `activity` AS `a` 
    ON `a`.`product_id` = `p`.`id` 
LEFT JOIN(
    SELECT 
    `product_id`, 
    COUNT(`product_id`) AS `salesCnt`, 
    SUM(`amount`) AS `amount` 
    FROM `sales` 
    GROUP BY `product_id` 
) AS `s` 
ON `s`.`product_id` = `a`.`product_id` 

GROUP BY 
    `category`; 

तो है सही परिणाम मुझे बताओ और मैं सहेजें चर में गणना के साथ क्वेरी अनुकूलित करेंगे। आज की

http://sqlfiddle.com/#!9/02f4b6/144