Question

问题是这样的。如果我在任何位置都有数量，则要对该job_no的每个成员执行以下计算。

这个想法是，如果loc3中有一个数量，那么以前在loc1和loc2中有相同的数量。

那么，如何在loc1和loc2中获得10可能是放置它的另一种方法？？

select s.job_no, s.part, s.location, s.qty, 
    coalesce(ptime.setup_time, '-') as setup_time, 
    coalesce(ptime.cycle_time, '-') as cycle_time,
    ci.rate
    from stock as s join part_timings as pt
    on pt.part = s.part
    join locations as l on s.location = l.location
    left join part_timings as ptime on s.part = ptime.part
    and ptime.location = s.location
    join costs_internal as ci
    group by s.part, s.location
    order by s.part, l.stage



job_no | part | location | qty | setup_time | cycle_time | rate | total
123      p1     loc1       0     60           30           0.5    ?
123      p1     loc2       0     30           15           0.5    ?
123      p1     loc3       10    60           15           0.5    ?
123      p1     loc4       0     60           15           0.5    ?
123      p1     loc5       0     60           15           0.5    ?
123      p1     loc6       0     60           15           0.5    ?
123      p1     loc7       20    60           15           0.5    ?

计算得出总计：

coalesce(round((pt.cycle_time * s.qty * ci.rate) + 
(pt.setup_time * ci.rate), 2), '-')

编辑：

我已将loc4添加到loc7。

loc3需要将计算应用于loc1和loc2（数量10）。

loc7需要将计算应用于之前的所有位置（数量20）。

也许我没有完美地解释它，有时很难用SQL传达我的意图！

Answer 1

使用数据的简化版本...

select * from stock;

job_no      qty         location  
----------  ----------  ----------
123         0           loc1      
123         0           loc2      
123         10          loc3      
123         0           loc4      
456         0           loc1      
456         20          loc2

您可以使用子选择来获取每个作业的数量，并与之一起获取每个作业的库存。

select stock.*, stocked.qty
from stock
join (select * from stock s where s.qty != 0) as stocked 
  on stock.job_no = stocked.job_no;

job_no      qty         location    qty       
----------  ----------  ----------  ----------
123         0           loc1        10        
123         0           loc2        10        
123         0           loc4        10        
123         10          loc3        10        
456         0           loc1        20        
456         20          loc2        20

stocked在当前库存的每个作业中都有一行。

请注意，除非您进行了限制，否则一份工作的存货行可能会超过一个。

loc7需要将计算应用于之前的所有位置（数量20）。

有了这些数据...

sqlite> select * from stock order by job_no, location;
job_no      qty         location  
----------  ----------  ----------
123         0           loc1      
123         0           loc2      
123         10          loc3      
123         0           loc4      
123         0           loc5      
123         0           loc6      
123         20          loc7      
456         0           loc1      
456         20          loc2

要做到这一点，与其在子选择上进行连接，不以每列为基础，否则我们将获得多个存储值的位置。（可能还有一种使用联接的方法）

为了确保我们仅选择先前的位置（或我们自己的位置），有必要检查stock.location <= stocked.location。为了确保获得最接近的一个，请按位置对它们进行排序，然后仅选择第一个。

select stock.*, (
    select stocked.qty
    from stock stocked
    where stock.job_no = stocked.job_no
      and qty != 0
      and stock.location <= stocked.location
    order by stocked.location asc
    limit 1
) as stocked_qty
from stock
order by job_no, location;

job_no      qty         location    stocked_qty
----------  ----------  ----------  -----------
123         0           loc1        10         
123         0           loc2        10         
123         10          loc3        10         
123         0           loc4        20         
123         0           loc5        20         
123         0           loc6        20         
123         20          loc7        20         
456         0           loc1        20         
456         20          loc2        20

作为列子选择，这可能效率不高。对job_no，qty和location都进行索引很重要。

SQLite-在前一行执行计算

1 个答案: