Home Esplora Aiuto
Accedi
DK-MES-2.0
/
SANHOPE.mes.web
6
0
Forka 0
File Problemi 0 Pull Requests 0 Wiki
Sfoglia il codice sorgente

欠点表 存储过程。

姜永辉 1 settimana fa
parent
dde1df5f09
commit
374f150f70
1 ha cambiato i file con 85 aggiunte e 2512 eliminazioni
Visualizzazione separata Mostra Diff Stats
  1. 85 2512
      wwwroot/mes/rpt/rpt304/rpt.ashx

+ 85 - 2512
wwwroot/mes/rpt/rpt304/rpt.ashx
Vedi File 

@@ -16,21 +16,21 @@ public class rpt : IHttpHandler, IReadOnlySessionState
 
 {
 
     public void ProcessRequest(HttpContext context)
 
     {
 
- context.Response.ContentType = "text/plain";
 
- using(IDataAccess conn = DataAccess.Create())
 
- {    DateTime dateBegin = Convert.ToDateTime(context.Request["datebeginMaster"]);
 
-     DateTime dateEnd = Convert.ToDateTime(context.Request["dateendMaster"]);
 
-     string kilproc = "16"; //出窑工序
 
-     string notInproc = " (61,28) ";//排除工序
 
-     string FunctionalTesting = "60"; //功能检测
 
-     // 241223 增加成型工号 
-     string userCode = context.Request["userCode"];
 
-     string sqltmp = "";
 
-     conn.BeginTransaction();
 
-     //插入如数据 250725
 
-     if (context.Request["procedureMaster"] == "3")
 
-     {
 
-  sqltmp = @" INSERT INTO TMP_PM_PRODUCTIONDATA_CHECKDT(GOODSNAME,
 
+        context.Response.ContentType = "text/plain";
 
+        using (IDataAccess conn = DataAccess.Create())
 
+        {
 
+            DateTime dateBegin = Convert.ToDateTime(context.Request["datebeginMaster"]);
 
+            DateTime dateEnd = Convert.ToDateTime(context.Request["dateendMaster"]);
 
+            int kilproc = 16; //出窑工序
 
+            string notInproc = "61,28";//排除工序 
+            // 241223 增加成型工号
 
+            string userCode = context.Request["userCode"];
 
+            string sqltmp = "";
 
+            conn.BeginTransaction();
 
+            //插入如数据 250725
 
+            if (context.Request["procedureMaster"] == "3")
 
+            {
 
+                sqltmp = @" INSERT INTO TMP_PM_PRODUCTIONDATA_CHECKDT(GOODSNAME,
 
      GROUTINGDAILYDETAILID,
 
      GOODSID,
 
      GOODSCODE,
 
@@ -80,8 +80,8 @@ public class rpt : IHttpHandler, IReadOnlySessionState
 
  -- 20251027 web报表中以末次质量登记时间节点统计质量数据调整为首次质量登记时间做统计质量数据变更 createtime - > checktime 
       AND PD28.checktime >= to_date('" + dateBegin.ToString("yyyy-MM-dd HH:mm:ss") + @"','yyyy-mm-dd hh24:mi:ss') 
        AND PD28.checktime <= to_date('" + dateEnd.ToString("yyyy-MM-dd HH:mm:ss") + @"','yyyy-mm-dd hh24:mi:ss') 
-       AND ('"+userCode+@"' IS NULL OR '"+userCode+@"' = '' OR
 
-  INSTR(PD28.GROUTINGUSERCODE, '"+userCode+@"') > 0)
 
+       AND ('" + userCode + @"' IS NULL OR '" + userCode + @"' = '' OR
 
+  INSTR(PD28.GROUTINGUSERCODE, '" + userCode + @"') > 0)
 
        AND PD24.PRODUCTIONDATAID < PD28.PRODUCTIONDATAID) T
 
     WHERE ROWNUMS = 1
 
       AND T.PROCEDUREID IN (55, 13)) PD1
 
@@ -101,10 +101,10 @@ public class rpt : IHttpHandler, IReadOnlySessionState
 
       AND PD28C.PRODUCTIONDATAID > PD1.PRODUCTIONDATAID
 
       AND PD28C.PRODUCTIONDATAID < PD61.PRODUCTIONDATAID)
 
    ";
 
-     }
 
-     else  if (context.Request["procedureMaster"] == "1")
 
-     {
 
-  sqltmp = @" INSERT INTO TMP_PM_PRODUCTIONDATA_CHECKDT(GOODSNAME,
 
+            }
 
+            else if (context.Request["procedureMaster"] == "1")
 
+            {
 
+                sqltmp = @" INSERT INTO TMP_PM_PRODUCTIONDATA_CHECKDT(GOODSNAME,
 
      GROUTINGDAILYDETAILID,
 
      GOODSID,
 
      GOODSCODE,
 
@@ -154,8 +154,8 @@ public class rpt : IHttpHandler, IReadOnlySessionState
 
  -- 20251027 web报表中以末次质量登记时间节点统计质量数据调整为首次质量登记时间做统计质量数据变更 createtime - > checktime 
        AND PD28.checktime >= to_date('" + dateBegin.ToString("yyyy-MM-dd HH:mm:ss") + @"','yyyy-mm-dd hh24:mi:ss') 
         AND PD28.checktime <= to_date('" + dateEnd.ToString("yyyy-MM-dd HH:mm:ss") + @"','yyyy-mm-dd hh24:mi:ss') 
-       AND ('"+userCode+@"' IS NULL OR '"+userCode+@"' = '' OR
 
-  INSTR(PD28.GROUTINGUSERCODE, '"+userCode+@"') > 0)
 
+       AND ('" + userCode + @"' IS NULL OR '" + userCode + @"' = '' OR
 
+  INSTR(PD28.GROUTINGUSERCODE, '" + userCode + @"') > 0)
 
        AND PD24.PRODUCTIONDATAID < PD28.PRODUCTIONDATAID) T
 
     WHERE ROWNUMS = 1
 
       AND T.PROCEDUREID = 42) PD1
 
@@ -174,10 +174,10 @@ public class rpt : IHttpHandler, IReadOnlySessionState
 
       AND PD28C.KILNCARBATCHNO = PD1.KILNCARBATCHNO
 
       AND PD28C.PRODUCTIONDATAID > PD1.PRODUCTIONDATAID
 
       AND PD28C.PRODUCTIONDATAID < PD61.PRODUCTIONDATAID) ";
 
-     }
 
-     else
 
-     {
 
-  sqltmp = @" INSERT INTO TMP_PM_PRODUCTIONDATA_CHECKDT(GOODSNAME,
 
+            }
 
+            else
 
+            {
 
+                sqltmp = @" INSERT INTO TMP_PM_PRODUCTIONDATA_CHECKDT(GOODSNAME,
 
      GROUTINGDAILYDETAILID,
 
      GOODSID,
 
      GOODSCODE,
 
@@ -227,8 +227,8 @@ public class rpt : IHttpHandler, IReadOnlySessionState
 
  -- 20251027 web报表中以末次质量登记时间节点统计质量数据调整为首次质量登记时间做统计质量数据变更 createtime - > checktime 
        AND PD28.checktime >= to_date('" + dateBegin.ToString("yyyy-MM-dd HH:mm:ss") + @"','yyyy-mm-dd hh24:mi:ss') 
         AND PD28.checktime <= to_date('" + dateEnd.ToString("yyyy-MM-dd HH:mm:ss") + @"','yyyy-mm-dd hh24:mi:ss') 
-       AND ('"+userCode+@"' IS NULL OR '"+userCode+@"' = '' OR
 
-  INSTR(PD28.GROUTINGUSERCODE, '"+userCode+@"') > 0)
 
+       AND ('" + userCode + @"' IS NULL OR '" + userCode + @"' = '' OR
 
+  INSTR(PD28.GROUTINGUSERCODE, '" + userCode + @"') > 0)
 
        AND PD24.PRODUCTIONDATAID < PD28.PRODUCTIONDATAID) T
 
     WHERE ROWNUMS = 1
 
       AND T.PROCEDUREID = 24) PD1
 
@@ -247,2498 +247,71 @@ public class rpt : IHttpHandler, IReadOnlySessionState
 
       AND PD28C.KILNCARBATCHNO = PD1.KILNCARBATCHNO
 
       AND PD28C.PRODUCTIONDATAID > PD1.PRODUCTIONDATAID
 
       AND PD28C.PRODUCTIONDATAID < PD61.PRODUCTIONDATAID) ";
 
-     }
 
+            }
 
 
-     int count = conn.ExecuteNonQuery(sqltmp);
 
+            int count = conn.ExecuteNonQuery(sqltmp);
 
 
-     //主表
 
-     string sqlStr = "";
 
-     if(context.Request["m"].ToString()=="master"){
 
-  //读取报表数据
 
-  if (context.Request["procedureMaster"] == "2")
 
-  {
 
-      kilproc = "28";//出窑工序
 
-      FunctionalTesting = "61";//功能检测
 
-      notInproc = " (16,60) ";//排除工序
 
-      sqlStr = @"WITH 
-     产品汇总缺陷 AS ( 
- SELECT     
-  CASE WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =5   THEN '小计'
 
- WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =6  AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001001' THEN '大件合计'
 
- WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =6  AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001002' THEN '小件合计'
 
- WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =7   THEN '总计'
 
- ELSE to_char(good.GOODSCODE) END AS GOODSCODE,
 
- GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME) AS GID,
 
-  good.GOODSSPECIFICATION,
 
-  good.GOODSNAME,
 
-    CASE WHEN GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6))=6 AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001001' THEN '大件' 
-     WHEN GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6))=6 AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001002' THEN '小件'
 
-      ELSE TO_CHAR(gtp.GOODSTYPENAME )END GOODSTYPENAME,
 
-  SUBSTR(gtp.GOODSTYPECODE, 0, 6)  AS GOODSTYPECODE,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN   df.DEFECTCODE IN ('01','02','03','04','05','06','07','08','09','10','12','13','14','15','16','17','18','19','21','22','23','24','25','26','27','28','29','30','31','32','33','34','35','001','002','099','99','1' ,'2' ,'3' )    THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 成型半检缺陷__缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '10', '12', '13', '14', '15', '16', '17', '18', '19', '23', '25', '35' )   THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 精修缺陷_打磨缺陷_缺陷汇总,  
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN PDs.PROCEDUREID IN (5,36,52)   AND df.DEFECTCODE IN ( '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '28', '34', '35') THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 精修缺陷_刷洗缺陷_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '36','37','38','39','40','41','42','43','44') THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 施釉擦坯缺陷_施釉缺陷_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '47','48','49','50','51','52','53','54','55','56','20','57')AND MDF.DEFECTCODE IS NOT NULL AND DF.BARCODE IS NOT NULL  THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END ))AS 施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '61','62','63','64','65','66','67', '11') THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 烧成缺陷_装窑缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '69','70','71','43','73','74','75','76','77','78','79','80') THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END ))AS 烧成缺陷_烧窑缺陷_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '83','84')  THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 烧成缺陷_出窑缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '86', '87','086', '88'  ) THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 原料缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '91', '92', '93', '083', '084') THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 冷修_缺陷汇总,     
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '091', '092', '093', '96') THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 回烧修补_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '061', '062', '063', '064', '065', '066', '067', '011' ) THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 回烧缺陷_装窑缺陷_缺陷汇总,     
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '069', '070', '071', '43', '073', '074', '075', '076', '077', '078', '079', '080' ) THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 回烧缺陷_烧窑缺陷_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '0083', '0084' ) THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 回烧缺陷_出窑缺陷_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '98'  ) THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 研磨_缺陷汇总,  
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN (  '100') THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 其他_缺陷汇总
 
-     FROM TP_PM_DEFECT df  
-     LEFT JOIN (TMP_PM_PRODUCTIONDATA_CHECKDT) pd
 
-ON (df.productiondataid  = pd.productiondataid or df.productiondataid  = pd.fproductiondataid)
 
-  LEFT JOIN TP_MST_GOODS good on good.GOODSID=PD.GOODSID
 
-  LEFT JOIN TP_MST_GOODSTYPE gtp ON good.GOODSTYPEID=gtp.GOODSTYPEID
 
-   LEFT JOIN TP_MST_DEFECT MDF ON DF.DEFECTID = MDF.DEFECTID     
-  INNER JOIN tp_pm_productiondata pds ON pds.barcode = pd.barcode  AND pds.valueflag = 1
 
-   WHERE df.VALUEFLAG=1    
-AND DF.PROCEDUREID NOT IN " + notInproc;
 
-  sqlStr += @" GROUP BY Grouping sets ( ( good.GOODSCODE, good.GOODSNAME,good.GOODSSPECIFICATION,gtp.GOODSTYPENAME ), ( gtp.GOODSTYPENAME) ,(SUBSTR(gtp.GOODSTYPECODE, 0, 6)),())  ),
 
-   产品明细缺陷 AS (
 
-   SELECT GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)),
 
-   CASE WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =5   THEN '小计'
 
-   WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =6   AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001001' THEN '大件合计'
 
-   WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =6   AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001002' THEN '小件合计'
 
-   WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =7   THEN '总计'
 
-   ELSE to_char(good.GOODSCODE) END AS GOODSCODE,
 
-  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME) AS GID,
 
-  good.GOODSNAME,
 
-  CASE WHEN GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6))=6 AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001001' THEN '大件' 
-       WHEN GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6))=6 AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001002' THEN '小件'
 
-       ELSE TO_CHAR(gtp.GOODSTYPENAME )END GOODSTYPENAME,
 
-  SUBSTR(gtp.GOODSTYPECODE, 0, 6)  AS GOODSTYPECODE,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '01' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_坯脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '02' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_棕眼,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '03' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂底,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '04' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂圈,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '05' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂鼻子,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '06' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂水道,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '07' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂管,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '08' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_沾接裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '09' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂眼,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '10' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_糙活,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '12' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_变形,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '13' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_渣,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '14' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_管道渣,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '15' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_孔眼不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '16' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_堵眼,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '17' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_眼歪,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '18' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_丢气孔,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '19' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_丢眼,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '21' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_漏气,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '22' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_空泡,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '23' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_水封不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '24' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_漏水,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '25' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_卡球,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '26' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_冲刷不好,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '27' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_泥埂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '28' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_断浆迹,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '29' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_模迹,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '30' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_重皮,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '31' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_气泡,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '32' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_眼扁,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '33' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_水绺,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '34' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '35' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_活糙,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '001' ) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_贴码不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '002' ) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_干补不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '1' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_内漏不合格,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '2' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_外漏不合格,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '3' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_试水不合格,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '99' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_隧道窑其他蹦脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '099' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_梭式窑其他蹦脏,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '10' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_糙活,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '12' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_变形,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '13' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_渣,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '14' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_管道渣,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '15' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_孔眼不良,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '16' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_睹眼,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '17' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_眼歪,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '18' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_丢气孔,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '19' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_丢眼,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '23' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_水封不良,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '25' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_卡球,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '35' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_活糙,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '01' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_坯脏,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '02' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_棕眼,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '03' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂底,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '04' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂圈,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '05' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂鼻子,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '06' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂水道,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '07' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂管,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '08' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_沾接裂,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '09' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂眼,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '10' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_糙活,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '28' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_断浆迹,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '34' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '35' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_活糙,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '36' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_滚釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '37' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉薄,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '38' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉不匀,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '39' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '40' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '41' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉沾,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '42' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉绺,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '43' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_针孔,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '44' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_色脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '47' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_灌釉不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '48' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_擦脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '49' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_崩标,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '50' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_倒标,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '51' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_标污,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '52' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_错标,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '53' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_丢标,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '54' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_标错位,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '55' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_未灌釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '56' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_灌磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '20' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_坯磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '57' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_碱石,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '61' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_落脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '62' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装沾,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '63' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '64' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '65' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装走,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '66' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '67' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_缺釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '11' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_板折,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '69' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_水滴,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '70' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_窑脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '71' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_烧裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '43' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_针孔,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '73' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_风惊,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '74' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_烧生,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '75' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_串烟,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '76' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_烧坑,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '77' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_桔釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '78' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_过火,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '79' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_火燎,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '80' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_烧走,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '83' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_出窑缺陷_磕碰,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '84' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_出窑缺陷_划釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '86' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 原料缺陷_泥料缺陷_铜脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '87' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 原料缺陷_泥料缺陷_料脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '086' ) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 原料缺陷_釉料缺陷_铜脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '88' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 原料缺陷_釉料缺陷_铁脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '91' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_修补不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '92' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_漏修,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '93' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_漏检,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '083' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_磕碰,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '084' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_划釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '091' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧修补缺陷_修补不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '092' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧修补缺陷_漏修,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '093' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧修补缺陷_漏检,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '96' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧修补缺陷_白点,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '061' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_落脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '062' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装沾,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '063' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '064' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '065' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装走,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '066' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '067' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_缺釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '011' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_板折,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '069' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_水滴,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '070' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_窑脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '071' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_烧裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '43' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_针孔,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '073' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_风惊,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '074' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_烧生,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '075' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_串烟,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '076' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_烧坑,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '077' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_桔釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '078' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_过火,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '079' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_火燎,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '080' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_烧走,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '0083')  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_出窑缺陷_磕碰,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '0084')  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_出窑缺陷_划釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '98' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 研磨缺陷_研磨不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '100' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 其他_隧道窑其他试验不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '0100')  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 其他_梭式窑其他试验不良
 
-     FROM TP_PM_DEFECT df   
-  LEFT JOIN ( TMP_PM_PRODUCTIONDATA_CHECKDT ) pd ON   (df.productiondataid  = pd.productiondataid or df.productiondataid  = pd.fproductiondataid)
 
-  LEFT JOIN TP_MST_GOODS good on good.GOODSID=PD.GOODSID
 
-  LEFT JOIN TP_MST_GOODSTYPE gtp ON good.GOODSTYPEID=gtp.GOODSTYPEID
 
-  LEFT JOIN TP_MST_DEFECT MDF ON DF.DEFECTID = MDF.DEFECTID 
-  INNER JOIN tp_pm_productiondata pds ON pds.barcode = pd.barcode  AND pds.valueflag = 1
 
-     WHERE df.VALUEFLAG=1  
- AND DF.PROCEDUREID NOT IN " + notInproc;
 
-  sqlStr += @"    GROUP BY
 
-  Grouping sets ( ( good.GOODSCODE, good.GOODSNAME,gtp.GOODSTYPENAME ), ( gtp.GOODSTYPENAME) , ( gtp.GOODSTYPENAME) ,(SUBSTR(gtp.GOODSTYPECODE, 0, 6)),()    ) 
-  ),
 
-  检验数 AS (    SELECT GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX),
 
-       CASE WHEN  GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX) =5   THEN '小计'
 
-      WHEN  GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX) =6   THEN '合计'
 
-      WHEN  GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX) =7   THEN '总计'
 
- ELSE to_char(GOODSCODE) END AS GOODSCODE,
 
-      CASE WHEN GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX)=6 AND GOODSTYPECODESIX='001001' THEN '大件' 
-   WHEN GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX)=6 AND GOODSTYPECODESIX='001002' THEN '小件'
 
-   ELSE TO_CHAR(GOODSTYPENAME )END GOODSTYPENAME,GOODSNAME,
 
-      SUM(检验量)检验量,SUM(合格量) 合格量,SUM(残品) 残品,
 
-     SUM(检验量*LUSTERWAREWEIGHT) 出窑重量,
 
-     SUM(合格量*LUSTERWAREWEIGHT) 合格品重量,
 
-     SUM(残品*LUSTERWAREWEIGHT) 残品重量
 
-      FROM(
 
-      SELECT distinct
 
-       pd.GOODSCODE,
 
-       SUBSTR(pd.GOODSTYPECODE, 0, 6) GOODSTYPECODESIX,
 
-       pd.GOODSNAME,
 
-       PD.GOODSTYPENAME,
 
-       COUNT(   pd.BARCODE ) AS 检验量,
 
-       COUNT(  CASE WHEN PD.GOODSLEVELTYPEID IN ( 4, 5 ) THEN BARCODE ELSE null END ) AS 合格量,
 
-       COUNT(  CASE WHEN PD.GOODSLEVELTYPEID  NOT IN ( 4, 5 ) THEN BARCODE ELSE null  END ) 残品,
 
-       LUSTERWAREWEIGHT
 
-       FROM (SELECT barcode
 
-      ,goodscode
 
-      ,goodsleveltypeid
 
-      ,goodsname
 
-      ,groutinguserid
 
-      ,groutingusercode
 
-      ,goodstypename
 
-      ,goodstypecode
 
-      ,lusterwareweight
 
-      ,createtime 
-  FROM (SELECT DISTINCT pd.barcode
 
-,good.goodscode
 
-,good.goodsname
 
-,pd.groutinguserid
 
-,pd.groutingusercode
 
-,gtp.goodstypecode
 
-,nvl(pd61.goodsleveltypeid, pd.goodsleveltypeid) goodsleveltypeid
 
-,pd.createtime
 
-,gtp.goodstypename
 
-,good.lusterwareweight
 
-   FROM (SELECT *
 
-       FROM (SELECT pd28.goodsname
 
-       ,pd28.groutingdailydetailid
 
-       ,pd28.goodsid
 
-       ,pd28.goodscode
 
-       ,pd28.goodsleveltypeid
 
-       ,pd28.groutinguserid
 
-       ,pd28.groutingusercode
 
-       ,pd28.createtime
 
-       ,pd24.procedureid
 
-       ,pd28.kilncarbatchno
 
-       ,pd28.barcode
 
-       ,pd28.productiondataid
 
-       ,row_number() over(PARTITION BY pd28.productiondataid ORDER BY pd24.productiondataid DESC) AS rownums
 
-   FROM tp_pm_productiondata pd28  
-  INNER JOIN tp_pm_productiondata pd24  
-     ON pd24.groutingdailydetailid = pd28.groutingdailydetailid
 
-  WHERE pd28.procedureid = 28
 
-    AND pd28.valueflag = 1
 
-    AND pd24.valueflag = 1
 
-    AND pd24.procedureid IN (24, 42)   
-    AND pd28.checktime >= @DATEBEGIN@
 
-    AND pd28.checktime <=   @DATEEND@ 
-    AND (@USERCODE@ is null or @USERCODE@ = '' or instr( pd28.GROUTINGUSERCODE,@USERCODE@) > 0 )   
-    AND pd24.productiondataid < pd28.productiondataid) t
 
-      WHERE rownums = 1
 
- AND t.procedureid = 24) pd
 
-   LEFT JOIN tp_pm_productiondata pd61 
- ON pd61.procedureid = 61 AND pd61.valueflag = 1
 
- AND pd61.groutingdailydetailid = pd.groutingdailydetailid
 
-    AND pd61.kilncarbatchno = pd.kilncarbatchno
 
-    AND pd61.productiondataid > pd.productiondataid 
-    AND NOT EXISTS
 
-(SELECT 1 FROM tp_pm_productiondata pd28c  
- WHERE pd28c.procedureid = 28
 
- AND pd28c.valueflag = 1
 
- AND pd28c.groutingdailydetailid = pd.groutingdailydetailid
 
- AND pd28c.kilncarbatchno = pd.kilncarbatchno
 
- AND pd28c.productiondataid > pd.productiondataid
 
- AND pd28c.productiondataid < pd61.productiondataid)  
-   LEFT JOIN tp_mst_goods good
 
- ON good.goodsid = pd.goodsid
 
-   LEFT JOIN tp_mst_goodstype gtp
 
- ON gtp.goodstypeid = good.goodstypeid   
- )) pd GROUP BY pd.GOODSCODE,SUBSTR(pd.GOODSTYPECODE, 0, 6),pd.GOODSNAME,PD.GOODSTYPENAME,LUSTERWAREWEIGHT )
 
-  GROUP BY Grouping sets((GOODSCODE,GOODSNAME,GOODSTYPENAME,GOODSTYPECODESIX),(GOODSTYPENAME),(GOODSTYPECODESIX),())),
 
-   产品 AS (
 
-   SELECT TO_CHAR(GOODSCODE) AS GOODSCODE,GOODSNAME,GOODSSPECIFICATION,gtp.GOODSTYPENAME 
-    ,TP_MST_GOODS.LUSTERWAREWEIGHT
 
-   FROM TP_MST_GOODS
 
-   LEFT JOIN TP_MST_GOODSTYPE gtp ON TP_MST_GOODS.GOODSTYPEID=gtp.GOODSTYPEID
 
-    WHERE TP_MST_GOODS.VALUEFLAG=1
 
-   UNION ALL
 
-   SELECT '总计' AS GOODSCODE,null,NULL ,NULL,null  FROM dual),
 
-打磨擦洗出窑数 AS ( SELECT  COUNT(DISTINCT CASE WHEN pds.PROCEDUREID IN (4,36,53) THEN PD.productiondataid ELSE NULL END ) 打磨,
 
-   COUNT(DISTINCT CASE WHEN pds.PROCEDUREID IN (5,36,52) THEN PD.productiondataid ELSE NULL END ) 擦洗,
 
-   COUNT(DISTINCT CASE WHEN pds.PROCEDUREID = @kilproc@ THEN PD.productiondataid ELSE NULL END ) 质量登记
 
-     FROM  ( SELECT * FROM (SELECT pd28.goodsname
 
-       ,pd28.groutingdailydetailid
 
-       ,pd28.goodsid
 
-       ,pd28.goodscode
 
-       ,pd28.goodsleveltypeid
 
-       ,pd28.groutinguserid
 
-       ,pd28.groutingusercode
 
-       ,pd28.createtime
 
-       ,pd24.procedureid
 
-       ,pd28.kilncarbatchno
 
-       ,pd28.barcode
 
-       ,pd28.productiondataid
 
-       ,row_number() over(PARTITION BY pd28.productiondataid ORDER BY pd24.productiondataid DESC) AS rownums
 
-   FROM tp_pm_productiondata pd28 
-  INNER JOIN tp_pm_productiondata pd24  
-     ON pd24.groutingdailydetailid = pd28.groutingdailydetailid
 
-  WHERE pd28.procedureid = 28
 
-    AND pd28.valueflag = 1
 
-    AND pd24.valueflag = 1
 
-    AND pd24.procedureid IN (24, 42)   
-    AND pd28.checktime >= @DATEBEGIN@
 
-    AND pd28.checktime <=   @DATEEND@ 
-    AND (@USERCODE@ is null or @USERCODE@ = '' or instr( pd28.GROUTINGUSERCODE,@USERCODE@) > 0 ) 
-    AND pd24.productiondataid < pd28.productiondataid) t
 
-     WHERE rownums = 1 AND t.procedureid = 24 ) pd 
-    INNER JOIN TP_PM_PRODUCTIONDATA pds ON pds.BARCODE=PD.BARCODE  AND pds.valueflag = 1   )
 
-     SELECT * FROM (
 
-  SELECT
 
-  to_CHAR(检验数.GOODSCODE) AS  产品编码,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.GOODSNAME) ELSE NULL END 产品名称,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(产品.GOODSSPECIFICATION) ELSE NULL END 产品规格,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.GOODSTYPENAME) ELSE NULL END 产品类别,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(产品.LUSTERWAREWEIGHT) ELSE NULL END 单重,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.检验量) ELSE NULL END 检验量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.出窑重量) ELSE NULL END 出窑重量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.合格量) ELSE NULL END 合格量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.合格品重量) ELSE NULL END 合格品重量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.残品) ELSE NULL END 残品,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.残品重量) ELSE NULL END 残品重量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN DECODE( NVL( 检验数.合格量, 0 ), 0, '0%', TO_CHAR( ( NVL( 检验数.合格量, 0 ) / DECODE( NVL( 检验数.检验量, 1 ), 0, 1, NVL( 检验数.检验量, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) ELSE NULL END AS 合格率,
 
-  to_char(nvl(s.成型半检缺陷_坯脏,0)) AS 成型半检缺陷__坯脏,
 
-  to_char(nvl(s.成型半检缺陷_棕眼,0)) AS 成型半检缺陷__棕眼,
 
-  to_char(nvl(s.成型半检缺陷_裂底,0)) AS 成型半检缺陷__裂底,
 
-  to_char(nvl(s.成型半检缺陷_裂圈,0)) AS 成型半检缺陷__裂圈,
 
-  to_char(nvl(s.成型半检缺陷_裂鼻子,0)) AS 成型半检缺陷__裂鼻子,
 
-  to_char(nvl(s.成型半检缺陷_裂水道,0)) AS 成型半检缺陷__裂水道,
 
-  to_char(nvl(s.成型半检缺陷_裂管,0)) AS 成型半检缺陷__裂管,
 
-  to_char(nvl(s.成型半检缺陷_沾接裂,0)) AS 成型半检缺陷__沾接裂,
 
-  to_char(nvl(s.成型半检缺陷_裂眼,0)) AS 成型半检缺陷__裂眼,
 
-  to_char(nvl(s.成型半检缺陷_糙活,0)) AS 成型半检缺陷__糙活,
 
-  to_char(nvl(s.成型半检缺陷_变形,0)) AS 成型半检缺陷__变形,
 
-  to_char(nvl(s.成型半检缺陷_渣,0)) AS 成型半检缺陷__渣,
 
-  to_char(nvl(s.成型半检缺陷_管道渣,0)) AS 成型半检缺陷__管道渣,
 
-  to_char(nvl(s.成型半检缺陷_孔眼不良,0)) AS 成型半检缺陷__孔眼不良,
 
-  to_char(nvl(s.成型半检缺陷_堵眼,0)) AS 成型半检缺陷__堵眼,
 
-  to_char(nvl(s.成型半检缺陷_眼歪,0)) AS 成型半检缺陷__眼歪,
 
-  to_char(nvl(s.成型半检缺陷_丢气孔,0)) AS 成型半检缺陷__丢气孔,
 
-  to_char(nvl(s.成型半检缺陷_丢眼,0)) AS 成型半检缺陷__丢眼,
 
-  to_char(nvl(s.成型半检缺陷_漏气,0)) AS 成型半检缺陷__漏气,
 
-  to_char(nvl(s.成型半检缺陷_空泡,0)) AS 成型半检缺陷__空泡,
 
-  to_char(nvl(s.成型半检缺陷_水封不良,0)) AS 成型半检缺陷__水封不良,
 
-  to_char(nvl(s.成型半检缺陷_漏水,0)) AS 成型半检缺陷__漏水,
 
-  to_char(nvl(s.成型半检缺陷_卡球,0)) AS 成型半检缺陷__卡球,
 
-  to_char(nvl(s.成型半检缺陷_冲刷不好,0)) AS 成型半检缺陷__冲刷不好,
 
-  to_char(nvl(s.成型半检缺陷_泥埂,0)) AS 成型半检缺陷__泥埂,
 
-  to_char(nvl(s.成型半检缺陷_断浆迹,0)) AS 成型半检缺陷__断浆迹,
 
-  to_char(nvl(s.成型半检缺陷_模迹,0)) AS 成型半检缺陷__模迹,
 
-  to_char(nvl(s.成型半检缺陷_重皮,0)) AS 成型半检缺陷__重皮,
 
-  to_char(nvl(s.成型半检缺陷_气泡,0)) AS 成型半检缺陷__气泡,
 
-  to_char(nvl(s.成型半检缺陷_眼扁,0)) AS 成型半检缺陷__眼扁,
 
-  to_char(nvl(s.成型半检缺陷_水绺,0)) AS 成型半检缺陷__水绺,
 
-  to_char(nvl(s.成型半检缺陷_裂,0)) AS 成型半检缺陷__裂,
 
-  to_char(nvl(s.成型半检缺陷_活糙 ,0)) AS 成型半检缺陷__活糙,
 
-  to_char(nvl(s.成型半检缺陷_贴码不良,0)) AS 成型半检缺陷__贴码不良,
 
-  to_char(nvl(s.成型半检缺陷_干补不良,0)) AS 成型半检缺陷__干补不良,
 
-  to_char(nvl(s.成型半检缺陷_内漏不合格,0)) AS 成型半检缺陷__内漏不合格,
 
-  to_char(nvl(s.成型半检缺陷_外漏不合格,0)) AS 成型半检缺陷__外漏不合格,
 
-  to_char(nvl(s.成型半检缺陷_试水不合格,0)) AS 成型半检缺陷__试水不合格,
 
-  to_char(nvl(s.成型半检缺陷_梭式窑其他蹦脏,0)) AS 成型半检缺陷__梭式窑蹦脏,
 
-  nvl(f.成型半检缺陷__缺陷汇总,0) AS 成型半检缺陷__缺陷汇总,
 
-  DECODE( NVL( f.成型半检缺陷__缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.成型半检缺陷__缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 成型半检缺陷__缺陷率,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_糙活,0)) AS 精修缺陷_打磨缺陷_糙活,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_变形,0)) AS 精修缺陷_打磨缺陷_变形,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_渣,0)) AS 精修缺陷_打磨缺陷_渣,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_管道渣,0)) AS 精修缺陷_打磨缺陷_管道渣,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_孔眼不良,0)) AS 精修缺陷_打磨缺陷_孔眼不良,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_睹眼,0)) AS 精修缺陷_打磨缺陷_睹眼,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_眼歪,0)) AS 精修缺陷_打磨缺陷_眼歪,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_丢气孔,0)) AS 精修缺陷_打磨缺陷_丢气孔,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_丢眼,0)) AS 精修缺陷_打磨缺陷_丢眼,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_水封不良,0)) AS 精修缺陷_打磨缺陷_水封不良,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_卡球,0)) AS 精修缺陷_打磨缺陷_卡球,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_活糙,0)) AS 精修缺陷_打磨缺陷_活糙,
 
-  nvl(f.精修缺陷_打磨缺陷_缺陷汇总,0) AS 精修缺陷_打磨缺陷_缺陷汇总,
 
-  DECODE( NVL( f.精修缺陷_打磨缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.精修缺陷_打磨缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 精修缺陷_打磨缺陷_缺陷率,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_坯脏,0)) AS 精修缺陷_刷洗缺陷_坯脏,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_棕眼,0)) AS 精修缺陷_刷洗缺陷_棕眼,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂底,0)) AS 精修缺陷_刷洗缺陷_裂底,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂圈,0)) AS 精修缺陷_刷洗缺陷_裂圈,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂鼻子,0)) AS 精修缺陷_刷洗缺陷_裂鼻子,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂水道,0)) AS 精修缺陷_刷洗缺陷_裂水道,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂管,0)) AS 精修缺陷_刷洗缺陷_裂管,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_沾接裂,0)) AS 精修缺陷_刷洗缺陷_沾接裂,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂眼,0)) AS 精修缺陷_刷洗缺陷_裂眼,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_糙活,0)) AS 精修缺陷_刷洗缺陷_糙活,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_断浆迹,0)) AS 精修缺陷_刷洗缺陷_断浆迹,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂,0)) AS 精修缺陷_刷洗缺陷_裂,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_活糙,0)) AS 精修缺陷_刷洗缺陷_活糙, 
-  nvl(f.精修缺陷_刷洗缺陷_缺陷汇总,0) AS 精修缺陷_刷洗缺陷_缺陷汇总,
 
-  DECODE( NVL( f.精修缺陷_刷洗缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.精修缺陷_刷洗缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL(打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 精修缺陷_刷洗缺陷_缺陷率,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_滚釉,0)) AS 施釉擦坯缺陷_施釉缺陷_滚釉,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉薄,0)) AS 施釉擦坯缺陷_施釉缺陷_釉薄,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉不匀,0)) AS 施釉擦坯缺陷_施釉缺陷_釉不匀,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉磕,0)) AS 施釉擦坯缺陷_施釉缺陷_釉磕,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉脏,0)) AS 施釉擦坯缺陷_施釉缺陷_釉脏,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉沾,0)) AS 施釉擦坯缺陷_施釉缺陷_釉沾,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉绺,0)) AS 施釉擦坯缺陷_施釉缺陷_釉绺,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_针孔,0)) AS 施釉擦坯缺陷_施釉缺陷_针孔,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_色脏,0)) AS 施釉擦坯缺陷_施釉缺陷_色脏,
 
-  nvl(f.施釉擦坯缺陷_施釉缺陷_缺陷汇总,0) AS 施釉擦坯缺陷_施釉缺陷_缺陷汇总,
 
-  DECODE( NVL( f.施釉擦坯缺陷_施釉缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.施釉擦坯缺陷_施釉缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 施釉擦坯缺陷_施釉缺陷_缺陷率,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_灌釉不良,0)) AS 施釉擦坯缺陷_擦坯缺陷_灌釉不良,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_擦脏,0)) AS 施釉擦坯缺陷_擦坯缺陷_擦脏,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_崩标,0)) AS 施釉擦坯缺陷_擦坯缺陷_崩标,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_倒标,0)) AS 施釉擦坯缺陷_擦坯缺陷_倒标,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_标污,0)) AS 施釉擦坯缺陷_擦坯缺陷_标污,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_错标,0)) AS 施釉擦坯缺陷_擦坯缺陷_错标,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_丢标,0)) AS 施釉擦坯缺陷_擦坯缺陷_丢标,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_标错位,0)) AS 施釉擦坯缺陷_擦坯缺陷_标错位,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_未灌釉,0)) AS 施釉擦坯缺陷_擦坯缺陷_未灌釉,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_灌磕,0)) AS 施釉擦坯缺陷_擦坯缺陷_灌磕,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_坯磕,0)) AS 施釉擦坯缺陷_擦坯缺陷_坯磕,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_碱石,0)) AS 施釉擦坯缺陷_擦坯缺陷_碱石,
 
-  nvl(f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总,0) AS 施釉擦坯缺陷_擦坯缺陷_缺陷汇总,
 
-  DECODE( NVL( f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 施釉擦坯缺陷_擦坯缺陷_缺陷率,
 
-  to_char(nvl(s.回烧缺陷_装窑缺陷_落脏,0)) AS 回烧缺陷_装窑缺陷_落脏,
 
-  to_char(nvl(s.回烧缺陷_装窑缺陷_装沾,0)) AS 回烧缺陷_装窑缺陷_装沾,
 
-  to_char(nvl(s.回烧缺陷_装窑缺陷_装磕,0)) AS 回烧缺陷_装窑缺陷_装磕,
 
-  to_char(nvl(s.回烧缺陷_装窑缺陷_装裂,0)) AS 回烧缺陷_装窑缺陷_装裂,
 
-  to_char(nvl(s.回烧缺陷_装窑缺陷_装走,0)) AS 回烧缺陷_装窑缺陷_装走,
 
-  to_char(nvl(s.回烧缺陷_装窑缺陷_装脏,0)) AS 回烧缺陷_装窑缺陷_装脏,
 
-  to_char(nvl(s.回烧缺陷_装窑缺陷_缺釉,0)) AS 回烧缺陷_装窑缺陷_缺釉,
 
-  to_char(nvl(s.回烧缺陷_装窑缺陷_板折,0)) AS 回烧缺陷_装窑缺陷_板折,
 
-  nvl(f.回烧缺陷_装窑缺陷_缺陷汇总,0) AS 回烧缺陷_装窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.回烧缺陷_装窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.回烧缺陷_装窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 回烧缺陷_装窑缺陷_缺陷率,
 
-  to_char(nvl(s.回烧缺陷_烧窑缺陷_水滴,0)) AS 回烧缺陷_烧窑缺陷_水滴,
 
-  to_char(nvl(s.回烧缺陷_烧窑缺陷_窑脏,0)) AS 回烧缺陷_烧窑缺陷_窑脏,
 
-  to_char(nvl(s.回烧缺陷_烧窑缺陷_烧裂,0)) AS 回烧缺陷_烧窑缺陷_烧裂,
 
-  to_char(nvl(s.回烧缺陷_烧窑缺陷_针孔,0)) AS 回烧缺陷_烧窑缺陷_针孔,
 
-  to_char(nvl(s.回烧缺陷_烧窑缺陷_风惊,0)) AS 回烧缺陷_烧窑缺陷_风惊,
 
-  to_char(nvl(s.回烧缺陷_烧窑缺陷_烧生,0)) AS 回烧缺陷_烧窑缺陷_烧生,
 
-  to_char(nvl(s.回烧缺陷_烧窑缺陷_串烟,0)) AS 回烧缺陷_烧窑缺陷_串烟,
 
-  to_char(nvl(s.回烧缺陷_烧窑缺陷_烧坑,0)) AS 回烧缺陷_烧窑缺陷_烧坑,
 
-  to_char(nvl(s.回烧缺陷_烧窑缺陷_桔釉,0)) AS 回烧缺陷_烧窑缺陷_桔釉,
 
-  to_char(nvl(s.回烧缺陷_烧窑缺陷_过火,0)) AS 回烧缺陷_烧窑缺陷_过火,
 
-  to_char(nvl(s.回烧缺陷_烧窑缺陷_火燎,0)) AS 回烧缺陷_烧窑缺陷_火燎,
 
-  to_char(nvl(s.回烧缺陷_烧窑缺陷_烧走,0)) AS 回烧缺陷_烧窑缺陷_烧走,
 
-  nvl(f.回烧缺陷_烧窑缺陷_缺陷汇总,0)AS 回烧缺陷_烧窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.回烧缺陷_烧窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.回烧缺陷_烧窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 回烧缺陷_烧窑缺陷_缺陷率,
 
-  TO_CHAR(nvl(s.回烧缺陷_出窑缺陷_磕碰,0))AS 回烧缺陷_出窑缺陷_磕碰,
 
-  TO_CHAR(nvl(s.回烧缺陷_出窑缺陷_划釉,0))AS 回烧缺陷_出窑缺陷_划釉,
 
-  nvl(f.回烧缺陷_出窑缺陷_缺陷汇总,0) AS 回烧缺陷_出窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.回烧缺陷_出窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.回烧缺陷_出窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 回烧缺陷_出窑缺陷_缺陷率,
 
-  TO_CHAR(nvl(s.回烧修补缺陷_修补不良,0)) AS  回烧缺陷_回烧修补缺陷_修补不良,
 
-  TO_CHAR(nvl(s.回烧修补缺陷_漏修,0)) AS 回烧缺陷_回烧修补缺陷_漏修,
 
-  TO_CHAR(nvl(s.回烧修补缺陷_漏检,0)) AS  回烧缺陷_回烧修补缺陷_漏检,
 
-  TO_CHAR(nvl(s.回烧修补缺陷_白点,0)) AS 回烧缺陷_回烧修补缺陷_白点,
 
-  nvl(f.回烧修补_缺陷汇总,0) AS 回烧缺陷_回烧修补缺陷_缺陷汇总,
 
-  DECODE( NVL( f.回烧修补_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.回烧修补_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 回烧缺陷_回烧修补缺陷_缺陷率,
 
-  TO_CHAR(nvl(s.原料缺陷_泥料缺陷_铜脏,0)) AS 原料缺陷_泥料缺陷_铜脏,
 
-  TO_CHAR(nvl(s.原料缺陷_泥料缺陷_料脏,0)) AS 原料缺陷_泥料缺陷_料脏,
 
-  TO_CHAR(nvl(s.原料缺陷_釉料缺陷_铜脏,0)) AS 原料缺陷_釉料缺陷_铜脏, 
-  TO_CHAR(nvl(s.原料缺陷_釉料缺陷_铁脏,0)) AS 原料缺陷_釉料缺陷_铁脏,
 
-  nvl(f.原料缺陷_缺陷汇总,0) AS 原料缺陷__缺陷汇总,
 
-  DECODE( NVL( f.原料缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.原料缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 原料缺陷__缺陷率,
 
-  to_char(nvl(s.其他_隧道窑其他试验不良,0)) AS 其他_隧道窑其他_试验不良,
 
-  nvl(f.其他_缺陷汇总,0) AS 其他_隧道窑其他_缺陷汇总,
 
-  DECODE( NVL( f.其他_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.其他_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 其他_隧道窑其他_缺陷率
 
-  FROM 检验数
 
-  LEFT JOIN 产品 ON 检验数.GOODSCODE=产品.GOODSCODE
 
-  LEFT JOIN  产品明细缺陷  s ON 产品.GOODSCODE=s.GOODSCODE
 
-  LEFT JOIN 产品汇总缺陷 f ON f.GOODSCODE=产品.GOODSCODE 
-  LEFT JOIN  打磨擦洗出窑数  ON 1=1
 
-   UNION ALL
 
-  SELECT
 
-  to_Char(检验数.GOODSCODE),
 
-  to_Char(检验数.GOODSNAME),
 
-  to_Char(产品.GOODSSPECIFICATION),
 
-  to_Char(产品.GOODSTYPENAME),
 
-  to_Char(产品.LUSTERWAREWEIGHT),
 
-  to_Char(检验数.检验量),to_Char(检验数.出窑重量),
 
-  to_Char(检验数.合格量),
 
-  to_Char(检验数.合格品重量),
 
-  to_Char(检验数.残品),
 
-  to_Char(检验数.残品重量),
 
-  DECODE( NVL( 检验数.合格量, 0 ), 0, '0%', TO_CHAR( ( NVL( 检验数.合格量, 0 ) / DECODE( NVL(检验数.检验量, 1 ), 0, 1, NVL(检验数.检验量, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 合格率,
 
-  DECODE( NVL( s.成型半检缺陷_坯脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_坯脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_棕眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_棕眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂底, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂底, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂圈, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂圈, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂鼻子, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂鼻子, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂水道, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂水道, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂管, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂管, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_沾接裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_沾接裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_糙活, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_糙活, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_变形, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_变形, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_渣, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_渣, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_管道渣, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_管道渣, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_孔眼不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_孔眼不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_堵眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_堵眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_眼歪, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_眼歪, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_丢气孔, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_丢气孔, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_丢眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_丢眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_漏气, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_漏气, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_空泡, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_空泡, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_水封不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_水封不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_漏水, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_漏水, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_卡球, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_卡球, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_冲刷不好, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_冲刷不好, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_泥埂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_泥埂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_断浆迹, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_断浆迹, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_模迹, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_模迹, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_重皮, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_重皮, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_气泡, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_气泡, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_眼扁, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_眼扁, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_水绺, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_水绺, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_活糙, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_活糙, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_贴码不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_贴码不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_干补不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_干补不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_内漏不合格, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_内漏不合格, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_外漏不合格, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_外漏不合格, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_试水不合格, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_试水不合格, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_梭式窑其他蹦脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_梭式窑其他蹦脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.成型半检缺陷__缺陷汇总,
 
-  DECODE( NVL( f.成型半检缺陷__缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.成型半检缺陷__缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 成型半检缺陷__缺陷率,
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_糙活, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_糙活, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_变形, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_变形, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_渣, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_渣, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_管道渣, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_管道渣, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_孔眼不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_孔眼不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_睹眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_睹眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_眼歪, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_眼歪, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_丢气孔, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_丢气孔, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_丢眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_丢眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_水封不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_水封不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_卡球, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_卡球, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_活糙, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_活糙, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.精修缺陷_打磨缺陷_缺陷汇总,
 
-  DECODE( NVL( f.精修缺陷_打磨缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.精修缺陷_打磨缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 精修缺陷_打磨缺陷_缺陷率,
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_坯脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_坯脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_棕眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_棕眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂底, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂底, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂圈, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂圈, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂鼻子, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂鼻子, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂水道, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂水道, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂管, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂管, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_沾接裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_沾接裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_糙活, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_糙活, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_断浆迹, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_断浆迹, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_活糙, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_活糙, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.精修缺陷_刷洗缺陷_缺陷汇总,
 
-  DECODE( NVL( f.精修缺陷_刷洗缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.精修缺陷_刷洗缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 精修缺陷_刷洗缺陷_缺陷率,
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_滚釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_滚釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉薄, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉薄, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉不匀, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉不匀, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉磕, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉磕, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉沾, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉沾, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉绺, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉绺, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_针孔, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_针孔, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_色脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_色脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-    f.施釉擦坯缺陷_施釉缺陷_缺陷汇总,
 
-  DECODE( NVL( f.施釉擦坯缺陷_施釉缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.施釉擦坯缺陷_施釉缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 施釉擦坯缺陷_施釉缺陷_缺陷率,
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_灌釉不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_灌釉不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_擦脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_擦脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_崩标, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_崩标, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_倒标, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_倒标, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_标污, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_标污, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_错标, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_错标, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_丢标, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_丢标, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_标错位, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_标错位, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_未灌釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_未灌釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_灌磕, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_灌磕, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_坯磕, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_坯磕, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_碱石, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_碱石, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-    f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总,
 
-  DECODE( NVL( f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 施釉擦坯缺陷_擦坯缺陷_缺陷率,
 
-DECODE( NVL( s.回烧缺陷_装窑缺陷_落脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_装窑缺陷_落脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_装窑缺陷_装沾, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_装窑缺陷_装沾, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_装窑缺陷_装磕, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_装窑缺陷_装磕, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_装窑缺陷_装裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_装窑缺陷_装裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_装窑缺陷_装走, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_装窑缺陷_装走, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_装窑缺陷_装脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_装窑缺陷_装脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_装窑缺陷_缺釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_装窑缺陷_缺釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_装窑缺陷_板折, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_装窑缺陷_板折, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.回烧缺陷_装窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.回烧缺陷_装窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.回烧缺陷_装窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 回烧缺陷_装窑缺陷_缺陷率,
 
-DECODE( NVL( s.回烧缺陷_烧窑缺陷_水滴, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_烧窑缺陷_水滴, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_烧窑缺陷_窑脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_烧窑缺陷_窑脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_烧窑缺陷_烧裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_烧窑缺陷_烧裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_烧窑缺陷_针孔, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_烧窑缺陷_针孔, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_烧窑缺陷_风惊, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_烧窑缺陷_风惊, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_烧窑缺陷_烧生, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_烧窑缺陷_烧生, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_烧窑缺陷_串烟, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_烧窑缺陷_串烟, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_烧窑缺陷_烧坑, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_烧窑缺陷_烧坑, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_烧窑缺陷_桔釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_烧窑缺陷_桔釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_烧窑缺陷_过火, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_烧窑缺陷_过火, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_烧窑缺陷_火燎, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_烧窑缺陷_火燎, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_烧窑缺陷_烧走, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_烧窑缺陷_烧走, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.回烧缺陷_烧窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.回烧缺陷_烧窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.回烧缺陷_烧窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 回烧缺陷_烧窑缺陷_缺陷率,
 
-DECODE( NVL( s.回烧缺陷_出窑缺陷_磕碰, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_出窑缺陷_磕碰, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧缺陷_出窑缺陷_划釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧缺陷_出窑缺陷_划釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.回烧缺陷_出窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.回烧缺陷_出窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.回烧缺陷_出窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 回烧缺陷_出窑缺陷_缺陷率,
 
+            //主表
 
+            //string sqlStr = "";
 
+            if (context.Request["m"].ToString() == "master")
 
+            {
 
+                //读取报表数据  回烧
 
+                if (context.Request["procedureMaster"] == "2")
 
+                {
 
+                    kilproc = 28;//出窑工序 
+                    notInproc = "16,60";//排除工序 
+                }
 
+                // 本烧
 
+                else if (context.Request["procedureMaster"] == "3")
 
+                {
 
+                }
 
+                // 冷修
 
+                else if (context.Request["procedureMaster"] == "1")
 
+                {
 
+                    kilproc = 28;//出窑工序 
+                    notInproc = "16,60";//排除工序 
+                }
 
+            }
 
+            //获取查询条件
 
+            List<CDAParameter> sqlPara = new List<CDAParameter>();
 
+            //sqlPara.Add(new CDAParameter("DATEBEGIN", dateBegin, DataType.DateTime));
 
+            //sqlPara.Add(new CDAParameter("DATEEND", dateEnd, DataType.DateTime));
 
+            //sqlPara.Add(new CDAParameter("kilproc", Convert.ToInt32(kilproc), DataType.Int32));
 
+            //sqlPara.Add(new CDAParameter("notInproc", notInproc, DataType.Char));
 
+            //sqlPara.Add(new CDAParameter("FunctionalTesting", Convert.ToInt32(FunctionalTesting), DataType.Int32));
 
+            //sqlPara.Add(new CDAParameter("USERCODE", userCode)); 
+            ////获取分页参数
 
+            //int page = HttpContext.Current.Request["page"] is object ? Convert.ToInt32(HttpContext.Current.Request["page"]) : 1;
 
+            //int rows = HttpContext.Current.Request["rows"] is int ? Convert.ToInt32(HttpContext.Current.Request["rows"]) : 10000;
 
+            //string sort = HttpContext.Current.Request["sort"] is object ? HttpContext.Current.Request["sort"] : "m.REPORTCODE";
 
+            //string order = HttpContext.Current.Request["order"] is object ? HttpContext.Current.Request["order"] : "";
 
+            // sqlStr = sqlStr.Replace("\t", " ");
 
+            //获取分页数据    
+            int total = 0;
 
+            //  DataTable dt = conn.SelectPages(page, rows, out total, sqlStr, sqlPara.ToArray());
 
+            sqlPara.Add(new CDAParameter("in_proceduremaster", context.Request["procedureMaster"] + "",DataType.NVarChar));
 
+            sqlPara.Add(new CDAParameter("in_kilproc",kilproc ,DataType.Int32));
 
+            sqlPara.Add(new CDAParameter("in_notinproc", notInproc,DataType.NVarChar));            
+            sqlPara.Add(new CDAParameter("in_stardate",Convert.ToDateTime( dateBegin.ToString("yyyy-MM-dd HH:mm:ss")), DataType.DateTime));
 
+            sqlPara.Add(new CDAParameter("in_enddate", Convert.ToDateTime( dateEnd.ToString("yyyy-MM-dd HH:mm:ss")), DataType.DateTime));
 
+            sqlPara.Add(new CDAParameter("in_usercode", userCode,DataType.NVarChar));
 
+            sqlPara.Add(new CDAParameter("out_result", DataType.Cursor, ParameterDirection.Output));
 
+            DataTable dt = conn.ExecuteSPDatatable("pro_pm_owinglist", sqlPara.ToArray());
 
+            string jsonStr = new JsonResult(dt) { total = total }.ToJson();
 
+            conn.Commit();
 
 
-DECODE( NVL( s.回烧修补缺陷_修补不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧修补缺陷_修补不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧修补缺陷_漏修, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧修补缺陷_漏修, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧修补缺陷_漏检, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧修补缺陷_漏检, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.回烧修补缺陷_白点, 0 ), 0, '0%', TO_CHAR( ( NVL( s.回烧修补缺陷_白点, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.回烧修补_缺陷汇总,
 
-  DECODE( NVL( f.回烧修补_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.回烧修补_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 回烧修补缺陷__缺陷率,
 
-DECODE( NVL( s.原料缺陷_泥料缺陷_铜脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.原料缺陷_泥料缺陷_铜脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.原料缺陷_泥料缺陷_料脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.原料缺陷_泥料缺陷_料脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.原料缺陷_釉料缺陷_铜脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.原料缺陷_釉料缺陷_铜脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.原料缺陷_釉料缺陷_铁脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.原料缺陷_釉料缺陷_铁脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.原料缺陷_缺陷汇总 AS 原料缺陷__缺陷汇总,
 
-  DECODE( NVL( f.原料缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.原料缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 原料缺陷__缺陷率,
 
-DECODE( NVL( s.其他_隧道窑其他试验不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.其他_隧道窑其他试验不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-    f.其他_缺陷汇总 AS 其他_缺陷汇总,
 
-  DECODE( NVL( f.其他_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.其他_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 其他_缺陷率
 
-     FROM 检验数
 
-  LEFT JOIN 产品 ON 检验数.GOODSCODE=产品.GOODSCODE
 
-  LEFT JOIN  产品明细缺陷  s ON 产品.GOODSCODE=s.GOODSCODE
 
-  LEFT JOIN 产品汇总缺陷 f ON f.GOODSCODE=产品.GOODSCODE 
-  LEFT JOIN  打磨擦洗出窑数  ON 1=1
 
-  WHERE 检验数.GOODSCODE='总计'
 
- UNION ALL    SELECT
 
-  '工序出窑量' AS  产品编码,
 
-  '' 产品名称,
 
-  '' 产品规格,
 
-  ''产品类别,
 
-  '' 重量,
 
-  '' 检验量,'',
 
-  '' 合格量,'',
 
-  '' 残品,'',
 
-  '' 合格率,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__坯脏,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__棕眼,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂底,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂圈,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂鼻子,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂水道,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂管,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__沾接裂,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂眼,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__糙活,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__变形,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__渣,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__管道渣,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__孔眼不良,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__堵眼,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__眼歪,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__丢气孔,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__丢眼,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__漏气,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__空泡,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__水封不良,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__漏水,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__卡球,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__冲刷不好,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__泥埂,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__断浆迹,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__模迹,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__重皮,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__气泡,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__眼扁,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__水绺,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__裂,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__活糙,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__贴码不良,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__干补不良,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__内漏不合格,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__外漏不合格,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__试水不合格,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__蹦脏,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__缺陷汇总,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__缺陷率,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_糙活,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_变形,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_渣,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_管道渣,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_孔眼不良,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_睹眼,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_眼歪,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_丢气孔,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_丢眼,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_水封不良,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_卡球,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_活糙,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_缺陷汇总,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_缺陷率,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_坯脏,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_棕眼,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂底,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂圈,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂鼻子,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂水道,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂管,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_沾接裂,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂眼,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_糙活,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_断浆迹,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_活糙,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_缺陷汇总,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_缺陷率,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_滚釉,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉薄,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉不匀,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉磕,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉脏,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉沾,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉绺,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_针孔,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_色脏,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_缺陷汇总,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_缺陷率,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_灌釉不良,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_擦脏,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_崩标,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_倒标,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_标污,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_错标,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_丢标,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_标错位,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_未灌釉,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_灌磕,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_坯磕,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_碱石,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_缺陷汇总,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_缺陷率,
 
-  TO_CHAR(检验数.检验量)  AS 回烧缺陷_装窑缺陷_落脏,
 
-  TO_CHAR(检验数.检验量)  AS 回烧缺陷_装窑缺陷_装沾,
 
-  TO_CHAR(检验数.检验量)  AS 回烧缺陷_装窑缺陷_装磕,
 
-  TO_CHAR(检验数.检验量)  AS 回烧缺陷_装窑缺陷_装裂,
 
-  TO_CHAR(检验数.检验量)  AS 回烧缺陷_装窑缺陷_装走,
 
-  TO_CHAR(检验数.检验量)  AS 回烧缺陷_装窑缺陷_装脏,
 
-  TO_CHAR(检验数.检验量)  AS 回烧缺陷_装窑缺陷_缺釉,
 
-  TO_CHAR(检验数.检验量)  AS 回烧缺陷_装窑缺陷_板折,
 
-  TO_CHAR(检验数.检验量)  AS 回烧缺陷_装窑缺陷_缺陷汇总,
 
-  TO_CHAR(检验数.检验量)  AS 回烧缺陷_装窑缺陷_缺陷率,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_水滴,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_窑脏,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_烧裂,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_针孔,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_风惊,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_烧生,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_串烟,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_烧坑,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_桔釉,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_过火,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_火燎,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_烧走,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_缺陷汇总,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_烧窑缺陷_缺陷率,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_出窑缺陷_磕碰,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_出窑缺陷_划釉,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_出窑缺陷_缺陷汇总,
 
-  to_char(检验数.检验量)  AS 回烧缺陷_出窑缺陷_缺陷率,
 
-  to_char(检验数.检验量)  AS 回烧修补缺陷_修补不良,
 
-  to_char(检验数.检验量)  AS 回烧修补缺陷_漏修,
 
-  to_char(检验数.检验量)  AS 回烧修补缺陷_漏检,
 
-  to_char(检验数.检验量)  AS 回烧修补缺陷_白点,
 
-  to_char(检验数.检验量)  AS 回烧修补_缺陷汇总,
 
-  to_char(检验数.检验量)  AS 回烧修补缺陷_缺陷率,
 
-  to_char(检验数.检验量)  AS 原料缺陷_泥料缺陷_铜脏,
 
-  to_char(检验数.检验量)  AS 原料缺陷_泥料缺陷_料脏,
 
-  to_char(检验数.检验量)  AS 原料缺陷_釉料缺陷_铜脏, 
-  to_char(检验数.检验量)  AS 原料缺陷_釉料缺陷_铁脏,
 
-  to_char(检验数.检验量)  AS 原料缺陷__缺陷汇总,
 
-  to_char(检验数.检验量)  AS 原料缺陷__缺陷率,
 
-  to_char(检验数.检验量)  AS 其他_隧道窑其他_试验不良,
 
-  to_char(检验数.检验量)  AS 其他__缺陷汇总,
 
-  to_char(检验数.检验量)  AS 其他__缺陷率
 
-  FROM 检验数 
-  LEFT JOIN  打磨擦洗出窑数  ON 1=1
 
-  WHERE 检验数.GOODSCODE='总计'
 
-)
 
-ORDER BY 产品类别,产品编码";
 
+            context.Response.Write(jsonStr);
 
 
-     }
 
-     else if(context.Request["procedureMaster"] == "3")
 
-     {
 
-  sqlStr = @"WITH 
-     产品汇总缺陷 AS ( 
-  SELECT   CASE WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =5   THEN '小计'
 
-   WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =6  AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001001' THEN '大件合计'
 
-   WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =6  AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001002' THEN '小件合计'
 
-   WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =7   THEN '总计'
 
-   ELSE to_char(good.GOODSCODE) END AS GOODSCODE,
 
-   GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME) AS GID,
 
-  good.GOODSSPECIFICATION,
 
-  good.GOODSNAME,
 
-      CASE WHEN GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6))=6 AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001001' THEN '大件' 
- WHEN GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6))=6 AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001002' THEN '小件'
 
- ELSE TO_CHAR(gtp.GOODSTYPENAME )END GOODSTYPENAME,
 
-  SUBSTR(gtp.GOODSTYPECODE, 0, 6)  AS GOODSTYPECODE,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN  df.DEFECTCODE IN ('01','02','03','04','05','06','07','08','09','10','12','13','14','15','16','17','18','19','21','22','23','24','25','26','27','28','29','30','31','32','33','34','35','001','002','099','99','1' ,'2' ,'3' ) AND PDS.VALUEFLAG=1   THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 成型半检缺陷__缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '10', '12', '13', '14', '15', '16', '17', '18', '19', '23', '25', '35' ) AND PDS.VALUEFLAG=1 THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 精修缺陷_打磨缺陷_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN PDS.PROCEDUREID IN (5,36,52)  AND PDS.VALUEFLAG=1 AND df.DEFECTCODE IN ( '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '28', '34', '35') THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 精修缺陷_刷洗缺陷_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '36','37','38','39','40','41','42','43','44') THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 施釉擦坯缺陷_施釉缺陷_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '47','48','49','50','51','52','53','54','55','56','20','57')AND MDF.DEFECTCODE IS NOT NULL AND DF.BARCODE IS NOT NULL  THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END ))AS 施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '61','62','63','64','65','66','67', '11') THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 烧成缺陷_装窑缺陷_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '69','70','71','43','73','74','75','76','77','78','79','80') THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END ))AS 烧成缺陷_烧窑缺陷_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '83','84')  THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 烧成缺陷_出窑缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '86', '87','086', '88'  ) THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 原料缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '91', '92', '93', '083', '084') THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 冷修_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '091', '092', '093', '96') THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 回烧修补_缺陷汇总,  
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '061', '062', '063', '064', '065', '066', '067', '011' ) THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 回烧装窑_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '069', '070', '071', '43', '073', '074', '075', '076', '077', '078', '079', '080' ) THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 回烧烧窑_缺陷汇总, 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '0083', '0084' ) THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 回烧出窑_缺陷汇总,  
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '98'  ) THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 研磨_缺陷汇总,   
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '99', '100') THEN to_char(pd.productiondataid || DF.BARCODE||df.DEFECTCODE ) ELSE NULL END )) AS 其他_缺陷汇总
 
-     FROM
 
-  TP_PM_DEFECT df
 
-  LEFT JOIN (TMP_PM_PRODUCTIONDATA_CHECKDT) pd
 
-    ON   (df.productiondataid  = pd.productiondataid or df.productiondataid  = pd.fproductiondataid)
 
-  INNER JOIN TP_PM_PRODUCTIONDATA PDS ON PDS.BARCODE=PD.BARCODE AND pds.valueflag = 1
 
-  LEFT JOIN TP_MST_GOODS good on good.GOODSID=PD.GOODSID
 
-  LEFT JOIN TP_MST_GOODSTYPE gtp ON good.GOODSTYPEID=gtp.GOODSTYPEID
 
-   LEFT JOIN TP_MST_DEFECT MDF ON DF.DEFECTID = MDF.DEFECTID 
-  WHERE df.VALUEFLAG=1   
-AND DF.PROCEDUREID NOT IN " + notInproc;
 
-  sqlStr += @" GROUP BY
 
-  Grouping sets ( ( good.GOODSCODE, good.GOODSNAME,good.GOODSSPECIFICATION,gtp.GOODSTYPENAME ), ( gtp.GOODSTYPENAME) ,(SUBSTR(gtp.GOODSTYPECODE, 0, 6)),()) 
-   ),
 
-   产品明细缺陷 AS (
 
-   SELECT GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)),
 
-   CASE WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =5   THEN '小计'
 
-   WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =6   AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001001' THEN '大件合计'
 
-   WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =6   AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001002' THEN '小件合计'
 
-   WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =7   THEN '总计'
 
-   ELSE to_char(good.GOODSCODE) END AS GOODSCODE,
 
-  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME) AS GID,
 
-  good.GOODSNAME,
 
-  CASE WHEN GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6))=6 AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001001' THEN '大件' 
- WHEN GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6))=6 AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001002' THEN '小件'
 
-  ELSE TO_CHAR(gtp.GOODSTYPENAME )END GOODSTYPENAME,
 
-  SUBSTR(gtp.GOODSTYPECODE, 0, 6)  AS GOODSTYPECODE,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '01' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_坯脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '02' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_棕眼,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '03' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂底,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '04' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂圈,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '05' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂鼻子,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '06' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂水道,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '07' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂管,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '08' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_沾接裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '09' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂眼,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '10' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_糙活,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '12' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_变形,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '13' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_渣,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '14' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_管道渣,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '15' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_孔眼不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '16' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_堵眼,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '17' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_眼歪,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '18' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_丢气孔,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '19' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_丢眼,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '21' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_漏气,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '22' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_空泡,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '23' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_水封不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '24' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_漏水,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '25' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_卡球,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '26' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_冲刷不好,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '27' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_泥埂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '28' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_断浆迹,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '29' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_模迹,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '30' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_重皮,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '31' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_气泡,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '32' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_眼扁,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '33' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_水绺,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '34' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '35' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_活糙,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '001' ) THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_贴码不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '002' ) THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_干补不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '1' )   THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_内漏不合格,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '2' )   THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_外漏不合格,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '3' )   THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_试水不合格,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '10' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_糙活,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '12' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_变形,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '13' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_渣,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '14' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_管道渣,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '15' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_孔眼不良,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '16' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_睹眼,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '17' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_眼歪,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '18' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_丢气孔,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '19' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_丢眼,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '23' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_水封不良,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '25' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_卡球,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '35' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_活糙,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '01' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_坯脏,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '02' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_棕眼,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '03' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂底,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '04' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂圈,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '05' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂鼻子,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '06' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂水道,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '07' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂管,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '08' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_沾接裂,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '09' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂眼,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '10' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_糙活,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '28' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_断浆迹,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '34' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂,
 
-count( DISTINCT CASE WHEN PDS.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '35' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_活糙,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '36' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_滚釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '37' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉薄,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '38' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉不匀,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '39' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '40' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '41' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉沾,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '42' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉绺,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '43' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_针孔,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '44' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_色脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '47' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_灌釉不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '48' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_擦脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '49' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_崩标,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '50' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_倒标,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '51' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_标污,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '52' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_错标,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '53' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_丢标,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '54' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_标错位,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '55' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_未灌釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '56' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_灌磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '20' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_坯磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '57' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_碱石,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '61' ) AND PDS.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_落脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '62' ) AND PDS.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装沾,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '63' ) AND PDS.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '64' ) AND PDS.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '65' ) AND PDS.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装走,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '66' ) AND PDS.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '67' ) AND PDS.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_缺釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '11' ) AND PDS.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_板折,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '69' ) AND PDS.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_水滴,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '70' ) AND PDS.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_窑脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '71' ) AND PDS.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_烧裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '43' ) AND PDS.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_针孔,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '73' ) AND PDS.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_风惊,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '74' ) AND PDS.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_烧生,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '75' ) AND PDS.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_串烟,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '76' ) AND PDS.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_烧坑,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '77' ) AND PDS.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_桔釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '78' ) AND PDS.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_过火,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '79' ) AND PDS.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_火燎,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '80' ) AND PDS.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_烧走,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '83' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_出窑缺陷_磕碰,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '84' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_出窑缺陷_划釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '86' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 原料缺陷_泥料缺陷_铜脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '87' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 原料缺陷_泥料缺陷_料脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '086' ) THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 原料缺陷_釉料缺陷_铜脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '88' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 原料缺陷_釉料缺陷_铁脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '91' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_修补不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '92' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_漏修,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '93' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_漏检,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '083' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_磕碰,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '084' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_划釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '091' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧修补缺陷_修补不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '092' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧修补缺陷_漏修,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '093' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧修补缺陷_漏检,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '96' )   THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧修补缺陷_白点,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '061' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_落脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '062' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装沾,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '063' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '064' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '065' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装走,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '066' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '067' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_缺釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '011' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_板折,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '069' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_水滴,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '070' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_窑脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '071' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_烧裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '43' )   THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_针孔,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '073' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_风惊,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '074' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_烧生,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '075' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_串烟,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '076' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_烧坑,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '077' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_桔釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '078' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_过火,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '079' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_火燎,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '080' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_烧走,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '0083')  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_出窑缺陷_磕碰,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '0084')  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_出窑缺陷_划釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '98' )   THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 研磨缺陷_研磨不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '99' )   THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_隧道窑其他蹦脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '100' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 其他_隧道窑其他试验不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '099' )  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_梭式窑其他蹦脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '0100')  THEN (pd.productiondataid || DF.BARCODE || df.DEFECTCODE) ELSE NULL END ) AS 其他_梭式窑其他试验不良
 
-     FROM
 
-  TP_PM_DEFECT df 
-  LEFT JOIN (TMP_PM_PRODUCTIONDATA_CHECKDT) pd
 
-    ON   (df.productiondataid  = pd.productiondataid or df.productiondataid  = pd.fproductiondataid)
 
-  INNER JOIN TP_PM_PRODUCTIONDATA PDS ON PDS.BARCODE=PD.BARCODE AND pds.valueflag = 1
 
-  LEFT JOIN TP_MST_GOODS good on good.GOODSID=PD.GOODSID
 
-  LEFT JOIN TP_MST_GOODSTYPE gtp ON good.GOODSTYPEID=gtp.GOODSTYPEID
 
-  LEFT JOIN TP_MST_DEFECT MDF ON DF.DEFECTID = MDF.DEFECTID 
-     WHERE df.VALUEFLAG=1   AND DF.PROCEDUREID NOT IN " + notInproc;
 
-  sqlStr += @"    GROUP BY
 
-  Grouping sets ( ( good.GOODSCODE, good.GOODSNAME,gtp.GOODSTYPENAME ), ( gtp.GOODSTYPENAME) ,(SUBSTR(gtp.GOODSTYPECODE, 0, 6)),()    ) 
-  ),
 
-  检验数 AS (    SELECT
 
-GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX),
 
- CASE WHEN  GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX) =5   THEN '小计'
 
- WHEN  GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX) =6 AND GOODSTYPECODESIX='001001'  THEN '大件合计'
 
- WHEN  GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX) =6 AND GOODSTYPECODESIX='001002'  THEN '小件合计'
 
- WHEN  GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX) =7   THEN '总计'
 
-       ELSE to_char(GOODSCODE) END AS GOODSCODE,
 
-CASE WHEN GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX)=6 AND GOODSTYPECODESIX='001001' THEN '大件' 
-  WHEN GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX)=6 AND GOODSTYPECODESIX='001002' THEN '小件'
 
-  ELSE TO_CHAR(GOODSTYPENAME )END GOODSTYPENAME,GOODSNAME,
 
-SUM(检验量)检验量,SUM(合格量) 合格量,SUM(残品) 残品,
 
-    SUM(检验量*LUSTERWAREWEIGHT) 出窑重量,
 
-    SUM(合格量*LUSTERWAREWEIGHT) 合格品重量,
 
-    SUM(残品*LUSTERWAREWEIGHT) 残品重量
 
-FROM(
 
-SELECT
 
-  pd.GOODSCODE,
 
-  SUBSTR(pd.GOODSTYPECODE, 0, 6) GOODSTYPECODESIX,
 
-  pd.GOODSNAME,
 
-  PD.GOODSTYPENAME,
 
-  COUNT(   pd.BARCODE ) AS 检验量,
 
-  SUM( CASE WHEN PD.GOODSLEVELTYPEID IN ( 4, 5 ) THEN 1 ELSE 0 END ) AS 合格量,
 
-  SUM( CASE WHEN PD.GOODSLEVELTYPEID  NOT IN ( 4, 5 ) THEN 1 ELSE 0  END ) 残品,
 
-  LUSTERWAREWEIGHT
 
- FROM (SELECT barcode
 
-      ,goodscode
 
-      ,goodsleveltypeid
 
-      ,goodsname
 
-      ,groutinguserid
 
-      ,groutingusercode
 
-      ,goodstypename
 
-      ,goodstypecode
 
-      ,lusterwareweight
 
-      ,createtime 
-  FROM (SELECT DISTINCT pd.barcode
 
-,good.goodscode
 
-,good.goodsname
 
-,pd.groutinguserid
 
-,pd.groutingusercode
 
-,gtp.goodstypecode
 
-,nvl(pd61.goodsleveltypeid, pd.goodsleveltypeid) goodsleveltypeid
 
-,pd.createtime
 
-,gtp.goodstypename
 
-,good.lusterwareweight
 
-   FROM (SELECT * FROM (SELECT pd28.goodsname
 
-       ,pd28.groutingdailydetailid
 
-       ,pd28.goodsid
 
-       ,pd28.goodscode
 
-       ,pd28.goodsleveltypeid
 
-       ,pd28.groutinguserid
 
-       ,pd28.groutingusercode
 
-       ,pd28.createtime
 
-       ,pd24.procedureid
 
-       ,pd28.kilncarbatchno
 
-       ,pd28.barcode
 
-       ,pd28.productiondataid
 
-       ,row_number() over(PARTITION BY pd28.productiondataid ORDER BY pd24.productiondataid DESC) AS rownums
 
-   FROM tp_pm_productiondata pd28 
-  INNER JOIN tp_pm_productiondata pd24  
-     ON pd24.groutingdailydetailid = pd28.groutingdailydetailid
 
-  WHERE pd28.procedureid = 16
 
-    AND pd28.valueflag = 1
 
-    AND pd24.valueflag = 1
 
-    AND pd24.procedureid IN (55, 13, 42)   
-    AND pd28.checktime >= @DATEBEGIN@
 
-    AND pd28.checktime <=   @DATEEND@ 
-    AND (@USERCODE@ is null or @USERCODE@ = '' or instr( pd28.GROUTINGUSERCODE,@USERCODE@) > 0 )   
-    AND pd24.productiondataid < pd28.productiondataid) t
 
-      WHERE rownums = 1 AND t.procedureid in (55, 13)) pd
 
-   LEFT JOIN tp_pm_productiondata pd61 
- ON pd61.procedureid = 60
 
-    AND pd61.valueflag = 1
 
-    AND pd61.groutingdailydetailid = pd.groutingdailydetailid
 
-    AND pd61.kilncarbatchno = pd.kilncarbatchno
 
-    AND pd61.productiondataid > pd.productiondataid 
-    AND NOT EXISTS
 
-  (SELECT 1
 
- FROM tp_pm_productiondata pd28c  
-      WHERE pd28c.procedureid = 16
 
-  AND pd28c.valueflag = 1
 
-  AND pd28c.groutingdailydetailid = pd.groutingdailydetailid
 
-  AND pd28c.kilncarbatchno = pd.kilncarbatchno
 
-  AND pd28c.productiondataid > pd.productiondataid
 
-  AND pd28c.productiondataid < pd61.productiondataid) 
-   LEFT JOIN tp_mst_goods good
 
- ON good.goodsid = pd.goodsid
 
-   LEFT JOIN tp_mst_goodstype gtp
 
- ON gtp.goodstypeid = good.goodstypeid 
- )) pd
 
-    GROUP BY pd.GOODSCODE,SUBSTR(pd.GOODSTYPECODE, 0, 6),pd.GOODSNAME,PD.GOODSTYPENAME,LUSTERWAREWEIGHT 
-)
 
- GROUP BY Grouping sets((GOODSCODE,GOODSNAME,GOODSTYPENAME,GOODSTYPECODESIX),(GOODSTYPENAME),(GOODSTYPECODESIX),())),
 
-  产品 AS (
 
-  SELECT TO_CHAR(GOODSCODE) AS GOODSCODE,GOODSNAME,GOODSSPECIFICATION,gtp.GOODSTYPENAME 
-    ,TP_MST_GOODS.LUSTERWAREWEIGHT
 
-  FROM TP_MST_GOODS
 
-  LEFT JOIN TP_MST_GOODSTYPE gtp ON TP_MST_GOODS.GOODSTYPEID=gtp.GOODSTYPEID
 
-   WHERE TP_MST_GOODS.VALUEFLAG=1
 
-  UNION ALL
 
-  SELECT '总计' AS GOODSCODE,null,NULL ,NULL,null  FROM dual
 
-    
-  ),
 
-打磨擦洗出窑数 AS (
 
-  SELECT  COUNT(DISTINCT CASE WHEN pds.PROCEDUREID IN (4,36,53) THEN PD.productiondataid ELSE NULL END ) 打磨,
 
-      COUNT(DISTINCT CASE WHEN pds.PROCEDUREID IN (5,36,52) THEN PD.productiondataid ELSE NULL END ) 擦洗,
 
-      COUNT(DISTINCT CASE WHEN pds.PROCEDUREID =@kilproc@ THEN PD.productiondataid ELSE NULL END ) 质量登记
 
-    FROM  ( SELECT * FROM (SELECT pd28.goodsname
 
-       ,pd28.groutingdailydetailid
 
-       ,pd28.goodsid
 
-       ,pd28.goodscode
 
-       ,pd28.goodsleveltypeid
 
-       ,pd28.groutinguserid
 
-       ,pd28.groutingusercode
 
-       ,pd28.createtime
 
-       ,pd24.procedureid
 
-       ,pd28.kilncarbatchno
 
-       ,pd28.barcode
 
-       ,pd28.productiondataid
 
-       ,row_number() over(PARTITION BY pd28.productiondataid ORDER BY pd24.productiondataid DESC) AS rownums
 
-   FROM tp_pm_productiondata pd28 
-  INNER JOIN tp_pm_productiondata pd24 
-     ON pd24.groutingdailydetailid = pd28.groutingdailydetailid
 
-  WHERE pd28.procedureid = 16
 
-    AND pd28.valueflag = 1
 
-    AND pd24.valueflag = 1
 
-    AND pd24.procedureid IN (55, 13, 42)   
-    AND pd28.checktime >= @DATEBEGIN@
 
-    AND pd28.checktime <=   @DATEEND@ 
-    AND (@USERCODE@ is null or @USERCODE@ = '' or instr( pd28.GROUTINGUSERCODE,@USERCODE@) > 0 )   
-    AND pd24.productiondataid < pd28.productiondataid) t
 
-      WHERE rownums = 1
 
-  AND t.procedureid in (55, 13) ) pd 
-   INNER JOIN TP_PM_PRODUCTIONDATA pds ON pds.BARCODE=PD.BARCODE   AND pds.valueflag = 1
 
-  
-    
-  )
 
- SELECT * FROM (
 
-  SELECT
 
-  to_CHAR(检验数.GOODSCODE) AS  产品编码,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.GOODSNAME) ELSE NULL END 产品名称,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(产品.GOODSSPECIFICATION) ELSE NULL END 产品规格,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.GOODSTYPENAME) ELSE NULL END 产品类别,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(产品.LUSTERWAREWEIGHT) ELSE NULL END 单重,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.检验量) ELSE NULL END 检验量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.出窑重量) ELSE NULL END 出窑重量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.合格量) ELSE NULL END 合格量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.合格品重量) ELSE NULL END 合格品重量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.残品) ELSE NULL END 残品,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.残品重量) ELSE NULL END 残品重量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN DECODE( NVL( 检验数.合格量, 0 ), 0, '0%', TO_CHAR( ( NVL( 检验数.合格量, 0 ) / DECODE( NVL( 检验数.检验量, 1 ), 0, 1, NVL( 检验数.检验量, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) ELSE NULL END AS 合格率,
 
-  to_char(nvl(s.成型半检缺陷_坯脏,0)) AS 成型半检缺陷__坯脏,
 
-  to_char(nvl(s.成型半检缺陷_棕眼,0)) AS 成型半检缺陷__棕眼,
 
-  to_char(nvl(s.成型半检缺陷_裂底,0)) AS 成型半检缺陷__裂底,
 
-  to_char(nvl(s.成型半检缺陷_裂圈,0)) AS 成型半检缺陷__裂圈,
 
-  to_char(nvl(s.成型半检缺陷_裂鼻子,0)) AS 成型半检缺陷__裂鼻子,
 
-  to_char(nvl(s.成型半检缺陷_裂水道,0)) AS 成型半检缺陷__裂水道,
 
-  to_char(nvl(s.成型半检缺陷_裂管,0)) AS 成型半检缺陷__裂管,
 
-  to_char(nvl(s.成型半检缺陷_沾接裂,0)) AS 成型半检缺陷__沾接裂,
 
-  to_char(nvl(s.成型半检缺陷_裂眼,0)) AS 成型半检缺陷__裂眼,
 
-  to_char(nvl(s.成型半检缺陷_糙活,0)) AS 成型半检缺陷__糙活,
 
-  to_char(nvl(s.成型半检缺陷_变形,0)) AS 成型半检缺陷__变形,
 
-  to_char(nvl(s.成型半检缺陷_渣,0)) AS 成型半检缺陷__渣,
 
-  to_char(nvl(s.成型半检缺陷_管道渣,0)) AS 成型半检缺陷__管道渣,
 
-  to_char(nvl(s.成型半检缺陷_孔眼不良,0)) AS 成型半检缺陷__孔眼不良,
 
-  to_char(nvl(s.成型半检缺陷_堵眼,0)) AS 成型半检缺陷__堵眼,
 
-  to_char(nvl(s.成型半检缺陷_眼歪,0)) AS 成型半检缺陷__眼歪,
 
-  to_char(nvl(s.成型半检缺陷_丢气孔,0)) AS 成型半检缺陷__丢气孔,
 
-  to_char(nvl(s.成型半检缺陷_丢眼,0)) AS 成型半检缺陷__丢眼,
 
-  to_char(nvl(s.成型半检缺陷_漏气,0)) AS 成型半检缺陷__漏气,
 
-  to_char(nvl(s.成型半检缺陷_空泡,0)) AS 成型半检缺陷__空泡,
 
-  to_char(nvl(s.成型半检缺陷_水封不良,0)) AS 成型半检缺陷__水封不良,
 
-  to_char(nvl(s.成型半检缺陷_漏水,0)) AS 成型半检缺陷__漏水,
 
-  to_char(nvl(s.成型半检缺陷_卡球,0)) AS 成型半检缺陷__卡球,
 
-  to_char(nvl(s.成型半检缺陷_冲刷不好,0)) AS 成型半检缺陷__冲刷不好,
 
-  to_char(nvl(s.成型半检缺陷_泥埂,0)) AS 成型半检缺陷__泥埂,
 
-  to_char(nvl(s.成型半检缺陷_断浆迹,0)) AS 成型半检缺陷__断浆迹,
 
-  to_char(nvl(s.成型半检缺陷_模迹,0)) AS 成型半检缺陷__模迹,
 
-  to_char(nvl(s.成型半检缺陷_重皮,0)) AS 成型半检缺陷__重皮,
 
-  to_char(nvl(s.成型半检缺陷_气泡,0)) AS 成型半检缺陷__气泡,
 
-  to_char(nvl(s.成型半检缺陷_眼扁,0)) AS 成型半检缺陷__眼扁,
 
-  to_char(nvl(s.成型半检缺陷_水绺,0)) AS 成型半检缺陷__水绺,
 
-  to_char(nvl(s.成型半检缺陷_裂,0)) AS 成型半检缺陷__裂,
 
-  to_char(nvl(s.成型半检缺陷_活糙,0)) AS 成型半检缺陷__活糙,
 
-  to_char(nvl(s.成型半检缺陷_贴码不良,0)) AS 成型半检缺陷__贴码不良,
 
-  to_char(nvl(s.成型半检缺陷_干补不良,0)) AS 成型半检缺陷__干补不良,
 
-  to_char(nvl(s.成型半检缺陷_内漏不合格,0)) AS 成型半检缺陷__内漏不合格,
 
-  to_char(nvl(s.成型半检缺陷_外漏不合格,0)) AS 成型半检缺陷__外漏不合格,
 
-  to_char(nvl(s.成型半检缺陷_试水不合格,0)) AS 成型半检缺陷__试水不合格,
 
-  to_char(nvl(s.成型半检缺陷_隧道窑其他蹦脏,0)) AS 成型半检缺陷__蹦脏,
 
-  nvl(f.成型半检缺陷__缺陷汇总,0) AS 成型半检缺陷__缺陷汇总,
 
-  DECODE( NVL( f.成型半检缺陷__缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.成型半检缺陷__缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 成型半检缺陷__缺陷率,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_糙活,0)) AS 精修缺陷_打磨缺陷_糙活,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_变形,0)) AS 精修缺陷_打磨缺陷_变形,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_渣,0)) AS 精修缺陷_打磨缺陷_渣,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_管道渣,0)) AS 精修缺陷_打磨缺陷_管道渣,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_孔眼不良,0)) AS 精修缺陷_打磨缺陷_孔眼不良,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_睹眼,0)) AS 精修缺陷_打磨缺陷_睹眼,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_眼歪,0)) AS 精修缺陷_打磨缺陷_眼歪,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_丢气孔,0)) AS 精修缺陷_打磨缺陷_丢气孔,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_丢眼,0)) AS 精修缺陷_打磨缺陷_丢眼,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_水封不良,0)) AS 精修缺陷_打磨缺陷_水封不良,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_卡球,0)) AS 精修缺陷_打磨缺陷_卡球,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_活糙,0)) AS 精修缺陷_打磨缺陷_活糙,
 
-  nvl(f.精修缺陷_打磨缺陷_缺陷汇总,0) AS 精修缺陷_打磨缺陷_缺陷汇总,
 
-  DECODE( NVL( f.精修缺陷_打磨缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.精修缺陷_打磨缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 精修缺陷_打磨缺陷_缺陷率,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_坯脏,0)) AS 精修缺陷_刷洗缺陷_坯脏,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_棕眼,0)) AS 精修缺陷_刷洗缺陷_棕眼,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂底,0)) AS 精修缺陷_刷洗缺陷_裂底,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂圈,0)) AS 精修缺陷_刷洗缺陷_裂圈,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂鼻子,0)) AS 精修缺陷_刷洗缺陷_裂鼻子,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂水道,0)) AS 精修缺陷_刷洗缺陷_裂水道,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂管,0)) AS 精修缺陷_刷洗缺陷_裂管,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_沾接裂,0)) AS 精修缺陷_刷洗缺陷_沾接裂,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂眼,0)) AS 精修缺陷_刷洗缺陷_裂眼,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_糙活,0)) AS 精修缺陷_刷洗缺陷_糙活,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_断浆迹,0)) AS 精修缺陷_刷洗缺陷_断浆迹,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂,0)) AS 精修缺陷_刷洗缺陷_裂,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_活糙,0)) AS 精修缺陷_刷洗缺陷_活糙,
 
-  nvl(f.精修缺陷_刷洗缺陷_缺陷汇总,0) AS 精修缺陷_刷洗缺陷_缺陷汇总,
 
-  DECODE( NVL( f.精修缺陷_刷洗缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.精修缺陷_刷洗缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL(打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 精修缺陷_刷洗缺陷_缺陷率,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_滚釉,0)) AS 施釉擦坯缺陷_施釉缺陷_滚釉,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉薄,0)) AS 施釉擦坯缺陷_施釉缺陷_釉薄,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉不匀,0)) AS 施釉擦坯缺陷_施釉缺陷_釉不匀,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉磕,0)) AS 施釉擦坯缺陷_施釉缺陷_釉磕,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉脏,0)) AS 施釉擦坯缺陷_施釉缺陷_釉脏,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉沾,0)) AS 施釉擦坯缺陷_施釉缺陷_釉沾,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉绺,0)) AS 施釉擦坯缺陷_施釉缺陷_釉绺,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_针孔,0)) AS 施釉擦坯缺陷_施釉缺陷_针孔,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_色脏,0)) AS 施釉擦坯缺陷_施釉缺陷_色脏,
 
-  nvl(f.施釉擦坯缺陷_施釉缺陷_缺陷汇总,0) AS 施釉擦坯缺陷_施釉缺陷_缺陷汇总,
 
-  DECODE( NVL( f.施釉擦坯缺陷_施釉缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.施釉擦坯缺陷_施釉缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 施釉擦坯缺陷_施釉缺陷_缺陷率,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_灌釉不良,0)) AS 施釉擦坯缺陷_擦坯缺陷_灌釉不良,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_擦脏,0)) AS 施釉擦坯缺陷_擦坯缺陷_擦脏,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_崩标,0)) AS 施釉擦坯缺陷_擦坯缺陷_崩标,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_倒标,0)) AS 施釉擦坯缺陷_擦坯缺陷_倒标,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_标污,0)) AS 施釉擦坯缺陷_擦坯缺陷_标污,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_错标,0)) AS 施釉擦坯缺陷_擦坯缺陷_错标,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_丢标,0)) AS 施釉擦坯缺陷_擦坯缺陷_丢标,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_标错位,0)) AS 施釉擦坯缺陷_擦坯缺陷_标错位,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_未灌釉,0)) AS 施釉擦坯缺陷_擦坯缺陷_未灌釉,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_灌磕,0)) AS 施釉擦坯缺陷_擦坯缺陷_灌磕,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_坯磕,0)) AS 施釉擦坯缺陷_擦坯缺陷_坯磕,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_碱石,0)) AS 施釉擦坯缺陷_擦坯缺陷_碱石,
 
-  nvl(f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总,0) AS 施釉擦坯缺陷_擦坯缺陷_缺陷汇总,
 
-  DECODE( NVL( f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 施釉擦坯缺陷_擦坯缺陷_缺陷率,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_落脏,0)) AS 烧成缺陷_装窑缺陷_落脏,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_装沾,0)) AS 烧成缺陷_装窑缺陷_装沾,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_装磕,0)) AS 烧成缺陷_装窑缺陷_装磕,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_装裂,0)) AS 烧成缺陷_装窑缺陷_装裂,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_装走,0)) AS 烧成缺陷_装窑缺陷_装走,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_装脏,0)) AS 烧成缺陷_装窑缺陷_装脏,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_缺釉,0)) AS 烧成缺陷_装窑缺陷_缺釉,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_板折,0)) AS 烧成缺陷_装窑缺陷_板折,
 
-  nvl(f.烧成缺陷_装窑缺陷_缺陷汇总,0) AS 烧成缺陷_装窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.烧成缺陷_装窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.烧成缺陷_装窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 烧成缺陷_装窑缺陷_缺陷率,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_水滴,0)) AS 烧成缺陷_烧窑缺陷_水滴,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_窑脏,0)) AS 烧成缺陷_烧窑缺陷_窑脏,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_烧裂,0)) AS 烧成缺陷_烧窑缺陷_烧裂,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_针孔,0)) AS 烧成缺陷_烧窑缺陷_针孔,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_风惊,0)) AS 烧成缺陷_烧窑缺陷_风惊,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_烧生,0)) AS 烧成缺陷_烧窑缺陷_烧生,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_串烟,0)) AS 烧成缺陷_烧窑缺陷_串烟,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_烧坑,0)) AS 烧成缺陷_烧窑缺陷_烧坑,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_桔釉,0)) AS 烧成缺陷_烧窑缺陷_桔釉,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_过火,0)) AS 烧成缺陷_烧窑缺陷_过火,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_火燎,0)) AS 烧成缺陷_烧窑缺陷_火燎,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_烧走,0)) AS 烧成缺陷_烧窑缺陷_烧走,
 
-  nvl(f.烧成缺陷_烧窑缺陷_缺陷汇总,0)AS 烧成缺陷_烧窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.烧成缺陷_烧窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.烧成缺陷_烧窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 烧成缺陷_烧窑缺陷_缺陷率,
 
-  TO_CHAR(nvl(s.烧成缺陷_出窑缺陷_磕碰,0))AS 烧成缺陷_出窑缺陷_磕碰,
 
-  TO_CHAR(nvl(s.烧成缺陷_出窑缺陷_划釉,0))AS 烧成缺陷_出窑缺陷_划釉,
 
-  nvl(f.烧成缺陷_出窑缺陷_缺陷汇总,0) AS 烧成缺陷_出窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.烧成缺陷_出窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.烧成缺陷_出窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 烧成缺陷_出窑缺陷_缺陷率,
 
-  TO_CHAR(nvl(s.原料缺陷_泥料缺陷_铜脏,0)) AS 原料缺陷_泥料缺陷_铜脏,
 
-  TO_CHAR(nvl(s.原料缺陷_泥料缺陷_料脏,0)) AS 原料缺陷_泥料缺陷_料脏,
 
-  TO_CHAR(nvl(s.原料缺陷_釉料缺陷_铜脏,0)) AS 原料缺陷_釉料缺陷_铜脏, 
-  TO_CHAR(nvl(s.原料缺陷_釉料缺陷_铁脏,0)) AS 原料缺陷_釉料缺陷_铁脏,
 
-  nvl(f.原料缺陷_缺陷汇总,0) AS 原料缺陷__缺陷汇总,
 
-  DECODE( NVL( f.原料缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.原料缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 原料缺陷__缺陷率,
 
-  
-  to_char(nvl(s.其他_隧道窑其他试验不良,0)) AS 其他_隧道窑其他_试验不良,
 
-  nvl(f.其他_缺陷汇总,0) AS 其他_隧道窑其他_缺陷汇总,
 
-  DECODE( NVL( f.其他_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.其他_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 其他_隧道窑其他_缺陷率
 
-  FROM 检验数
 
-  LEFT JOIN 产品 ON 检验数.GOODSCODE=产品.GOODSCODE
 
-  LEFT JOIN  产品明细缺陷  s ON (检验数.GOODSCODE=s.GOODSCODE and (检验数.GOODSTYPENAME=s.GOODSTYPENAME or (检验数.GOODSTYPENAME is null and s.GOODSTYPENAME is null)) and s.gid>0) or(检验数.GOODSCODE=s.GOODSCODE and s.gid=0)
 
-  LEFT JOIN 产品汇总缺陷 f ON f.GOODSCODE=产品.GOODSCODE 
-  LEFT JOIN  打磨擦洗出窑数  ON 1=1
 
-    UNION ALL
 
-  SELECT
 
-  to_Char(检验数.GOODSCODE),
 
-  to_Char(检验数.GOODSNAME),
 
-  to_Char(产品.GOODSSPECIFICATION),
 
-  to_Char(产品.GOODSTYPENAME),
 
-  to_Char(产品.LUSTERWAREWEIGHT),
 
-  to_Char(检验数.检验量),to_Char(检验数.出窑重量),
 
-  to_Char(检验数.合格量),
 
-  to_Char(检验数.合格品重量),
 
-  to_Char(检验数.残品),
 
-  to_Char(检验数.残品重量),
 
-  DECODE( NVL( 检验数.合格量, 0 ), 0, '0%', TO_CHAR( ( NVL( 检验数.合格量, 0 ) / DECODE( NVL(检验数.检验量, 1 ), 0, 1, NVL( 检验数.检验量, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 合格率,
 
-  DECODE( NVL( s.成型半检缺陷_坯脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_坯脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_棕眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_棕眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂底, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂底, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂圈, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂圈, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂鼻子, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂鼻子, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂水道, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂水道, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂管, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂管, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_沾接裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_沾接裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_糙活, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_糙活, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_变形, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_变形, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_渣, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_渣, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_管道渣, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_管道渣, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_孔眼不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_孔眼不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_堵眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_堵眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_眼歪, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_眼歪, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_丢气孔, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_丢气孔, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_丢眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_丢眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_漏气, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_漏气, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_空泡, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_空泡, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_水封不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_水封不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_漏水, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_漏水, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_卡球, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_卡球, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_冲刷不好, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_冲刷不好, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_泥埂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_泥埂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_断浆迹, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_断浆迹, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_模迹, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_模迹, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_重皮, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_重皮, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_气泡, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_气泡, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_眼扁, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_眼扁, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_水绺, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_水绺, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_活糙, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_活糙, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_贴码不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_贴码不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_干补不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_干补不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_内漏不合格, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_内漏不合格, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_外漏不合格, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_外漏不合格, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_试水不合格, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_试水不合格, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_隧道窑其他蹦脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_隧道窑其他蹦脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.成型半检缺陷__缺陷汇总,
 
-  DECODE( NVL( f.成型半检缺陷__缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.成型半检缺陷__缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 成型半检缺陷__缺陷率,
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_糙活, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_糙活, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_变形, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_变形, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_渣, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_渣, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_管道渣, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_管道渣, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_孔眼不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_孔眼不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_睹眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_睹眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_眼歪, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_眼歪, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_丢气孔, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_丢气孔, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_丢眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_丢眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_水封不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_水封不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_卡球, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_卡球, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_活糙, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_活糙, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.精修缺陷_打磨缺陷_缺陷汇总,
 
-  DECODE( NVL( f.精修缺陷_打磨缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.精修缺陷_打磨缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 精修缺陷_打磨缺陷_缺陷率,
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_坯脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_坯脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_棕眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_棕眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂底, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂底, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂圈, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂圈, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂鼻子, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂鼻子, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂水道, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂水道, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂管, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂管, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_沾接裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_沾接裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_糙活, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_糙活, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_断浆迹, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_断浆迹, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_活糙, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_活糙, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.精修缺陷_刷洗缺陷_缺陷汇总,
 
-  DECODE( NVL( f.精修缺陷_刷洗缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.精修缺陷_刷洗缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 精修缺陷_刷洗缺陷_缺陷率,
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_滚釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_滚釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉薄, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉薄, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉不匀, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉不匀, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉磕, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉磕, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉沾, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉沾, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉绺, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉绺, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_针孔, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_针孔, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_色脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_色脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-    f.施釉擦坯缺陷_施釉缺陷_缺陷汇总,
 
-  DECODE( NVL( f.施釉擦坯缺陷_施釉缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.施釉擦坯缺陷_施釉缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 施釉擦坯缺陷_施釉缺陷_缺陷率,
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_灌釉不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_灌釉不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_擦脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_擦脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_崩标, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_崩标, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_倒标, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_倒标, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_标污, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_标污, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_错标, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_错标, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_丢标, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_丢标, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_标错位, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_标错位, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_未灌釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_未灌釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_灌磕, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_灌磕, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_坯磕, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_坯磕, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_碱石, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_碱石, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-    f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总,
 
-  DECODE( NVL( f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 施釉擦坯缺陷_擦坯缺陷_缺陷率,
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_落脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_落脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_装沾, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_装沾, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_装磕, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_装磕, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_装裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_装裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_装走, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_装走, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_装脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_装脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_缺釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_缺釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_板折, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_板折, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.烧成缺陷_装窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.烧成缺陷_装窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.烧成缺陷_装窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 烧成缺陷_装窑缺陷_缺陷率,
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_水滴, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_水滴, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_窑脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_窑脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_烧裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_烧裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_针孔, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_针孔, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_风惊, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_风惊, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_烧生, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_烧生, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_串烟, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_串烟, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_烧坑, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_烧坑, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_桔釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_桔釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_过火, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_过火, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_火燎, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_火燎, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_烧走, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_烧走, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.烧成缺陷_烧窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.烧成缺陷_烧窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.烧成缺陷_烧窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 烧成缺陷_烧窑缺陷_缺陷率,
 
-DECODE( NVL( s.烧成缺陷_出窑缺陷_磕碰, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_出窑缺陷_磕碰, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_出窑缺陷_划釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_出窑缺陷_划釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.烧成缺陷_出窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.烧成缺陷_出窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.烧成缺陷_出窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 烧成缺陷_出窑缺陷_缺陷率,
 
-DECODE( NVL( s.原料缺陷_泥料缺陷_铜脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.原料缺陷_泥料缺陷_铜脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.原料缺陷_泥料缺陷_料脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.原料缺陷_泥料缺陷_料脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.原料缺陷_釉料缺陷_铜脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.原料缺陷_釉料缺陷_铜脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.原料缺陷_釉料缺陷_铁脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.原料缺陷_釉料缺陷_铁脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.原料缺陷_缺陷汇总 AS 原料缺陷__缺陷汇总,
 
-  DECODE( NVL( f.原料缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.原料缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 原料缺陷__缺陷率,
 
-DECODE( NVL( s.其他_隧道窑其他试验不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.其他_隧道窑其他试验不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-    f.其他_缺陷汇总 AS 其他_缺陷汇总,
 
-  DECODE( NVL( f.其他_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.其他_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 其他_缺陷率
 
-     FROM 检验数
 
-  LEFT JOIN 产品 ON 检验数.GOODSCODE=产品.GOODSCODE
 
-  LEFT JOIN  产品明细缺陷  s ON 产品.GOODSCODE=s.GOODSCODE
 
-  LEFT JOIN 产品汇总缺陷 f ON f.GOODSCODE=产品.GOODSCODE 
-  LEFT JOIN  打磨擦洗出窑数  ON 1=1
 
-  WHERE 检验数.GOODSCODE='总计'
 
- UNION ALL SELECT
 
-  '工序出窑量' AS  产品编码,
 
-  '' 产品名称,
 
-  '' 产品规格,
 
-  ''产品类别,
 
-  '' 重量,
 
-  '' 检验量,'',
 
-  '' 合格量,'',
 
-  '' 残品,'',
 
-  '' 合格率,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__坯脏,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__棕眼,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂底,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂圈,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂鼻子,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂水道,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂管,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__沾接裂,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂眼,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__糙活,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__变形,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__渣,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__管道渣,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__孔眼不良,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__堵眼,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__眼歪,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__丢气孔,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__丢眼,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__漏气,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__空泡,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__水封不良,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__漏水,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__卡球,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__冲刷不好,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__泥埂,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__断浆迹,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__模迹,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__重皮,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__气泡,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__眼扁,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__水绺,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__裂,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__活糙,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__贴码不良,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__干补不良,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__内漏不合格,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__外漏不合格,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__试水不合格,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷_蹦脏,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__缺陷汇总,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__缺陷率,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_糙活,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_变形,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_渣,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_管道渣,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_孔眼不良,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_睹眼,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_眼歪,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_丢气孔,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_丢眼,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_水封不良,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_卡球,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_活糙,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_缺陷汇总,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_缺陷率,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_坯脏,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_棕眼,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂底,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂圈,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂鼻子,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂水道,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂管,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_沾接裂,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂眼,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_糙活,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_断浆迹,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_活糙,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_缺陷汇总,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_缺陷率,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_滚釉,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉薄,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉不匀,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉磕,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉脏,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉沾,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉绺,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_针孔,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_色脏,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_缺陷汇总,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_缺陷率,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_灌釉不良,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_擦脏,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_崩标,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_倒标,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_标污,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_错标,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_丢标,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_标错位,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_未灌釉,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_灌磕,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_坯磕,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_碱石,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_缺陷汇总,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_缺陷率,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_落脏,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_装沾,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_装磕,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_装裂,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_装走,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_装脏,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_缺釉,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_板折,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_缺陷汇总,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_缺陷率,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_水滴,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_窑脏,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_烧裂,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_针孔,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_风惊,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_烧生,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_串烟,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_烧坑,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_桔釉,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_过火,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_火燎,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_烧走,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_缺陷汇总,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_缺陷率,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_出窑缺陷_磕碰,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_出窑缺陷_划釉,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_出窑缺陷_缺陷汇总,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_出窑缺陷_缺陷率,
 
-  to_char(检验数.检验量)  AS 原料缺陷_泥料缺陷_铜脏,
 
-  to_char(检验数.检验量)  AS 原料缺陷_泥料缺陷_料脏,
 
-  to_char(检验数.检验量)  AS 原料缺陷_釉料缺陷_铜脏,
 
-  to_char(检验数.检验量)  AS 原料缺陷_釉料缺陷_铁脏,
 
-  to_char(检验数.检验量)  AS 原料缺陷__缺陷汇总,
 
-  to_char(检验数.检验量)  AS 原料缺陷__缺陷率,
 
-  to_char(检验数.检验量)  AS 其他_隧道窑其他_试验不良,
 
-  to_char(检验数.检验量)  AS 其他__缺陷汇总,
 
-  to_char(检验数.检验量)  AS 其他__缺陷率
 
-  FROM 检验数 
-  LEFT JOIN  打磨擦洗出窑数  ON 1=1
 
-  WHERE 检验数.GOODSCODE='总计'
 
-
 
-)
 
-ORDER BY 产品类别,产品编码
 
-     ";
 
-     }else if (context.Request["procedureMaster"] == "1") {
 
-  kilproc = "28";//出窑工序
 
-  FunctionalTesting = " 61";//功能检测
 
-  notInproc = " (16,60) ";//排除工序
 
-  sqlStr = @"WITH 
-     产品汇总缺陷 AS ( 
-  SELECT     
-    CASE WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =5   THEN '小计'
 
-    WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =6  AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001001' THEN '大件合计'
 
-    WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =6  AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001002' THEN '小件合计'
 
-    WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =7   THEN '总计'
 
-   ELSE to_char(good.GOODSCODE) END AS GOODSCODE,
 
-  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME) AS GID,
 
-  good.GOODSSPECIFICATION,
 
-  good.GOODSNAME,
 
-      CASE WHEN GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6))=6 AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001001' THEN '大件' 
- WHEN GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6))=6 AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001002' THEN '小件'
 
- ELSE TO_CHAR(gtp.GOODSTYPENAME )END GOODSTYPENAME,
 
-  SUBSTR(gtp.GOODSTYPECODE, 0, 6)  AS GOODSTYPECODE,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN   df.DEFECTCODE IN ('01','02','03','04','05','06','07','08','09','10','12','13','14','15','16','17','18','19','21','22','23','24','25','26','27','28','29','30','31','32','33','34','35','001','002','099','99','1' ,'2' ,'3' )    THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 成型半检缺陷__缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '10', '12', '13', '14', '15', '16', '17', '18', '19', '23', '25', '35' )  THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 精修缺陷_打磨缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN PDs.PROCEDUREID IN (5,36,52)    AND df.DEFECTCODE IN ( '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '28', '34', '35') THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 精修缺陷_刷洗缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '36','37','38','39','40','41','42','43','44') THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 施釉擦坯缺陷_施釉缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '47','48','49','50','51','52','53','54','55','56','20','57')AND MDF.DEFECTCODE IS NOT NULL AND DF.BARCODE IS NOT NULL  THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END ))AS 施釉擦坯缺陷_擦坯缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '61','62','63','64','65','66','67', '11') THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 烧成缺陷_装窑缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '69','70','71','43','73','74','75','76','77','78','79','80') THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END ))AS 烧成缺陷_烧窑缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT  CASE WHEN df.DEFECTCODE IN ( '83','84')  THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 烧成缺陷_出窑缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '86', '87','086', '88'  ) THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 原料缺陷_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '91', '92', '93', '083', '084') THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 冷修_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '091', '092', '093', '96') THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 回烧修补_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '061', '062', '063', '064', '065', '066', '067', '011' ) THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 回烧装窑_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '069', '070', '071', '43', '073', '074', '075', '076', '077', '078', '079', '080' ) THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 回烧烧窑_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '0083', '0084' ) THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 回烧出窑_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '98'  ) THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 研磨_缺陷汇总,
 
-  TO_CHAR(COUNT( DISTINCT CASE WHEN df.DEFECTCODE IN ( '99', '100') THEN to_char(pd.productiondataid || df.barcode || df.DEFECTCODE ) ELSE NULL END )) AS 其他_缺陷汇总
 
-     FROM
 
-  TP_PM_DEFECT df
 
- LEFT JOIN (TMP_PM_PRODUCTIONDATA_CHECKDT) pd
 
-       ON   (df.productiondataid  = pd.productiondataid or df.productiondataid  = pd.fproductiondataid)
 
-  LEFT JOIN TP_MST_GOODS good on good.GOODSID=PD.GOODSID
 
-  LEFT JOIN TP_MST_GOODSTYPE gtp ON good.GOODSTYPEID=gtp.GOODSTYPEID
 
-  LEFT JOIN TP_MST_DEFECT MDF ON DF.DEFECTID = MDF.DEFECTID 
-  INNER JOIN tp_pm_productiondata pds ON pds.barcode = pd.barcode  AND pds.valueflag = 1
 
-    WHERE df.VALUEFLAG=1  
-AND DF.PROCEDUREID NOT IN " + notInproc;
 
-   sqlStr += @" GROUP BY
 
-  Grouping sets ( ( good.GOODSCODE, good.GOODSNAME,good.GOODSSPECIFICATION,gtp.GOODSTYPENAME ), ( gtp.GOODSTYPENAME) ,(SUBSTR(gtp.GOODSTYPECODE, 0, 6)),()) 
-    ),
 
-    产品明细缺陷 AS (
 
-    SELECT GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)),
 
-   CASE WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =5   THEN '小计'
 
-    WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =6   AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001001' THEN '大件合计'
 
-    WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =6   AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001002' THEN '小件合计'
 
-    WHEN  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6)) =7   THEN '总计'
 
-   ELSE to_char(good.GOODSCODE) END AS GOODSCODE,
 
-  GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME) AS GID,
 
-  good.GOODSNAME,
 
-  CASE WHEN GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6))=6 AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001001' THEN '大件' 
- WHEN GROUPING_ID(good.GOODSCODE,gtp.GOODSTYPENAME,SUBSTR(gtp.GOODSTYPECODE, 0, 6))=6 AND SUBSTR(gtp.GOODSTYPECODE, 0, 6)='001002' THEN '小件'
 
- ELSE TO_CHAR(gtp.GOODSTYPENAME )END GOODSTYPENAME,
 
-  SUBSTR(gtp.GOODSTYPECODE, 0, 6)  AS GOODSTYPECODE,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '01' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_坯脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '02' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_棕眼,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '03' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂底,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '04' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂圈,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '05' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂鼻子,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '06' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂水道,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '07' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂管,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '08' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_沾接裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '09' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂眼,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '10' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_糙活,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '12' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_变形,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '13' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_渣,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '14' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_管道渣,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '15' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_孔眼不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '16' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_堵眼,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '17' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_眼歪,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '18' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_丢气孔,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '19' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_丢眼,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '21' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_漏气,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '22' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_空泡,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '23' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_水封不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '24' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_漏水,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '25' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_卡球,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '26' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_冲刷不好,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '27' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_泥埂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '28' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_断浆迹,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '29' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_模迹,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '30' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_重皮,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '31' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_气泡,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '32' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_眼扁,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '33' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_水绺,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '34' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '35' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_活糙,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '001' ) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_贴码不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '002' ) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_干补不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '1' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_内漏不合格,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '2' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_外漏不合格,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '3' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_试水不合格,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '10' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_糙活,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '12' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_变形,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '13' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_渣,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '14' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_管道渣,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '15' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_孔眼不良,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '16' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_睹眼,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '17' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_眼歪,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '18' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_丢气孔,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '19' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_丢眼,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '23' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_水封不良,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '25' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_卡球,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (4,36,53) AND df.DEFECTCODE IN ( '35' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_打磨缺陷_活糙,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '01' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_坯脏,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '02' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_棕眼,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '03' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂底,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '04' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂圈,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '05' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂鼻子,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '06' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂水道,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '07' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂管,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '08' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_沾接裂,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '09' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂眼,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '10' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_糙活,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '28' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_断浆迹,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '34' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_裂,
 
-count( DISTINCT CASE WHEN PDs.PROCEDUREID IN (5,36,52) AND df.DEFECTCODE IN ( '35' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 精修缺陷_刷洗缺陷_活糙,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '36' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_滚釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '37' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉薄,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '38' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉不匀,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '39' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '40' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '41' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉沾,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '42' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_釉绺,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '43' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_针孔,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '44' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_施釉缺陷_色脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '47' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_灌釉不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '48' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_擦脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '49' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_崩标,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '50' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_倒标,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '51' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_标污,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '52' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_错标,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '53' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_丢标,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '54' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_标错位,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '55' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_未灌釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '56' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_灌磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '20' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_坯磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '57' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 施釉擦坯缺陷_擦坯缺陷_碱石,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '61' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_落脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '62' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装沾,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '63' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '64' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '65' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装走,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '66' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_装脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '67' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_缺釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '11' ) AND PD.PROCEDUREID IN (55,13,25) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_装窑缺陷_板折,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '69' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_水滴,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '70' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_窑脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '71' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_烧裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '43' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_针孔,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '73' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_风惊,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '74' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_烧生,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '75' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_串烟,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '76' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_烧坑,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '77' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_桔釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '78' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_过火,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '79' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_火燎,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '80' ) AND PD.PROCEDUREID IN (30,39,57)  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_烧窑缺陷_烧走,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '83' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_出窑缺陷_磕碰,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '84' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 烧成缺陷_出窑缺陷_划釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '86' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 原料缺陷_泥料缺陷_铜脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '87' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 原料缺陷_泥料缺陷_料脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '086' ) THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 原料缺陷_釉料缺陷_铜脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '88' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 原料缺陷_釉料缺陷_铁脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '91' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_修补不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '92' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_漏修,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '93' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_漏检,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '083' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_磕碰,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '084' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 冷修缺陷_划釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '091' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧修补缺陷_修补不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '092' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧修补缺陷_漏修,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '093' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧修补缺陷_漏检,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '96' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧修补缺陷_白点,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '061' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_落脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '062' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装沾,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '063' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装磕,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '064' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '065' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装走,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '066' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_装脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '067' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_缺釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '011' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_装窑缺陷_板折,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '069' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_水滴,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '070' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_窑脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '071' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_烧裂,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '43' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_针孔,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '073' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_风惊,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '074' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_烧生,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '075' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_串烟,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '076' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_烧坑,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '077' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_桔釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '078' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_过火,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '079' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_火燎,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '080' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_烧窑缺陷_烧走,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '0083')  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_出窑缺陷_磕碰,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '0084')  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 回烧缺陷_出窑缺陷_划釉,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '98' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 研磨缺陷_研磨不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '99' )   THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_隧道窑其他蹦脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '100' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 其他_隧道窑其他试验不良,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '099' )  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 成型半检缺陷_梭式窑其他蹦脏,
 
-count( DISTINCT CASE WHEN df.DEFECTCODE IN ( '0100')  THEN (pd.productiondataid || df.barcode ||  df.DEFECTCODE) ELSE NULL END ) AS 其他_梭式窑其他试验不良
 
-     FROM
 
-  TP_PM_DEFECT df   
-   LEFT JOIN (TMP_PM_PRODUCTIONDATA_CHECKDT) pd
 
-   ON (df.productiondataid  = pd.productiondataid or df.productiondataid  = pd.fproductiondataid)
 
-  LEFT JOIN TP_MST_GOODS good on good.GOODSID=PD.GOODSID
 
-  LEFT JOIN TP_MST_GOODSTYPE gtp ON good.GOODSTYPEID=gtp.GOODSTYPEID
 
-  LEFT JOIN TP_MST_DEFECT MDF ON DF.DEFECTID = MDF.DEFECTID  
-  INNER JOIN tp_pm_productiondata pds ON pds.barcode = pd.barcode  AND pds.valueflag = 1
 
-     WHERE
 
-  df.VALUEFLAG=1  AND DF.PROCEDUREID NOT IN " + notInproc;
 
-   sqlStr += @"    GROUP BY
 
-  Grouping sets ( ( good.GOODSCODE, good.GOODSNAME,gtp.GOODSTYPENAME ), ( gtp.GOODSTYPENAME) , ( gtp.GOODSTYPENAME) ,(SUBSTR(gtp.GOODSTYPECODE, 0, 6)),()    ) 
-  ),
 
-  检验数 AS (    SELECT
 
-GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX),
 
- CASE WHEN  GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX) =5   THEN '小计'
 
- WHEN  GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX) =6   THEN '合计'
 
- WHEN  GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX) =7   THEN '总计'
 
-       ELSE to_char(GOODSCODE) END AS GOODSCODE,
 
-CASE WHEN GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX)=6 AND GOODSTYPECODESIX='001001' THEN '大件' 
-  WHEN GROUPING_ID(GOODSCODE,GOODSTYPENAME,GOODSTYPECODESIX)=6 AND GOODSTYPECODESIX='001002' THEN '小件'
 
-   ELSE TO_CHAR(GOODSTYPENAME )END GOODSTYPENAME,GOODSNAME,
 
-SUM(检验量)检验量,SUM(合格量) 合格量,SUM(残品) 残品,
 
-     SUM(检验量*LUSTERWAREWEIGHT) 出窑重量,
 
-     SUM(合格量*LUSTERWAREWEIGHT) 合格品重量,
 
-     SUM(残品*LUSTERWAREWEIGHT) 残品重量
 
-FROM(
 
-SELECT distinct
 
-  pd.GOODSCODE,
 
-  SUBSTR(pd.GOODSTYPECODE, 0, 6) GOODSTYPECODESIX,
 
-  pd.GOODSNAME,
 
-  PD.GOODSTYPENAME,
 
-  COUNT(   pd.BARCODE ) AS 检验量,
 
-  COUNT(  CASE WHEN PD.GOODSLEVELTYPEID IN ( 4, 5 ) THEN BARCODE ELSE null END ) AS 合格量,
 
-  COUNT(  CASE WHEN PD.GOODSLEVELTYPEID  NOT IN ( 4, 5 ) THEN BARCODE ELSE null  END ) 残品,
 
-  LUSTERWAREWEIGHT
 
-     FROM (SELECT barcode
 
- ,goodscode
 
- ,goodsleveltypeid
 
- ,goodsname
 
- ,groutinguserid
 
- ,groutingusercode
 
- ,goodstypename
 
- ,goodstypecode
 
- ,lusterwareweight
 
- ,createtime 
-   FROM (SELECT DISTINCT pd.barcode
 
- ,good.goodscode
 
- ,good.goodsname
 
- ,pd.groutinguserid
 
- ,pd.groutingusercode
 
- ,gtp.goodstypecode
 
- ,nvl(pd61.goodsleveltypeid, pd.goodsleveltypeid) goodsleveltypeid
 
- ,pd.createtime
 
- ,gtp.goodstypename
 
- ,good.lusterwareweight
 
-     FROM (SELECT *
 
-  FROM (SELECT pd28.goodsname
 
-  ,pd28.groutingdailydetailid
 
-  ,pd28.goodsid
 
-  ,pd28.goodscode
 
-  ,pd28.goodsleveltypeid
 
-  ,pd28.groutinguserid
 
-  ,pd28.groutingusercode
 
-  ,pd28.createtime
 
-  ,pd24.procedureid
 
-  ,pd28.kilncarbatchno
 
-  ,pd28.barcode
 
-  ,pd28.productiondataid
 
-  ,row_number() over(PARTITION BY pd28.productiondataid ORDER BY pd24.productiondataid DESC) AS rownums
 
-    FROM tp_pm_productiondata pd28 
-   INNER JOIN tp_pm_productiondata pd24 
-ON pd24.groutingdailydetailid = pd28.groutingdailydetailid
 
-   WHERE pd28.procedureid = 28
 
-     AND pd28.valueflag = 1
 
-     AND pd24.valueflag = 1
 
-     AND pd24.procedureid IN (24, 42)   
-     AND pd28.checktime >= @DATEBEGIN@
 
-     AND pd28.checktime <=   @DATEEND@ 
-     AND (@USERCODE@ is null or @USERCODE@ = '' or instr( pd28.GROUTINGUSERCODE,@USERCODE@) > 0 )   
-     AND pd24.productiondataid < pd28.productiondataid) t
 
- WHERE rownums = 1
 
-   AND t.procedureid = 42) pd
 
-     LEFT JOIN tp_pm_productiondata pd61 
-       ON pd61.procedureid = 61
 
-      AND pd61.valueflag = 1
 
-      AND pd61.groutingdailydetailid = pd.groutingdailydetailid
 
-      AND pd61.kilncarbatchno = pd.kilncarbatchno
 
-      AND pd61.productiondataid > pd.productiondataid 
-      AND NOT EXISTS
 
-    (SELECT 1
 
-  FROM tp_pm_productiondata pd28c  
- WHERE pd28c.procedureid = 28
 
-   AND pd28c.valueflag = 1
 
-   AND pd28c.groutingdailydetailid = pd.groutingdailydetailid
 
-   AND pd28c.kilncarbatchno = pd.kilncarbatchno
 
-   AND pd28c.productiondataid > pd.productiondataid
 
-   AND pd28c.productiondataid < pd61.productiondataid)
 
-   
-     LEFT JOIN tp_mst_goods good
 
-       ON good.goodsid = pd.goodsid
 
-     LEFT JOIN tp_mst_goodstype gtp
 
-       ON gtp.goodstypeid = good.goodstypeid   
-   )) pd
 
-    GROUP BY pd.GOODSCODE,SUBSTR(pd.GOODSTYPECODE, 0, 6),pd.GOODSNAME,PD.GOODSTYPENAME,LUSTERWAREWEIGHT
 
-     
-)
 
- GROUP BY Grouping sets((GOODSCODE,GOODSNAME,GOODSTYPENAME,GOODSTYPECODESIX),(GOODSTYPENAME),(GOODSTYPECODESIX),())),
 
-  产品 AS (
 
-  SELECT TO_CHAR(GOODSCODE) AS GOODSCODE,GOODSNAME,GOODSSPECIFICATION,gtp.GOODSTYPENAME 
-    ,TP_MST_GOODS.LUSTERWAREWEIGHT
 
-  FROM TP_MST_GOODS
 
-  LEFT JOIN TP_MST_GOODSTYPE gtp ON TP_MST_GOODS.GOODSTYPEID=gtp.GOODSTYPEID
 
-   WHERE TP_MST_GOODS.VALUEFLAG=1
 
-  UNION ALL
 
-  SELECT '总计' AS GOODSCODE,null,NULL ,NULL,null  FROM dual
 
-    
-  ),
 
-打磨擦洗出窑数 AS (
 
-  SELECT  COUNT(DISTINCT CASE WHEN pds.PROCEDUREID IN (4,36,53) THEN PD.productiondataid ELSE NULL END ) 打磨,
 
-      COUNT(DISTINCT CASE WHEN pds.PROCEDUREID IN (5,36,52) THEN PD.productiondataid ELSE NULL END ) 擦洗,
 
-      COUNT(DISTINCT CASE WHEN pds.PROCEDUREID =@kilproc@ THEN PD.productiondataid ELSE NULL END ) 质量登记
 
-   FROM (SELECT *
 
-  FROM (SELECT pd28.goodsname
 
-   ,pd28.groutingdailydetailid
 
-   ,pd28.goodsid
 
-   ,pd28.goodscode
 
-   ,pd28.goodsleveltypeid
 
-   ,pd28.groutinguserid
 
-   ,pd28.groutingusercode
 
-   ,pd28.createtime
 
-   ,pd24.procedureid
 
-   ,pd28.kilncarbatchno
 
-   ,pd28.barcode
 
-   ,pd28.productiondataid
 
-   ,pd28.valueflag
 
-   ,row_number() over(PARTITION BY pd28.productiondataid ORDER BY pd24.productiondataid DESC) AS rownums
 
-   FROM tp_pm_productiondata pd28 
-  INNER JOIN tp_pm_productiondata pd24 
- ON pd24.groutingdailydetailid = pd28.groutingdailydetailid
 
-  WHERE pd28.procedureid = 28
 
-    AND pd28.valueflag = 1
 
-    AND pd24.valueflag = 1
 
-    AND pd24.procedureid IN (24, 42)   
-    AND pd28.checktime >= @DATEBEGIN@
 
-    AND pd28.checktime <=   @DATEEND@ 
-    AND (@USERCODE@ is null or @USERCODE@ = '' or instr( pd28.GROUTINGUSERCODE,@USERCODE@) > 0 )
 
-    AND pd24.productiondataid < pd28.productiondataid) t
 
- WHERE rownums = 1
 
-   AND t.procedureid = 42) pd 
-   INNER JOIN TP_PM_PRODUCTIONDATA pds ON pds.BARCODE=PD.BARCODE   AND pds.valueflag = 1  )
 
- SELECT * FROM (
 
-  SELECT
 
-  to_CHAR(检验数.GOODSCODE) AS  产品编码,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.GOODSNAME) ELSE NULL END 产品名称,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(产品.GOODSSPECIFICATION) ELSE NULL END 产品规格,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.GOODSTYPENAME) ELSE NULL END 产品类别,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(产品.LUSTERWAREWEIGHT) ELSE NULL END 单重,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.检验量) ELSE NULL END 检验量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.出窑重量) ELSE NULL END 出窑重量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.合格量) ELSE NULL END 合格量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.合格品重量) ELSE NULL END 合格品重量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.残品) ELSE NULL END 残品,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN to_CHAR(检验数.残品重量) ELSE NULL END 残品重量,
 
-  CASE WHEN 检验数.GOODSCODE <> '总计' THEN DECODE( NVL( 检验数.合格量, 0 ), 0, '0%', TO_CHAR( ( NVL( 检验数.合格量, 0 ) / DECODE( NVL( 检验数.检验量, 1 ), 0, 1, NVL( 检验数.检验量, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) ELSE NULL END AS 合格率,
 
-  to_char(nvl(s.成型半检缺陷_坯脏,0)) AS 成型半检缺陷__坯脏,
 
-  to_char(nvl(s.成型半检缺陷_棕眼,0)) AS 成型半检缺陷__棕眼,
 
-  to_char(nvl(s.成型半检缺陷_裂底,0)) AS 成型半检缺陷__裂底,
 
-  to_char(nvl(s.成型半检缺陷_裂圈,0)) AS 成型半检缺陷__裂圈,
 
-  to_char(nvl(s.成型半检缺陷_裂鼻子,0)) AS 成型半检缺陷__裂鼻子,
 
-  to_char(nvl(s.成型半检缺陷_裂水道,0)) AS 成型半检缺陷__裂水道,
 
-  to_char(nvl(s.成型半检缺陷_裂管,0)) AS 成型半检缺陷__裂管,
 
-  to_char(nvl(s.成型半检缺陷_沾接裂,0)) AS 成型半检缺陷__沾接裂,
 
-  to_char(nvl(s.成型半检缺陷_裂眼,0)) AS 成型半检缺陷__裂眼,
 
-  to_char(nvl(s.成型半检缺陷_糙活,0)) AS 成型半检缺陷__糙活,
 
-  to_char(nvl(s.成型半检缺陷_变形,0)) AS 成型半检缺陷__变形,
 
-  to_char(nvl(s.成型半检缺陷_渣,0)) AS 成型半检缺陷__渣,
 
-  to_char(nvl(s.成型半检缺陷_管道渣,0)) AS 成型半检缺陷__管道渣,
 
-  to_char(nvl(s.成型半检缺陷_孔眼不良,0)) AS 成型半检缺陷__孔眼不良,
 
-  to_char(nvl(s.成型半检缺陷_堵眼,0)) AS 成型半检缺陷__堵眼,
 
-  to_char(nvl(s.成型半检缺陷_眼歪,0)) AS 成型半检缺陷__眼歪,
 
-  to_char(nvl(s.成型半检缺陷_丢气孔,0)) AS 成型半检缺陷__丢气孔,
 
-  to_char(nvl(s.成型半检缺陷_丢眼,0)) AS 成型半检缺陷__丢眼,
 
-  to_char(nvl(s.成型半检缺陷_漏气,0)) AS 成型半检缺陷__漏气,
 
-  to_char(nvl(s.成型半检缺陷_空泡,0)) AS 成型半检缺陷__空泡,
 
-  to_char(nvl(s.成型半检缺陷_水封不良,0)) AS 成型半检缺陷__水封不良,
 
-  to_char(nvl(s.成型半检缺陷_漏水,0)) AS 成型半检缺陷__漏水,
 
-  to_char(nvl(s.成型半检缺陷_卡球,0)) AS 成型半检缺陷__卡球,
 
-  to_char(nvl(s.成型半检缺陷_冲刷不好,0)) AS 成型半检缺陷__冲刷不好,
 
-  to_char(nvl(s.成型半检缺陷_泥埂,0)) AS 成型半检缺陷__泥埂,
 
-  to_char(nvl(s.成型半检缺陷_断浆迹,0)) AS 成型半检缺陷__断浆迹,
 
-  to_char(nvl(s.成型半检缺陷_模迹,0)) AS 成型半检缺陷__模迹,
 
-  to_char(nvl(s.成型半检缺陷_重皮,0)) AS 成型半检缺陷__重皮,
 
-  to_char(nvl(s.成型半检缺陷_气泡,0)) AS 成型半检缺陷__气泡,
 
-  to_char(nvl(s.成型半检缺陷_眼扁,0)) AS 成型半检缺陷__眼扁,
 
-  to_char(nvl(s.成型半检缺陷_水绺,0)) AS 成型半检缺陷__水绺,
 
-  to_char(nvl(s.成型半检缺陷_裂,0)) AS 成型半检缺陷__裂,
 
-  to_char(nvl(s.成型半检缺陷_活糙,0)) AS 成型半检缺陷__活糙,
 
-  to_char(nvl(s.成型半检缺陷_贴码不良,0)) AS 成型半检缺陷__贴码不良,
 
-  to_char(nvl(s.成型半检缺陷_干补不良,0)) AS 成型半检缺陷__干补不良,
 
-  to_char(nvl(s.成型半检缺陷_内漏不合格,0)) AS 成型半检缺陷__内漏不合格,
 
-  to_char(nvl(s.成型半检缺陷_外漏不合格,0)) AS 成型半检缺陷__外漏不合格,
 
-  to_char(nvl(s.成型半检缺陷_试水不合格,0)) AS 成型半检缺陷__试水不合格,
 
-  to_char(nvl(s.成型半检缺陷_隧道窑其他蹦脏,0)) AS 成型半检缺陷__蹦脏,
 
-  nvl(f.成型半检缺陷__缺陷汇总,0) AS 成型半检缺陷__缺陷汇总,
 
-  DECODE( NVL( f.成型半检缺陷__缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.成型半检缺陷__缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 成型半检缺陷__缺陷率,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_糙活,0)) AS 精修缺陷_打磨缺陷_糙活,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_变形,0)) AS 精修缺陷_打磨缺陷_变形,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_渣,0)) AS 精修缺陷_打磨缺陷_渣,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_管道渣,0)) AS 精修缺陷_打磨缺陷_管道渣,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_孔眼不良,0)) AS 精修缺陷_打磨缺陷_孔眼不良,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_睹眼,0)) AS 精修缺陷_打磨缺陷_睹眼,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_眼歪,0)) AS 精修缺陷_打磨缺陷_眼歪,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_丢气孔,0)) AS 精修缺陷_打磨缺陷_丢气孔,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_丢眼,0)) AS 精修缺陷_打磨缺陷_丢眼,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_水封不良,0)) AS 精修缺陷_打磨缺陷_水封不良,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_卡球,0)) AS 精修缺陷_打磨缺陷_卡球,
 
-  to_char(nvl(s.精修缺陷_打磨缺陷_活糙,0)) AS 精修缺陷_打磨缺陷_活糙,
 
-  nvl(f.精修缺陷_打磨缺陷_缺陷汇总,0) AS 精修缺陷_打磨缺陷_缺陷汇总,
 
-  DECODE( NVL( f.精修缺陷_打磨缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.精修缺陷_打磨缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 精修缺陷_打磨缺陷_缺陷率,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_坯脏,0)) AS 精修缺陷_刷洗缺陷_坯脏,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_棕眼,0)) AS 精修缺陷_刷洗缺陷_棕眼,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂底,0)) AS 精修缺陷_刷洗缺陷_裂底,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂圈,0)) AS 精修缺陷_刷洗缺陷_裂圈,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂鼻子,0)) AS 精修缺陷_刷洗缺陷_裂鼻子,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂水道,0)) AS 精修缺陷_刷洗缺陷_裂水道,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂管,0)) AS 精修缺陷_刷洗缺陷_裂管,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_沾接裂,0)) AS 精修缺陷_刷洗缺陷_沾接裂,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂眼,0)) AS 精修缺陷_刷洗缺陷_裂眼,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_糙活,0)) AS 精修缺陷_刷洗缺陷_糙活,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_断浆迹,0)) AS 精修缺陷_刷洗缺陷_断浆迹,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_裂,0)) AS 精修缺陷_刷洗缺陷_裂,
 
-  to_char(nvl(s.精修缺陷_刷洗缺陷_活糙,0)) AS 精修缺陷_刷洗缺陷_活糙,
 
-  nvl(f.精修缺陷_刷洗缺陷_缺陷汇总,0) AS 精修缺陷_刷洗缺陷_缺陷汇总,
 
-  DECODE( NVL( f.精修缺陷_刷洗缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.精修缺陷_刷洗缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL(打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 精修缺陷_刷洗缺陷_缺陷率,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_滚釉,0)) AS 施釉擦坯缺陷_施釉缺陷_滚釉,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉薄,0)) AS 施釉擦坯缺陷_施釉缺陷_釉薄,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉不匀,0)) AS 施釉擦坯缺陷_施釉缺陷_釉不匀,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉磕,0)) AS 施釉擦坯缺陷_施釉缺陷_釉磕,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉脏,0)) AS 施釉擦坯缺陷_施釉缺陷_釉脏,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉沾,0)) AS 施釉擦坯缺陷_施釉缺陷_釉沾,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_釉绺,0)) AS 施釉擦坯缺陷_施釉缺陷_釉绺,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_针孔,0)) AS 施釉擦坯缺陷_施釉缺陷_针孔,
 
-  to_char(nvl(s.施釉擦坯缺陷_施釉缺陷_色脏,0)) AS 施釉擦坯缺陷_施釉缺陷_色脏,
 
-  nvl(f.施釉擦坯缺陷_施釉缺陷_缺陷汇总,0) AS 施釉擦坯缺陷_施釉缺陷_缺陷汇总,
 
-  DECODE( NVL( f.施釉擦坯缺陷_施釉缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.施釉擦坯缺陷_施釉缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 施釉擦坯缺陷_施釉缺陷_缺陷率,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_灌釉不良,0)) AS 施釉擦坯缺陷_擦坯缺陷_灌釉不良,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_擦脏,0)) AS 施釉擦坯缺陷_擦坯缺陷_擦脏,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_崩标,0)) AS 施釉擦坯缺陷_擦坯缺陷_崩标,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_倒标,0)) AS 施釉擦坯缺陷_擦坯缺陷_倒标,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_标污,0)) AS 施釉擦坯缺陷_擦坯缺陷_标污,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_错标,0)) AS 施釉擦坯缺陷_擦坯缺陷_错标,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_丢标,0)) AS 施釉擦坯缺陷_擦坯缺陷_丢标,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_标错位,0)) AS 施釉擦坯缺陷_擦坯缺陷_标错位,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_未灌釉,0)) AS 施釉擦坯缺陷_擦坯缺陷_未灌釉,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_灌磕,0)) AS 施釉擦坯缺陷_擦坯缺陷_灌磕,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_坯磕,0)) AS 施釉擦坯缺陷_擦坯缺陷_坯磕,
 
-     to_char(nvl(s.施釉擦坯缺陷_擦坯缺陷_碱石,0)) AS 施釉擦坯缺陷_擦坯缺陷_碱石,
 
-  nvl(f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总,0) AS 施釉擦坯缺陷_擦坯缺陷_缺陷汇总,
 
-  DECODE( NVL( f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 施釉擦坯缺陷_擦坯缺陷_缺陷率,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_落脏,0)) AS 烧成缺陷_装窑缺陷_落脏,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_装沾,0)) AS 烧成缺陷_装窑缺陷_装沾,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_装磕,0)) AS 烧成缺陷_装窑缺陷_装磕,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_装裂,0)) AS 烧成缺陷_装窑缺陷_装裂,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_装走,0)) AS 烧成缺陷_装窑缺陷_装走,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_装脏,0)) AS 烧成缺陷_装窑缺陷_装脏,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_缺釉,0)) AS 烧成缺陷_装窑缺陷_缺釉,
 
-  to_char(nvl(s.烧成缺陷_装窑缺陷_板折,0)) AS 烧成缺陷_装窑缺陷_板折,
 
-  nvl(f.烧成缺陷_装窑缺陷_缺陷汇总,0) AS 烧成缺陷_装窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.烧成缺陷_装窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.烧成缺陷_装窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 烧成缺陷_装窑缺陷_缺陷率,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_水滴,0)) AS 烧成缺陷_烧窑缺陷_水滴,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_窑脏,0)) AS 烧成缺陷_烧窑缺陷_窑脏,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_烧裂,0)) AS 烧成缺陷_烧窑缺陷_烧裂,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_针孔,0)) AS 烧成缺陷_烧窑缺陷_针孔,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_风惊,0)) AS 烧成缺陷_烧窑缺陷_风惊,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_烧生,0)) AS 烧成缺陷_烧窑缺陷_烧生,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_串烟,0)) AS 烧成缺陷_烧窑缺陷_串烟,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_烧坑,0)) AS 烧成缺陷_烧窑缺陷_烧坑,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_桔釉,0)) AS 烧成缺陷_烧窑缺陷_桔釉,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_过火,0)) AS 烧成缺陷_烧窑缺陷_过火,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_火燎,0)) AS 烧成缺陷_烧窑缺陷_火燎,
 
-  to_char(nvl(s.烧成缺陷_烧窑缺陷_烧走,0)) AS 烧成缺陷_烧窑缺陷_烧走,
 
-  nvl(f.烧成缺陷_烧窑缺陷_缺陷汇总,0)AS 烧成缺陷_烧窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.烧成缺陷_烧窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.烧成缺陷_烧窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 烧成缺陷_烧窑缺陷_缺陷率,
 
-  TO_CHAR(nvl(s.烧成缺陷_出窑缺陷_磕碰,0))AS 烧成缺陷_出窑缺陷_磕碰,
 
-  TO_CHAR(nvl(s.烧成缺陷_出窑缺陷_划釉,0))AS 烧成缺陷_出窑缺陷_划釉,
 
-  nvl(f.烧成缺陷_出窑缺陷_缺陷汇总,0) AS 烧成缺陷_出窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.烧成缺陷_出窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.烧成缺陷_出窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 烧成缺陷_出窑缺陷_缺陷率,
 
-  TO_CHAR(nvl(s.冷修缺陷_修补不良,0)) AS 冷修_冷修缺陷_修补不良,
 
-  TO_CHAR(nvl(s.冷修缺陷_漏修,0)) AS 冷修_冷修缺陷_漏修,
 
-  TO_CHAR(nvl(s.冷修缺陷_漏检,0)) AS 冷修_冷修缺陷_漏检,
 
-  TO_CHAR(nvl(s.冷修缺陷_磕碰,0)) AS 冷修_冷修缺陷_磕碰,
 
-  TO_CHAR(nvl(s.冷修缺陷_划釉,0)) AS 冷修_冷修缺陷_划釉,
 
-  nvl(f.冷修_缺陷汇总,0) AS 冷修_冷修缺陷_缺陷汇总,
 
-  DECODE( NVL( f.冷修_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.冷修_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 冷修_冷修缺陷_缺陷率,
 
-  TO_CHAR(nvl(s.原料缺陷_泥料缺陷_铜脏,0)) AS 原料缺陷_泥料缺陷_铜脏,
 
-  TO_CHAR(nvl(s.原料缺陷_泥料缺陷_料脏,0)) AS 原料缺陷_泥料缺陷_料脏,
 
-  TO_CHAR(nvl(s.原料缺陷_釉料缺陷_铜脏,0)) AS 原料缺陷_釉料缺陷_铜脏, 
-  TO_CHAR(nvl(s.原料缺陷_釉料缺陷_铁脏,0)) AS 原料缺陷_釉料缺陷_铁脏,
 
-  nvl(f.原料缺陷_缺陷汇总,0) AS 原料缺陷__缺陷汇总,
 
-  DECODE( NVL( f.原料缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.原料缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 原料缺陷__缺陷率,
 
-  to_char(nvl(s.其他_隧道窑其他试验不良,0)) AS 其他_隧道窑其他_试验不良,
 
-  nvl(f.其他_缺陷汇总,0) AS 其他_隧道窑其他_缺陷汇总,
 
-  DECODE( NVL( f.其他_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.其他_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 其他_隧道窑其他_缺陷率
 
-  FROM 检验数
 
-  LEFT JOIN 产品 ON 检验数.GOODSCODE=产品.GOODSCODE
 
-  LEFT JOIN  产品明细缺陷  s ON 产品.GOODSCODE=s.GOODSCODE
 
-  LEFT JOIN 产品汇总缺陷 f ON f.GOODSCODE=产品.GOODSCODE 
-  LEFT JOIN  打磨擦洗出窑数  ON 1=1
 
-    UNION ALL
 
-  SELECT
 
-  to_Char(检验数.GOODSCODE),
 
-  to_Char(检验数.GOODSNAME),
 
-  to_Char(产品.GOODSSPECIFICATION),
 
-  to_Char(产品.GOODSTYPENAME),
 
-  to_Char(产品.LUSTERWAREWEIGHT),
 
-  to_Char(检验数.检验量),to_Char(检验数.出窑重量),
 
-  to_Char(检验数.合格量),
 
-  to_Char(检验数.合格品重量),
 
-  to_Char(检验数.残品),
 
-  to_Char(检验数.残品重量),
 
-  DECODE( NVL( 检验数.合格量, 0 ), 0, '0%', TO_CHAR( ( NVL( 检验数.合格量, 0 ) / DECODE( NVL( 检验数.检验量, 1 ), 0, 1, NVL(检验数.检验量, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 合格率,
 
-  DECODE( NVL( s.成型半检缺陷_坯脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_坯脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_棕眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_棕眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂底, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂底, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂圈, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂圈, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂鼻子, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂鼻子, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂水道, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂水道, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂管, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂管, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_沾接裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_沾接裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_糙活, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_糙活, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_变形, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_变形, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_渣, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_渣, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_管道渣, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_管道渣, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_孔眼不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_孔眼不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_堵眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_堵眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_眼歪, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_眼歪, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_丢气孔, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_丢气孔, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_丢眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_丢眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_漏气, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_漏气, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_空泡, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_空泡, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_水封不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_水封不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_漏水, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_漏水, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_卡球, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_卡球, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_冲刷不好, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_冲刷不好, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_泥埂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_泥埂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_断浆迹, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_断浆迹, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_模迹, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_模迹, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_重皮, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_重皮, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_气泡, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_气泡, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_眼扁, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_眼扁, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_水绺, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_水绺, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_活糙, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_活糙, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_贴码不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_贴码不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_干补不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_干补不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_内漏不合格, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_内漏不合格, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_外漏不合格, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_外漏不合格, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_试水不合格, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_试水不合格, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.成型半检缺陷_隧道窑其他蹦脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.成型半检缺陷_隧道窑其他蹦脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.成型半检缺陷__缺陷汇总,
 
-  DECODE( NVL( f.成型半检缺陷__缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.成型半检缺陷__缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 成型半检缺陷__缺陷率,
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_糙活, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_糙活, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_变形, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_变形, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_渣, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_渣, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_管道渣, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_管道渣, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_孔眼不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_孔眼不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_睹眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_睹眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_眼歪, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_眼歪, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_丢气孔, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_丢气孔, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_丢眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_丢眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_水封不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_水封不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_卡球, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_卡球, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_打磨缺陷_活糙, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_打磨缺陷_活糙, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.精修缺陷_打磨缺陷_缺陷汇总,
 
-  DECODE( NVL( f.精修缺陷_打磨缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.精修缺陷_打磨缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.打磨, 1 ), 0, 1, NVL( 打磨擦洗出窑数.打磨, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 精修缺陷_打磨缺陷_缺陷率,
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_坯脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_坯脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_棕眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_棕眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂底, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂底, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂圈, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂圈, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂鼻子, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂鼻子, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂水道, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂水道, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂管, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂管, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_沾接裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_沾接裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂眼, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂眼, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_糙活, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_糙活, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_断浆迹, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_断浆迹, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.精修缺陷_刷洗缺陷_活糙, 0 ), 0, '0%', TO_CHAR( ( NVL( s.精修缺陷_刷洗缺陷_活糙, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.精修缺陷_刷洗缺陷_缺陷汇总,
 
-  DECODE( NVL( f.精修缺陷_刷洗缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.精修缺陷_刷洗缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.擦洗, 1 ), 0, 1, NVL( 打磨擦洗出窑数.擦洗, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 精修缺陷_刷洗缺陷_缺陷率,
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_滚釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_滚釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉薄, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉薄, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉不匀, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉不匀, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉磕, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉磕, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉沾, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉沾, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_釉绺, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_釉绺, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_针孔, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_针孔, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_施釉缺陷_色脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_施釉缺陷_色脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-    f.施釉擦坯缺陷_施釉缺陷_缺陷汇总,
 
-  DECODE( NVL( f.施釉擦坯缺陷_施釉缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.施釉擦坯缺陷_施釉缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 施釉擦坯缺陷_施釉缺陷_缺陷率,
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_灌釉不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_灌釉不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_擦脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_擦脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_崩标, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_崩标, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_倒标, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_倒标, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_标污, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_标污, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_错标, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_错标, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_丢标, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_丢标, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_标错位, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_标错位, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_未灌釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_未灌釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_灌磕, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_灌磕, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_坯磕, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_坯磕, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.施釉擦坯缺陷_擦坯缺陷_碱石, 0 ), 0, '0%', TO_CHAR( ( NVL( s.施釉擦坯缺陷_擦坯缺陷_碱石, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-    f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总,
 
-  DECODE( NVL( f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.施釉擦坯缺陷_擦坯缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 施釉擦坯缺陷_擦坯缺陷_缺陷率,
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_落脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_落脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_装沾, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_装沾, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_装磕, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_装磕, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_装裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_装裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_装走, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_装走, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_装脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_装脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_缺釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_缺釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_装窑缺陷_板折, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_装窑缺陷_板折, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.烧成缺陷_装窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.烧成缺陷_装窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.烧成缺陷_装窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 烧成缺陷_装窑缺陷_缺陷率,
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_水滴, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_水滴, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_窑脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_窑脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_烧裂, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_烧裂, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_针孔, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_针孔, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_风惊, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_风惊, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_烧生, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_烧生, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_串烟, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_串烟, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_烧坑, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_烧坑, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_桔釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_桔釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_过火, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_过火, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_火燎, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_火燎, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_烧窑缺陷_烧走, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_烧窑缺陷_烧走, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.烧成缺陷_烧窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.烧成缺陷_烧窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.烧成缺陷_烧窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 烧成缺陷_烧窑缺陷_缺陷率,
 
-DECODE( NVL( s.烧成缺陷_出窑缺陷_磕碰, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_出窑缺陷_磕碰, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.烧成缺陷_出窑缺陷_划釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.烧成缺陷_出窑缺陷_划釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.烧成缺陷_出窑缺陷_缺陷汇总,
 
-  DECODE( NVL( f.烧成缺陷_出窑缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.烧成缺陷_出窑缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 烧成缺陷_出窑缺陷_缺陷率,
 
-DECODE( NVL( s.冷修缺陷_修补不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.冷修缺陷_修补不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
- DECODE( NVL( s.冷修缺陷_漏修, 0 ), 0, '0%', TO_CHAR( ( NVL( s.冷修缺陷_漏修, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.冷修缺陷_漏检, 0 ), 0, '0%', TO_CHAR( ( NVL( s.冷修缺陷_漏检, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.冷修缺陷_磕碰, 0 ), 0, '0%', TO_CHAR( ( NVL( s.冷修缺陷_磕碰, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.冷修缺陷_划釉, 0 ), 0, '0%', TO_CHAR( ( NVL( s.冷修缺陷_划釉, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.冷修_缺陷汇总 AS 冷修_冷修缺陷_缺陷汇总,
 
-  DECODE( NVL( f.冷修_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.冷修_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 冷修_冷修缺陷_缺陷率,
 
-DECODE( NVL( s.原料缺陷_泥料缺陷_铜脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.原料缺陷_泥料缺陷_铜脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.原料缺陷_泥料缺陷_料脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.原料缺陷_泥料缺陷_料脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.原料缺陷_釉料缺陷_铜脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.原料缺陷_釉料缺陷_铜脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-DECODE( NVL( s.原料缺陷_釉料缺陷_铁脏, 0 ), 0, '0%', TO_CHAR( ( NVL( s.原料缺陷_釉料缺陷_铁脏, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-f.原料缺陷_缺陷汇总 AS 原料缺陷__缺陷汇总,
 
-  DECODE( NVL( f.原料缺陷_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.原料缺陷_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 原料缺陷__缺陷率,
 
-DECODE( NVL( s.其他_隧道窑其他试验不良, 0 ), 0, '0%', TO_CHAR( ( NVL( s.其他_隧道窑其他试验不良, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ),
 
-    f.其他_缺陷汇总 AS 其他_缺陷汇总,
 
-  DECODE( NVL( f.其他_缺陷汇总, 0 ), 0, '0%', TO_CHAR( ( NVL( f.其他_缺陷汇总, 0 ) / DECODE( NVL( 打磨擦洗出窑数.质量登记, 1 ), 0, 1, NVL( 打磨擦洗出窑数.质量登记, 1 ) ) ) * 100, 'fm99990.00' ) || '%' ) AS 其他_缺陷率
 
-     FROM 检验数
 
-  LEFT JOIN 产品 ON 检验数.GOODSCODE=产品.GOODSCODE
 
-  LEFT JOIN  产品明细缺陷  s ON 产品.GOODSCODE=s.GOODSCODE
 
-  LEFT JOIN 产品汇总缺陷 f ON f.GOODSCODE=产品.GOODSCODE 
-  LEFT JOIN  打磨擦洗出窑数  ON 1=1
 
-  WHERE 检验数.GOODSCODE='总计'
 
- UNION ALL SELECT
 
-  '工序出窑量' AS  产品编码,
 
-  '' 产品名称,
 
-  '' 产品规格,
 
-  ''产品类别,
 
-  '' 重量,
 
-  '' 检验量,'',
 
-  '' 合格量,'',
 
-  '' 残品,'',
 
-  '' 合格率,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__坯脏,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__棕眼,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂底,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂圈,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂鼻子,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂水道,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂管,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__沾接裂,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__裂眼,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__糙活,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__变形,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__渣,
 
-  to_Char(检验数.检验量)  AS 成型半检缺陷__管道渣,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__孔眼不良,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__堵眼,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__眼歪,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__丢气孔,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__丢眼,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__漏气,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__空泡,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__水封不良,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__漏水,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__卡球,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__冲刷不好,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__泥埂,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__断浆迹,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__模迹,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__重皮,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__气泡,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__眼扁,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__水绺,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__裂,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__活糙,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__贴码不良,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__干补不良,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__内漏不合格,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__外漏不合格,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__试水不合格,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷_蹦脏,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__缺陷汇总,
 
-  to_char(检验数.检验量)  AS 成型半检缺陷__缺陷率,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_糙活,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_变形,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_渣,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_管道渣,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_孔眼不良,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_睹眼,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_眼歪,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_丢气孔,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_丢眼,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_水封不良,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_卡球,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_活糙,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_缺陷汇总,
 
-  to_char(打磨擦洗出窑数.打磨) AS 精修缺陷_打磨缺陷_缺陷率,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_坯脏,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_棕眼,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂底,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂圈,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂鼻子,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂水道,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂管,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_沾接裂,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂眼,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_糙活,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_断浆迹,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_裂,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_活糙,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_缺陷汇总,
 
-  to_char(打磨擦洗出窑数.擦洗) AS 精修缺陷_刷洗缺陷_缺陷率,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_滚釉,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉薄,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉不匀,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉磕,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉脏,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉沾,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_釉绺,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_针孔,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_色脏,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_缺陷汇总,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_施釉缺陷_缺陷率,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_灌釉不良,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_擦脏,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_崩标,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_倒标,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_标污,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_错标,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_丢标,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_标错位,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_未灌釉,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_灌磕,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_坯磕,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_碱石,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_缺陷汇总,
 
-  TO_CHAR(检验数.检验量)  AS 施釉擦坯缺陷_擦坯缺陷_缺陷率,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_落脏,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_装沾,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_装磕,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_装裂,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_装走,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_装脏,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_缺釉,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_板折,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_缺陷汇总,
 
-  TO_CHAR(检验数.检验量)  AS 烧成缺陷_装窑缺陷_缺陷率,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_水滴,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_窑脏,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_烧裂,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_针孔,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_风惊,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_烧生,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_串烟,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_烧坑,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_桔釉,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_过火,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_火燎,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_烧走,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_缺陷汇总,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_烧窑缺陷_缺陷率,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_出窑缺陷_磕碰,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_出窑缺陷_划釉,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_出窑缺陷_缺陷汇总,
 
-  to_char(检验数.检验量)  AS 烧成缺陷_出窑缺陷_缺陷率,
 
-  to_char(检验数.检验量)  AS 冷修_冷修缺陷_修补不良,
 
-  to_char(检验数.检验量)  AS 冷修_冷修缺陷_漏修,
 
-  to_char(检验数.检验量)  AS 冷修_冷修缺陷_漏检, 
-  to_char(检验数.检验量)  AS 冷修_冷修缺陷_磕碰,
 
-  to_char(检验数.检验量)  AS 冷修_冷修缺陷_划釉,
 
-  to_char(检验数.检验量)  AS 冷修_冷修缺陷_缺陷汇总,
 
-  to_char(检验数.检验量)  AS 冷修_冷修缺陷_缺陷率,
 
-  to_char(检验数.检验量)  AS 原料缺陷_泥料缺陷_铜脏,
 
-  to_char(检验数.检验量)  AS 原料缺陷_泥料缺陷_料脏,
 
-  to_char(检验数.检验量)  AS 原料缺陷_釉料缺陷_铜脏, 
-  to_char(检验数.检验量)  AS 原料缺陷_釉料缺陷_铁脏,
 
-  to_char(检验数.检验量)  AS 原料缺陷__缺陷汇总,
 
-  to_char(检验数.检验量)  AS 原料缺陷__缺陷率,
 
-  to_char(检验数.检验量)  AS 其他_隧道窑其他_试验不良,
 
-  to_char(检验数.检验量)  AS 其他__缺陷汇总,
 
-  to_char(检验数.检验量)  AS 其他__缺陷率
 
-  FROM 检验数 
-  LEFT JOIN  打磨擦洗出窑数  ON 1=1
 
-  WHERE 检验数.GOODSCODE='总计'
 
-
 
-)
 
-ORDER BY 产品类别,产品编码";
 
-     }
 
- }
 
-     //获取查询条件
 
-     List<CDAParameter> sqlPara = new List<CDAParameter>();
 
-     sqlPara.Add(new CDAParameter("DATEBEGIN", dateBegin, DataType.DateTime));
 
-     sqlPara.Add(new CDAParameter("DATEEND", dateEnd, DataType.DateTime));
 
-     // sqlPara.Add(new CDAParameter("GOODSNAME", context.Request["goodsid"], DataType.VarChar));
 
-
 
-     sqlPara.Add(new CDAParameter("kilproc", Convert.ToInt32(kilproc), DataType.Int32));
 
-     sqlPara.Add(new CDAParameter("notInproc",notInproc, DataType.Char));
 
-     sqlPara.Add(new CDAParameter("FunctionalTesting", Convert.ToInt32(FunctionalTesting), DataType.Int32));
 
-     sqlPara.Add(new CDAParameter("USERCODE", userCode));
 
-     //sqlPara.Add(new CDAParameter("PROCEDUREID", context.Request["procedureidMaster"]));
 
-     ////获取分页参数
 
-     int page = HttpContext.Current.Request["page"] is object ? Convert.ToInt32(HttpContext.Current.Request["page"]) : 1;
 
-     int rows = HttpContext.Current.Request["rows"] is int ? Convert.ToInt32(HttpContext.Current.Request["rows"]) : 10000;
 
-     string sort = HttpContext.Current.Request["sort"] is object ? HttpContext.Current.Request["sort"] : "m.REPORTCODE";
 
-     string order = HttpContext.Current.Request["order"] is object ? HttpContext.Current.Request["order"] : "";
 
-     // sqlStr = sqlStr.Replace("\t", " ");
 
-     //获取分页数据    
-     int total = 0;  
-     DataTable dt = conn.SelectPages(page, rows, out total, sqlStr, sqlPara.ToArray());
 
-     //DataTable dt = conn.ExecuteDatatable(sqlStr, sqlPara.ToArray());
 
-     // total = dt.Rows.Count;
 
-                 
-     string jsonStr = new JsonResult(dt) { total = total }.ToJson();
 
-     conn.Commit();
 
-
 
-     context.Response.Write(jsonStr);
 
-
 
- }
 
+        }
 
 
     }
 
 
     public bool IsReusable
 
     {
 
- get
 
- {
 
-     return false;
 
- }
 
+        get
 
+        {
 
+            return false;
 
+        }
 
     }
 
 
 }