Início / coding / Perguntas / 76921714
Accepted
Leyla Elkhamlichi
Asked: 2023-08-17 20:51:42 +0800 CST

o cálculo da porcentagem de uma coluna é a tabela neo4j/Cypher

  • 772

Quero calcular a porcentagem de quanto cada tipo de habilidade está presente para cada ocupação. Eu fiz uma ocupação de nós diferentes e Soft_skills eles têm um relacionamento [r:MAPS_TO] o relacionamento tem dois tipos de propriedade ('essentieel', 'optioneel') e b (esse tipo de peso essentieel = 1,0 e optioneel = 0,5)

veja abaixo um exemplo do arquivo que estou usando

ocupação código_ocupação skill_code nome tipo b
dokter sk_565 sk_687 aprender opcional 0,5
dokter sk_565 sk_687 aprender opcional 0,5
dokter sk_565 sk_687 aprender essencial 1,0
dokter sk_565 sk_687 aprender essencial 1,0

fiz uma consulta onde posso calcular qual é a soma de cada ocupação veja abaixo minha consulta:

match (b:BOC_beroep)-[r:MAPS_TO]-(s:Soft_Skill)                                                     
return b.beroepstitel as beroep,                             
sum(toFloat(r.b)) as sum order by sum desc                         
limit 10

esta é a minha saída

beroep soma
Doker 5
Kapper 7

sei que quero atingir qual é a porcentagem do tipo de habilidade que meu cálculo será

Dokter have in total 4 skills en the percentage of each skill is 
2/4 * 100 = 50% essentieel 
1/4 * 100 = 25% optioneel 

i was trying to make a new calculation with this query:

  MATCH (b:BOC_beroep)-[r:MAPS_TO]->(s:Soft_skill)
  WITH SUM(toFloat(r.b)) As total
  MATCH (b:BOC_beroep)-[r:MAPS_TO]->(s:Soft_Skill)
  RETURN b.beroepstitel  AS beroep, 
  (toFloat(total/(r.b)))*100 AS percent
  order by percent desc

Minha saída é Não é possível dividir 'Long' por 'string' Não entendo o erro

fui inspirado por esta pergunta e resposta Aqui está um link embutido para stackoverflow .

neo4j

2 respostas

  1. Pelo que entendi, você pode querer algo assim:

    MATCH (b:BOC_beroep)-[r:MAPS_TO]->(s:Soft_Skill)
WITH SUM(1) AS total, r.type AS type, COLLECT(r.b) AS type_sum
WITH REDUCE(total=0, number in type_sum | total + number) AS type_sum, type, total
WITH COLLECT ({type: type, type_sum: toFloat(type_sum)}) AS data, SUM(total) AS total
UNWIND data AS d
WITH d.type_sum / total * 100 AS percent, d.type AS type
RETURN percent, type
ORDER BY percent DESC

    Qual para dados de exemplo:

    MERGE (a1:BOC_beroep {occupation: 'dokter', code_occupation: 'sk_565'})  
MERGE (a2:Soft_Skill {skill_code: 'sk_687', name: 'leren'}) 
MERGE (a1)-[:MAPS_TO{type:"optioneel", b:0.5, k:1}]-(a2)
MERGE (a1)-[:MAPS_TO{type:"optioneel", b:0.5, k:2}]-(a2)
MERGE (a1)-[:MAPS_TO{type:"essentieel", b:1, k:3}]-(a2)
MERGE (a1)-[:MAPS_TO{type:"essentieel", b:1, k:4}]-(a2)

    Retorna:

    ╒═════════╤════════════╕
│"percent"│"type"      │
╞═════════╪════════════╡
│50.0     │"essentieel"│
├─────────┼────────────┤
│25.0     │"optioneel" │
└─────────┴────────────┘
    • 1
  2. Best Answer

    Seus MAPS_TOrelacionamentos aparentemente armazenam sua bpropriedade como uma string, portanto, qualquer consulta deve sempre convertê-la em float para fazer matemática com ela. Além disso, a matemática em sua consulta está errada - r.bdeve estar no numerador e totalno denominador.

    Esta consulta pode funcionar para você:

    MATCH (b:BOC_beroep)-[r:MAPS_TO]->(s:Soft_Skill)
WITH b.beroepstitel AS beorep, r.type AS type, s.name AS skill, SUM(TOFLOAT(r.b)) AS weight
WITH SUM(weight) As total, COLLECT([beorep, type, skill, weight]) AS data
UNWIND data AS datum
RETURN
  datum[0] AS beroep,
  datum[1] AS type,
  datum[2] AS skill,
  datum[3]/total*100 AS percent
ORDER BY percent desc

    A primeira WITHcláusula soma todos os pesos para um determinado beorep, typee skill. A segunda WITHcláusula calcula um total de todos os pesos e coleta todos os outros dados necessários. O resto da consulta é simples.

    Aqui está um resultado de amostra:

    ╒════════╤════════════╤═══════╤═════════════════╕
│beroep  │type        │skill  │percent          │
╞════════╪════════════╪═══════╪═════════════════╡
│"dokter"│"essentieel"│"leren"│66.66666666666666│
├────────┼────────────┼───────┼─────────────────┤
│"dokter"│"optioneel" │"leren"│33.33333333333333│
└────────┴────────────┴───────┴─────────────────┘

    Recomendações

    1. Se você armazenou a bpropriedade como float em vez de string, pode evitar o custo de fazer TOFLOATconversões o tempo todo. Você pode converter facilmente todos os pesos armazenados desta maneira:

      MATCH ()-[r:MAPS_TO]->()
SET r.b = TOFLOAT(r.b)

    2. Se typetiver apenas 2 valores possíveis, seria necessário menos espaço de armazenamento para armazenar essa propriedade como um booleano (chamado, digamos, isRequired). Isso também pode simplificar as consultas usando essa propriedade. Você pode facilmente converter essa propriedade desta maneira:

      MATCH ()-[r:MAPS_TO]->()
SET r.isRequired = CASE r.type WHEN 'essentieel' THEN true ELSE false END
REMOVE r.type
    • 0

relate perguntas