SQL - FILTRO DE VALORES

Que tal foro.

Soy nuevo en SQL y les agradeceria infinitamente si me pueden ayudar.

Tengo una consulta de base de datos de la siguiente estructura

No_de_cliente No._de_fact. Can1 Cant2 Cant3 (1+2)
24 123 6 0 6
24 123 0 -6 -6
24 444 2 0 2

la columna de Cant3 es la suma de la Cant1+Cant2.

En la consula que realizo agrupo los datos por No_de_Fact por lo que tengo el siguiente resultado:

No_de_cliente No._de_fact. Can3
24 123 0
24 444 2

Mi consulta y la ayuda que solicito es... EXISTE LA POSIBILIDAD DE QUE LA CONSULTA SOLO ME DEVUELVA LOS VALORES DISTINTOS DE CERO EN LA COLUMNA Cant3, para que el resultado de la consulta sea:

No_de_cliente No._de_fact. Can3
24 444 2

como comprenderan existen mas registros y como resultado tengo 30000 filas que tienen 0 y eso dificulta mi trabajo.

de antemano agradezco la ayuda.

saludos José

Hola José, en tu post no mencionas qué manejador de bd estás utilizando, pero lo que necesitas puedes hacerlo utilizando la cláusula HAVING y especificando que la suma de las dos columnas tiene que ser diferente de cero. Te pongo un ejemplo de cómo sería en SQL Server, pero debería funcionar para cualquier manejador de BD. Partiendo del hecho de que tiene una tabla con la siguiente información

No_de_cliente|No_de_fact|Cant1|Cant2
24|123|6|0
24|123|0|-6
24|444|2|0

Tu consulta debería ir más o menos así:

select x.No_de_cliente, x.No_de_fact, sum(x.cant1 + x.cant2) as Cant3 from
TuTabla x
group by x.No_de_cliente, x.No_de_fact
HAVING
sum(x.cant1 + x.cant2) != 0

Saludos
Leo

Que tal Leo, gracias por la atencion, te comento.

soy super nuevo con esto de SQL, utilizo el Microsoft Query, que hasta donde se utiliza sentencias de SQL, no se si estoy bien.

Mi consulta basicamente es esta:

SELECT MAX(AROPNFIL_SQL.cus_no), MAX(AROPNFIL_SQL.doc_dt), MAX(AROPNFIL_SQL.doc_no), MAX(AROPNFIL_SQL.doc_type), MAX(AROPNFIL_SQL.apply_to_no),
(SUM(AROPNFIL_SQL.amt_1)+ SUM(AROPNFIL_SQL.amt_2))
FROM AROPNFIL_SQL
INNER JOIN ARCUSFIL_SQL ON AROPNFIL_SQL.cus_no = ARCUSFIL_SQL.cus_no
INNER JOIN CMCURCOD_SQL ON AROPNFIL_SQL.curr_cd = CMCURCOD_SQL.curr_cd
WHERE AROPNFIL_SQL.cus_no = '000000000024'
AND AROPNFIL_SQL.doc_dt <= 20091231
GROUP BY AROPNFIL_SQL.apply_to_no
ORDER BY AROPNFIL_SQL.apply_to_no

te explico:

.cus_no = Codigo del cliente
.doc_dt = fecha del documento
.doc_no = numero del documento
.doc_type = tipo de documento
.amt_1 = monto 1
.amt_1 = monto 2

utilice la clausula de Having pero me sale un error:

Column 'AROPNFIL_SQL.amt_1' is invalid in the HAVING clause because it is not contained in either an aggregate function or the GROUP BY clause.
Column 'AROPNFIL_SQL.amt_2' is invalid in the HAVING clause because it is not contained in either an aggregate function or the GROUP BY clause.

Leo te agradezco mucho la atencion, estuve intentando con la cluasula de having y ya me funciono a la perfeccion, las sentencia final quedo asi,

SELECT MAX(AROPNFIL_SQL.cus_no) , MAX(AROPNFIL_SQL.doc_dt) , MAX(AROPNFIL_SQL.doc_no) , MAX(AROPNFIL_SQL.doc_type) , MAX(AROPNFIL_SQL.apply_to_no) , (SUM(AROPNFIL_SQL.amt_1)+ SUM(AROPNFIL_SQL.amt_2))
FROM AROPNFIL_SQL
INNER JOIN ARCUSFIL_SQL ON AROPNFIL_SQL.cus_no = ARCUSFIL_SQL.cus_no
INNER JOIN CMCURCOD_SQL ON AROPNFIL_SQL.curr_cd = CMCURCOD_SQL.curr_cd
WHERE AROPNFIL_SQL.cus_no = '000000000024'
AND AROPNFIL_SQL.doc_dt <= 20091231
GROUP BY AROPNFIL_SQL.apply_to_no


having sum((AROPNFIL_SQL.amt_1 + AROPNFIL_SQL.amt_2)) <>0

ORDER BY AROPNFIL_SQL.apply_to_no

Te agradezco mucho....!

Hola de nuevo José, como te diste cuenta el problema estaba en el órden en el que colocaste la cláusula HAVING en la consulta,

Esta cláusula es un complemento del GROUP BY, por lo que debe ir inmediatamente después de este. y otra recomendación, puedes cambiar esta linea en tu select

(SUM(AROPNFIL_SQL.amt_1)+ SUM(AROPNFIL_SQL.amt_2))

por esto:

SUM(AROPNFIL_SQL.amt_1 + AROPNFIL_SQL.amt_2)

qué es exactamente como lo tienes en el HAVING. Aunque aparentemente son iguales, en la línea que te propongo sólo se hace una acumulación, pero bueno, eso es cuestión de gustos.

Saludos
Leo.

Te comento que lo intente de esa manera pero me saltaba un error en el parte de GROUP.

Leo, disculpa la molestia, pero tengo otra consulta con respecto a lo mismo.

la sentencia me resulta perfecta para determinar el sado de las facturas que estan pendientes de pago.

por ejemplo, tengo:

FACTURA---- TIPO----MONTO3 (MONTO1+MONTO2)
XXX---------------V---------10
XXX---------------P--------(10)
SSS--------------V--------1000
SSS--------------P--------(200)
SSS--------------P--------(200)
YYY--------------V---------60
YYY--------------V---------(30)
YYY--------------V---------(30)

La sentencia que tengo (gracias a ti), me da como resultado en este caso el saldo de la factura SSS que seria 600, osea me devuelve solo esto:

FACTURA---- TIPO----MONTO3 (MONTO1+MONTO2)
SSS---------------P---------600

Mi pregunta, es; Hay alguna manera de al realizar la consulta me devuelva el movimiento de las facturas que estan pendientes de pago. Osea al momento de agrupar (o no se si se pueda hacer de otra manera) , las facturas que estan con saldo 0 en monto 3 no aparezcan, pero las demas facturas me muestre todo, de esta manera:

FACTURA---- TIPO----MONTO3 (MONTO1+MONTO2)
SSS--------------V--------1000
SSS--------------P--------(200)
SSS--------------P--------(200)

Espero haberme hecho entender, y una vez mas gracias por la atención y disculpas por la molestia.

Hola de nuevo José...

Con respecto al error que dices que te marca la sentencia que te propuse, la verdad me parece muy raro, Nunca he utilizado el Microsoft Query, puede ser que no soporte esta sentencia, pero bueno, como te dije ayer es cuestión de gustos y en este caso de manejadores.

Para hacer lo que estás solicitando necesitarás hacer subconsultas, ya que por un lado necesitas agrupar todos los registros para determinar qué facturas no se deben mostrar, pero quieres mostrar "desagrupados" los registros. Te pongo un ejemplo de cómo sería para SQL Server, Sería cuestión de ver si tu manejador lo puede implementar.

Tomando la información que tienes de ejemplo, agregué una columna id como referencia, de tal manera que tenemos lo siguiente:

ID|FACTURA|TIPO|MONTO3
1|XXX|V|10
2|XXX|P|-10
3|SSS|V|1000
4|SSS|P|-200
5|SSS|P|-200
6|YYY|V|60
7|YYY|V|-30
8|YYY|V|-30

si hacemos esto

Select FACTURA, sum(MONTO3)
from TABLA group by FACTURA having sum(MONTO3) != 0

Entonces nos regresa como resultado lo siguiente;

FACTURA|MONTO
SSS|800

Ahora bien, como lo que tu necesitas es el desglose completo de aquellas facturas que no tienen saldo cero entonces lo que puedes hacer es utilizar la consulta pasada como insumo para otra consulta, quedaría algo como esto

select ID, FACTURA, TIPO, MONTO3 from TABLA where FACTURA IN
(
select FACTURA
from TABLA group by FACTURA having sum(MONTO3) != 0
)

Si observas en la consulta interna ya no es necesario poner el campo
SUM(Monto3) porque lo único que interesa es el # de la factura, lo demás queda exactamente igual. De esta manera te deberá regresar lo siguiente.

ID|FACTURA|TIPO|MONTO3
3|SSS|V|1000
4|SSS|P|-200
5|SSS|P|-200

Intentalo y si tienes problemas pues lo comentas en el Foro

Saludos
Leo.

Que tal de nuevo Leo.

Te comento:

utilice la siguiente sentencia

SELECT MAX(AROPNFIL_SQL.cus_no), MAX(ARCUSFIL_SQL.cus_name), MAX(AROPNFIL_SQL.doc_dt), MAX(AROPNFIL_SQL.doc_no), MAX(AROPNFIL_SQL.doc_type),
MAX(AROPNFIL_SQL.apply_to_no), MAX(AROPNFIL_SQL.doc_due_dt), (SUM(AROPNFIL_SQL.amt_1)+ SUM(AROPNFIL_SQL.amt_2))
FROM AROPNFIL_SQL
INNER JOIN ARCUSFIL_SQL ON AROPNFIL_SQL.cus_no = ARCUSFIL_SQL.cus_no
INNER JOIN CMCURCOD_SQL ON AROPNFIL_SQL.curr_cd = CMCURCOD_SQL.curr_cd
WHERE AROPNFIL_SQL.doc_dt <= 20100802
and AROPNFIL_SQL.apply_to_no in

(SELECT MAX(AROPNFIL_SQL.apply_to_no)
FROM AROPNFIL_SQL

WHERE AROPNFIL_SQL.doc_dt <= 20100802
GROUP BY AROPNFIL_SQL.apply_to_no
HAVING SUM((AROPNFIL_SQL.amt_1 + AROPNFIL_SQL.amt_2)) <>0)

pero al consultar me aparece un solo registro, osea creo que les agrupa todo, por que me aparece un solo cliente y una sola factura con el valor total.

Vámos José... yo te doy ideas, pero tú tienes que intentar también resolver los problemas.

¿qué te regresa esta consulta?

SELECT MAX(AROPNFIL_SQL.cus_no), MAX(ARCUSFIL_SQL.cus_name), MAX(AROPNFIL_SQL.doc_dt), MAX(AROPNFIL_SQL.doc_no), MAX(AROPNFIL_SQL.doc_type),
MAX(AROPNFIL_SQL.apply_to_no), MAX(AROPNFIL_SQL.doc_due_dt), (SUM(AROPNFIL_SQL.amt_1)+ SUM(AROPNFIL_SQL.amt_2))
FROM AROPNFIL_SQL
INNER JOIN ARCUSFIL_SQL ON AROPNFIL_SQL.cus_no = ARCUSFIL_SQL.cus_no
INNER JOIN CMCURCOD_SQL ON AROPNFIL_SQL.curr_cd = CMCURCOD_SQL.curr_cd
WHERE AROPNFIL_SQL.doc_dt <= 20100802

Esta primer consulta debería regresarte todos los registros, sin agrupar.

¿qué te regresa esta consulta?

SELECT MAX(AROPNFIL_SQL.apply_to_no)
FROM AROPNFIL_SQL
WHERE AROPNFIL_SQL.doc_dt <= 20100802
GROUP BY AROPNFIL_SQL.apply_to_no
HAVING SUM((AROPNFIL_SQL.amt_1 + AROPNFIL_SQL.amt_2)) <>0

Esta consulta debería regresarte la llave de los registros que una vez acumulados la sumatoria es diferente de cero, sólo tendrías que filtrar la consulta uno.

Saludos
Leo.

Que tal leo

como te dije soy nuevo en esto y no entiendo muy bien como funcionan las clausulas.

te comento, ya resolvi el problemita con la siguiente sentencia:

SELECT MAX(AROPNFIL_SQL.cus_no), MAX(ARCUSFIL_SQL.cus_name), MAX(AROPNFIL_SQL.doc_dt), MAX(AROPNFIL_SQL.doc_no), MAX(AROPNFIL_SQL.doc_type), MAX(AROPNFIL_SQL.doc_due_dt), MAX(AROPNFIL_SQL.apply_to_no), (SUM(AROPNFIL_SQL.amt_1)+ SUM(AROPNFIL_SQL.amt_2))
FROM AROPNFIL_SQL
INNER JOIN ARCUSFIL_SQL ON AROPNFIL_SQL.cus_no = ARCUSFIL_SQL.cus_no
INNER JOIN CMCURCOD_SQL ON AROPNFIL_SQL.curr_cd = CMCURCOD_SQL.curr_cd
WHERE AROPNFIL_SQL.doc_dt <= 20100802
AND AROPNFIL_SQL.apply_to_no IN

(SELECT AROPNFIL_SQL.apply_to_no FROM AROPNFIL_SQL WHERE AROPNFIL_SQL.doc_dt <= 20100802 GROUP BY AROPNFIL_SQL.apply_to_no HAVING SUM((AROPNFIL_SQL.amt_1 + AROPNFIL_SQL.amt_2)) <>0)

GROUP BY AROPNFIL_SQL.cus_no, ARCUSFIL_SQL.cus_name, AROPNFIL_SQL.doc_dt, AROPNFIL_SQL.doc_no, AROPNFIL_SQL.apply_to_no, AROPNFIL_SQL.doc_type

Lo que se me hace raro, es que; para que me aparezcan y no se me agrupe en uno solo registro, tengo que poner las ultimas tres lineas:

GROUP BY AROPNFIL_SQL.cus_no, ARCUSFIL_SQL.cus_name, AROPNFIL_SQL.doc_dt, AROPNFIL_SQL.doc_no, AROPNFIL_SQL.apply_to_no, AROPNFIL_SQL.doc_type

Entiendo que esa clausula me agrupa, pero en mi caso al ponerlas al final, me desagrupa. (jajajajaja)

Te agradezco mucho la atencion y la ayuda que me proporcionaste.