Problemas conhecidos do Python e do R nos Serviços de Machine Learning do SQL Server

Aplica-se a: SQL Server 2016 (13.x) e versões posteriores

Importante

O suporte para Machine Learning Server (conhecido anteriormente como Microsoft R Server) terminou em 1º de julho de 2022. Para obter mais informações, confira O que está acontecendo com Machine Learning Server?

Este artigo descreve problemas ou limitações conhecidos com os componentes do Python e do R que são fornecidos nos Serviços de Machine Learning do SQL Server e no SQL Server 2016 R Services.

Problemas de instalação e de configuração

Para obter uma descrição dos processos relacionados à instalação inicial e à configuração, confira Instalar Serviços de Machine Learning do SQL Server. Ali estão contidas informações sobre atualizações, instalação lado a lado e instalação de novos componentes de R ou Python.

Resultados inconsistentes em computações do MKL devido a uma variável de ambiente ausente

Aplica-se a: Binários do R_SERVER 9.0, 9.1, 9.2 ou 9.3.

O R_SERVER usa a Intel MKL (Math Kernel Library). Em cálculos que envolvam a MKL, resultados inconsistentes poderão ocorrer caso o sistema não tenha uma variável de ambiente.

Defina a variável de ambiente 'MKL_CBWR'=AUTO para garantir a reprodutibilidade numérica condicional no R_SERVER. Para obter mais informações, confira Introdução à CNR (Reprodutibilidade Numérica Condicional).

Solução alternativa

1. No Painel de Controle, selecione Sistema e Segurança>Sistema>Configurações Avançadas do Sistema>Variáveis de Ambiente.

2. Crie uma variável de usuário ou do sistema.

   • Defina a variável como MKL_CBWR.
   • Defina o valor como AUTO.

3. Reinicie o R_SERVER. No SQL Server, você pode reiniciar o serviço SQL Server Launchpad.

Observação

Caso esteja executando o SQL Server 2019 (15.x) no Linux, edite ou crie o .bash_profile no diretório base do usuário, adicionando a linha export MKL_CBWR="AUTO". Execute esse arquivo digitando source .bash_profile em um prompt de comando de Bash. Reinicie o R_SERVER digitando Sys.getenv() no prompt de comando do R.

Erro de runtime do R Script (regressão do SQL Server 2017 CU 5 – CU 7)

Para SQL Server 2017 (14.x), nas atualizações cumulativas de 5 a 7, há uma regressão no arquivo rlauncher.config em que o caminho do arquivo do diretório temporário inclui um espaço. Essa regressão é corrigida em CU 8.

O erro que você verá ao executar o script R incluirá as seguintes mensagens:

Não é possível se comunicar com o runtime do script 'R'. Verifique os requisitos do runtime do "R"

Mensagens STDERR do script externo:

Erro fatal: não é possível criar 'R_TempDir'

Solução alternativa

Aplique CU 8 quando ficar disponível. Como alternativa, você pode recriar rlauncher.config executando registerrext com desinstalar/instalar em um prompt de comandos com privilégios elevados.

<SQLInstancePath>\R_SERVICES\library\RevoScaleR\rxLibs\x64\RegisterRExt.exe /uninstall /sqlbinnpath:<SQLInstanceBinnPath> /userpoolsize:0 /instance:<SQLInstanceName>

<SQLInstancePath>\R_SERVICES\library\RevoScaleR\rxLibs\x64\RegisterRExt.exe /install /sqlbinnpath:<SQLInstanceBinnPath> /userpoolsize:0 /instance:<SQLInstanceName>

O exemplo a seguir mostra os comandos com a instância padrão "MSSQL14.MSSQLSERVER" instalada em C:\Program Files\Microsoft SQL Server\:

"C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\R_SERVICES\library\RevoScaleR\rxLibs\x64\RegisterRext.exe" /uninstall /sqlbinnpath:"C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\MSSQL\Binn" /userpoolsize:0 /instance:MSSQLSERVER

"C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\R_SERVICES\library\RevoScaleR\rxLibs\x64\RegisterRext.exe" /install /sqlbinnpath:"C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\MSSQL\Binn" /userpoolsize:0 /instance:MSSQLSERVER

Não é possível instalar recursos de aprendizado de máquina do SQL Server em um controlador de domínio

Se você tentar instalar o SQL Server 2016 (13.x) R Services ou Serviços de Machine Learning do SQL Server em um controlador de domínio, a instalação falhará com estes erros:

Erro durante o processo de instalação do recurso

Não é possível localizar o grupo com a identidade

Código de erro do componente: 0x80131509

A falha ocorre porque, em um controlador de domínio, o serviço não pode criar as 20 contas locais necessárias para executar o aprendizado de máquina. Em geral, não recomendamos a instalação do SQL Server em um controlador de domínio. Para obter mais informações, confira Boletim de suporte 2032911.

Instalar a versão mais recente do serviço para garantir a compatibilidade com o Microsoft R Client

Se você instalar a última versão do Microsoft R Client e usá-la para executar o R no SQL Server em um contexto de computação remota, poderá receber um erro como o seguinte:

Você está executando a versão 9.x.x do Microsoft R Client em seu computador, que é incompatível com o Microsoft R Server versão 8.x.x. Baixe e instale uma versão compatível.

O SQL Server 2016 (13.x) requer que as bibliotecas R no cliente correspondam exatamente às bibliotecas R no servidor. A restrição foi removida para versões posteriores ao R Server 9.0.1. No entanto, se você encontrar esse erro, verifique a versão das bibliotecas do R que é usada pelo cliente e o servidor e, se necessário, atualize o cliente para corresponder à versão do servidor.

Normalmente, a versão do R instalada com o SQL Server R Services é atualizada sempre que uma versão do serviço SQL Server é instalada. Para garantir que você sempre tenha as versões mais atualizadas dos componentes do R, instale todos os service packs.

Você poderá receber a seguinte mensagem de erro ao executar o R Server 8.0.3 no SQL Server 2016: You are running version 9.0.0 of Microsoft R client on your computer, which is incompatible with the Microsoft R server version 8.0.3. Download and install a compatible version. A compatibilidade com o Microsoft R Client 9.0.0 no SQL Server 2016 foi garantida nos seguintes patches:

• SQL Server 2016 SP1 MDS GDR
• SQL Server 2016 RTM MDS GDR
• SQL Server 2016 RTM COD GDR

Para evitar problemas com pacotes do R, você também pode atualizar a versão das bibliotecas do R que estão instaladas no servidor, alterando seu contrato de manutenção para usar a política de suporte do ciclo de vida moderno, conforme descrito na próxima seção. Ao fazer isso, a versão do R instalada com o SQL Server será atualizada no mesmo agendamento usado para atualizações do Machine Learning Server (anteriormente Microsoft R Server).

Aplica-se a: SQL Server 2016 (13.x) R Services, com Microsoft R Server versão 9.0.0 ou anterior

Componentes R ausentes na configuração CU 3 do SQL Server 2017

Um número limitado de máquinas virtuais do Azure foram provisionadas sem os arquivos de instalação do R que devem ser incluídos com SQL Server. O problema se aplica às máquinas virtuais provisionadas no período de 05/01/2018 a 23/01/2018. Esse problema também pode afetar as instalações locais, se você aplicou a atualização CU 3 ao SQL Server 2017 (14.x) durante o período de 05/01/2018 a 23/01/2018.

Foi fornecida uma versão de serviço que inclui a versão correta dos arquivos de instalação do R.

• Pacote de Atualização Cumulativa 3 para o SQL Server 2017 KB4052987.

Para instalar os componentes e reparar a CU 3 do SQL Server 2017 (14.x), você deve desinstalar a CU 3 e reinstalar a versão atualizada:

1. Baixe o arquivo de instalação atualizado da CU 3, que inclui os instaladores do R.
2. Desinstalação CU 3. No painel de controle, procure Desinstalar uma atualização e, em seguida, selecione "Hotfix 3015 para SQL Server 2017 (KB4052987) (64 bits)". Prossiga com as etapas de desinstalação.
3. Reinstale a atualização CU 3 clicando duas vezes na atualização para KB4052987 que você baixou: SQLServer2017-KB4052987-x64.exe. Siga as instruções de instalação.

Não é possível instalar os componentes do Python em instalações offline do SQL Server 2017 ou posterior

Se você instalar uma versão de pré-lançamento do SQL Server 2017 (14.x) em um computador sem acesso à Internet, o instalador poderá não exibir a página que solicita a localização dos componentes do Python baixados. Nessa instância, você pode instalar o recurso Serviços de Machine Learning, mas não os componentes do Python.

Esse problema é corrigido na próxima versão do SSMS. Além disso, essa limitação não se aplica aos componentes do R.

Aplica-se: SQL Server 2017 (14.x) com Python

Aviso de versão incompatível ao se conectar a uma versão anterior do SQL Server R Services por meio de um cliente usando o SQL Server 2017

Ao executar código R em um contexto de computação do SQL Server 2016 (13.x), você poderá ver o seguinte erro:

Você está executando a versão 9.0.0 do Microsoft R Client em seu computador, que é incompatível com o Microsoft R Server versão 8.0.3. Baixe e instale uma versão compatível.

Esta mensagem será exibida se uma das duas seguintes afirmações for verdadeira:

• Você instalou o R Server (autônomo) em um computador cliente usando o assistente de instalação do para SQL Server 2017 (14.x).
• Você instalou o Microsoft R Server usando o Windows Installer separado.

Para garantir que o servidor e o cliente usem a mesma versão, talvez seja necessário usar associação, compatível com o Microsoft R Server 9.0 e versões posteriores, para atualizar os componentes do R em instâncias do SQL Server 2016 (13.x). Para determinar se há suporte para atualizações disponível para sua versão do R Services, confira Atualizar uma instância do R Services usando o SqlBindR.exe.

Aplica-se a: SQL Server 2016 (13.x) R Services, com Microsoft R Server versão 9.0.0 ou anterior

A instalação de versões de serviço do SQL Server 2016 poderá falhar ao instalar versões mais novas dos componentes do R

Quando você instala uma atualização cumulativa ou um service pack para o SQL Server 2016 (13.x) em um computador que não está conectado à Internet, o assistente de instalação poderá falhar ao exibir o aviso que permite atualizar os componentes do R usando os arquivos CAB baixados. Essa falha normalmente ocorre quando vários componentes foram instalados juntos com o mecanismo de banco de dados.

Como solução alternativa, você pode instalar a versão de serviço usando a linha de comando e especificando o argumento MRCACHEDIRECTORY conforme mostrado neste exemplo, que instala atualizações de CU 1:

C:\<path to installation media>\SQLServer2016-KB3164674-x64.exe /Action=Patch /IACCEPTROPENLICENSETERMS /MRCACHEDIRECTORY=<path to CU 1 CAB files>

Para obter os instaladores mais recentes, confira Instalar componentes de aprendizado de máquina sem acesso à Internet.

Aplica-se a: SQL Server 2016 (13.x) R Services, com Microsoft R Server versão 9.0.0 ou anterior

Os serviços do Launchpad falham ao iniciar se a versão é diferente da versão do R

Se você instalar SQL Server R Services separadamente do mecanismo de banco de dados e as versões de build forem diferentes, você poderá ver o seguinte erro no log de eventos do sistema:

O serviço do SQL Server Launchpad falhou ao iniciar devido ao seguinte erro: O serviço não respondeu à solicitação de início ou de controle em um tempo oportuno.

Por exemplo, esse erro poderá ocorrer se você instalar o mecanismo de banco de dados usando a versão de lançamento, aplicar um patch para atualizar o mecanismo de banco de dados e, em seguida, adicionar o recurso R Services usando a versão de lançamento.

Para evitar esse problema, use um utilitário como o Gerenciador de Arquivos para comparar as versões do Launchpad.exe com a versão dos binários SQL, como sqldk.dll. Todos os componentes devem ter o mesmo número de versão. Se você atualizar um componente, lembre-se de aplicar a mesma atualização a todos os outros componentes instalados.

Procure o Launchpad na pasta Binn da instância. Por exemplo, em uma instalação padrão do SQL Server 2016 (13.x), o caminho pode ser C:\Program Files\Microsoft SQL Server\MSSQL.13.InstanceNameMSSQL\Binn.

Contextos de computação remota bloqueados por um firewall nas instâncias do SQL Server em execução em Máquinas Virtuais do Azure

Se você tiver instalado o SQL Server em uma máquina virtual do Azure, não será possível usar contextos de computação que exijam o uso do workspace da máquina virtual. O motivo é que, por padrão, o firewall nas máquinas virtuais do Azure inclui uma regra que bloqueia o acesso de rede para contas de usuários locais de R.

Como alternativa, na VM do Azure, abra o Firewall do Windows com Segurança Avançada, selecione as Regras de Saída e desabilite a regra a seguir: Bloquear o acesso à rede para contas de usuário local do R na instância MSSQLSERVER do SQL Server. Você também pode deixar a regra habilitada, mas alterar a propriedade de segurança para Permitir caso seja seguro.

Autenticação implícita na edição Express do SQL Server 2016

Quando você executar trabalhos do R em uma estação de trabalho de ciência de dados remota usando a Autenticação Integrada do Windows, o SQL Server usará a autenticação implícita para gerar as chamadas ODBC locais que poderão ser exigidas pelo script. No entanto, esse recurso não funcionou na versão RTM da edição Express do SQL Server 2016 (13.x).

Para corrigir o problema, recomendamos atualizar para uma versão de serviço posterior. Se a atualização não for viável, como solução alternativa, use um logon do SQL para executar trabalhos remotos do R que podem exigir chamadas ODBC incorporadas.

Aplica-se: edição Express do SQL Server 2016 (13.x) R Services

Limites de desempenho quando as bibliotecas usadas pelo SQL Server são chamadas de outras ferramentas

É possível chamar as bibliotecas de aprendizado de máquina instaladas para o SQL Server de um aplicativo externo, tal como o RGui. Fazer isso pode ser a melhor maneira de realizar determinadas tarefas, assim como instalar novos pacotes ou executar testes ad hoc em amostras de código muito curtas. No entanto, fora do SQL Server, o desempenho pode ser limitado.

Por exemplo, mesmo se você estiver usando a Edição Enterprise do SQL Server, o R será executado no modo single-threaded, caso você execute o código R usando ferramentas externas. Para obter os benefícios de desempenho no SQL Server, inicie uma conexão SQL Server e use sp_execute_external_script para chamar o runtime de script externo.

Em geral, evite chamar as bibliotecas de aprendizado de máquina que são usadas pelo SQL Server por meio de ferramentas externas. Se você precisar depurar o código R ou Python, normalmente será mais fácil fazer isso fora do SQL Server. Para obter as mesmas bibliotecas que estão no SQL Server, você pode instalar o Microsoft R Client ou SQL Server 2017 Machine Learning Server (Autônomo).

O SQL Server Data Tools não oferece suporte a permissões exigidas por scripts externos

Quando você usar o Visual Studio ou SQL Server Data Tools para publicar um projeto de banco de dados, se qualquer entidade tiver permissões específicas para a execução de script externo, você poderá receber um erro como este:

Modelo TSQL: erro detectado ao fazer engenharia reversa do banco de dados. A permissão não foi reconhecida e não foi importada.

Atualmente, o modelo DACPAC não dá suporte às permissões usadas por R Services ou Machine Learning Services, como GRANT ANY EXTERNAL SCRIPT ou EXECUTE ANY EXTERNAL SCRIPT. Esse problema será corrigido em uma versão posterior.

Como alternativa, execute as instruções GRANT adicionais em um script pós-implantação.

A execução de script externo é limitada devido aos valores padrão de governança de recursos

Na edição Enterprise, você pode usar pools de recursos para gerenciar processos de script externo. Em alguns builds de versões anteriores, a memória máxima que podia ser alocada para os processos do R era de 20%. Portanto, se o servidor tivesse 32 GB de RAM, os executáveis R (RTerm.exe e BxlServer.exe) poderiam usar no máximo 6,4 GB em uma única solicitação.

Se você encontrar limitações de recursos, verifique o padrão atual. Se 20% não for suficiente, consulte a documentação do SQL Server sobre como alterar esse valor.

Aplica-se: edição do SQL Server 2016 (13.x) R Services Enterprise

Erro ao usar sp_execute_external_script sem libc++.so no Linux

Em uma máquina Linux limpa que não tenha o libc++.so instalado, a execução de uma consulta sp_execute_external_script (SPEES) com Java ou uma linguagem externa falha porque o commonlauncher.so falha ao carregar libc++.so.

Por exemplo:

EXECUTE sp_execute_external_script @language = N'Java'
    , @script = N'JavaTestPackage.PassThrough'
    , @parallel = 0
    , @input_data_1 = N'select 1'
WITH RESULT SETS((col1 INT NOT NULL));
GO

Isso falha com uma mensagem semelhante à seguinte:

Msg 39012, Level 16, State 14, Line 0

Unable to communicate with the runtime for 'Java' script for request id: 94257840-1704-45E8-83D2-2F74AEB46CF7. Please check the requirements of 'Java' runtime.

Os logs de mssql-launchpadd mostrarão uma mensagem de erro semelhante à seguinte:

Oct 18 14:03:21 sqlextmls launchpadd[57471]: [launchpad] 2019/10/18 14:03:21 WARNING: PopulateLauncher failed: Library /opt/mssql-extensibility/lib/commonlauncher.so not loaded. Error: libc++.so.1: cannot open shared object file: No such file or directory

Solução alternativa

Você pode usar uma das soluções alternativas a seguir:

1. Copie libc++* de /opt/mssql/lib para o caminho do sistema padrão /lib64

2. Adicione as entradas a seguir para /var/opt/mssql/mssql.conf a fim de expor o caminho:

   [extensibility]
   readabledirectories = /opt/mssql
   

Aplica-se a: SQL Server 2019 (15.x) no Linux

Erro de instalação ou de atualização nos servidores habilitados para FIPS

Se você instalar o SQL Server 2019 (15.x) com o recurso Serviços de Machine Learning e Extensões de Linguagem ou atualizar a instância do SQL Server em um servidor habilitado para FIPS (Federal Information Processing Standard), o seguinte erro será exibido:

Ocorreu um erro ao instalar o recurso de extensibilidade, gerando a seguinte mensagem de erro: Falha na criação do AppContainer gerando a mensagem de erro NENHUM, estado Esta implementação não faz parte dos algoritmos de criptografia validados pelo FIPS da Plataforma Windows.

Solução alternativa

Desabilite o FIPS antes da instalação do SQL Server 2019 (15.x) com o recurso Serviços de Machine Learning e Extensões de Linguagem ou da atualização da instância do SQL Server. Depois que a instalação ou a atualização for concluída, você poderá reabilitar o FIPS.

Aplica-se a: SQL Server 2019 (15.x)

Bibliotecas R usando algoritmos específicos, streaming ou particionamento

Problema

As limitações a seguir se aplicam ao SQL Server 2017 (14.x) com atualização de runtime. Esse problema é aplicável à Edição Enterprise.

• Paralelismo: o paralelismo de thread do algoritmo RevoScaleR e MicrosoftML para cenários está limitado ao máximo de dois threads.
• Streaming e particionamento: cenários envolvendo o parâmetro @r_rowsPerRead passado para T-SQL sp_execute_external_script não são aplicados.
• Streaming e particionamento: as fontes de dados RevoScaleR e MicrosoftML (ou seja ODBC, XDF) não oferecem suporte à leitura de linhas em partes para cenários de treinamento ou pontuação. Esses cenários sempre levam todos os dados à memória para computação e as operações são vinculadas à memória

Solução

A melhor solução é atualizar para o SQL Server 2019 (15.x). Como alternativa, você pode continuar a usar SQL Server 2017 (14.x) com a atualização de runtime configurada usando RegisterRext.exe /configure, depois de concluir as tarefas a seguir.

1. Edite o Registro para criar uma chave Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SQL Server\150 e adicionar um valor SharedCode com os dados C:\Program Files\Microsoft SQL Server\150\Shared ou o diretório compartilhado da instância, conforme configurado.
2. Crie uma pasta C:\Program Files\Microsoft SQL Server\150\Shared and copy instapi140.dll da pasta C:\Program Files\Microsoft SQL Server\140\Shared para a pasta recém-criada.
3. Renomeie instapi140.dll como instapi150.dll na nova pasta C:\Program Files\Microsoft SQL Server\150\Shared.

Importante

Se você realizar as etapas acima, precisará remover manualmente a chave adicionada antes de atualizar para uma versão posterior do SQL Server.

Problemas de desempenho do Pool de Processos nos Serviços do ML (R e Python)

Esta seção contém problemas conhecidos e soluções alternativas para usar os serviços do ML (R e Python) no SQL Server.

Inicialização a frio de Desempenho do Pool de Processos nos Serviços do ML

Após a execução do sp_execute_external_script, o serviço launchpad inicia os processos satélite que iniciam os runtimes externos, como R e Python. Para amortizar o custo de inicialização, um pool de processos é criado e pode ser usado na execução subsequente de sp_execute_external_script. Esse pool de processos é específico para esse usuário, banco de dados e a linguagem usada (R ou Python nos Serviços do ML).

Execução da primeira consulta

Os processos satélite precisam ser aquecidos quando sp_execute_external_script é executado pela primeira vez ou após um período de tempo ocioso (os processos são encerrados por meio de uma tarefa de limpeza se não forem usados por um tempo). A inicialização a frio desses processos em pool pode ser lenta (por exemplo, devido a restrições de recursos).

Solução alternativa

Se o desempenho da primeira chamada for importante, é recomendável manter as consultas aquecidas. Por exemplo, uma tarefa em segundo plano pode ser executada que dispara uma consulta sp_execute_external_script simples antes que os processos expirem. Por exemplo, para manter as consultas R aquecidas, você pode executar a consulta a seguir periodicamente.

EXECUTE sp_execute_external_script @language = N'R', @script = N'';
GO

Alto número de consultas simultâneas

Se o número de execuções simultâneas de sp_execute_external_script for maior do que os processos ativos do R/Python no pool, a inicialização a frio da adição de processos adicionais ao pool poderá ser lenta (por exemplo, devido a restrições de recursos).

Solução alternativa

Para superar o problema de desempenho de escala, várias solicitações podem ser agrupadas em lote (por exemplo, por meio de conexões de loopback ou reescrita do script para lidar com várias solicitações). Além disso, para cenários em tempo real, SQL PREDICT pode ser utilizado.

Problemas de execução do script R

Esta seção contém problemas conhecidos que são específicos da execução do R no SQL Server, bem como alguns problemas relacionados às bibliotecas e ferramentas do R publicadas pela Microsoft, incluindo o RevoScaleR.

Para problemas conhecidos adicionais que podem afetar as soluções de R, confira o site do Machine Learning Server.

Aviso de acesso negado ao executar scripts R no SQL Server em uma localização não padrão

Se a instância do SQL Server tiver sido instalada em uma localização não padrão, por exemplo, fora da pasta Program Files, o aviso ACCESS_DENIED será gerado quando você tentar executar scripts que instalam um pacote. Por exemplo:

Em normalizePath(path.expand(path), winslash, mustWork): path[2]="~ExternalLibraries/R/8/1": Acesso negado

O motivo é que uma função R tenta ler o caminho e falha se o grupo de usuários interno SQLRUserGroup não tem acesso de leitura. O aviso gerado não bloqueia a execução do script R atual, mas o aviso pode ocorrer repetidamente sempre que o usuário executar qualquer outro script R.

Se você instalou o SQL Server no local padrão, esse erro não ocorre porque todos os usuários do Windows têm permissões de leitura na pasta Program Files.

Esse problema será resolvido em uma versão futura do serviço. Como alternativa, forneça acesso de leitura para todas as pastas pai de ExternalLibraries ao grupo SQLRUserGroup.

Erro de serialização entre as versões antiga e nova do RevoScaleR

Ao passar um modelo usando um formato serializado para uma instância remota do SQL Server, você pode receber o erro:

Erro em memDecompress(data, type = decompress) erro interno -3 em memDecompress(2).

Esse erro é gerado se você salvou o modelo usando uma versão recente da função de serialização, rxSerializeModel, mas a instância do SQL Server em que você desserializa o modelo tem uma versão mais antiga das APIs RevoScaleR, da CU 2 do SQL Server 2017 (14.x) ou anterior.

Como solução alternativa, você pode atualizar a instância do SQL Server 2017 (14.x) para CU 3 ou posterior.

O erro não aparece se a versão da API for a mesma ou se você estiver movendo um modelo salvo com uma função de serialização mais antiga para um servidor que usa uma versão mais recente da API de serialização.

Em outras palavras, use a mesma versão do RevoScaleR para operações de serialização e desserialização.

A pontuação em tempo real não lida corretamente com o parâmetro learningRate em modelos de árvore e floresta

Se criar um modelo usando uma árvore de decisão ou um método de floresta de decisão e especificar a taxa de aprendizado, você poderá ver resultados inconsistentes ao usar sp_rxpredict ou a função SQL PREDICT, em comparação com o uso de rxPredict.

A causa é um erro na API que processa modelos serializados e é limitada ao parâmetro learningRate: por exemplo, em rxBTrees ou

Esse problema será resolvido em uma versão futura do serviço.

Limitações na afinidade do processador para trabalhos do R

No build da versão inicial do SQL Server 2016 (13.x), você podia definir a afinidade do processador somente para CPUs no primeiro grupo k. Por exemplo, se o servidor for um computador de dois soquetes com dois grupos k, apenas os processadores do primeiro grupo k serão usados para os processos do R. A mesma limitação se aplica ao configurar a governança de recursos para trabalhos de script do R.

Esse problema foi corrigido no Service Pack 1 do SQL Server 2016 (13.x). Recomendamos atualizar para uma versão posterior do serviço.

Aplica-se a: SQL Server 2016 (13.x) R Services (versão RTM)

As alterações nos tipos de coluna não podem ser executadas ao ler dados em um contexto de computação do SQL Server

Se o contexto de computação estiver definido para a instância do SQL Server, você não poderá usar o argumento colClasses (ou outros argumentos semelhantes) para alterar o tipo de dados das colunas em seu código R.

Por exemplo, a seguinte instrução resultará em um erro se a coluna CRSDepTimeStr ainda não for um número inteiro:

data <- RxSqlServerData(
  sqlQuery = "SELECT CRSDepTimeStr, ArrDelay FROM AirlineDemoSmall",
  connectionString = connectionString,
  colClasses = c(CRSDepTimeStr = "integer"))

Como solução alternativa, você pode reescrever a consulta SQL para usar CAST ou CONVERT e apresentar os dados para R usando o tipo de dados correto. Em geral, o desempenho é melhor ao trabalhar com os dados usando o SQL em vez de alterar dados no código R.

Aplica-se a: SQL Server 2016 (13.x) R Services

Limites no tamanho de modelos serializados

Quando salva um modelo em uma tabela do SQL Server, você deve serializar o modelo e salvá-lo em um formato binário. Teoricamente, o tamanho máximo de um modelo que pode ser armazenado com esse método é 2 GB, que é o tamanho máximo das colunas varbinary no SQL Server.

Se você precisar usar modelos maiores, as seguintes soluções alternativas estarão disponíveis:

• Tome medidas para reduzir o tamanho do seu modelo. Alguns pacotes R de software livre incluem uma grande quantidade de informações no objeto de modelo e muitas dessas informações podem ser removidas para implantação.

• Use a seleção de recursos para remover as colunas desnecessárias.

• Se você estiver usando um algoritmo de software livre, considere uma implementação semelhante usando o algoritmo correspondente em MicrosoftML ou RevoScaleR. Esses pacotes foram otimizados para cenários de implantação.

• Depois que o modelo tiver sido racionalizado e o tamanho reduzido usando as etapas anteriores, veja se a função memCompress no R base pode ser usada para reduzir o tamanho do modelo antes de passá-lo para o SQL Server. Essa opção é melhor quando o modelo está perto do limite de 2 GB.

• Para modelos maiores, você pode usar o recurso FileTable do SQL Server para armazenar os modelos, em vez de usar uma coluna varbinary.

  Para usar FileTables, você deve adicionar uma exceção de firewall, pois os dados armazenados em FileTables são gerenciados pelo driver de sistema de arquivos do fluxo de arquivos no SQL Server e as regras de firewall padrão bloqueiam o acesso ao arquivo de rede. Para obter mais informações, confira Habilitar pré-requisitos para FileTable.

  Depois de habilitar o FileTable, para gravar o modelo, você obtém um caminho do SQL usando a API do FileTable e, em seguida, grava o modelo nessa localização por meio do seu código. Quando você precisa ler o modelo, você obtém o caminho do SQL Server e, em seguida, chama o modelo usando o caminho do seu script. Para obter mais informações, confira Acessar FileTables com APIs de entrada e saída de arquivo.

Evite limpar workspaces ao executar código R em um contexto de computação do SQL Server

Se você usar um comando do R para limpar o workspace de objetos durante a execução de código R em um contexto de computação do SQL Server ou se limpar o workspace como parte de um script do R chamado pelo uso de sp_execute_external_script, você poderá receber este erro: objeto do workspace revoScriptConnection não encontrado

OrevoScriptConnection é um objeto no workspace do R que contém informações sobre uma sessão do R chamada por meio de SQL Server. No entanto, se o código R incluir um comando para limpar o workspace (como rm(list=ls()))), todas as informações sobre a sessão e outros objetos no workspace do R também serão limpos.

Como alternativa, evite a limpeza indiscriminada de variáveis e outros objetos ao executar o R no SQL Server. Embora a limpeza do workspace seja comum ao trabalhar no console do R, ela poderá trazer consequências indesejadas.

• Para excluir variáveis específicas, use a função remove do R: por exemplo, remove('name1', 'name2', ...)
• Se houver várias variáveis a serem excluídas, salve os nomes das variáveis temporárias em uma lista e execute a coleta de lixo periódica.

Restrições sobre dados que podem ser fornecidos como entrada para um script R

Você não pode usar os seguintes tipos de resultados de consulta em um script R:

• Dados de uma consulta Transact-SQL que faz referência às colunas AlwaysEncrypted.

• Dados de uma consulta Transact-SQL que faz referência à colunas mascaradas.

  Se precisar usar dados mascarados em um script R, uma solução alternativa é copiar os dados em uma tabela temporária e usar esses dados.

O uso de cadeias de caracteres como fatores pode levar à degradação do desempenho

Usar variáveis de tipo de cadeia de caracteres como fatores pode aumentar muito a quantidade de memória usada para operações de R. Esse é um problema conhecido com o R em geral e há muitos artigos sobre o assunto. Por exemplo, veja Factors aren't first-class citizens in R, by John Mount, in R-bloggers) ou stringsAsFactors: An unauthorized biography, por Roger Peng.

Embora o problema não seja específico do SQL Server, ele pode afetar bastante o desempenho do código R executado no SQL Server. Em geral, as cadeias de caracteres são armazenadas como varchar ou nvarchar e, se uma coluna de dados de cadeia tem muitos valores exclusivos, o processo de convertê-las internamente para inteiros e voltar para cadeias por R pode até mesmo levar a erros de alocação de memória.

Se você não precisar absolutamente de um tipo de dados de cadeia de caracteres para outras operações, mapear os valores de cadeia de caracteres para um tipo de dados numérico (número inteiro) como parte da preparação de dados seria benéfico de uma perspectiva de desempenho e escala.

Para obter uma discussão sobre esse problema e outras dicas, confira Desempenho para R Services – otimização de dados.

Os argumentos varsToKeep e varsToDrop não têm suporte para fontes de dados do SQL Server

Quando você usa a função rxDataStep para gravar resultados em uma tabela, usar varsToKeep e varsToDrop é uma maneira útil de especificar as colunas a serem incluídas ou excluídas como parte da operação. No entanto, esses argumentos não têm suporte para fontes de dados do SQL Server.

Suporte limitado para tipos de dados SQL no sp_execute_external_script

Nem todos os tipos de dados com suporte no SQL podem ser usados no R. Como solução alternativa, considere converter o tipo de dados sem suporte em um tipo de dados com suporte antes de passar os dados para sp_execute_external_script.

Para obter mais informações, confira Tipos de dados e bibliotecas do R.

Possível corrupção de cadeia de caracteres usando cadeias de caracteres Unicode em colunas varchar

Passar dados Unicode em colunas varchar do SQL Server para R/Python pode resultar em corrupção de cadeia de caracteres. Isso ocorre porque a codificação dessas cadeias de caracteres Unicode nos agrupamentos do SQL Server pode não corresponder à codificação UTF-8 padrão usada no R/Python.

Para enviar dados de cadeia de caracteres não ASCII do SQL Server para R/Python, use a codificação UTF-8 (disponível no SQL Server 2019 (15.x)) ou use o tipo nvarchar para eles.

Somente um valor do tipo raw pode ser retornado de sp_execute_external_script

Quando um tipo de dados binário é retornado de R (o tipo de dados brutos de R), o valor precisa ser enviado no quadro de dados de saída.

Com tipos de dados diferentes de bruto, é possível retornar valores de parâmetro junto com os resultados do procedimento armazenado apenas adicionando a palavra-chave OUTPUT. Para obter mais informações, confira Parâmetros.

Caso pretenda usar vários conjuntos de saída que incluam valores do tipo bruto, uma possível solução alternativa é fazer várias chamadas do procedimento armazenado e enviar os conjuntos de resultados de volta para o SQL Server usando o ODBC.

Perda de precisão

Já que o Transact-SQL e o R dão suporte a diferentes tipos de dados, os tipos de dados numéricos podem sofrer perda de precisão durante a conversão.

Para obter mais informações sobre a conversão implícita de tipos de dados, confira Tipos de dados e bibliotecas do R.

Erro de escopo de variável ao usar o parâmetro transformFunc

Para transformar os dados ao modelar, você pode passar um argumento transformFunc em uma função como rxLinmod ou rxLogit. No entanto, as chamadas de função aninhadas podem gerar erros de escopo no contexto de computação do SQL Server, mesmo que as chamadas funcionem corretamente no contexto de computação local.

O conjunto de dados de exemplo para a análise não tem nenhuma variável

Por exemplo, digamos que você tenha definido duas funções f e g no ambiente global local e então g chama f. Nas chamadas distribuídas ou remotas envolvendo g, a chamada para g pode falhar com esse erro porque f não pode ser encontrado, mesmo que você passe f e g para a chamada remota.

Para contornar esse problema, caso o encontre, incorpore a definição de f em qualquer local dentro da sua definição de g, antes que g possa chamar fnormalmente.

Por exemplo:

f <- function(x) { 2*x * 3 }
g <- function(y) {
              a <- 10 * y
               f(a)
}

Para evitar o erro, reescreva a definição da seguinte maneira:

g <- function(y){
              f <- function(x) { 2*x +3}
              a <- 10 * y
              f(a)
}

Importação e manipulação de dados usando o RevoScaleR

Durante a leitura de colunas varchar de um banco de dados, o sistema retira os espaços em branco. Para evitar isso, coloque as cadeias de caracteres entre caracteres de espaço não em branco.

Quando funções como rxDataStep são usadas para criar tabelas de bancos de dados que contêm colunas varchar, a largura da coluna é calculada com base em uma amostra dos dados. Se a largura for variável, talvez seja necessário preencher todas as cadeias de caracteres com um comprimento comum.

Não há suporte para o uso de uma transformação para alterar o tipo de dados de uma variável quando chamadas repetidas para rxImport ou rxTextToXdf são usadas para importar e anexar linhas, combinando vários arquivos de entrada em um único arquivo .xdf.

Suporte limitado para rxExec

No SQL Server 2016 (13.x), a função rxExec fornecida pelo pacote RevoScaleR pode ser usada somente no modo de thread único.

Aumentar o tamanho máximo do parâmetro para dar suporte à função rxGetVarInfo

Se usar conjuntos de dados com um número muito grande de variáveis (por exemplo, mais de 40.000), defina o sinalizador max-ppsize quando iniciar o R para usar funções como rxGetVarInfo. O sinalizador max-ppsize especifica o tamanho máximo da pilha de proteção do ponteiro.

Se estiver usando o console de R (por exemplo, em RGui.exe ou em RTerm.exe), defina o valor máximo de max-ppsize para 500000 digitando:

R --max-ppsize=500000

Problemas com a função rxDTree

Atualmente, a função rxDTree não oferece suporte para transformações na fórmula. Em especial, não há suporte para o uso da sintaxe F() para criar fatores em tempo real. No entanto, os dados numéricos são compartimentalizados automaticamente.

Os fatores ordenados são tratados da mesma forma que os fatores de todas as funções de análise RevoScaleR, exceto o rxDTree.

data.table como um OutputDataSet em R

O uso de data.table como um OutputDataSet em R não tem suporte na CU 13 (Atualização Cumulativa 13) do SQL Server 2017 (14.x) e anteriores. A seguinte mensagem pode aparecer:

Msg 39004, Level 16, State 20, Line 2
A 'R' script error occurred during execution of
'sp_execute_external_script' with HRESULT 0x80004004.
Msg 39019, Level 16, State 2, Line 2
An external script error occurred:
Error in alloc.col(newx) :
  Internal error: length of names (0) is not length of dt (11)
Calls: data.frame ... as.data.frame -> as.data.frame.data.table -> copy -> alloc.col

Error in execution.  Check the output for more information.
Error in eval(expr, envir, enclos) :
  Error in execution.  Check the output for more information.
Calls: source -> withVisible -> eval -> eval -> .Call
Execution halted

data.table como um OutputDataSet em R é suportado na CU 14 (Atualização Cumulativa 14) do SQL Server 2017 (14.x) e posteriores.

A execução de um script longo falha durante a instalação de uma biblioteca

Executar uma sessão de script externo de execução prolongada e fazer paralelamente com que o dbo tente instalar uma biblioteca em um banco de dados diferente pode encerrar o script.

Por exemplo, executar esse script externo em relação ao banco de dados master:

USE MASTER
DECLARE @language nvarchar(1) = N'R'
DECLARE @script nvarchar(max) = N'Sys.sleep(100)'
DECLARE @input_data_1 nvarchar(max) = N'select 1'
EXEC sp_execute_external_script @language = @language, @script = @script, @input_data_1 = @input_data_1 with result sets none
go

Enquanto o dbo instala paralelamente uma biblioteca em LibraryManagementFunctional:

USE [LibraryManagementFunctional]
go

CREATE EXTERNAL LIBRARY [RODBC] FROM (CONTENT = N'/home/ani/var/opt/mssql/data/RODBC_1.3-16.tar.gz') WITH (LANGUAGE = 'R')
go

DECLARE @language nvarchar(1) = N'R'
DECLARE @script nvarchar(14) = N'library(RODBC)'
DECLARE @input_data_1 nvarchar(8) = N'select 1'
EXEC sp_execute_external_script @language = @language, @script = @script, @input_data_1 = @input_data_1
go

O script externo de execução prolongada anterior em relação ao banco de dados master será encerrado com a seguinte mensagem de erro:

Um erro de script 'R' ocorreu durante a execução de 'sp_execute_external_script' com HRESULT 0x800704d4.

Solução alternativa

Não execute a instalação da biblioteca em paralelo à consulta de execução prolongada. Ou execute novamente a consulta de execução prolongada após a conclusão da instalação.

Aplica-se: apenas aos Clusters de Big Data e do SQL Server 2019 (15.x) no Linux.

SQL Server para de responder ao executar scripts R contendo execução paralela

O SQL Server 2019 (15.x) contém uma regressão que afeta os scripts R que usam execução paralela. Exemplos incluem o uso de rxExec com scripts e contexto de computação RxLocalPar que usam o pacote paralelo. Esse problema é causado por erros que o pacote paralelo encontra ao ser gravado no dispositivo nulo durante a execução no SQL Server.

Aplica-se a: o SQL Server 2019 (15.x).

Perda de precisão para tipos de dados money/numeric/decimal/bigint

A execução de um script R com sp_execute_external_script permite tipos de dados money, numeric, decimal e bigint como dados de entrada. No entanto, como eles são convertidos no tipo numérico do R, eles sofrem uma perda de precisão com valores muito altos ou que têm valores de ponto decimal.

• money: Às vezes, os valores de centavos podem ser imprecisos, o que gera um aviso: Aviso: não foi possível representar os valores de centavos.
• numérico/decimal: sp_execute_external_script com um script R não oferece suporte a toda a gama desses tipos de dados e alteraria os últimos dígitos decimais, especialmente aqueles com fração.
• bigint: O R só é compatível com números inteiros de 53 bits. Mais do que isso, ele começa a apresentar perda de precisão.

Problemas com a função rxExecBy – a função rxExecBy não consegue localizar o pacote instalado

Quando a função rxExecBy é chamada, um novo processo de runtime do R é iniciado. Esse novo processo não tem caminhos de biblioteca atualizados. Portanto, os pacotes instalados em locais diferentes do caminho da biblioteca padrão não são encontrados durante a execução.

Solução alternativa

O caminho para pacotes do R precisa ser atualizado explicitamente. Suponha que os pacotes estejam instalados no caminho das bibliotecas externas. O seguinte script R pode ser usado para atualizar o caminho da biblioteca: .libPaths(c(Sys.getenv("MRS_EXTLIB_USER_PATH"), Sys.getenv("MRS_EXTLIB_SHARED_PATH"), .libPaths()))

Problemas de execução de script Python

Esta seção contém problemas conhecidos que são específicos da execução do Python no SQL Server, bem como problemas relacionados aos pacotes do Python publicados pela Microsoft, incluindo revoscalepy e microsoftml.

A chamada para o modelo previamente treinado falhará se o caminho para o modelo for muito longo

Se você instalou os modelos pré-treinados em uma versão anterior do SQL Server 2017 (14.x), o caminho completo para o arquivo de modelo treinado pode ser muito longo para o Python ler. Essa limitação é corrigida em uma versão posterior do serviço.

Há várias soluções alternativas possíveis:

• Ao instalar os modelos pré-treinados, escolha uma localização personalizado.
• Se possível, instale a instância do SQL Server em um caminho de instalação personalizado com um caminho mais curto, como C:\SQL\MSSQL14.MSSQLSERVER.
• Use o utilitário fsutil do Windows para criar um link físico que mapeia o arquivo de modelo para um caminho mais curto.
• Atualize para a versão mais recente do serviço.

Erro ao salvar o modelo serializado para o SQL Server

Quando você passa um modelo para uma instância remota do SQL Server e tenta ler o modelo binário usando a função rx_unserialize em revoscalepy, você pode receber o erro:

NameError: o nome 'rx_unserialize_model' não está definido

Esse erro é gerado se você salvou o modelo usando uma versão recente da função de serialização, mas a instância do SQL Server em que você desserializa o modelo não reconhece a API de serialização.

Para resolver o problema, atualize a instância do SQL Server 2017 (14.x) para CU 3 ou posterior.

A falha ao inicializar uma variável varbinary causa um erro no BxlServer

Se você executar o código Python no SQL Server usando sp_execute_external_script e o código tiver variáveis de saída do tipo varbinary(max), varchar(max) ou tipos semelhantes, a variável deverá ser inicializada ou definida como parte do seu script. Caso contrário, o componente de troca de dados, BxlServer, gerará um erro e deixará de funcionar.

Essa limitação será corrigida em uma versão de serviço futura. Como alternativa, verifique se a variável é inicializada dentro do script Python. Qualquer valor válido pode ser usado, assim como nos exemplos a seguir:

declare @b varbinary(max);
exec sp_execute_external_script
  @language = N'Python'
  , @script = N'b = 0x0'
  , @params = N'@b varbinary(max) OUTPUT'
  , @b = @b OUTPUT;
go

declare @b varchar(30);
exec sp_execute_external_script
  @language = N'Python'
  , @script = N' b = ""  '
  , @params = N'@b varchar(30) OUTPUT'
  , @b = @b OUTPUT;
go

Aviso de telemetria sobre a execução bem-sucedida do código Python

Da CU 2 do SQL Server 2017 (14.x) em diante, a seguinte mensagem pode aparecer, mesmo que o código Python tenha sido executado com êxito:

Mensagens STDERR do script externo:~PYTHON_SERVICES\lib\site-packages\revoscalepy\utils\RxTelemetryLoggerSyntaxWarning: telemetry_state é usado antes da declaração global

Este problema foi corrigido na CU 3 (Atualização Cumulativa 3) do em SQL Server 2017 (14.x).

Os tipos de dados numérico, decimal e money não são compatíveis

Começando com a CU 12 (Atualização Cumulativa 12) do SQL Server 2017 (14.x), tipos de dados numéricos, decimais e monetários em WITH RESULT SETS não têm suporte ao usar Python com sp_execute_external_script. As seguintes mensagens podem aparecer:

[Código: 39004, estado do SQL: S1000] Um erro de script 'Python' ocorreu durante a execução de 'sp_execute_external_script' com HRESULT 0x80004004.

[Código: 39019, estado do SQL: S1000] Ocorreu um erro de script externo:

Erro SqlSatelliteCall: tipo sem suporte no esquema de saída. Tipos compatíveis: bit, smallint, int, DateTime, SmallMoney, real e float. char, varchar são parcialmente compatíveis.

Isso foi corrigido na CU 14 (Atualização Cumulativa 14) do SQL Server 2017 (14.x).

Erro de interpretador incorreto ao instalar pacotes do Python com pip no Linux

No SQL Server 2019 (15.x), se você tentar usar o pip. Por exemplo:

/opt/mssql/mlservices/runtime/python/bin/pip -h

Você receberá então este erro:

bash: /opt/mssql/mlservices/runtime/python/bin/pip: /opt/microsoft/mlserver/9.4.7/bin/python/python: bad interpreter: Esse arquivo ou diretório não existe

Solução alternativa

Instale o pip da PyPA (autoridade de pacote do Python):

wget 'https://bootstrap.pypa.io/get-pip.py'
/opt/mssql/mlservices/bin/python/python ./get-pip.py

Recomendação

Confira Instalar pacotes Python com o sqlmlutils.

Aplica-se a: SQL Server 2019 (15.x) no Linux

Não é possível instalar os pacotes do Python usando o pip após a instalação do SQL Server 2019 no Windows

Depois de instalar o SQL Server 2019 (15.x) no Windows, a tentativa de instalar um pacote do Python via pip por meio de uma linha de comando do DOS falhará. Por exemplo:

pip install quantfolio

Isso retornará o erro a seguir:

O pip é configurado com locais que exigem TLS/SSL, no entanto, o módulo SSL no Python não está disponível.

Esse é um problema específico do pacote Anaconda. Ele será corrigido em uma versão futura do serviço.

Solução alternativa

Copie os seguintes arquivos:

• libssl-1_1-x64.dll
• libcrypto-1_1-x64.dll

da pasta
C:\Program Files\Microsoft SQL Server\MSSSQL15.MSSQLSERVER\PYTHON_SERVICES\Library\bin

para a pasta
C:\Program Files\Microsoft SQL Server\MSSSQL15.MSSQLSERVER\PYTHON_SERVICES\DLLs

Em seguida, abra um novo prompt do shell de comando do DOS.

Aplica-se a: SQL Server 2019 (15.x) no Windows

Erro ao usar sp_execute_external_script sem libc++abo.so no Linux

Em um computador Linux limpo que não tem o libc++abi.so instalado, a execução de uma consulta sp_execute_external_script (SPEES) falha com um erro "Esse arquivo ou diretório não existe".

Por exemplo:

EXEC sp_execute_external_script
    @language = N'Python'
    , @script = N'
OutputDataSet = InputDataSet'
    , @input_data_1 = N'select 1'
    , @input_data_1_name = N'InputDataSet'
    , @output_data_1_name = N'OutputDataSet'
    WITH RESULT SETS (([output] int not null));

Msg 39012, Level 16, State 14, Line 0
Unable to communicate with the runtime for 'Python' script for request id: 94257840-1704-45E8-83D2-2F74AEB46CF7. Please check the requirements of 'Python' runtime.
STDERR message(s) from external script:

Failed to load library /opt/mssql-extensibility/lib/sqlsatellite.so with error libc++abi.so.1: cannot open shared object file: No such file or directory.

SqlSatelliteCall error: Failed to load library /opt/mssql-extensibility/lib/sqlsatellite.so with error libc++abi.so.1: cannot open shared object file: No such file or directory.
STDOUT message(s) from external script:
SqlSatelliteCall function failed. Please see the console output for more information.
Traceback (most recent call last):
  File "/opt/mssql/mlservices/libraries/PythonServer/revoscalepy/computecontext/RxInSqlServer.py", line 605, in rx_sql_satellite_call
    rx_native_call("SqlSatelliteCall", params)
  File "/opt/mssql/mlservices/libraries/PythonServer/revoscalepy/RxSerializable.py", line 375, in rx_native_call
    ret = px_call(functionname, params)
RuntimeError: revoscalepy function failed.
Total execution time: 00:01:00.387

Solução alternativa

Execute o comando a seguir:

sudo cp /opt/mssql/lib/libc++abi.so.1 /opt/mssql-extensibility/lib/

Aplica-se a: SQL Server 2019 (15.x) no Linux

Erro genérico ao executar sp_execute_external_script no Ubuntu 20.04 com o SQL Server 2022 CU6 no Linux

A instalação do SQL Server 2022 CU6 para Linux no Ubuntu 20.04 pode resultar no seguinte erro ao executar sp_execute_external_script para scripts R e Python:

Msg 39012, Level 16, State 14, Line 0
Unable to communicate with the runtime for 'R' script for request id: 94257840-1704-45E8-83D2-2F74AEB46CF7. Please check the requirements of 'R' runtime.

STDERR message(s) from external script: 
/usr/lib/R/library/RevoScaleR/rxLibs/x64/libExaCore.so.2(_Z21CriticalSignalHandleri+0x29)[0x7f2568289d89]
/usr/lib/x86_64-linux-gnu/libc.so.6(+0x43090)[0x7f2568d66090]

Solução alternativa

Execute o comando a seguir para instalar a dependência de pacote libssl-dev, que permite que o SQL Server resolva as bibliotecas compartilhadas libssl e libcrypto fornecidas pelo sistema.

sudo apt-get update
sudo apt-get install libssl-dev

Erro de criação de regra de firewall no modprobe ao executar mssql-launchpadd no Linux

Ao visualizar os logs do mssql-launchpadd usando o sudo journalctl -a -u mssql-launchpadd, você pode ver um erro de criação de regra de firewall semelhante à saída a seguir.

-- Logs begin at Sun 2021-03-28 12:03:30 PDT, end at Wed 2022-10-12 13:20:17 PDT. --
Mar 22 16:57:51 sqlVm systemd[1]: Started Microsoft SQL Server Extensibility Launchpad Daemon.
Mar 22 16:57:51 sqlVm launchpadd[195658]: 2022/03/22 16:57:51 [launchpadd] INFO: Extensibility Log Header: <timestamp> <process> <sandboxId> <sessionId> <message>
Mar 22 16:57:51 sqlVm launchpadd[195658]: 2022/03/22 16:57:51 [launchpadd] INFO: No extensibility section in /var/opt/mssql/mssql.conf file. Using default settings.
Mar 22 16:57:51 sqlVm launchpadd[195658]: 2022/03/22 16:57:51 [launchpadd] INFO: DataDirectories =  /bin:/etc:/lib:/lib32:/lib64:/sbin:/usr/bin:/usr/include:/usr/lib:/usr/lib32:/usr/lib64:/usr/libexec/gcc:/usr/sbin:/usr/share:/var/lib:/opt/microsoft:/opt/mssql-extensibility:/opt/mssql/mlservices:/opt/mssql/lib/zulu-jre-11:/opt/mssql-tools
Mar 22 16:57:51 sqlVm launchpadd[195658]: 2022/03/22 16:57:51 [launchpadd] INFO: [RG] SQL Extensibility Cgroup initialization is done.
Mar 22 16:57:51 sqlVm launchpadd[195658]: 2022/03/22 16:57:51 [launchpadd] INFO: Found 1 IP address(es) from the bridge.
Mar 22 16:57:51 sqlVm launchpadd[195676]: modprobe: ERROR: could not insert 'ip6_tables': Operation not permitted
Mar 22 16:57:51 sqlVm launchpadd[195673]: ip6tables v1.8.4 (legacy): can't initialize ip6tables table `filter': Table does not exist (do you need to insmod?)
Mar 22 16:57:51 sqlVm launchpadd[195673]: Perhaps ip6tables or your kernel needs to be upgraded.
Mar 22 16:57:51 sqlVm launchpadd[195678]: modprobe: ERROR: could not insert 'ip6_tables': Operation not permitted
Mar 22 16:57:51 sqlVm launchpadd[195677]: ip6tables v1.8.4 (legacy): can't initialize ip6tables table `filter': Table does not exist (do you need to insmod?)
Mar 22 16:57:51 sqlVm launchpadd[195677]: Perhaps ip6tables or your kernel needs to be upgraded.
Mar 22 16:57:51 sqlVm launchpadd[195670]: 2022/03/22 16:57:51 [setnetbr] ERROR: Failed to set firewall rules: exit status 3

Solução alternativa

Execute os seguintes comandos para configurar modprobe e reinicie o serviço SQL Server Launchpad:

sudo modprobe ip6_tables
sudo systemctl restart mssql-launchpadd

Aplica-se a: SQL Server 2019 (15.x) e posteriores no Linux

Não é possível instalar o pacote tensorflow usando sqlmlutils

O pacote sqlmlutils é usado para instalar pacotes do Python no SQL Server 2019 (15.x). Você precisa baixar, instalar e atualizar os Redistribuíveis do Microsoft Visual C++ 2015-2019 (x64). No entanto, o pacote tensorflow não pode ser instalado usando o sqlmlutils. O pacote tensorflow depende de uma versão mais recente do numpy do que a versão instalada no SQL Server. No entanto, numpy é um pacote de sistema pré-instalado que o sqlmlutils não pode atualizar ao tentar instalar o tensorflow.

Solução alternativa

Usando um prompt de comando no modo de administrador, execute o seguinte comando, substituindo "MSSQLSERVER" pelo nome da sua instância SQL:

"C:\Program Files\Microsoft SQL Server\MSSQL15.MSSQLSERVER\PYTHON_SERVICES\python.exe" -m pip install --upgrade tensorflow

Se você receber um erro "TLS/SSL", confira a seção 7. Não é possível instalar os pacotes do Python usando o pip, descrita anteriormente neste artigo.

Aplica-se a: SQL Server 2019 (15.x) no Windows

Revolution R Enterprise e Microsoft R Open

Esta seção lista problemas específicos à conectividade, ao desenvolvimento e às ferramentas de desempenho do R fornecidas pela Revolution Analytics. Essas ferramentas foram fornecidas em versões de pré-lançamento anteriores do SQL Server.

Em geral, recomendamos a desinstalação dessas versões anteriores e a instalação da última versão do SQL Server ou do Microsoft R Server.

Não há suporte para o Revolution R Enterprise

Não há suporte para instalação do Revolution R Enterprise lado a lado com qualquer versão do R Services (no banco de dados).

Se tiver uma licença existente do Revolution R Enterprise, coloque-a em um computador separado, na instância do SQL Server e na estação de trabalho que pretende usar para se conectar à instância do SQL Server.

Algumas versões de pré-lançamento do R Services (no Banco de Dados) incluíram um ambiente de desenvolvimento do R para o Windows criado pela Revolution Analytics. Não há mais suporte para essa ferramenta e ela não é mais fornecida.

Para obter compatibilidade com o R Services (no Banco de Dados), recomendamos que você instale o Microsoft R Client em seu lugar. As Ferramentas do R para Visual Studio e o Visual Studio Code também dão suporte a soluções do Microsoft R.

Problemas de compatibilidade com o driver ODBC do SQLite e o RevoScaleR

A revisão 0.92 do driver ODBC do SQLite é incompatível com o RevoScaleR. As revisões 0.88-0.91, a 0.93 e as demais posteriores são tidas como compatíveis.

Próximas etapas

• Coletar dados para solucionar problemas dos Serviços de Machine Learning do SQL Server