numerar filas KB

20/11/2003 - 19:21 por Manuel Etcheto | Informe spam
Hola gente
Ayer he visto (por simple curiosidad) un artículo que
postearon aquí para generarlos junto al resultado:
http://support.microsoft.com/defaul...cid=kb;EN-
US;q186133#1
El procedimiento se basa en count(*) y where x >= y

1) Según entiendo yo, en los ejemplos 2 y 3 que tienen una
suma, la cláusula group by hace que los resultados se
multipliquen por la cantidad de veces que cumple la
condición (rank=count(*)), haciendo que sólo la fila 1
entregue el resultado correcto, la fila 2 el doble, la 3
el triple, y así...
Creo que lo correcto sería volver a "deshacer" la suma que
hace el group by, dividiendo por count:
select rank=count(*), s1.pub_id, sales=sum(s1.sales)/COUNT
(*)
from (select ...

2) Yo eso mismo lo he hecho en una ocasión con una #tabla
con un campo identity, la pregunta es ¿es realmente más
eficiente como dice allí esta solución que proponen,
teniendo en cuenta que hace una lectura doble de cada
tabla, y hasta veo en el plan de ejecución que al final
igual está creando una tabla temporal?
Gracias
Manuel

pd: Gracias y felicitaciones por la colaboración que
prestan día a día. Es un grupo excepcional.

Preguntas similare

Leer las respuestas

#1 ulises
21/11/2003 - 05:03 | Informe spam
Sí, tienes razón, se debería dividir entre count(*) para
tener el resultado correcto, sería una buena idea que le
escribas a Microsoft en el enlace que te brinda para que
les hagas llegar tus comentarios, ahora bien esta técnica
de auto-join es bastante usada para otros casos y lo
encuentro más eficientem que la técnica típica de tablas
temporales y cursores que es con la cual lo comparan en el
artículo.

Saludos,
Ulises

Hola gente
Ayer he visto (por simple curiosidad) un artículo que
postearon aquí para generarlos junto al resultado:
http://support.microsoft.com/defaul...cid=kb;EN-
US;q186133#1
El procedimiento se basa en count(*) y where x >= y

1) Según entiendo yo, en los ejemplos 2 y 3 que tienen


una
suma, la cláusula group by hace que los resultados se
multipliquen por la cantidad de veces que cumple la
condición (rank=count(*)), haciendo que sólo la fila 1
entregue el resultado correcto, la fila 2 el doble, la 3
el triple, y así...
Creo que lo correcto sería volver a "deshacer" la suma


que
hace el group by, dividiendo por count:
select rank=count(*), s1.pub_id, sales=sum(s1.sales)/COUNT
(*)
from (select ...

2) Yo eso mismo lo he hecho en una ocasión con una #tabla
con un campo identity, la pregunta es ¿es realmente más
eficiente como dice allí esta solución que proponen,
teniendo en cuenta que hace una lectura doble de cada
tabla, y hasta veo en el plan de ejecución que al final
igual está creando una tabla temporal?
Gracias
Manuel

pd: Gracias y felicitaciones por la colaboración que
prestan día a día. Es un grupo excepcional.
Respuesta Responder a este mensaje
#2 Javier Loria
21/11/2003 - 05:13 | Informe spam
Hola Manuel:
Yo no he realizado pruebas, pero en principio la "lectura doble" debe
ser trivial si las tablas caben en memoria RAM, ya que se leen una vez y
luego estan en el cache. Mientras que la tabla temporal exige 2 escrituras
en la BD TempDB y el Log de TempDB. Asi que me parece normal que sean mucho
mas rapidas.


Javier Loria
Costa Rica
Se aprecia la inclusion de DDL (CREATE, INSERTS, etc.)
que pueda ser copiado y pegado al Query Analizer.
La version de SQL y Service Pack tambien ayuda.
Manuel Etcheto escribio:
Hola gente
Ayer he visto (por simple curiosidad) un artículo que
postearon aquí para generarlos junto al resultado:
http://support.microsoft.com/defaul...cid=kb;EN-
US;q186133#1
El procedimiento se basa en count(*) y where x >= y

1) Según entiendo yo, en los ejemplos 2 y 3 que tienen una
suma, la cláusula group by hace que los resultados se
multipliquen por la cantidad de veces que cumple la
condición (rank=count(*)), haciendo que sólo la fila 1
entregue el resultado correcto, la fila 2 el doble, la 3
el triple, y así...
Creo que lo correcto sería volver a "deshacer" la suma que
hace el group by, dividiendo por count:
select rank=count(*), s1.pub_id, sales=sum(s1.sales)/COUNT
(*)
from (select ...

2) Yo eso mismo lo he hecho en una ocasión con una #tabla
con un campo identity, la pregunta es ¿es realmente más
eficiente como dice allí esta solución que proponen,
teniendo en cuenta que hace una lectura doble de cada
tabla, y hasta veo en el plan de ejecución que al final
igual está creando una tabla temporal?
Gracias
Manuel

pd: Gracias y felicitaciones por la colaboración que
prestan día a día. Es un grupo excepcional.
Respuesta Responder a este mensaje
#3 Manuel Etcheto
21/11/2003 - 20:04 | Informe spam
Gracias Javier, lo tendré en cuenta

y ¿qué pasaría si en lugar de una #tabla se hace con una
función que devuelve Table? ¿se realizan igualmente esas
escrituras o se maneja todo en memoria?

Salu2
Manuel

Hola Manuel:
Yo no he realizado pruebas, pero en principio


la "lectura doble" debe
ser trivial si las tablas caben en memoria RAM, ya que se


leen una vez y
luego estan en el cache. Mientras que la tabla temporal


exige 2 escrituras
en la BD TempDB y el Log de TempDB. Asi que me parece


normal que sean mucho
mas rapidas.


Javier Loria
Respuesta Responder a este mensaje
#4 Manuel Etcheto
21/11/2003 - 20:07 | Informe spam
Gracias Ulises
Sí les he enviado un comentario

Salu2
Manuel

Sí, tienes razón, se debería dividir entre count(*) para
tener el resultado correcto, sería una buena idea que le
escribas a Microsoft en el enlace que te brinda para que
les hagas llegar tus comentarios, ahora bien esta técnica
de auto-join es bastante usada para otros casos y lo
encuentro más eficientem que la técnica típica de tablas
temporales y cursores que es con la cual lo comparan en


el
artículo.

Saludos,
Ulises
Respuesta Responder a este mensaje
#5 Javier Loria
21/11/2003 - 20:26 | Informe spam
Hola Manuel:
En principio no, la variable Table no deberia requerir estas escrituras.
Adicionalmente si estan en un procedimiento almacenado no deberia requerir
la recompilacion del mismo como si lo hace una tabla temporal.
Saludos,


Javier Loria
Costa Rica
Se aprecia la inclusion de DDL (CREATE, INSERTS, etc.)
que pueda ser copiado y pegado al Query Analizer.
La version de SQL y Service Pack tambien ayuda.
Manuel Etcheto escribio:
Gracias Javier, lo tendré en cuenta

y ¿qué pasaría si en lugar de una #tabla se hace con una
función que devuelve Table? ¿se realizan igualmente esas
escrituras o se maneja todo en memoria?

Salu2
Manuel

Hola Manuel:
Yo no he realizado pruebas, pero en principio


la "lectura doble" debe
ser trivial si las tablas caben en memoria RAM, ya que se leen una
vez y luego estan en el cache. Mientras que la tabla temporal exige
2 escrituras en la BD TempDB y el Log de TempDB. Asi que me parece
normal que sean mucho mas rapidas.


Javier Loria
Respuesta Responder a este mensaje
Ads by Google
Help Hacer una preguntaSiguiente Respuesta Tengo una respuesta
Search Busqueda sugerida