sp_execute_external_script (Transact-SQL)sp_execute_external_script (Transact-SQL)

S’APPLIQUE À : ouiSQL Server nonAzure SQL Database nonAzure Synapse Analytics (SQL DW) nonParallel Data WarehouseAPPLIES TO: yesSQL Server noAzure SQL Database noAzure Synapse Analytics (SQL DW) noParallel Data Warehouse

La procédure stockée sp_execute_external_script exécute un script fourni en tant qu’argument d’entrée pour la procédure et est utilisé avec les Extensionsde machine learning services et de langage.The sp_execute_external_script stored procedure executes a script provided as an input argument to the procedure, and is used with Machine Learning Services and Language Extensions.

Pour Machine Learning Services, python et R sont des langages pris en charge.For Machine Learning Services, Python and R are supported languages. Pour les extensions de langage, Java est pris en charge, mais doit être défini avec Create External Language.For Language Extensions, Java is supported but must be defined with CREATE EXTERNAL LANGUAGE.

Pour exécuter sp_execute_external_script, vous devez d’abord installer les Extensions de machine learning services ou de langage.To execute sp_execute_external_script, you must first install Machine Learning Services or Language Extensions. Pour plus d’informations, consultez installer SQL Server machine learning services (Python et R) sur Windows et Linux, ou installer les extensions de langage SQL Server sur Windows et Linux.For more information, see Install SQL Server Machine Learning Services (Python and R) on Windows and Linux, or Install SQL Server Language Extensions on Windows and Linux.

La procédure stockée sp_execute_external_script exécute un script fourni en tant qu’argument d’entrée pour la procédure et est utilisé avec Machine Learning Services sur SQL Server 2017.The sp_execute_external_script stored procedure executes a script provided as an input argument to the procedure, and is used with Machine Learning Services on SQL Server 2017.

Pour Machine Learning Services, python et R sont des langages pris en charge.For Machine Learning Services, Python and R are supported languages.

Pour exécuter sp_execute_external_script, vous devez d’abord installer machine learning services.To execute sp_execute_external_script, you must first install Machine Learning Services. Pour plus d’informations, consultez installer SQL Server machine learning services (Python et R) sur Windows.For more information, see Install SQL Server Machine Learning Services (Python and R) on Windows.

La procédure stockée sp_execute_external_script exécute un script fourni en tant qu’argument d’entrée pour la procédure et est utilisé avec R Services sur SQL Server 2016.The sp_execute_external_script stored procedure executes a script provided as an input argument to the procedure, and is used with R Services on SQL Server 2016.

Pour R services, r est le langage pris en charge.For R Services, R is the supported language.

Pour exécuter sp_execute_external_script, vous devez d’abord installer R services.To execute sp_execute_external_script, you must first install R Services. Pour plus d’informations, consultez installer SQL Server machine learning services (Python et R) sur Windows.For more information, see Install SQL Server Machine Learning Services (Python and R) on Windows.

Icône Lien de rubrique Conventions de la syntaxe Transact-SQLTopic link icon Transact-SQL Syntax Conventions

SyntaxeSyntax

sp_execute_external_script   
    @language = N'language',   
    @script = N'script'  
    [ , @input_data_1 = N'input_data_1' ]   
    [ , @input_data_1_name = N'input_data_1_name' ]  
    [ , @input_data_1_order_by_columns = N'input_data_1_order_by_columns' ]    
    [ , @input_data_1_partition_by_columns = N'input_data_1_partition_by_columns' ]  
    [ , @output_data_1_name = N'output_data_1_name' ]  
    [ , @parallel = 0 | 1 ]  
    [ , @params = N'@parameter_name data_type [ OUT | OUTPUT ] [ ,...n ]' ] 
    [ , @parameter1 = 'value1' [ OUT | OUTPUT ] [ ,...n ] ]

Syntaxe pour 2017 et versions antérieuresSyntax for 2017 and earlier

sp_execute_external_script   
    @language = N'language',   
    @script = N'script'  
    [ , @input_data_1 = N'input_data_1' ]   
    [ , @input_data_1_name = N'input_data_1_name' ]  
    [ , @output_data_1_name = N'output_data_1_name' ]  
    [ , @parallel = 0 | 1 ]  
    [ , @params = N'@parameter_name data_type [ OUT | OUTPUT ] [ ,...n ]' ] 
    [ , @parameter1 = 'value1' [ OUT | OUTPUT ] [ ,...n ] ]

ArgumentsArguments

@Language = N'Language'@language = N'language'

Indique le langage de script.Indicates the script language. Language est de type sysname.language is sysname. Les valeurs valides sont R, pythonet n’importe quel langage défini avec Create External Language (par exemple, Java).Valid values are R, Python, and any language defined with CREATE EXTERNAL LANGUAGE (for example, Java).

Indique le langage de script.Indicates the script language. Language est de type sysname.language is sysname. Dans SQL Server 2017, les valeurs valides sont R et python.In SQL Server 2017, valid values are R and Python.

Indique le langage de script.Indicates the script language. Language est de type sysname.language is sysname. Dans SQL Server 2016, la seule valeur valide est R.In SQL Server 2016, the only valid value is R.

@ script du langage externescript = N est spécifié en tant qu’entrée littérale ou variable.@script = N'script' External language script specified as a literal or variable input. le script est de type nvarchar (max) .script is nvarchar(max).

[ @input_data_1 = N'input_data_1' ] spécifie les données d’entrée utilisées par le script externe sous la forme d’une requête Transact-SQLTransact-SQL.[ @input_data_1 = N'input_data_1' ] Specifies the input data used by the external script in the form of a Transact-SQLTransact-SQL query. Le type de données de input_data_1 est nvarchar (max) .The data type of input_data_1 is nvarchar(max).

[ @input_data_1_name = N'input_data_1_name' ] spécifie le nom de la variable utilisée pour représenter la requête définie par @input_data_1.[ @input_data_1_name = N'input_data_1_name' ] Specifies the name of the variable used to represent the query defined by @input_data_1. Le type de données de la variable dans le script externe dépend de la langue.The data type of the variable in the external script depends on the language. Dans le cas de R, la variable d’entrée est une trame de données.In case of R, the input variable is a data frame. Dans le cas de Python, l’entrée doit être tabulaire.In the case of Python, input must be tabular. input_data_1_name est de type sysname.input_data_1_name is sysname. La valeur par défaut est InputDataSet.Default value is InputDataSet.

[ @input_data_1_order_by_columns = N'input_data_1_order_by_columns' ] utilisé pour générer des modèles par partition.[ @input_data_1_order_by_columns = N'input_data_1_order_by_columns' ] Used to build per-partition models. Spécifie le nom de la colonne utilisée pour trier le jeu de résultats, par exemple par nom de produit.Specifies the name of the column used to order the result set, for example by product name. Le type de données de la variable dans le script externe dépend de la langue.The data type of the variable in the external script depends on the language. Dans le cas de R, la variable d’entrée est une trame de données.In case of R, the input variable is a data frame. Dans le cas de Python, l’entrée doit être tabulaire.In the case of Python, input must be tabular.

[ @input_data_1_partition_by_columns = N'input_data_1_partition_by_columns' ] utilisé pour générer des modèles par partition.[ @input_data_1_partition_by_columns = N'input_data_1_partition_by_columns' ] Used to build per-partition models. Spécifie le nom de la colonne utilisée pour segmenter les données, telles que la région géographique ou la date.Specifies the name of the column used to segment data, such as geographic region or date. Le type de données de la variable dans le script externe dépend de la langue.The data type of the variable in the external script depends on the language. Dans le cas de R, la variable d’entrée est une trame de données.In case of R, the input variable is a data frame. Dans le cas de Python, l’entrée doit être tabulaire.In the case of Python, input must be tabular.

[ @output_data_1_name = N'output_data_1_name' ] spécifie le nom de la variable dans le script externe qui contient les données à retourner à SQL ServerSQL Server à la fin de l’appel de la procédure stockée.[ @output_data_1_name = N'output_data_1_name' ] Specifies the name of the variable in the external script that contains the data to be returned to SQL ServerSQL Server upon completion of the stored procedure call. Le type de données de la variable dans le script externe dépend de la langue.The data type of the variable in the external script depends on the language. Pour R, la sortie doit être une trame de données.For R, the output must be a data frame. Pour Python, la sortie doit être une trame de données pandas.For Python, the output must be a pandas data frame. output_data_1_name est de type sysname.output_data_1_name is sysname. La valeur par défaut est OutputDataSet.Default value is OutputDataSet.

[ @parallel = 0 | 1 ] permet l’exécution parallèle de scripts R en affectant la valeur 1 au paramètre @parallel.[ @parallel = 0 | 1 ] Enable parallel execution of R scripts by setting the @parallel parameter to 1. La valeur par défaut de ce paramètre est 0 (aucun parallélisme).The default for this parameter is 0 (no parallelism). Si @parallel = 1 et que la sortie est diffusée directement sur l’ordinateur client, la clause WITH RESULT SETS est requise et un schéma de sortie doit être spécifié.If @parallel = 1 and the output is being streamed directly to the client machine, then the WITH RESULT SETS clause is required and an output schema must be specified.

  • Pour les scripts R qui n’utilisent pas de fonctions RevoScaleR, l’utilisation du paramètre @parallel peut être bénéfique pour le traitement de jeux de données volumineux, en supposant que le script peut être parallélisée de façon triviale.For R scripts that do not use RevoScaleR functions, using the @parallel parameter can be beneficial for processing large datasets, assuming the script can be trivially parallelized. Par exemple, lors de l’utilisation de la fonction R predict avec un modèle pour générer de nouvelles prédictions, définissez @parallel = 1 comme indicateur pour le moteur de requête.For example, when using the R predict function with a model to generate new predictions, set @parallel = 1 as a hint to the query engine. Si la requête peut être parallélisée, les lignes sont distribuées selon le paramètre MAXDOP .If the query can be parallelized, rows are distributed according to the MAXDOP setting.

  • Pour les scripts R qui utilisent des fonctions RevoScaleR, le traitement parallèle est géré automatiquement et vous ne devez pas spécifier @parallel = 1 à l’appel sp_execute_external_script .For R scripts that use RevoScaleR functions, parallel processing is handled automatically and you should not specify @parallel = 1 to the sp_execute_external_script call.

[ @params = N'@parameter_name data_type [ OUT | OUTPUT ] [ ,...n ]' ] liste des déclarations de paramètres d’entrée utilisées dans le script externe.[ @params = N'@parameter_name data_type [ OUT | OUTPUT ] [ ,...n ]' ] A list of input parameter declarations that are used in the external script.

[ @parameter1 = 'value1' [ OUT | OUTPUT ] [ ,...n ] ] liste de valeurs pour les paramètres d’entrée utilisés par le script externe.[ @parameter1 = 'value1' [ OUT | OUTPUT ] [ ,...n ] ] A list of values for the input parameters used by the external script.

NotesRemarks

Important

L’arborescence de requêtes est contrôlée par SQL ServerSQL Server et les utilisateurs ne peuvent pas effectuer d’opérations arbitraires sur la requête.The query tree is controlled by SQL ServerSQL Server and users cannot perform arbitrary operations on the query.

Utilisez sp_execute_external_script pour exécuter des scripts écrits dans un langage pris en charge.Use sp_execute_external_script to execute scripts written in a supported language. Les langues prises en charge sont python et R utilisées avec machine learning services, ainsi que tous les langages définis avec Create External Language (par exemple, Java) utilisés avec les extensions de langage.Supported languages are Python and R used with Machine Learning Services, and any language defined with CREATE EXTERNAL LANGUAGE (for example, Java) used with Language Extensions.

Utilisez sp_execute_external_script pour exécuter des scripts écrits dans un langage pris en charge.Use sp_execute_external_script to execute scripts written in a supported language. Les langues prises en charge sont python et R dans SQL Server 2017 machine learning services.Supported languages are Python and R in SQL Server 2017 Machine Learning Services.

Utilisez sp_execute_external_script pour exécuter des scripts écrits dans un langage pris en charge.Use sp_execute_external_script to execute scripts written in a supported language. La seule langue prise en charge est r dans SQL Server les Services r 2016.The only supported language is R in SQL Server 2016 R Services.

Par défaut, les jeux de résultats retournés par cette procédure stockée sont générés avec des colonnes sans nom.By default, result sets returned by this stored procedure are output with unnamed columns. Les noms de colonne utilisés dans un script sont locaux dans l’environnement de script et ne sont pas reflétés dans le jeu de résultats sorti.Column names used within a script are local to the scripting environment and are not reflected in the outputted result set. Pour nommer les colonnes du jeu de résultats, utilisez la clause WITH RESULT SET de EXECUTE.To name result set columns, use the WITH RESULT SET clause of EXECUTE.

En plus de retourner un jeu de résultats, vous pouvez retourner des valeurs scalaires à SQL ServerSQL Server à l’aide des paramètres de sortie.In addition to returning a result set, you can return scalar values to SQL ServerSQL Server by using OUTPUT parameters.

Vous pouvez contrôler les ressources utilisées par les scripts externes en configurant un pool de ressources externes.You can control the resources used by external scripts by configuring an external resource pool. Pour plus d’informations, consultez CREATE EXTERNAL RESOURCE POOL (Transact-SQL).For more information, see CREATE EXTERNAL RESOURCE POOL (Transact-SQL). Les informations sur la charge de travail peuvent être obtenues à partir des affichages catalogue du gouverneur de ressources, des DMV et des compteurs.Information about the workload can be obtained from the resource governor catalog views, DMV's, and counters. Pour plus d’informations, consultez Resource Governor les (affichages catalogue)Transact-SQL, Resource Governor les (vues de gestion)dynamique associées à Transact-SQLet SQL Server, objet scripts externes.For more information, see Resource Governor Catalog Views (Transact-SQL), Resource Governor Related Dynamic Management Views (Transact-SQL), and SQL Server, External Scripts Object.

Surveiller l’exécution du scriptMonitor script execution

Surveiller l’exécution du script à l’aide de sys. DM _external_script_requests et sys. DM _external_script_execution_stats.Monitor script execution using sys.dm_external_script_requests and sys.dm_external_script_execution_stats.

Paramètres pour la modélisation de partitionParameters for partition modeling

Vous pouvez définir deux paramètres supplémentaires qui activent la modélisation sur des données partitionnées, où les partitions sont basées sur une ou plusieurs colonnes que vous fournissez, qui segmentent naturellement un jeu de données en partitions logiques créées et utilisées uniquement pendant l’exécution du script.You can set two additional parameters that enable modeling on partitioned data, where partitions are based on one or more columns you provide that naturally segment a data set into logical partitions created and used only during script execution. Les colonnes contenant des valeurs répétitives pour l’âge, le sexe, la région géographique, la date ou l’heure, sont quelques exemples qui se prêtent à des jeux de données partitionnés.Columns containing repeating values for age, gender, geographic region, date or time, are a few examples that lend themselves to partitioned data sets.

Les deux paramètres sont input_data_1_partition_by_columns et input_data_1_order_by_columns, où le deuxième paramètre est utilisé pour trier le jeu de résultats.The two parameters are input_data_1_partition_by_columns and input_data_1_order_by_columns, where the second parameter is used to order the result set. Les paramètres sont passés comme entrées à sp_execute_external_script avec le script externe qui s’exécute une fois pour chaque partition.The parameters are passed as inputs to sp_execute_external_script with the external script executing once for every partition. Pour plus d’informations et d’exemples, consultez Didacticiel : créer des modèles basés sur une partition.For more information and examples, see Tutorial: Create partition-based models.

Vous pouvez exécuter le script en parallèle en spécifiant @parallel=1.You can execute script in parallel by specifying @parallel=1. Si la requête d’entrée peut être parallélisée, vous devez définir @parallel=1 dans le cadre de vos arguments pour sp_execute_external_script.If the input query can be parallelized, you should set @parallel=1 as part of your arguments to sp_execute_external_script. Par défaut, l’optimiseur de requête fonctionne sous @parallel=1 sur les tables contenant plus de 256 lignes, mais si vous souhaitez gérer cela explicitement, ce script comprend le paramètre comme une démonstration.By default, the query optimizer operates under @parallel=1 on tables having more than 256 rows, but if you want to handle this explicitly, this script includes the parameter as a demonstration.

Conseil

Pour la formation workoads, vous pouvez utiliser @parallel avec n’importe quel script d’apprentissage arbitraire, même ceux qui utilisent des algorithmes non-Microsoft-RX.For training workoads, you can use @parallel with any arbitrary training script, even those using non-Microsoft-rx algorithms. En règle générale, seuls les algorithmes RevoScaleR (avec le préfixe RX) offrent un parallélisme dans les scénarios d’apprentissage dans SQL Server.Typically, only RevoScaleR algorithms (with the rx prefix) offer parallelism in training scenarios in SQL Server. Mais avec les nouveaux paramètres dans SQL Server vNext, vous pouvez paralléliser un script qui appelle des fonctions qui ne sont pas spécifiquement conçues avec cette fonctionnalité.But with the new parameters in SQL Server vNext, you can parallelize a script that calls functions not specifically engineered with that capability.

Exécution de la diffusion en continu pour les scripts Python et RStreaming execution for Python and R scripts

La diffusion en continu permet au script Python ou R de travailler avec plus de données que la mémoire ne peut en contenir.Streaming allows the Python or R script to work with more data than can fit in memory. Pour contrôler le nombre de lignes transmises pendant la diffusion en continu, spécifiez une valeur entière pour le paramètre, @r_rowsPerRead dans la collection @params.To control the number of rows passed during streaming, specify an integer value for the parameter, @r_rowsPerRead in the @params collection. Par exemple, si vous effectuez l’apprentissage d’un modèle qui utilise des données très larges, vous pouvez ajuster la valeur pour lire moins de lignes, afin de vous assurer que toutes les lignes peuvent être envoyées dans un segment de données.For example, if you are training a model that uses very wide data, you could adjust the value to read fewer rows, to ensure that all rows can be sent in one chunk of data. Vous pouvez également utiliser ce paramètre pour gérer le nombre de lignes lues et traitées en même temps, afin d’atténuer les problèmes de performances du serveur.You might also use this parameter to manage the number of rows being read and processed at one time, to mitigate server performance issues.

Le paramètre @r_rowsPerRead pour la diffusion en continu et l’argument @parallel doivent être considérés comme des indicateurs.Both the @r_rowsPerRead parameter for streaming and the @parallel argument should be considered hints. Pour que l’indicateur soit appliqué, il doit être possible de générer un plan de requête SQL qui comprend un traitement parallèle.For the hint to be applied, it must be possible to generate a SQL query plan that includes parallel processing. Si ce n’est pas possible, le traitement parallèle ne peut pas être activé.If this is not possible, parallel processing cannot be enabled.

Notes

La diffusion en continu et le traitement parallèle sont pris en charge uniquement dans Enterprise Edition.Streaming and parallel processing are supported only in Enterprise Edition. Vous pouvez inclure les paramètres dans vos requêtes dans l’édition standard sans générer d’erreur, mais les paramètres n’ont aucun effet et les scripts R s’exécutent dans un processus unique.You can include the parameters in your queries in Standard Edition without raising an error, but the parameters have no effect and R scripts run in a single process.

RestrictionsRestrictions

Types de donnéesData types

Les types de données suivants ne sont pas pris en charge lorsqu’ils sont utilisés dans la requête ou les paramètres d’entrée de la procédure sp_execute_external_script , et renvoient une erreur de type non pris en charge.The following data types are not supported when used in the input query or parameters of sp_execute_external_script procedure, and return an unsupported type error.

En guise de solution de contournement, effectuez un cast de la colonne ou de la valeur en un type pris en charge dans Transact-SQLTransact-SQL avant de l’envoyer au script externe.As a workaround, CAST the column or value to a supported type in Transact-SQLTransact-SQL before sending it to the external script.

  • cursorcursor

  • timestamptimestamp

  • datetime2, DateTimeOffset, Timedatetime2, datetimeoffset, time

  • sql_variantsql_variant

  • texte, imagetext, image

  • xmlxml

  • hierarchyid, Geometry, Geographyhierarchyid, geometry, geography

  • Types CLR définis par l’utilisateurCLR user-defined types

En général, tout jeu de résultats qui ne peut pas être mappé à un type de données Transact-SQLTransact-SQL est généré en tant que valeur NULL.In general, any result set that cannot be mapped to a Transact-SQLTransact-SQL data type, is output as NULL.

Restrictions spécifiques à RRestrictions specific to R

Si l’entrée comprend des valeurs DateTime qui ne correspondent pas à la plage de valeurs autorisée dans R, les valeurs sont converties en na.If the input includes datetime values that do not fit the permissible range of values in R, values are converted to NA. Cela est nécessaire, car SQL ServerSQL Server autorise une plus grande plage de valeurs que ce qui est pris en charge dans le langage R.This is required because SQL ServerSQL Server permits a larger range of values than is supported in the R language.

Les valeurs float (par exemple, +Inf, -Inf, NaN) ne sont pas prises en charge dans SQL ServerSQL Server, même si les deux langages utilisent IEEE 754.Float values (for example, +Inf, -Inf, NaN) are not supported in SQL ServerSQL Server even though both languages use IEEE 754. Le comportement actuel envoie simplement les valeurs à SQL ServerSQL Server directement ; par conséquent, le client SQL de Management StudioManagement Studio génère une erreur.Current behavior just sends the values to SQL ServerSQL Server directly; as a result, the SQL client in Management StudioManagement Studio throws an error. Par conséquent, ces valeurs sont converties en valeurs null.Therefore, these values are converted to NULL.

AutorisationsPermissions

Requiert l’autorisation exécuter une base de données de script externe.Requires EXECUTE ANY EXTERNAL SCRIPT database permission.

ExemplesExamples

Cette section contient des exemples de la façon dont cette procédure stockée peut être utilisée pour exécuter des scripts R ou python à l’aide de Transact-SQLTransact-SQL.This section contains examples of how this stored procedure can be used to execute R or Python scripts using Transact-SQLTransact-SQL.

A.A. Retourne un jeu de données R SQL ServerReturn an R data set to SQL Server

L’exemple suivant crée une procédure stockée qui utilise sp_execute_external_script pour retourner le jeu de données Iris inclus avec R à SQL ServerSQL Server.The following example creates a stored procedure that uses sp_execute_external_script to return the Iris dataset included with R to SQL ServerSQL Server.

DROP PROC IF EXISTS get_iris_dataset;  
go  
CREATE PROC get_iris_dataset
AS  
BEGIN  
 EXEC   sp_execute_external_script  
       @language = N'R'  
     , @script = N'iris_data <- iris;'
     , @input_data_1 = N''  
     , @output_data_1_name = N'iris_data'
     WITH RESULT SETS (("Sepal.Length" float not null,   
           "Sepal.Width" float not null,  
        "Petal.Length" float not null,   
        "Petal.Width" float not null, "Species" varchar(100)));  
END;
GO

B.B. Générer un modèle R basé sur les données de SQL ServerGenerate an R model based on data from SQL Server

L’exemple suivant crée une procédure stockée qui utilise sp_execute_external_script pour générer un modèle d’IRIS et retourner le modèle à SQL ServerSQL Server.The following example creates a stored procedure that uses sp_execute_external_script to generate an iris model and return the model to SQL ServerSQL Server.

Notes

Cet exemple nécessite une installation avancée du package e1071.This example requires advance installation of the e1071 package. Pour plus d’informations, consultez installer des packages R supplémentaires sur SQL Server.For more information, see Install additional R packages on SQL Server.

DROP PROC IF EXISTS generate_iris_model;
GO
CREATE PROC generate_iris_model
AS
BEGIN
 EXEC sp_execute_external_script  
      @language = N'R'  
     , @script = N'  
          library(e1071);  
          irismodel <-naiveBayes(iris_data[,1:4], iris_data[,5]);  
          trained_model <- data.frame(payload = as.raw(serialize(irismodel, connection=NULL)));  
'  
     , @input_data_1 = N'select "Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", "Species" from iris_data'  
     , @input_data_1_name = N'iris_data'  
     , @output_data_1_name = N'trained_model'  
    WITH RESULT SETS ((model varbinary(max)));  
END;
GO

Pour générer un modèle semblable à l’aide de Python, vous devez remplacer l’identificateur de langage @language=N'R' par @language = N'Python' et apporter les modifications nécessaires à l’argument @script.To generate a similar model using Python, you would change the language identifier from @language=N'R' to @language = N'Python', and make necessary modifications to the @script argument. Autrement, tous les paramètres fonctionnent de la même manière que pour R.Otherwise, all parameters function the same way as for R.

C.C. Créer un modèle Python et générer des scores à partir de celui-ciCreate a Python model and generate scores from it

Cet exemple illustre l’utilisation de sp_execute_external_script pour générer des scores sur un modèle Python simple.This example illustrates how to use sp_execute_external_script to generate scores on a simple Python model.

CREATE PROCEDURE [dbo].[py_generate_customer_scores]
AS
BEGIN

-- Input query to generate the customer data
DECLARE @input_query NVARCHAR(MAX) = N'SELECT customer, orders, items, cost FROM dbo.Sales.Orders'

EXEC sp_execute_external_script @language = N'Python', @script = N'
import pandas as pd
from sklearn.cluster import KMeans

# Get data from input query
customer_data = my_input_data

# Define the model
n_clusters = 4
est = KMeans(n_clusters=n_clusters, random_state=111).fit(customer_data[["orders","items","cost"]])
clusters = est.labels_
customer_data["cluster"] = clusters

OutputDataSet = customer_data
'
, @input_data_1 = @input_query
, @input_data_1_name = N'my_input_data'
WITH RESULT SETS (("CustomerID" int, "Orders" float,"Items" float,"Cost" float,"ClusterResult" float));
END;
GO

Les en-têtes de colonne utilisés dans le code python ne sont pas générés dans SQL Server ; par conséquent, utilisez l’instruction WITH RESULT pour spécifier les noms de colonnes et les types de données que SQL doit utiliser.Column headings used in Python code are not output to SQL Server; therefore, use the WITH RESULT statement to specify the column names and data types for SQL to use.

Pour calculer les scores, vous pouvez également utiliser la fonction PREDICT native, qui est généralement plus rapide car elle évite d’appeler le runtime Python ou R.For scoring, you can also use the native PREDICT function, which is typically faster because it avoids calling the Python or R runtime.

Voir aussiSee also