Mais

Iterate Row Selection leva muito do modelo para o loop do ModelBuilder?

Iterate Row Selection leva muito do modelo para o loop do ModelBuilder?


Estou um pouco preso a um modelo relativamente simples.

O que eu quero:

1) Crie uma tabela de "resultados".

2) Loop sobre "Pontos".

3) Faça algum buffer e contagem

4) Coloque os resultados (OBJECTID e contagem) em "resultados" via "addRecord"

5) Vá para 2

O que ele faz: 1) -> 2) -> 3) -> 4) e então cria "resultados" novamente que de alguma forma esvazia os resultados.

Alguma dica?

addRecord se parece com isto:

import arcpy infile = arcpy.GetParameterAsText (0) IDFieldValue = long (arcpy.GetParameterAsText (1)) CountFieldValue = arcpy.GetParameterAsText (2) rows = arcpy.InsertCursor (infile) row = rows.newRow () row.setValue () ", IDFieldValue) row.setValue (" count ", CountFieldValue) rows.insertRow (row) del row del rows


Você precisa separar seu modelo em dois modelos. Como você a tem agora, a tabela de resultados é criada a cada iteração. A etapa 1 precisa estar em um modelo separado que chama um submodelo, que executa o restante das etapas. Consulte este arquivo de ajuda para saber como configurar modelos aninhados.


A criação de documentos Excel é muito lenta

Em anexo está um código genérico que escrevi para criar um arquivo Excel com x número de planilhas.

O problema que estou tendo é que é muito lento, como 5 segundos por folha. Era meu entendimento que usar um loop for ao criar as tabelas era o ideal, mas o problema parece ser com tabelas contendo mais de mil ou mais registros. Eu ainda não acho que deveria demorar tanto.

Quaisquer sugestões serão apreciadas. Além disso, se eu estiver completamente perdido com este código, deixe-me saber que os recursos de código do Excel atualizados parecem ser difíceis de encontrar.


5 respostas 5

Eu não faria isso com um loop; existem alternativas muito melhores. De longe o melhor, quando você ter dividir, é CLR, e a abordagem de Adam Machanic é a mais rápida que testei.

A próxima melhor abordagem IMHO, se você não puder implementar CLR, é uma tabela de números:

. que permite esta função:

Acredito que tudo isso terá um desempenho melhor do que a função que você tem, quando você faz com que funcione, especialmente porque eles são embutidos em vez de múltiplas instruções. Não investiguei por que o seu não está funcionando, porque não acho que vale a pena fazer essa função funcionar.

Mas isso tudo dito.

Já que você está usando o SQL Server 2008, há um motivo para você precisar dividir em primeiro lugar? Eu prefiro usar um TVP para isso:

Agora você pode aceitar isso como um parâmetro para seus procedimentos armazenados e usar o conteúdo da mesma forma que faria com um TVF:

E você pode passar um TVP diretamente de C # etc. como um DataTable. Isso quase certamente superará qualquer uma das soluções acima, especialmente se você estiver construindo uma string separada por vírgulas em seu aplicativo especificamente para que seu procedimento armazenado possa chamar um TVP para separá-lo novamente. Para mais informações sobre TVPs, veja o excelente artigo de Erland Sommarskog.

Mais recentemente, escrevi uma série sobre divisão de strings:

E se você estiver usando o SQL Server 2016 ou mais recente (ou Banco de Dados SQL do Azure), há uma nova função STRING_SPLIT, sobre a qual escrevi aqui:


3 respostas 3

Como você não está fazendo nenhuma alteração nos objetos existentes, pode definir a propriedade AutoDetectChangesEnabled do seu contexto como false.

Obtém ou define um valor que indica se o método DetectChanges é chamado automaticamente por métodos de DbContext e classes relacionadas. O valor padrão é verdadeiro.

Chamar o Add chama o método DetectChanges todas as vezes e é caro. Desligue-o e, no final, ligue-o novamente.

Além disso, você chama o método SaveChanges cada iteração em seu loop. Isso significa que você faz uma chamada para seu banco de dados a cada iteração para persistir essa entidade, o que é intenso e demorado. Coloque essa linha de código fora do seu loop.

É muito mais eficiente fazer 1 chamada para muitos itens do que muitas chamadas para 1 item!


Sessão de atualização de SQL demorando muito / alto uso de disco por horas

Sim, parece um problema muito genérico, mas ainda não consegui restringi-lo muito.

Portanto, tenho uma instrução UPDATE em um arquivo em lote sql:

B tem 40k registros, A tem 4M registros e eles estão relacionados 1-para-n via A.B_ID, embora não haja FK entre os dois.

Então, basicamente, estou pré-calculando um campo para fins de mineração de dados. Embora eu tenha mudado o nome das tabelas para esta questão, não mudei a instrução, é realmente tão simples.

Isso leva horas para ser executado, então decidi cancelar tudo. O banco de dados foi corrompido, então eu o apaguei, restaurei um backup que fiz pouco antes de executar a instrução e decidi entrar em mais detalhes com um cursor:

Agora posso vê-lo rodando com uma mensagem com o id decrescente. O que acontece é que leva cerca de 5 minutos para ir de para>

E então, na id 13, por algum motivo, parece travar. O DB não tem nenhuma conexão com ele além do SSMS, mas não está realmente suspenso:

    o disco rígido está funcionando continuamente, então ele definitivamente está fazendo algo (eu verifiquei no Process Explorer se é realmente o processo sqlserver.exe que o está usando)

Executei sp_who2, encontrei o SPID (70) da sessão SUSPENDED e executei o seguinte script:

select * from sys.dm_exec_requests r join sys.dm_os_tasks t on r.session_id = t.session_id onde r.session_id = 70

Isso me dá o wait_type, que é PAGEIOLATCH_SH na maioria das vezes, mas na verdade muda para WRITE_COMPLETION às vezes, o que eu acho que acontece quando está limpando o log

Outras informações talvez úteis:

  • o número de registros na tabela A para B_ID 13 não é grande (14)
  • Minha colega não tem o mesmo problema na máquina dela, com uma cópia deste DB (de alguns meses atrás) com a mesma estrutura.
  • a tabela A é de longe a maior tabela do banco de dados
  • Ele tem vários índices e várias visualizações indexadas o utilizam.
  • Não há nenhum outro usuário no banco de dados, ele é local e nenhum aplicativo o está usando.
  • O tamanho do arquivo LDF não é limitado.
  • O modelo de recuperação é SIMPLES, o nível de compatibilidade é 100
  • Procmon não me dá muitas informações: sqlserver.exe está lendo e gravando muito nos arquivos MDF e LDF.

Ainda estou esperando que termine (já faz 1h30), mas esperava que talvez alguém me desse alguma outra ação que eu pudesse tentar resolver isso.

Editado: adicionando extrato do log do procmon

Usando DBCC PAGE, parece estar lendo e gravando em campos que se parecem com a tabela A (ou um de seus índices), mas para B_ID diferentes que 13. Reconstruindo índices, talvez?

Editado 2: plano de execução

Então, cancelei a consulta (na verdade, excluí o banco de dados e seus arquivos e, em seguida, restaurei-o) e verifiquei o plano de execução para:

O plano de execução (estimado) é o mesmo de qualquer B.ID e parece bastante simples. A cláusula WHERE usa uma busca de índice em um índice não agrupado de B, o JOIN usa uma busca de índice agrupado em ambos os PKs das tabelas. A busca de índice clusterizado em A usa paralelismo (x7) e representa 90% do tempo de CPU.

Mais importante, a execução da consulta com ID 13 é imediata.

Editado 3: fragmentação do índice

A estrutura dos índices é a seguinte:

B tem um PK clusterizado (não o campo ID) e um índice exclusivo não clusterizado, cujo primeiro campo é B.ID - esse segundo índice parece ser usado sempre.

A tem um PK agrupado (campo não relacionado).

Existem também 7 visualizações em A (todas incluem o campo A.X), cada uma com seu próprio PK agrupado e um outro índice que também inclui o campo A.X

As visualizações são filtradas (com campos que não estão nesta equação), então eu duvido que haja alguma maneira de o UPDATE A usar as próprias visualizações. Mas eles têm um índice incluindo A.X, portanto, alterar A.X significa escrever as 7 visualizações e os 7 índices que eles possuem que incluem o campo.

Embora se espere que o UPDATE seja mais lento para isso, não há razão para que um ID específico seja muito mais longo do que os outros.

Eu verifiquei a fragmentação de todos os índices, todos estavam em & lt0,1%, exceto os índices secundários das visualizações, tudo entre 25% e 50%. Fatores de preenchimento para todos os índices parecem ok, entre 90% e 95%.

Reorganizei todos os índices secundários e executei novamente meu script.

Ainda está enforcado, mas em um ponto diferente:

Enquanto anteriormente, o log de mensagens era assim:

Isso é estranho, porque significa que ele nem mesmo está travado no mesmo ponto do loop WHILE. O resto parece o mesmo: mesma linha UPDATE esperando em sp_who2, mesmo tipo de espera PAGEIOLATCH_EX e mesmo uso pesado de HD de sqlserver.exe.

O próximo passo é excluir todos os índices e visualizações e recriá-los, eu acho.

Editado 4: exclusão e reconstrução de índices

Portanto, excluí todas as visualizações indexadas que tinha na tabela (7 delas, 2 índices por visualização incluindo a clusterizada). Eu executei o script inicial (sem cursor), e ele realmente foi executado em 5 minutos.

Então o meu problema tem origem na existência desses índices.

Recriei meus índices depois de executar a atualização e demorou 16 minutos.

Agora eu entendo que os índices demoram para reconstruir, e estou realmente bem com a tarefa completa que leva 20 minutos.

O que eu ainda não entendo é por que quando eu executo a atualização sem excluir os índices primeiro, leva várias horas, mas quando eu os excluo primeiro e depois os recrio, leva 20 minutos. Não deveria demorar quase o mesmo tempo de qualquer maneira?


  • Ciclo de limpeza ultrarrápido de 1,5 horas
  • Software de mapeamento de última geração
  • Ação de escovagem tripla incrível
  • Recursos de filtragem superiores
  • Nunca fica preso em ralos
  • Ideal para piscinas no solo de até 50 pés.

O Dolphin Nautilus CC Supreme possui uma impressionante variedade de recursos avançados. Por exemplo, a maioria dos limpadores robóticos tem apenas duas escovas de esfregar. No entanto, o Supreme oferece uma terceira escova que gira em alta velocidade para eliminar a gosma desagradável das paredes e do chão da piscina.

Também possui quatro modos de limpeza com três ciclos cronometrados diferentes. Isso permite que você realize trabalhos de limpeza com maior precisão e eficiência.

Com 1,5 horas, esta máquina tem um dos tempos de limpeza mais rápidos de qualquer robô de piscina do planeta. Ao contrário de outros modelos, pode escalar as paredes da piscina para chegar à linha de água. E continuará a limpar implacavelmente até que todas as manchas, manchas e descolorações que prejudicam o fascínio visual de sua piscina sejam banidas para sempre.

O Dolphin Nautilus CC Supreme não vem com um caddie. Você acha que conseguiria um com um limpador robótico que custa tanto assim! Você também não tem um controle remoto. Provavelmente está tudo bem, porque com o aplicativo MyDolphin, você pode fazer tudo que um controlador faz.

Como a maioria dos outros robôs, não é muito bom subir escadas.

Os clientes estão em êxtase por ele não ficar preso nos ralos. Além disso, há um consenso esmagador de que este robô tem mais poder de sucção do que qualquer um que eles tenham tentado anteriormente.

Outra coisa que os usuários adoram é o quão fantástica é a poderosa ação da escova tripla em esfregar biofilme potencialmente tóxico de cada superfície da piscina. Por último, muitos clientes estão maravilhados com os recursos superiores de filtragem desta unidade.

O ciclo de limpeza mais rápido no Dolphin Nautilus Plus é de duas horas. No entanto, o Dolphin Nautilus CC Supreme supera isso com um tempo de limpeza de 1,5. O CC Plus também não faz um trabalho tão completo quanto o Supreme, então você pode ter que executá-lo mais de uma vez para limpar sua piscina.

A CC Plus também não possui a terceira escova de limpeza que a Supreme possui. Isso significa que não será possível limpar sua linha de água ou seu ralo. Leia nossa análise completa do Dolphin Nautilus CC Plus.

O Dolphin Nautilus CC está limitado à limpeza de piscinas com 35 pés de comprimento ou menos. No entanto, o Dolphin Nautilus Supreme pode limpar piscinas maiores & # 8211 até 50 pés, na verdade. O Dolphin Nautilus CC é muito mais barato porque não tem os recursos avançados do Supreme.

Além disso, o Dolphin Nautilus CC não tem um cabo anti-emaranhado, por isso é mais provável que se prenda a um obstáculo durante a limpeza.

Com um ciclo de limpeza de três horas, o Dolphin Nautilus leva muito mais tempo para fazer seu trabalho do que o Supreme. Além disso, remover os cartuchos para limpá-los é MUITO mais fácil no Supremo, porque eles carregam por cima em vez de por baixo.

Outra diferença entre os dois é que o Dolphin Nautilus tem apenas duas escovas padrão, enquanto a Supreme adiciona um depurador central de alta velocidade à mistura. Leia nossa análise completa do Dolphin Nautilus.


Por que R demora tanto para executar auto.arima (). Como posso encurtar o tempo de cálculo? [duplicado]

Tenho tentado fazer análises e modelar uma série de preços spot de gás natural. Com dados fornecidos pela API Qandl.

Toda a análise estava funcionando bem, no entanto, tenho problemas com a função auto.arima.

1- Se eu especificar a série NG como XTS, a função auto.arima não leva em consideração a sazonalidade. É uma chatice para o Gás Natural, pois o consumo desse recurso é totalmente voltado para a época do ano.

2- Se eu especificar a série NG como TS, a função auto.arima leva uma eternidade para calcular, e eu nem tenho certeza se ela pode finalizá-la. Como eu o deixei executar o cálculo por 20 minutos uma vez, e ele não poderia vir com uma resposta. Portanto, gostaria de saber se há um problema com meu código ou minha especificação. Sou novo em ciência de dados, é meu primeiro projeto de TS. Eu realmente amo o que estou fazendo!

O que você sugere que eu faça ? Eu estava pensando em especificar manualmente a função arima sazonal, mas não tenho as habilidades para fazer isso por enquanto, por onde devo começar a aprender como especificar a função sozinho? O que eu fiz de errado no meu código?


O relógio pode ter sido reiniciado. Ajustar o relógio pode resolver esse problema.

  1. Entre no modo de recuperação.
  2. Selecione Utilites na barra de menus.
  3. Abra o Terminal.
  4. Tipo: data , por exemplo. data 0804221520 para 4 de agosto de 2020, 22:15.
  5. Tente executar a instalação novamente. Agora deve prosseguir em menos de um minuto.

Se isso não ajudar, mostrar os & quotIstaller logs & quot pode fornecer dicas de por que demora muito.


Considere o desempenho e o tamanho dos formatos de arquivo do Excel

A partir do Excel 2007, o Excel contém uma ampla variedade de formatos de arquivo em comparação com as versões anteriores. Ignorando as variações de formato de arquivo Macro, Modelo, Suplemento, PDF e XPS, os três formatos principais são XLS, XLSB e XLSX.

O formato XLS é o mesmo formato das versões anteriores. Ao usar esse formato, você fica restrito a 256 colunas e 65.536 linhas. Quando você salva uma pasta de trabalho do Excel 2007 ou Excel 2010 no formato XLS, o Excel executa uma verificação de compatibilidade. O tamanho do arquivo é quase o mesmo das versões anteriores (algumas informações adicionais podem ser armazenadas) e o desempenho é um pouco mais lento do que nas versões anteriores. Qualquer otimização multi-threaded que o Excel faz em relação à ordem de cálculo das células não é salva no formato XLS. Portanto, o cálculo de uma pasta de trabalho pode ser mais lento depois de salvar a pasta de trabalho no formato XLS, fechar e reabrir a pasta de trabalho.

Formato XLSB

XLSB é o formato binário a partir do Excel 2007. Ele é estruturado como uma pasta compactada que contém muitos arquivos binários. É muito mais compacto do que o formato XLS, mas a quantidade de compactação depende do conteúdo da pasta de trabalho. Por exemplo, dez pastas de trabalho mostram um fator de redução de tamanho variando de dois a oito com um fator de redução médio de quatro. A partir do Excel 2007, o desempenho de abertura e salvamento é apenas um pouco mais lento do que o formato XLS.

Formato XLSX

XLSX é o formato XML a partir do Excel 2007 e é o formato padrão a partir do Excel 2007. O formato XLSX é uma pasta compactada que contém muitos arquivos XML (se você alterar a extensão do nome do arquivo para .zip, poderá abrir a pasta compactada e examinar seu conteúdo). Normalmente, o formato XLSX cria arquivos maiores do que o formato XLSB (1,5 vezes maiores em média), mas eles ainda são significativamente menores do que os arquivos XLS. Você deve esperar que os tempos de abertura e salvamento sejam um pouco maiores do que para arquivos XLSB.


6 Respostas 6

Com base na resposta anterior, Java permite que enums tenham propriedades para que você possa definir um padrão de estratégia, algo como

Então o seu executor (estratégia) seria

E todo o seu if / else em seu método doPost se torna algo como

Dessa forma, você pode até usar lambdas para os executores nas enums.

Em vez de usar reflexão, use uma interface dedicada.

Implementa cada um deles para cada ação e, em seguida:

É claro que essa solução não é a mais leve, então você não precisa ir tão longe.

Use o padrão de comando, isso exigirá uma interface de comando semelhante a esta:

Se as Ações forem leves e baratas de construir, use um Método de Fábrica. Carregue os nomes de classe de um arquivo de propriedades que mapeia actionName = className e use um método de fábrica simples para construir as ações para execução.

Se as ações são caras para construir, use um pool, como um HashMap, no entanto, na maioria dos casos, eu sugeriria que isso poderia ser evitado sob o princípio de responsabilidade única delegando caro elemento a algum pool de recursos comum pré-construído, em vez dos comandos em si.

Estes podem ser executados com

Esta é uma abordagem muito robusta e desacoplada que aplica SRP, LSP e ISP dos princípios SOLID. Novos comandos não alteram o código do mapeador de comando. Os comandos são simples de implementar. Eles podem ser apenas adicionados ao arquivo de projeto e propriedades. Os comandos devem ser reentrantes e isso os torna muito eficientes.