Não iterativa / não-loop Way para calcular Data de Vigência?
https://stackoverflow.com/questions/92699
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu tenho uma tabela chamada OffDays, onde finais de semana e feriados são mantidos. Eu tenho uma tabela chamada LeadTime onde quantidade de tempo (em dias) para um produto a ser fabricado é armazenado. Finalmente eu tenho uma tabela chamada Ordem onde um produto e a data do pedido é mantido.
É possível consulta quando um produto será de fabricação acabado sem o uso de procedimentos ou loops armazenados?
Por exemplo:
- OffDays tem 2008-01-10, 2008-01-11, 2008-01-14.
- LeadTime tem 5 para o produto 9.
- Ordem tem 2008-01-09 para o produto 9.
O cálculo que eu estou procurando é a seguinte:
- 2008-01-09 1
- 2008-01-10 x
- 2008-01-11 x
- 2008-01-12 2
- 2008-01-13 3
- 2008-01-14 x
- 2008-01-15 4
- 2008-01-16 5
Eu estou querendo saber se é possível ter um retorno consulta 2008-01-16 sem ter que usar um procedimento armazenado, ou calculá-lo em meu código do aplicativo.
Editar (porque há procedimentos armazenados / loops): A razão que eu não posso usar procedimentos armazenados é que eles não são suportados pelo banco de dados. Eu só pode adicionar mesas extras / dados. A aplicação é uma terceira ferramenta de relatórios festa onde só posso controlar a consulta SQL.
Editar (como eu estou fazendo isso agora): Meu método atual é que eu tenho uma coluna extra na tabela de forma a manter a data calculada, em seguida, um trabalho tarefa / cron agendada executa o cálculo de todas as ordens a cada hora. Isso é menos do que ideal para várias razões.
Solução
Você pode gerar uma tabela de dias úteis de antecedência.
WDId | WDDate
-----+-----------
4200 | 2008-01-08
4201 | 2008-01-09
4202 | 2008-01-12
4203 | 2008-01-13
4204 | 2008-01-16
4205 | 2008-01-17
Em seguida, faça uma consulta, como
SELECT DeliveryDay.WDDate FROM WorkingDay OrderDay, WorkingDay DeliveryDay, LeadTime, Order where DeliveryDay.WDId = OrderDay.WDId + LeadTime.LTDays AND OrderDay.WDDate = '' AND LeadTime.ProductId = Order.ProductId AND Order.OrderId = 1234
Você precisaria de um procedimento armazenado com um loop para gerar a tabela de workingdays, mas não para consultas regulares. É também menos ida e volta para o servidor que se você usar código do aplicativo para contar os dias.
Outras dicas
A melhor abordagem é usar uma tabela de calendário.
Em seguida, sua consulta poderia ser algo como:
SELECT c.dt, l.*, o.*, c.*
FROM [statistics].dbo.[calendar] c,
[order] o JOIN
lead l ON l.leadId = o.leadId
WHERE c.isWeekday = 1
AND c.isHoliday =0
AND o.orderId = 1
AND l.leadDays = (
SELECT COUNT(*)
FROM [statistics].dbo.Calendar c2
WHERE c2.dt >= o.startDate
AND c2.dt <= c.dt
AND c2.isWeekday=1
AND c2.isHoliday=0
)
Espero que ajude,
RB.
Apenas calculá-lo no código do aplicativo ... muito mais fácil e você não terá que escrever uma consulta realmente feio em sua sql
aqui é uma maneira - usando a função dateadd.
Eu preciso levar esta resposta fora da mesa. Isso não vai funcionar corretamente para prazos longos. Foi simplesmente adicionando o # de dias de folga encontrada no tempo de espera e empurrando a data fora. Isto irá causar um problema quando mais dias de folga aparecer na nova gama.
-- Setup test
create table #odays (offd datetime)
create table #leadtime (pid int , ltime int)
create table [#order] (pid int, odate datetime)
insert into #odays
select '1/10/8'
insert into #odays
select '1/11/8'
insert into #odays
select '1/14/8'
insert into #Leadtime
values (3,5)
insert into #leadtime
values (9, 5)
insert into #order
values( 9, '1/9/8')
select dateadd(dd,
(select count(*)-1
from #odays
where offd between odate and
(select odate+ltime
from #order o
left join #leadtime l
on o.pid = l.pid
where l.pid = 9
)
),
odate+ltime)
from #order o
left join #leadtime l
on o.pid = l.pid
where o.pid = 9
Por que você é contra o uso de loops?
// alguns pseudocódigo
int leadtime = 5;
date order = 2008-01-09;
date finishdate = order;
while (leadtime > 0) {
finishdate.addDay();
if (!IsOffday(finishdate)) leadtime--;
}
return finishdate;este parece ser uma função simples demais para tentar encontrar uma maneira não-looping.
Hmm .. uma solução poderia ser a de armazenar uma tabela de datas com um deslocamento baseado em uma contagem de dias não-off desde o início do ano. Vamos dizer janeiro 2 é um dia. 1/1/08 teria um deslocamento de 1 (ou 0 se quiser começar do 0). 1/3/08 teria um deslocamento de 2, porque a contagem pula 1/2/08. De lá é um cálculo simples. Se o deslocamento da data do pedido, adicione o tempo de espera, em seguida, fazer uma pesquisa sobre o calculado compensar para obter a data de término.
Uma maneira (sem criar outra tabela) está usando uma espécie de função de teto: para cada offdate, descobrir quantos "em datas" vir antes que, em relação à data do pedido, em uma subconsulta. Em seguida, tomar o maior número que é menor do que o tempo de espera. Use a data correspondente a isso, mais o restante.
Este código pode ser específico para PostgreSQL, desculpe se isso não é o que você está usando.
CREATE DATABASE test;
CREATE TABLE offdays
(
offdate date NOT NULL,
CONSTRAINT offdays_pkey PRIMARY KEY (offdate)
);
insert into offdays (offdate) values ('2008-01-10');
insert into offdays (offdate) values ('2008-01-11');
insert into offdays (offdate) values ('2008-01-14');
insert into offdays (offdate) values ('2008-01-18'); -- just for testing
CREATE TABLE product
(
id integer NOT NULL,
CONSTRAINT product_pkey PRIMARY KEY (id)
);
insert into product (id) values (9);
CREATE TABLE leadtime
(
product integer NOT NULL,
leaddays integer NOT NULL,
CONSTRAINT leadtime_pkey PRIMARY KEY (product),
CONSTRAINT leadtime_product_fkey FOREIGN KEY (product)
REFERENCES product (id) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION
);
insert into leadtime (product, leaddays) values (9, 5);
CREATE TABLE "order"
(
product integer NOT NULL,
"start" date NOT NULL,
CONSTRAINT order_pkey PRIMARY KEY (product),
CONSTRAINT order_product_fkey FOREIGN KEY (product)
REFERENCES product (id) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION
);
insert into "order" (product, "start") values (9, '2008-01-09');
-- finally, the query:
select e.product, offdate + (leaddays - ondays)::integer as "end"
from
(
select c.product, offdate, (select (a.offdate - c."start") - count(b.offdate) from offdays b where b.offdate < a.offdate) as ondays, d.leaddays
from offdays a, "order" c
inner join leadtime d on d.product = c.product
) e
where leaddays >= ondays
order by "end" desc
limit 1;
Esta é a sintaxe PostgreSQL, mas deve ser fácil de traduzir para outro dialeto SQL
--Sample data
create table offdays(datum date);
insert into offdays(datum)
select to_date('2008-01-10','yyyy-MM-dd') UNION
select to_date('2008-01-11','yyyy-MM-dd') UNION
select to_date('2008-01-14','yyyy-MM-dd') UNION
select to_date('2008-01-20','yyyy-MM-dd') UNION
select to_date('2008-01-21','yyyy-MM-dd') UNION
select to_date('2008-01-26','yyyy-MM-dd');
create table leadtime (product_id integer , lead_time integer);
insert into leadtime(product_id,lead_time) values (9,5);
create table myorder (order_id integer,product_id integer, datum date);
insert into myorder(order_id,product_id,datum)
values (1,9,to_date('2008-01-09','yyyy-MM-dd'));
insert into myorder(order_id,product_id,datum)
values (2,9,to_date('2008-01-16','yyyy-MM-dd'));
insert into myorder(order_id,product_id,datum)
values (3,9,to_date('2008-01-23','yyyy-MM-dd'));
--Query
select order_id,min(finished_date)
FROM
(select mo.order_id,(mo.datum+lead_time+count(od2.*)::integer-1) as finished_date
from
myorder mo
join leadtime lt on (mo.product_id=lt.product_id)
join offdays od1 on (mo.datum<od1.datum)
left outer join offdays od2 on (mo.datum<od2.datum and od2.datum<od1.datum)
group by mo.order_id,mo.datum,lt.lead_time,od1.datum
having (mo.datum+lead_time+count(od2.*)::integer-1) < od1.datum) tmp
group by 1;
--Results :
1 2008.01.16
2 2008.01.22
Esta vontade não retorna resultado para ordens que seria concluído após a última data na tabela offdays (número de ordem 3), assim que você deve tomar cuidado para inserir offdays sobre time.It é assumido que as ordens fazer não comece em offdays.
