PIVOT con Linq

Question

Hola desarrolladores, tengo una duda, tengo un list y quisiera hacerle un pivot para tener algunas filas en columnas, eso es posible desde linq??

Aquí tengo la consulta que hice pero la idea es hacerlo desde la lista que tengo en C# ya que tengo la informacion en memoria.

SELECT centro,
       ROUND(MAX(DECODE(codestrato, 11, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS E1,
       ROUND(MAX(DECODE(codestrato, 12, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS E2,
       ROUND(MAX(DECODE(codestrato, 13, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS E3,
       ROUND(MAX(DECODE(codestrato, 14, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS E4,
       ROUND(MAX(DECODE(codestrato, 15, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS E5,
       ROUND(MAX(DECODE(codestrato, 16, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS E6,
       ROUND(MAX(DECODE(codestrato, 21, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) + ROUND(MAX(DECODE(codestrato, 22, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS COMERCIAL,
       ROUND(MAX(DECODE(codestrato, 31, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS A,
       CASE ROUND(MAX(DECODE(codestrato, 32, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) WHEN NULL THEN 0 END AS B,
       ROUND(MAX(DECODE(codestrato, 35, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS C,
       ROUND(MAX(DECODE(codestrato, 36, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS D,
       ROUND(MAX(DECODE(codestrato, 37, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS E,
       ROUND(MAX(DECODE(codestrato, 38, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS F,
       ROUND(MAX(DECODE(codestrato, 39, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS G,
       ROUND(MAX(DECODE(codestrato, 50, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS H,
       ROUND(MAX(DECODE(codestrato, 51, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS I,
       ROUND(MAX(DECODE(codestrato, 52, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS INDUSTRIAL,
       ROUND(MAX(DECODE(codestrato, 33, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS E33,       
       ROUND(MAX(DECODE(codestrato, 41, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS E41,
       ROUND(MAX(DECODE(codestrato, 42, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS E42,
       ROUND(MAX(DECODE(codestrato, 43, CASE faccorriente WHEN 0 THEN 0 ELSE (reccorriente + recvencido)/faccorriente END)),4) AS E43
FROM facrec_mensual
WHERE periodo = '201702'
GROUP BY centro
ORDER BY centro

Es posible hacer esa consulta en linq con los datos que tengo en la list??

Answer 1

No, en LINQ no existe una instrucción para hacer PIVOT. Pero si ya tienes la información en memoria, tampoco es muy necesaria esa instrucción. Simplemente, cuando vayas a procesar la información, en lugar de poner un bucle que la recorra por filas y dentro del bucle recorrer las columnas, invierte el orden en el código fuente de forma que proceses las columnas y dentro metes el bucle que recorre las filas. Es un simple cambio en el orden de las sentencias en el código fuente, y con eso logras extraer la información en el mismo orden en el que te la habría entregado el Pivot.

Answer 2

No, en LINQ no existe una instrucción para hacer PIVOT. Pero si ya tienes la información en memoria, tampoco es muy necesaria esa instrucción. Simplemente, cuando vayas a procesar la información, en lugar de poner un bucle que la recorra por filas y dentro del bucle recorrer las columnas, invierte el orden en el código fuente de forma que proceses las columnas y dentro metes el bucle que recorre las filas. Es un simple cambio en el orden de las sentencias en el código fuente, y con eso logras extraer la información en el mismo orden en el que te la habría entregado el Pivot.

Hola Alberto. No te entendí cómo sería lo de invertir el código fuentes?

Answer 3

Bueno, yo partía de la presunción de que, si vas a ejecutar una sentencia linq sobre una tabla en memoria es porque quieres luego procesar los datos devueltos por esa consulta y hacer algo con ellos. Y para procesar los datos que devuelve, lo normal es que tengas que hacer un bucle que los vaya recorriendo y que dentro del bucle vayas accediendo a los distintos campos. Si quieres, pon aquí el bucle tal como lo habrías hecho si la sentencia linq existiera y te devolviese los datos pivotados (y pon también la estructura de la lista original sobre la que pretendías ejecutar la sentencia), y te indico cómo alterarlo para que en lugar de acceder a las columnas dentro del bucle se acceda al bucle dentro de las columnas.

Answer 4

Hola alberto, es que no tengo la sentencia linq ya que lo que quiero es solo cambiar de sentido los registros, osea los tengo asi en memoria

201701        Bogotá          11            23000

201701        Bogotá          12            40000

201701        Bogotá          13            50000

201701        Medellin        11            23000

201701        Medellin        12            31000

201701        Medellin        13            90000

y Quiero tenerlos ahora asi

201701      Bogota        11         23000       12        40000         13       50000

201701      Medellin      11         23000       12        31000         13       90000

Answer 5

y Quiero tenerlos ahora asi

¿A qué le llamas "tenerlos"? En realidad no los tienes de ninguna manera, lo que tienes es una colección de unos y ceros en memoria, que se puede interpretar de cualquier manera. Seguramente lo que quieres no es "tenerlos" sino "procesarlos" en cierto orden. Es decir, quieres irlos extrayendo de donde están almacenados, y al extraerlos que salgan en determinado orden. ¿Y cómo los extraerías normalmente? Pues con un bucle que diga algo así como for fila=1 to N for columna =1 to M hacerAlgo(N,M). Para sacar los datos en el otro orden, cámbialo por for columna=1 to M for fila=1 to N hacerAlgo(N,M).

Evidentemente esa es una "pseudo-sintaxis", la forma concreta en la que se escriban los bucles dependerá de la estructura del objeto que guarda esos datos en memoria, y del lenguaje de programación que estés usando.