none
Ayuda con registros de una tabla RRS feed

  • Pregunta

  • Buena tarde:

    Necesito que me puedan asesorar, por favor en un problema que tengo con datos de una tabla. Les explico con un ejemplo:

    Tengo una tabla Registros como la siguiente:

    TABLA ORIGINAL
              Código            Padre             Nivel       IMPORTE
    10000 0 1 0
    12000 10000 2 0
    12100 12000 3 0
    12101 12100 4 0
    14000 10000 2 0
    14100 14000 3 0
    14101 14100 4 0
    14102 14100 4 0
    14200 14000 3 0
    14201 14200 4 0
    14300 14000 3 0
    14301 14300 4 0
    14400 14000 3 0
    14401 14400 4 0
    14402 14400 4 0

    Por una serie de datos obtenidos llego a esta otra tabla Solicitudes con importes. Sólo tengo importe en códigos Nivel=4 y puedo tener en unos si y en otros no.

    DATOS CON IMPORTE
              Código          Padre             Nivel      IMPORTE
    14101 14100 4 120
    14102 14100 4 50
    14301 14300 4 30
    14401 14400 4 25

    Con los datos de la tabla Solicitudes en unión con la tabla Registros necesito sólo agregar los niveles de 1 a 3 que tengan correspondencia con los datos de nivel 4 que tienen importe. Quedaría así.

    TABLA  A ARMAR
           Código          Padre              Nivel       IMPORTE
    10000 0 1 0
    14000 10000 2 0
    14100 14000 3 0
    14101 14100 4 120
    14102 14100 4 50
    14300 14000 3 0
    14301 14300 4 30
    14400 14000 3 0
    14401 14400 4 25

    El fin de todo es hacer sumas por niveles. Ya tengo la sentencia que me suma haciendo un INNER JOIN de la misma tabla y sumando IMPORTE. 

    TABLA  FINAL CON SUMAS
           Código           Padre            Nivel       IMPORTE
    10000 0 1 225
    14000 10000 2 225
    14100 14000 3 170
    14101 14100 4 120
    14102 14100 4 50
    14300 14000 3 30
    14301 14300 4 30
    14400 14000 3 25
    14401 14400 4 25

    Espero haberme explicado, les agradezco su ayuda.

    jueves, 25 de agosto de 2016 17:38

Respuestas

  • Eso esta mejor, vez :)

    A proposito, creo se te fue una fila dos veces (codigo 12000). Muestra de que usar clave primaria es importante.

    Aca tienes el codigo. Lo desglose con el proposito de explicar que hace cada parte pero en realidad solo necesitas la parte combinada.

    SET NOCOUNT ON;
    GO
    CREATE TABLE #Registros(
    	[Codigo] [numeric](5, 0) NOT NULL,
    	[Padre] [numeric](5, 0) NOT NULL,
    	[Nivel] [numeric](1, 0) NOT NULL,
    	[Importe] [numeric](12, 2) NOT NULL
    ) ON [PRIMARY]
    GO
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(10000,	0,	1,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(12000,	10000,	2,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(12100,	12000,	3,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(12101,	12100,	4,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14000,	10000,	2,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14100,	14000,	3,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14101,	14100,	4,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14102,	14100,	4,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14200,	14000,	3,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14201,	14200,	4,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14300,	14000,	3,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14301,	14300,	4,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14400,	14000,	3,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14401,	14400,	4,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14402,	14400,	4,	0)
    GO
    CREATE TABLE #Solicitudes(
    	[Codigo] [numeric](5, 0) NOT NULL,
    	[Padre] [numeric](5, 0) NOT NULL,
    	[Nivel] [numeric](1, 0) NOT NULL,
    	[Importe] [numeric](12, 2) NOT NULL
    )
    GO
    INSERT INTO #Solicitudes([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14101,	14100,	4,	120)
    INSERT INTO #Solicitudes([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14102,	14100,	4,	50)
    INSERT INTO #Solicitudes([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14301,	14300,	4,	30)    
    INSERT INTO #Solicitudes([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14401,	14400,	4,	25)
    GO
    -- Codigo que muestra como generar el Transitive Closure
    WITH TC AS (
    SELECT
        Codigo,
        Codigo AS descendiente
    FROM
        #Registros
    UNION ALL
    SELECT 
    	P.Codigo,
        C.Codigo AS descendiente
    FROM
    	TC AS P
        INNER JOIN
        #Registros AS C
        ON C.Padre = P.descendiente
    )
    SELECT 
    	TC.Codigo,
        TC.descendiente 
    FROM
    	TC
    ORDER BY
        TC.Codigo,
        TC.descendiente;
    
    -- Codigo que muestra como combinar el Transitive Closure y la tabla solicitudes para agregar
    WITH TC AS (
    SELECT
        Codigo,
        Codigo AS descendiente
    FROM
        #Registros
    UNION ALL
    SELECT 
    	P.Codigo,
        C.Codigo AS descendiente
    FROM
    	TC AS P
        INNER JOIN
        #Registros AS C
        ON C.Padre = P.descendiente
    )
    SELECT 
    	TC.Codigo,
        SUM(S.Importe) AS total_importe
    FROM
    	TC
        INNER JOIN
        #Solicitudes AS S
        ON S.Codigo = TC.descendiente
    GROUP BY
        TC.Codigo;
    
    -- Codigo que muestra como recorrer jerarqueia
    WITH H AS (
    SELECT 
    	Codigo,
        Padre,
        Nivel,
        CAST(Codigo AS varbinary(MAX)) AS sort_order
    FROM
    	#Registros
    WHERE
        Padre = 0
    UNION ALL
    SELECT 
    	C.Codigo,
        C.Padre,
        C.Nivel,
        CAST(P.sort_order + CAST(CAST(C.Codigo AS int) AS binary(4)) AS varbinary(MAX))
    FROM
    	H AS P
        INNER JOIN
        #Registros AS C
        ON C.Padre = P.Codigo
    )
    SELECT 
    	REPLICATE('|', (H.Nivel - 1) * 8) + STR(H.Codigo, 5, 0) AS Codigo,
        H.Padre,
        H.Nivel,
        H.sort_order
    FROM
    	H
    ORDER BY
        sort_order;
    
    -- Poner todos los codigos a trabajar de forma conjunta 
    -- Generar el Transitive Closure
    WITH TC AS (
    SELECT
        Codigo,
        Codigo AS descendiente
    FROM
        #Registros
    UNION ALL
    SELECT 
    	P.Codigo,
        C.Codigo AS descendiente
    FROM
    	TC AS P
        INNER JOIN
        #Registros AS C
        ON C.Padre = P.descendiente
    )
    -- Calcular agregacion
    , AGG AS (
    SELECT 
    	TC.Codigo,
        SUM(S.Importe) AS total_importe
    FROM
    	TC
        INNER JOIN
        #Solicitudes AS S
        ON S.Codigo = TC.descendiente
    GROUP BY
        TC.Codigo
    )
    -- Recorrer jerarqueia
    , H AS (
    SELECT 
    	Codigo,
        Nivel,
        CAST(Codigo AS varbinary(MAX)) AS sort_order
    FROM
    	#Registros
    WHERE
        Padre = 0
    UNION ALL
    SELECT 
    	C.Codigo,
        C.Nivel,
        CAST(P.sort_order + CAST(CAST(C.Codigo AS int) AS binary(4)) AS varbinary(MAX))
    FROM
    	H AS P
        INNER JOIN
        #Registros AS C
        ON C.Padre = P.Codigo
    )
    SELECT 
    	REPLICATE('|', (H.Nivel - 1) * 8) + STR(H.Codigo, 5, 0) AS Codigo,
        H.Nivel,
        COALESCE(AGG.total_importe, 0.00) AS total_importe
    FROM
    	H
        LEFT OUTER JOIN
        AGG
        ON AGG.Codigo = H.Codigo
    ORDER BY
        sort_order;
    GO
    DROP TABLE #Registros, #Solicitudes;
    GO

    Aca el resultado:

    Si no deseas las filas con total importe igual a cero entonces agrega el filtro en la sentencia SELECT final.

    Por ultimo y no menos importante, porque usas el tipo de dato numeric(5, 0) si puedes hacer lo mismo con [int]?


    AMB

    Some guidelines for posting questions...

    AYÚDANOS A AYUDARTE, guía básica de consejos para formular preguntas


    • Editado HunchbackMVP viernes, 26 de agosto de 2016 14:36
    • Propuesto como respuesta Enric Vives viernes, 26 de agosto de 2016 14:45
    • Marcado como respuesta Zyanya5 lunes, 29 de agosto de 2016 14:16
    viernes, 26 de agosto de 2016 14:34

Todas las respuestas

  • Para preguntas como esta, es aconsejable postear la estructura de las tablas (solo columnas de interes) asi como datos de ejemplo en forma de sentencias INSERt y resultados esperados. De esa forma tendremos con que probar nuestras sugerencias sin tener que mal gastar nuestro tiempo recreando to ambiente.

    En cuanto a la solucion, el estandar SQL no cuenta con operador alguno que permita hacer rollup en una jerarquia.

    Una forma de hacerlo es usando el concepto de "Transitive Closure" en la teoria de grafos, pero con un pequenio trueque.

    http://www.geeksforgeeks.org/transitive-closure-of-a-graph/

    La clave es formar una tabla o conjunto donde se combina cada codigo con todos sus descendientes, incluyendo a él consigo mismo si es que este tambien puede estar asociado a un importe. Veamos un ejemplo:

    El padre 14100 tiene los descendientes 14101 y 14102 por lo que el TC seria:

    codigo  descendiente
    14100 14100
    14100 14101
    14100 14102
    14101 14101
    14102 14102

    Si ahora unes este resultado con la tabla de importes usando el codigo de los descendientes (segundo codigo en el ejemplo), entonces tendriamos:

    14100 14100 -> 0
    14100 14101 -> 120
    14100 14102 - >50
    14101 14101 -> 120
    14102 14102 -> 50

    ahora agrupamos por codigo (primera columna) y agregamos:

    14100 -> 170
    14101 -> 120
    14102 -> 50

    Cogistes la idea?

    Para generar el TC puedes usar una CTE recursiva que permita navegar la jerarquia. Luego unes esta con la tabla de impuestos para hacer la agregacion. Otra CTE que recorrar la jerarquia y que unas con la agregacion para mostrar el resultado final.

    Ahora no tengo tiempo para escribir la solucion completa (hora de irme a casa). Mañana podria dedicarle unos minutos pero seria de ayuda que postees la estructura de la tabla y datos de ejemplos. Algo asi como:

    create table dbo.T1 (col1 int not null primary key, clo2 char(8) null);
    
    insert into dbo.T1 (col1, col2) 
    values (1, 'uno'), (2, 'dos');
    
    --...


    Puedes leer mas sobre este tema en el libro de Itzik Ben-Gan sobre T-SQL Querying.

    Aca un post que hice hace algun tiempo en el foro de T-SQL en ingles.

    https://social.technet.microsoft.com/Forums/sqlserver/en-US/146c5699-c659-4c34-9930-b722879e62e1/sql-query-recursive?forum=transactsql


    AMB

    Some guidelines for posting questions...

    AYÚDANOS A AYUDARTE, guía básica de consejos para formular preguntas



    jueves, 25 de agosto de 2016 20:14
  • Gracias AMB por tu ayuda...  Es la primera vez que pregunto, por eso no sabía bien la dinámica.  Te paso lo que me has pedido.  Estoy analizando y leyendo lo que me dices sobre  el concepto de "Transitive Closure", aun estoy echa un lío.  Seguiré intentando entender.. Gracias.   Actualmente hago estoy con cursores, pero le lleva mucho tiempo al procedimiento y estoy tratando de optimizar.

    CREATE TABLE [dbo].[Registros](
    	[Codigo] [numeric](5, 0) NOT NULL,
    	[Padre] [numeric](5, 0) NOT NULL,
    	[Nivel] [numeric](1, 0) NOT NULL,
    	[Importe] [numeric](12, 2) NOT NULL
    ) ON [PRIMARY]
    
    GO
    
    
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(10000,	0,	1,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(12000,	10000,	2,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(12000,	10000,	2,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(12100,	12000,	3,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(12101,	12100,	4,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14000,	10000,	2,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14100,	14000,	3,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14101,	14100,	4,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14102,	14100,	4,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14200,	14000,	3,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14201,	14200,	4,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14300,	14000,	3,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14301,	14300,	4,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14400,	14000,	3,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14401,	14400,	4,	0)
    INSERT INTO [Registros]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14402,	14400,	4,	0)
    
    
    CREATE TABLE [dbo].[Solicitudes](
    	[Codigo] [numeric](5, 0) NOT NULL,
    	[Padre] [numeric](5, 0) NOT NULL,
    	[Nivel] [numeric](1, 0) NOT NULL,
    	[Importe] [numeric](12, 2) NOT NULL
    ) ON [PRIMARY]
    
    GO
    
    INSERT INTO [Solicitudes]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14101,	14100,	4,	120)
    INSERT INTO [Solicitudes]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14102,	14100,	4,	50)
    INSERT INTO [Solicitudes]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14301,	14300,	4,	30)    
    INSERT INTO [Solicitudes]([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14401,	14400,	4,	25)


    • Editado Zyanya5 jueves, 25 de agosto de 2016 21:08 Agregar aclaración.
    jueves, 25 de agosto de 2016 21:05
  • Eso esta mejor, vez :)

    A proposito, creo se te fue una fila dos veces (codigo 12000). Muestra de que usar clave primaria es importante.

    Aca tienes el codigo. Lo desglose con el proposito de explicar que hace cada parte pero en realidad solo necesitas la parte combinada.

    SET NOCOUNT ON;
    GO
    CREATE TABLE #Registros(
    	[Codigo] [numeric](5, 0) NOT NULL,
    	[Padre] [numeric](5, 0) NOT NULL,
    	[Nivel] [numeric](1, 0) NOT NULL,
    	[Importe] [numeric](12, 2) NOT NULL
    ) ON [PRIMARY]
    GO
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(10000,	0,	1,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(12000,	10000,	2,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(12100,	12000,	3,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(12101,	12100,	4,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14000,	10000,	2,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14100,	14000,	3,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14101,	14100,	4,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14102,	14100,	4,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14200,	14000,	3,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14201,	14200,	4,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14300,	14000,	3,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14301,	14300,	4,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14400,	14000,	3,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14401,	14400,	4,	0)
    INSERT INTO #Registros([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14402,	14400,	4,	0)
    GO
    CREATE TABLE #Solicitudes(
    	[Codigo] [numeric](5, 0) NOT NULL,
    	[Padre] [numeric](5, 0) NOT NULL,
    	[Nivel] [numeric](1, 0) NOT NULL,
    	[Importe] [numeric](12, 2) NOT NULL
    )
    GO
    INSERT INTO #Solicitudes([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14101,	14100,	4,	120)
    INSERT INTO #Solicitudes([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14102,	14100,	4,	50)
    INSERT INTO #Solicitudes([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14301,	14300,	4,	30)    
    INSERT INTO #Solicitudes([Codigo],[Padre],[Nivel],[Importe])
         VALUES(14401,	14400,	4,	25)
    GO
    -- Codigo que muestra como generar el Transitive Closure
    WITH TC AS (
    SELECT
        Codigo,
        Codigo AS descendiente
    FROM
        #Registros
    UNION ALL
    SELECT 
    	P.Codigo,
        C.Codigo AS descendiente
    FROM
    	TC AS P
        INNER JOIN
        #Registros AS C
        ON C.Padre = P.descendiente
    )
    SELECT 
    	TC.Codigo,
        TC.descendiente 
    FROM
    	TC
    ORDER BY
        TC.Codigo,
        TC.descendiente;
    
    -- Codigo que muestra como combinar el Transitive Closure y la tabla solicitudes para agregar
    WITH TC AS (
    SELECT
        Codigo,
        Codigo AS descendiente
    FROM
        #Registros
    UNION ALL
    SELECT 
    	P.Codigo,
        C.Codigo AS descendiente
    FROM
    	TC AS P
        INNER JOIN
        #Registros AS C
        ON C.Padre = P.descendiente
    )
    SELECT 
    	TC.Codigo,
        SUM(S.Importe) AS total_importe
    FROM
    	TC
        INNER JOIN
        #Solicitudes AS S
        ON S.Codigo = TC.descendiente
    GROUP BY
        TC.Codigo;
    
    -- Codigo que muestra como recorrer jerarqueia
    WITH H AS (
    SELECT 
    	Codigo,
        Padre,
        Nivel,
        CAST(Codigo AS varbinary(MAX)) AS sort_order
    FROM
    	#Registros
    WHERE
        Padre = 0
    UNION ALL
    SELECT 
    	C.Codigo,
        C.Padre,
        C.Nivel,
        CAST(P.sort_order + CAST(CAST(C.Codigo AS int) AS binary(4)) AS varbinary(MAX))
    FROM
    	H AS P
        INNER JOIN
        #Registros AS C
        ON C.Padre = P.Codigo
    )
    SELECT 
    	REPLICATE('|', (H.Nivel - 1) * 8) + STR(H.Codigo, 5, 0) AS Codigo,
        H.Padre,
        H.Nivel,
        H.sort_order
    FROM
    	H
    ORDER BY
        sort_order;
    
    -- Poner todos los codigos a trabajar de forma conjunta 
    -- Generar el Transitive Closure
    WITH TC AS (
    SELECT
        Codigo,
        Codigo AS descendiente
    FROM
        #Registros
    UNION ALL
    SELECT 
    	P.Codigo,
        C.Codigo AS descendiente
    FROM
    	TC AS P
        INNER JOIN
        #Registros AS C
        ON C.Padre = P.descendiente
    )
    -- Calcular agregacion
    , AGG AS (
    SELECT 
    	TC.Codigo,
        SUM(S.Importe) AS total_importe
    FROM
    	TC
        INNER JOIN
        #Solicitudes AS S
        ON S.Codigo = TC.descendiente
    GROUP BY
        TC.Codigo
    )
    -- Recorrer jerarqueia
    , H AS (
    SELECT 
    	Codigo,
        Nivel,
        CAST(Codigo AS varbinary(MAX)) AS sort_order
    FROM
    	#Registros
    WHERE
        Padre = 0
    UNION ALL
    SELECT 
    	C.Codigo,
        C.Nivel,
        CAST(P.sort_order + CAST(CAST(C.Codigo AS int) AS binary(4)) AS varbinary(MAX))
    FROM
    	H AS P
        INNER JOIN
        #Registros AS C
        ON C.Padre = P.Codigo
    )
    SELECT 
    	REPLICATE('|', (H.Nivel - 1) * 8) + STR(H.Codigo, 5, 0) AS Codigo,
        H.Nivel,
        COALESCE(AGG.total_importe, 0.00) AS total_importe
    FROM
    	H
        LEFT OUTER JOIN
        AGG
        ON AGG.Codigo = H.Codigo
    ORDER BY
        sort_order;
    GO
    DROP TABLE #Registros, #Solicitudes;
    GO

    Aca el resultado:

    Si no deseas las filas con total importe igual a cero entonces agrega el filtro en la sentencia SELECT final.

    Por ultimo y no menos importante, porque usas el tipo de dato numeric(5, 0) si puedes hacer lo mismo con [int]?


    AMB

    Some guidelines for posting questions...

    AYÚDANOS A AYUDARTE, guía básica de consejos para formular preguntas


    • Editado HunchbackMVP viernes, 26 de agosto de 2016 14:36
    • Propuesto como respuesta Enric Vives viernes, 26 de agosto de 2016 14:45
    • Marcado como respuesta Zyanya5 lunes, 29 de agosto de 2016 14:16
    viernes, 26 de agosto de 2016 14:34
  • Gracias.. respondo a tu pregunta. En realidad es una tabla de ejemplo, mi tabla original tiene más dígitos y niveles, que requiero usar para tal fin numeric y seguí con el mismo tipo de datos.

    He estado probando esta sentencia 

    select t1.codigo, SUM(t2.Importe) AS TOTAL  from #Registros as t1 
    inner join #Solicitudes as t2 
    on (t2.codigo like (SUBSTRING (str(t1.codigo,5),1,t1.nivel))+'%') and t1.nivel<>4
    group by t1.codigo

    La cual me hace la suma, me trae sólo los registros padre que tienen hijos con importe. Lo único que tengo que hacer es en este resultado hacer un join con la tabla de Solicitudes para tener completo el resultado.  Aún lo estoy probando para ver si hay algo raro.    Resulta que mi tabla Registros tiene más de 8,000 (registros/filas)  y con el Transitive Closure me manda error de máxima recursión.  He estado leyendo que le puedes poner 0 para que no tenga límite, lo probaré y ya te aviso como me va.  Gracias.


    Zyanya

    viernes, 26 de agosto de 2016 18:58
  • Buen día AMB

    Estuve probando con datos reales, como te comenté el viernes, el código que me sugieres y de 8 segundos que duraba el sp que tenía bajó a 2 segundos.  :)   Muchas gracias por tu ayuda y disposición a apoyarme.  Aún estoy afinándolo. 

    Saludos.


    Zyanya

    lunes, 29 de agosto de 2016 14:18