[AYUDA] MySQL 5.0: ayuda para plantear consultar

[realbo]

creo que es algo asi como lo que te explique en el messenger pero programado

[vlad]

creo que es algo asi como lo que te explique en el messenger pero programado

Me imagino que si, como bien me decias, no parece haber forma de hacerlo con 1 simple query, pese a que parece ser algo tan básico/simple.


Lo acabo de poner en el foro de soporte de MySQL tambien, para no quedarnos con la duda:
http://forums.mysql.com/read.php?10,279053,279053#msg-279053

[tekun]

Si fueras tan amable de proponer tu solucion aunque sea en otra variante de SQL?, de ahí podría figurarme mejor si hay alguna forma parecida en MySQL

el truco esta en "concatenar" todos los valores de la columna "valor"

yo he creado tu tabla ejemplo en postgres y ahí estuve haciendo pruebas, de entrada imagine la solución que aquí te planteo porque ya he tenido que hacer algo parecido a lo que buscas....

teniendo la siguiente tabla
grupo   valor
1         a
1         b
1         c
1         d
2         a
2         b
2            f
3         a 


yo en postgres hago el siguiente script

select grupo, array_agg(valor)
from test
group by grupo;

retorna:

1   {a,b,c,d}
2   {a}
3   {a,b,f}

[rdoggsv]

Por eso siempre prefiero las entidad relacion que las entidad atributo propiedad :P , estas EAV son medio problematicas al escalar :P

SELECT grupo
FROM   mitabla
WHERE mitabla.valor in ('a', 'b') AND mitabla.grupo IN (SELECT mitabla.grupo FROM mitabla GROUP BY grupo HAVING COUNT(*) =2)
GROUP BY mitabla.grupo

Por cierto la mayorita de personas solo lo hacen qu tenga los atributos que buscas, no que tenga exactamente los que buscas, se recorta un monton.


SELECT grupo
FROM   mitabla
WHERE mitabla.valor in ('a', 'b')
GROUP BY mitabla.grupo
HAVING COUNT(DISTINCT mitabla.valor) = 2

[tekun]

yo tambien probe utilizando el having count=cantidad de valores ingresados, pero me tope con un error cuando hay otro grupo que tiene solamente dos valores y uno de ellos esta en el rango ingresado

ejemplo
grupo   valor
1         a
1         b
1         c
2         a
2         z
3         a
3         f

[realbo]

yo sinceramente por query lo veo dificil para mi es mezcla de querys y programacion

[rdoggsv]

Por eso siempre prefiero las entidad relacion que las entidad atributo propiedad :P , estas EAV son medio problematicas al escalar :P

SELECT grupo
FROM   mitabla
WHERE mitabla.valor in ('a', 'b') AND mitabla.grupo IN (SELECT mitabla.grupo FROM mitabla GROUP BY grupo HAVING COUNT(*) =2)
GROUP BY mitabla.grupo

Por cierto la mayorita de personas solo lo hacen qu tenga los atributos que buscas, no que tenga exactamente los que buscas, se recorta un monton.


SELECT grupo
FROM   mitabla
WHERE mitabla.valor in ('a', 'b')
GROUP BY mitabla.grupo
HAVING COUNT(DISTINCT mitabla.valor) = 2

yo tambien probe utilizando el having count=cantidad de valores ingresados, pero me tope con un error cuando hay otro grupo que tiene solamente dos valores y uno de ellos esta en el rango ingresado

ejemplo
grupo   valor
1         a
1         b
1         c
2         a
2         z
3         a
3         f

Pequeño error que en el primero le borre la ultima parte

SELECT grupo
FROM   mitabla
WHERE mitabla.valor in ('a', 'b', 'c') AND mitabla.grupo IN (SELECT mitabla.grupo FROM mitabla GROUP BY grupo HAVING COUNT(*) =3)
GROUP BY mitabla.grupo HAVING COUNT(DISTINCT mitabla.valor) = 3

SELECT grupo
FROM   mitabla
WHERE mitabla.valor in ('a', 'z',) AND mitabla.grupo IN (SELECT mitabla.grupo FROM mitabla GROUP BY grupo HAVING COUNT(*) =2)
GROUP BY mitabla.grupo HAVING COUNT(DISTINCT mitabla.valor) = 2


SELECT grupo
FROM   mitabla
WHERE mitabla.valor in ('a', 'f',) AND mitabla.grupo IN (SELECT mitabla.grupo FROM mitabla GROUP BY grupo HAVING COUNT(*) =2)
GROUP BY mitabla.grupo HAVING COUNT(DISTINCT mitabla.valor) = 2

Listo espero que hoy si funcione con todo

[vlad]

el truco esta en "concatenar" todos los valores de la columna "valor"

yo he creado tu tabla ejemplo en postgres y ahí estuve haciendo pruebas, de entrada imagine la solución que aquí te planteo porque ya he tenido que hacer algo parecido a lo que buscas....

teniendo la siguiente tabla
grupo   valor
1         a
1         b
1         c
1         d
2         a
2         b
2            f
3         a 


yo en postgres hago el siguiente script

select grupo, array_agg(valor)
from test
group by grupo;

retorna:

1   {a,b,c,d}
2   {a}
3   {a,b,f}

Muy interesante, eso vienen siendo el GROUP_CONCAT en MySQL:

Código: [Seleccionar]

mysql> select GROUP_CONCAT(valor) from tester group by grupo;
+---------------------+
| GROUP_CONCAT(valor) |
+---------------------+
| a,b,c,d             |
| a,b,f               |
| a                   |
+---------------------+
3 rows in set (0.08 sec)

Sería de ver como evaluar los resultados despues de eso

Por eso siempre prefiero las entidad relacion que las entidad atributo propiedad :P , estas EAV son medio problematicas al escalar :P

SELECT grupo
FROM   mitabla
WHERE mitabla.valor in ('a', 'b') AND mitabla.grupo IN (SELECT mitabla.grupo FROM mitabla GROUP BY grupo HAVING COUNT(*) =2)
GROUP BY mitabla.grupo

Por cierto la mayorita de personas solo lo hacen qu tenga los atributos que buscas, no que tenga exactamente los que buscas, se recorta un monton.


SELECT grupo
FROM   mitabla
WHERE mitabla.valor in ('a', 'b')
GROUP BY mitabla.grupo
HAVING COUNT(DISTINCT mitabla.valor) = 2

Hey gracias   buen truco lo de usar la cuenta para deducir los validos!, ya lo voy a probar.
Precalcular el valor de comparación del count no es ningun problema, aunque fuera bueno una funcion de MySQL que contara los argumentos, pero eso ya es hacer cosas de mas  

Y pues la mayoria podra hacer otras cosas pero para el caso quisiera experimentar con filtrar los resultados en base a propiedades exactas   ya veremos como "escala" de bien o mal este asunto :P

Gracias voy a probar!.

yo tambien probe utilizando el having count=cantidad de valores ingresados, pero me tope con un error cuando hay otro grupo que tiene solamente dos valores y uno de ellos esta en el rango ingresado

ejemplo
grupo   valor
1         a
1         b
1         c
2         a
2         z
3         a
3         f

Umm eso es cierto, pues si ahi buscaras por "a", "b" y "c" el count para el grupo 2 y 3 sería de "2" mientras que para el grupo 1 sería de "3" - estaría bien.

Pero si buscara por "a" y  "z"  el count seria siempre igual (grupo 2 y 3 sería de "2" mientras que para el grupo 1 sería de "3") pero mostraria tanto el grupo 3 como el 2 :\

Parece que le hayaste un bug a la tecnica de rdoggsv jeje

[rdoggsv]

Se me olvido el ultimo conteo vlad, lo q si me gustaria agregar esq mejor uses una has propiedades para esta onda, las columnas siendo las propiedades :P

[vlad]

ya voy a hacer el cambio entonces =)

Solo por probar la ultima solucion tekun/rdoggsv:

Código: [Seleccionar]

create table mitabla (grupo varchar(10), valor varchar(10));
insert into mitabla (grupo,valor) VALUES ('1','a'),('1','b'),('1','c'),('2','a'),('2','z'),('3','a'),('3','f');

mysql> SELECT grupo FROM   mitabla WHERE mitabla.valor in ('a', 'b', 'c') AND mitabla.grupo IN (SELECT mitabla.grupo FROM mitabla GROUP BY grupo HAVING COUNT(*) =3) GROUP BY mitabla.grupo HAVING COUNT(DISTINCT mitabla.valor) = 3;
+-------+
| grupo |
+-------+
| 1     |
+-------+
1 row in set (0.07 sec)

mysql> SELECT grupo FROM   mitabla WHERE mitabla.valor in ('a', 'z') AND mitabla.grupo IN (SELECT mitabla.grupo FROM mitabla GROUP BY grupo HAVING COUNT(*) =2) GROUP BY mitabla.grupo HAVING COUNT(DISTINCT mitabla.valor) = 2;
+-------+
| grupo |
+-------+
| 2     |
+-------+
1 row in set (0.00 sec)

mysql> SELECT grupo FROM   mitabla WHERE mitabla.valor in ('a', 'f') AND mitabla.grupo IN (SELECT mitabla.grupo FROM mitabla GROUP BY grupo HAVING COUNT(*) =2) GROUP BY mitabla.grupo HAVING COUNT(DISTINCT mitabla.valor) = 2;
+-------+
| grupo |
+-------+
| 3     |
+-------+
1 row in set (0.00 sec)

Parece que funciona bien =D, al menos quedo de aprendizaje jeje gracias a todos.

[tekun]

Muy interesante, eso vienen siendo el GROUP_CONCAT en MySQL:

Código: [Seleccionar]

mysql> select GROUP_CONCAT(valor) from tester group by grupo;
+---------------------+
| GROUP_CONCAT(valor) |
+---------------------+
| a,b,c,d             |
| a,b,f               |
| a                   |
+---------------------+
3 rows in set (0.08 sec)


apos aqui ta tu solucion
select GROUP_CONCAT(valor) from tester
where GROUP_CONCAT(valor) ='a,b'
group by grupo;

[vlad]

Se me olvido el ultimo conteo vlad, lo q si me gustaria agregar esq mejor uses una has propiedades para esta onda, las columnas siendo las propiedades :P

err.. recapitulando, ya me acorde porque lo habia hecho asi   ¿y si las propiedades son variables en cantidad?, digamos, quien sabe si de acá a mañana las propiedades crezcan  , tendria que ir agregando mas columnas por cada propiedad y dejar en NULL todas las nuevas celdas para las filas filas que antes no tenian esas propiedades.

¿Aun asi te parece mejor?

apos aqui ta tu solucion
select GROUP_CONCAT(valor) from tester
where GROUP_CONCAT(valor) ='a,b'
group by grupo;

Hey si verdad, teniendo en cuenta que puedo ordenar valor y que puedo ordenar la entrada a comparar, solo haría unos cambios (el principal seria usar HAVING en lugar de WHERE para que sea valido :

Código: [Seleccionar]

mysql> select grupo from tester group by grupo having GROUP_CONCAT(valor ORDER BY valor ASC) ='a';
+-------+
| grupo |
+-------+
|     3 |
+-------+
1 row in set (0.00 sec)

Interesante solución a la que has llegado tekun!

[vlad]

Poniendolo asi:

Código: [Seleccionar]

mysql> explain select grupo from tester group by grupo having GROUP_CONCAT(valor ORDER BY valor ASC) ='a';
+----+-------------+--------+------+---------------+------+---------+------+------+----------------+
| id | select_type | table  | type | possible_keys | key  | key_len | ref  | rows | Extra          |
+----+-------------+--------+------+---------------+------+---------+------+------+----------------+
|  1 | SIMPLE      | tester | ALL  | NULL          | NULL | NULL    | NULL |    8 | Using filesort |
+----+-------------+--------+------+---------------+------+---------+------+------+----------------+
1 row in set (0.00 sec)


Código: [Seleccionar]

mysql> explain SELECT grupo FROM   mitabla WHERE mitabla.valor in ('a', 'f') AND mitabla.grupo IN (SELECT mitabla.grupo FROM mitabla GROUP BY grupo HAVING COUNT(*) =2) GROUP BY mitabla.grupo HAVING COUNT(DISTINCT mitabla.valor) = 2;
+----+--------------------+---------+------+---------------+------+---------+------+------+---------------------------------+
| id | select_type        | table   | type | possible_keys | key  | key_len | ref  | rows | Extra                           |
+----+--------------------+---------+------+---------------+------+---------+------+------+---------------------------------+
|  1 | PRIMARY            | mitabla | ALL  | NULL          | NULL | NULL    | NULL |    7 | Using where; Using filesort     |
|  2 | DEPENDENT SUBQUERY | mitabla | ALL  | NULL          | NULL | NULL    | NULL |    7 | Using temporary; Using filesort |
+----+--------------------+---------+------+---------------+------+---------+------+------+---------------------------------+
2 rows in set (0.00 sec)

Pinta bastante bien el metodo del group_concat como solución (excluyendo los posibles problemas en el orden de las propiedades a buscar claro), algun comentario ?

[tekun]

Código: [Seleccionar]

mysql> explain select grupo from tester group by grupo having GROUP_CONCAT(valor ORDER BY valor ASC) ='a';
+----+-------------+--------+------+---------------+------+---------+------+------+----------------+
| id | select_type | table  | type | possible_keys | key  | key_len | ref  | rows | Extra          |
+----+-------------+--------+------+---------------+------+---------+------+------+----------------+
|  1 | SIMPLE      | tester | ALL  | NULL          | NULL | NULL    | NULL |    8 | Using filesort |
+----+-------------+--------+------+---------------+------+---------+------+------+----------------+
1 row in set (0.00 sec)


No habría problema si los ordenas, tal como lo hiciste aca...


tal como lo dijiste al inicio, la solución era muy simple, el truco esta en dejar de programar en modo procedual... Y encontrar la manera de decirla a la máquina QUE debe hacer, no COMO hacerlo

[vlad]

Pues ya estuve probando tu metodo y pues la verdad esta bastante practico y me ha funcionado (siempre teniendo en cuenta que hay que ordenar tanto el grupo concatenado como los valores a probar de la misma forma).

Asi que ahorita he dejado opcional en el programa el metodo a utilizar y con el tiempo se verá cual resultó mejor