INSERT (Transact-SQL)INSERT (Transact-SQL)

S’applique à :Applies to: ouiSQL ServerSQL Server (toutes les versions prises en charge) yesSQL ServerSQL Server (all supported versions) OuiAzure SQL DatabaseAzure SQL DatabaseYesAzure SQL DatabaseAzure SQL Database OuiAzure SQL Managed InstanceAzure SQL Managed InstanceYesAzure SQL Managed InstanceAzure SQL Managed Instance ouiAzure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics ouiParallel Data WarehouseParallel Data WarehouseyesParallel Data WarehouseParallel Data WarehouseS’applique à :Applies to: ouiSQL ServerSQL Server (toutes les versions prises en charge) yesSQL ServerSQL Server (all supported versions) OuiAzure SQL DatabaseAzure SQL DatabaseYesAzure SQL DatabaseAzure SQL Database OuiAzure SQL Managed InstanceAzure SQL Managed InstanceYesAzure SQL Managed InstanceAzure SQL Managed Instance ouiAzure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics ouiParallel Data WarehouseParallel Data WarehouseyesParallel Data WarehouseParallel Data Warehouse

Ajoute une ou plusieurs lignes à une table ou une vue dans SQL ServerSQL Server.Adds one or more rows to a table or a view in SQL ServerSQL Server. Pour obtenir des exemples, consultez Exemples.For examples, see Examples.

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

SyntaxeSyntax

-- Syntax for SQL Server and Azure SQL Database  

[ WITH <common_table_expression> [ ,...n ] ]  
INSERT   
{  
        [ TOP ( expression ) [ PERCENT ] ]   
        [ INTO ]   
        { <object> | rowset_function_limited   
          [ WITH ( <Table_Hint_Limited> [ ...n ] ) ]  
        }  
    {  
        [ ( column_list ) ]   
        [ <OUTPUT Clause> ]  
        { VALUES ( { DEFAULT | NULL | expression } [ ,...n ] ) [ ,...n     ]   
        | derived_table   
        | execute_statement  
        | <dml_table_source>  
        | DEFAULT VALUES   
        }  
    }  
}  
[;]  
  
<object> ::=  
{   
    [ server_name . database_name . schema_name .   
      | database_name .[ schema_name ] .   
      | schema_name .   
    ]  
  table_or_view_name  
}  
  
<dml_table_source> ::=  
    SELECT <select_list>  
    FROM ( <dml_statement_with_output_clause> )   
      [AS] table_alias [ ( column_alias [ ,...n ] ) ]  
    [ WHERE <search_condition> ]  
        [ OPTION ( <query_hint> [ ,...n ] ) ]  
-- External tool only syntax  

INSERT   
{  
    [BULK]  
    { database_name.schema_name.table_or_view_name | schema_name.table_or_view_name | table_or_view_name }  
    ( <column_definition> )  
    [ WITH (  
        [ [ , ] CHECK_CONSTRAINTS ]  
        [ [ , ] FIRE_TRIGGERS ]  
        [ [ , ] KEEP_NULLS ]  
        [ [ , ] KILOBYTES_PER_BATCH = kilobytes_per_batch ]  
        [ [ , ] ROWS_PER_BATCH = rows_per_batch ]  
        [ [ , ] ORDER ( { column [ ASC | DESC ] } [ ,...n ] ) ]  
        [ [ , ] TABLOCK ]  
    ) ]  
}  
  
[; ] <column_definition> ::=  
 column_name <data_type>  
    [ COLLATE collation_name ]  
    [ NULL | NOT NULL ]  
  
<data type> ::=   
[ type_schema_name . ] type_name   
    [ ( precision [ , scale ] | max ]  
-- Syntax for Azure Synapse Analytics and Parallel Data Warehouse  

INSERT INTO { database_name.schema_name.table_name | schema_name.table_name | table_name }
    [ ( column_name [ ,...n ] ) ]  
    {   
      VALUES ( { NULL | expression } )  
      | SELECT <select_criteria>  
    }  
    [ OPTION ( <query_option> [ ,...n ] ) ]  
[;]  

Notes

Pour afficher la syntaxe Transact-SQL pour SQL Server 2014 et versions antérieures, consultez Versions antérieures de la documentation.To view Transact-SQL syntax for SQL Server 2014 and earlier, see Previous versions documentation.

ArgumentsArguments

WITH <common_table_expression>WITH <common_table_expression>
Spécifie le jeu de résultats nommé temporaire, également appelé expression de table commune, défini dans l'étendue de l'instruction INSERT.Specifies the temporary named result set, also known as common table expression, defined within the scope of the INSERT statement. Le jeu de résultats est dérivé d'une instruction SELECT.The result set is derived from a SELECT statement. Pour plus d’informations, consultez WITH common_table_expression (Transact-SQL).For more information, see WITH common_table_expression (Transact-SQL).

TOP (expression) [ PERCENT ]TOP (expression) [ PERCENT ]
Spécifie le nombre ou le pourcentage de lignes aléatoires qui seront insérées.Specifies the number or percent of random rows that will be inserted. L'argument expression peut être un nombre ou un pourcentage de lignes.expression can be either a number or a percent of the rows. Pour plus d’informations, consultez TOP (Transact-SQL).For more information, see TOP (Transact-SQL).

INTOINTO
Mot clé facultatif qui peut être inséré entre le mot clé INSERT et la table cible.Is an optional keyword that can be used between INSERT and the target table.

server_nameserver_name
S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

Nom du serveur lié sur lequel se trouve la table ou la vue.Is the name of the linked server on which the table or view is located. server_name peut être spécifié comme nom de serveur lié ou à l’aide de la fonction OPENDATASOURCE.server_name can be specified as a linked server name, or by using the OPENDATASOURCE function.

Quand server_name est spécifié comme serveur lié, database_name et schema_name sont obligatoires.When server_name is specified as a linked server, database_name and schema_name are required. Quand server_name est spécifié avec OPENDATASOURCE, database_name et schema_name peuvent ne pas s’appliquer à toutes les sources de données ; par ailleurs, ils dépendent des fonctionnalités du fournisseur OLE DB qui accède à l’objet distant.When server_name is specified with OPENDATASOURCE, database_name and schema_name may not apply to all data sources and is subject to the capabilities of the OLE DB provider that accesses the remote object.

database_namedatabase_name
S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

Nom de la base de données.Is the name of the database.

schema_nameschema_name
Nom du schéma auquel la table ou la vue appartient.Is the name of the schema to which the table or view belongs.

table_or view_nametable_or view_name
Nom de la table ou de la vue qui doit recevoir les données.Is the name of the table or view that is to receive the data.

Une variable de table, dans son étendue, peut être utilisée comme source de table dans une instruction INSERT.A table variable, within its scope, can be used as a table source in an INSERT statement.

La vue référencée par table_or_view_name doit pouvoir être mise à jour et faire référence à une seule table de base dans la clause FROM de la vue.The view referenced by table_or_view_name must be updatable and reference exactly one base table in the FROM clause of the view. Par exemple, une instruction INSERT dans une vue contenant plusieurs tables doit utiliser un column_list qui référence uniquement les colonnes d’une seule table de base.For example, an INSERT into a multi-table view must use a column_list that references only columns from one base table. Pour plus d’informations sur les vues pouvant être mises à jour, consultez CREATE VIEW (Transact-SQL).For more information about updatable views, see CREATE VIEW (Transact-SQL).

rowset_function_limitedrowset_function_limited
S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

Fonction OPENQUERY ou OPENROWSET.Is either the OPENQUERY or OPENROWSET function. L'utilisation de ces fonctions dépend des fonctionnalités du fournisseur OLE DB qui accède à l'objet distant.Use of these functions is subject to the capabilities of the OLE DB provider that accesses the remote object.

WITH ( <table_hint_limited> [... n ] )WITH ( <table_hint_limited> [... n ] )
Spécifie un ou plusieurs indicateurs de table autorisés pour une table cible.Specifies one or more table hints that are allowed for a target table. Le mot clé WITH et les parenthèses sont obligatoires.The WITH keyword and the parentheses are required.

READPAST, NOLOCK et READUNCOMMITTED ne sont pas autorisés.READPAST, NOLOCK, and READUNCOMMITTED are not allowed. Pour plus d’informations sur les indicateurs de table, consultez Indicateurs de table (Transact-SQL).For more information about table hints, see Table Hints (Transact-SQL).

Important

La possibilité de spécifier les indicateurs HOLDLOCK, SERIALIZABLE, READCOMMITTED, REPEATABLEREAD ou UPDLOCK sur les tables qui sont des cibles d'instructions INSERT sera supprimée dans une future version de SQL ServerSQL Server.The ability to specify the HOLDLOCK, SERIALIZABLE, READCOMMITTED, REPEATABLEREAD, or UPDLOCK hints on tables that are targets of INSERT statements will be removed in a future version of SQL ServerSQL Server. Ces indicateurs n'affectent pas les performances des instructions INSERT.These hints do not affect the performance of INSERT statements. Évitez de les utiliser dans les nouveaux travaux de développement et prévoyez la modification des applications qui les utilisent actuellement.Avoid using them in new development work, and plan to modify applications that currently use them.

La spécification de l'indicateur TABLOCK sur une table qui est la cible d'une instruction INSERT a le même effet que la spécification de l'indicateur TABLOCKX.Specifying the TABLOCK hint on a table that is the target of an INSERT statement has the same effect as specifying the TABLOCKX hint. Un verrou exclusif est appliqué à la table.An exclusive lock is taken on the table.

(column_list)(column_list)
Liste d'une ou plusieurs colonnes dans lesquelles insérer des données.Is a list of one or more columns in which to insert data. column_list doit être placé entre parenthèses et délimité par des virgules.column_list must be enclosed in parentheses and delimited by commas.

Si une colonne ne se trouve pas dans column_list, le Moteur de base de donnéesDatabase Engine doit pouvoir fournir une valeur basée sur la définition de la colonne ; sinon, il n’est pas possible de charger la ligne.If a column is not in column_list, the Moteur de base de donnéesDatabase Engine must be able to provide a value based on the definition of the column; otherwise, the row cannot be loaded. Le Moteur de base de donnéesDatabase Engine fournit automatiquement une valeur pour la colonne si :The Moteur de base de donnéesDatabase Engine automatically provides a value for the column if the column:

  • a une propriété IDENTITY.Has an IDENTITY property. la valeur d'identité incrémentielle suivante est utilisée ;The next incremental identity value is used.

  • elle a une valeur par défaut,Has a default. la valeur par défaut de la colonne est utilisée ;The default value for the column is used.

  • la colonne a un type de données timestamp ;Has a timestamp data type. la valeur d'horodateur actuelle est utilisée ;The current timestamp value is used.

  • Autorise la valeur NULL.Is nullable. Une valeur Null est utilisée.A null value is used.

  • Colonne calculée.Is a computed column. la valeur calculée est utilisée.The calculated value is used.

column_list doit être utilisé lors de l’insertion de valeurs explicites dans une colonne d’identité ; par ailleurs, l’option SET IDENTITY_INSERT doit avoir la valeur ON pour la table.column_list must be used when explicit values are inserted into an identity column, and the SET IDENTITY_INSERT option must be ON for the table.

Clause OUTPUTOUTPUT Clause
Retourne des lignes insérées dans le cadre de l'opération d'insertion.Returns inserted rows as part of the insert operation. Les résultats peuvent être retournés à l'application de traitement ou être insérés dans une table ou une variable de table pour un traitement ultérieur.The results can be returned to the processing application or inserted into a table or table variable for further processing.

La clause OUTPUT n’est pas prise en charge dans les instructions DML qui font référence à des vues partitionnées locales, à des vues partitionnées distribuées, à des tables distantes ou à des instructions INSERT contenant un execute_statement.The OUTPUT clause is not supported in DML statements that reference local partitioned views, distributed partitioned views, or remote tables, or INSERT statements that contain an execute_statement. La clause OUTPUT INTO n’est pas prise en charge dans les instructions INSERT qui contiennent une clause <dml_table_source>.The OUTPUT INTO clause is not supported in INSERT statements that contain a <dml_table_source> clause. Pour plus d’informations sur les arguments et le comportement de cette clause, consultez Clause OUTPUT (Transact-SQL).For more information about the arguments and behavior of this clause, see OUTPUT Clause (Transact-SQL).

VALUESVALUES
Présente la ou les listes de valeurs de données à insérer.Introduces the list or lists of data values to be inserted. Il doit y avoir une valeur de données pour chaque colonne de column_list (le cas échéant) ou de la table.There must be one data value for each column in column_list, if specified, or in the table. La liste de valeurs doit être mise entre parenthèses.The value list must be enclosed in parentheses.

Si les valeurs de la liste de valeurs ne sont pas dans le même ordre que les colonnes de la table ou n’ont pas de valeur pour chaque colonne de la table, column_list doit être utilisé afin de spécifier de manière explicite la colonne qui stocke chaque valeur entrante.If the values in the Value list are not in the same order as the columns in the table or do not have a value for each column in the table, column_list must be used to explicitly specify the column that stores each incoming value.

Vous pouvez utiliser le constructeur ROW Transact-SQLTransact-SQL (également appelé constructeur de valeurs de table) pour spécifier plusieurs lignes dans une seule instruction INSERT.You can use the Transact-SQLTransact-SQL row constructor (also called a table value constructor) to specify multiple rows in a single INSERT statement. Le constructeur ROW est constitué d'une seule clause VALUES comportant plusieurs listes de valeurs placées entre parenthèses et séparées par une virgule.The row constructor consists of a single VALUES clause with multiple value lists enclosed in parentheses and separated by a comma. Pour plus d’informations, consultez Constructeur de valeurs de table (Transact-SQL).For more information, see Table Value Constructor (Transact-SQL).

DEFAULTDEFAULT
Force le Moteur de base de donnéesDatabase Engine à charger la valeur par défaut définie pour une colonne.Forces the Moteur de base de donnéesDatabase Engine to load the default value defined for a column. S'il n'existe pas de valeur par défaut pour la colonne et si celle-ci autorise les valeurs NULL, NULL est inséré.If a default does not exist for the column and the column allows null values, NULL is inserted. Pour une colonne définie avec le type de données timestamp, la valeur d’horodateur suivante est insérée.For a column defined with the timestamp data type, the next timestamp value is inserted. DEFAULT n'est pas valide pour une colonne d'identité.DEFAULT is not valid for an identity column.

expressionexpression
Constante, variable ou expression.Is a constant, a variable, or an expression. L'expression ne peut pas contenir d'instruction EXECUTE.The expression cannot contain an EXECUTE statement.

Quand vous faites référence aux types de données caractères Unicode nchar, nvarchar et ntext, 'expression' doit être précédé de la majuscule « N ».When referencing the Unicode character data types nchar, nvarchar, and ntext, 'expression' should be prefixed with the capital letter 'N'. Si vous ne spécifiez pas « N », SQL ServerSQL Server convertit la chaîne dans la page de codes qui correspond au classement par défaut de la base de données ou de la colonne.If 'N' is not specified, SQL ServerSQL Server converts the string to the code page that corresponds to the default collation of the database or column. Tous les caractères absents de cette page de codes sont alors perdus.Any characters not found in this code page are lost.

derived_tablederived_table
Toute instruction SELECT valide qui retourne des lignes de données à charger dans la table.Is any valid SELECT statement that returns rows of data to be loaded into the table. L'instruction SELECT ne peut pas contenir une expression de table commune.The SELECT statement cannot contain a common table expression (CTE).

execute_statementexecute_statement
Toute instruction EXECUTE valide qui retourne des données avec les instructions SELECT ou READTEXT.Is any valid EXECUTE statement that returns data with SELECT or READTEXT statements. Pour plus d’informations, consultez EXECUTE (Transact-SQL).For more information, see EXECUTE (Transact-SQL).

Les options RESULT SETS de l’instruction EXECUTE ne peuvent pas être spécifiées dans une instruction INSERT...EXEC.The RESULT SETS options of the EXECUTE statement cannot be specified in an INSERT...EXEC statement.

Si execute_statement est utilisé avec INSERT, chaque jeu de résultats doit être compatible avec les colonnes de la table ou de column_list.If execute_statement is used with INSERT, each result set must be compatible with the columns in the table or in column_list.

execute_statement peut être utilisé pour exécuter des procédures stockées sur le même serveur ou sur un serveur distant.execute_statement can be used to execute stored procedures on the same server or a remote server. La procédure du serveur distant est exécutée et les jeux de résultats sont retournés au serveur local où ils sont chargés dans la table.The procedure in the remote server is executed, and the result sets are returned to the local server and loaded into the table in the local server. Dans une transaction distribuée, execute_statement ne peut pas être émis sur un serveur lié en boucle quand MARS (Multiple Active Result Set) est activé pour la connexion.In a distributed transaction, execute_statement cannot be issued against a loopback linked server when the connection has multiple active result sets (MARS) enabled.

Si execute_statement retourne des données avec l’instruction READTEXT, chaque instruction READTEXT peut retourner au maximum 1 Mo (1 024 Ko) de données.If execute_statement returns data with the READTEXT statement, each READTEXT statement can return a maximum of 1 MB (1024 KB) of data. execute_statement peut également être utilisé avec des procédures étendues.execute_statement can also be used with extended procedures. execute_statement insère les données retournées par le thread principal de la procédure étendue ; en revanche, les sorties de threads autres que le thread principal ne sont pas insérées.execute_statement inserts the data returned by the main thread of the extended procedure; however, output from threads other than the main thread are not inserted.

Vous ne pouvez pas spécifier de paramètre table en tant que cible d'une instruction INSERT EXEC ; néanmoins, vous pouvez le spécifier en tant que source de la chaîne ou procédure stockée INSERT EXEC.You cannot specify a table-valued parameter as the target of an INSERT EXEC statement; however, it can be specified as a source in the INSERT EXEC string or stored-procedure. Pour plus d’informations, consultez Utiliser les paramètres table (moteur de base de données).For more information, see Use Table-Valued Parameters (Database Engine).

<dml_table_source>
Spécifie que les lignes insérées dans la table cible sont les lignes retournées par la clause OUTPUT d'une instruction INSERT, UPDATE, DELETE ou MERGE, éventuellement filtrées par une clause WHERE.Specifies that the rows inserted into the target table are those returned by the OUTPUT clause of an INSERT, UPDATE, DELETE, or MERGE statement, optionally filtered by a WHERE clause. Si <dml_table_source> est spécifié, la cible de l’instruction INSERT externe doit respecter les restrictions suivantes :If <dml_table_source> is specified, the target of the outer INSERT statement must meet the following restrictions:

  • La table doit être une table de base et non une vue.It must be a base table, not a view.

  • La table ne peut pas être une table distante.It cannot be a remote table.

  • Aucun déclencheur ne peut être défini sur la table.It cannot have any triggers defined on it.

  • Elle ne peut participer à aucune relation clé primaire-clé étrangère.It cannot participate in any primary key-foreign key relationships.

  • Elle ne peut pas participer à la réplication de fusion ou à des abonnements pouvant être mis à jour pour la réplication transactionnelle.It cannot participate in merge replication or updatable subscriptions for transactional replication.

Le niveau de compatibilité de la base de données doit être 100 ou plus.The compatibility level of the database must be set to 100 or higher. Pour plus d’informations, consultez Clause OUTPUT (Transact-SQL).For more information, see OUTPUT Clause (Transact-SQL).

<select_list>
Liste séparée par des virgules qui spécifie les colonnes retournées par la clause OUTPUT qu'il convient d'insérer.Is a comma-separated list specifying which columns returned by the OUTPUT clause to insert. Les colonnes dans <select_list> doivent être compatibles avec les colonnes dans lesquelles les valeurs sont insérées.The columns in <select_list> must be compatible with the columns into which values are being inserted. <select_list> ne peut pas faire référence à des fonctions d’agrégation ni à TEXTPTR.<select_list> cannot reference aggregate functions or TEXTPTR.

Notes

Toutes les variables répertoriées dans la liste SELECT font référence à leurs valeurs d’origine, indépendamment des modifications qui leur ont été apportées dans <dml_statement_with_output_clause>.Any variables listed in the SELECT list refer to their original values, regardless of any changes made to them in <dml_statement_with_output_clause>.

<dml_statement_with_output_clause>
Instruction INSERT, UPDATE, DELETE ou MERGE valide qui retourne les lignes affectées dans une clause OUTPUT.Is a valid INSERT, UPDATE, DELETE, or MERGE statement that returns affected rows in an OUTPUT clause. L'instruction ne peut pas contenir de clause WITH et ne peut pas cibler les tables distantes ni les vues partitionnées.The statement cannot contain a WITH clause, and cannot target remote tables or partitioned views. Si l'instruction UPDATE ou DELETE est spécifiée, elle ne peut pas être basée sur un curseur.If UPDATE or DELETE is specified, it cannot be a cursor-based UPDATE or DELETE. Les lignes sources ne peuvent pas être référencées comme des instructions DML imbriquées.Source rows cannot be referenced as nested DML statements.

WHERE <search_condition>WHERE <search_condition>
Toute clause WHERE contenant une <search_condition> valide qui filtre les lignes retournées par l’<dml_statement_with_output_clause>.Is any WHERE clause containing a valid <search_condition> that filters the rows returned by <dml_statement_with_output_clause>. Pour plus d’informations, consultez Condition de recherche (Transact-SQL).For more information, see Search Condition (Transact-SQL). Utilisée dans ce contexte, la <search_condition> ne peut pas contenir de sous-requêtes, de fonctions scalaires définies par l’utilisateur qui accèdent aux données, de fonctions d’agrégation, TEXTPTR ni de prédicats de recherche en texte intégral.When used in this context, <search_condition> cannot contain subqueries, scalar user-defined functions that perform data access, aggregate functions, TEXTPTR, or full-text search predicates.

DEFAULT VALUESDEFAULT VALUES
S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

Force la nouvelle ligne à prendre les valeurs par défaut définies pour chaque colonne.Forces the new row to contain the default values defined for each column.

BULKBULK
S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

Utilisé par les outils externes pour télécharger un flux de données binaires.Used by external tools to upload a binary data stream. Cette option n’est pas destinée à être utilisée avec des outils tels que SQL Server Management StudioSQL Server Management Studio, SQLCMD, OSQL ou des interfaces de programmation d’applications d’accès aux données telles que SQL ServerSQL Server Native Client.This option is not intended for use with tools such as SQL Server Management StudioSQL Server Management Studio, SQLCMD, OSQL, or data access application programming interfaces such as SQL ServerSQL Server Native Client.

FIRE_TRIGGERSFIRE_TRIGGERS
S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

Spécifie que tous les déclencheurs d'insertion définis sur la table de destination seront exécutés au cours de l'opération de téléchargement de flux de données binaires.Specifies that any insert triggers defined on the destination table execute during the binary data stream upload operation. Pour plus d’informations, consultez BULK INSERT (Transact-SQL).For more information, see BULK INSERT (Transact-SQL).

CHECK_CONSTRAINTSCHECK_CONSTRAINTS
S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

Spécifie que toutes les contraintes sur la table ou la vue cible doivent être vérifiées pendant l'opération de téléchargement de flux de données binaires.Specifies that all constraints on the target table or view must be checked during the binary data stream upload operation. Pour plus d’informations, consultez BULK INSERT (Transact-SQL).For more information, see BULK INSERT (Transact-SQL).

KEEPNULLSKEEPNULLS
S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

Spécifie que les colonnes vides doivent conserver une valeur NULL pendant l'opération de téléchargement de flux de données binaires.Specifies that empty columns should retain a null value during the binary data stream upload operation. Pour plus d’informations, consultez Conserver les valeurs NULL ou utiliser la valeur par défaut lors de l’importation en bloc (SQL Server).For more information, see Keep Nulls or Use Default Values During Bulk Import (SQL Server).

KILOBYTES_PER_BATCH = kilo-octets par lotKILOBYTES_PER_BATCH = kilobytes_per_batch
Indique le nombre approximatif de kilo-octets (Ko) de données par lot sous la forme kilobytes_per_batch.Specifies the approximate number of kilobytes (KB) of data per batch as kilobytes_per_batch. Pour plus d’informations, consultez BULK INSERT (Transact-SQL).For more information, see BULK INSERT (Transact-SQL).

ROWS_PER_BATCH =rows_per_batchROWS_PER_BATCH =rows_per_batch
S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

Nombre approximatif de lignes de données que compte le flux de données binaires.Indicates the approximate number of rows of data in the binary data stream. Pour plus d’informations, consultez BULK INSERT (Transact-SQL).For more information, see BULK INSERT (Transact-SQL).

Notes

Une erreur de syntaxe est générée si aucune liste de colonnes n’est fournie.A syntax error is raised if a column list is not provided.

NotesRemarks

Pour obtenir des informations spécifiques à l’insertion de données dans des tables graphiques SQL, consultez INSERT (graphe SQL).For information specific to inserting data into SQL graph tables, see INSERT (SQL Graph).

Bonnes pratiquesBest Practices

Utilisez la fonction @@ROWCOUNT pour retourner le nombre de lignes insérées dans l’application cliente.Use the @@ROWCOUNT function to return the number of inserted rows to the client application. Pour plus d’informations, consultez @@ROWCOUNT (Transact-SQL).For more information, see @@ROWCOUNT (Transact-SQL).

Recommandations pour l'importation de données en blocBest Practices for Bulk Importing Data

Utilisation d’INSERT INTO...SELECT pour importer des données en bloc avec une journalisation et un parallélisme minimauxUsing INSERT INTO...SELECT to Bulk Import data with minimal logging and parallelism

Vous pouvez utiliser INSERT INTO <target_table> SELECT <columns> FROM <source_table> pour transférer efficacement un grand nombre de lignes d’une table, par exemple une table intermédiaire, vers une autre table avec une journalisation minimale.You can use INSERT INTO <target_table> SELECT <columns> FROM <source_table> to efficiently transfer a large number of rows from one table, such as a staging table, to another table with minimal logging. La journalisation minimale peut améliorer les performances de l'instruction et réduire le risque de voir l'opération remplir l'espace disponible du journal des transactions au cours de la transaction.Minimal logging can improve the performance of the statement and reduce the possibility of the operation filling the available transaction log space during the transaction.

La journalisation minimale pour cette instruction comporte les impératifs suivants :Minimal logging for this statement has the following requirements:

  • Le mode de récupération de la base de données doit correspondre au mode simple ou au mode de récupération utilisant les journaux de transactions.The recovery model of the database is set to simple or bulk-logged.
  • La table cible est un segment de mémoire vide ou non vide.The target table is an empty or non-empty heap.
  • La table cible n'est pas utilisée dans la réplication.The target table is not used in replication.
  • L'indicateur TABLOCK est spécifié pour la table cible.The TABLOCK hint is specified for the target table.

Les lignes insérées dans un segment de mémoire à la suite d'une action d'insertion dans une instruction MERGE peuvent également être journalisées de façon minimale.Rows that are inserted into a heap as the result of an insert action in a MERGE statement may also be minimally logged.

Contrairement à l’instruction BULK INSERT, qui maintient un verrou de mise à jour en bloc (BU) moins restrictif, INSERT INTO … SELECT avec l’indicateur TABLOCK maintient un verrou exclusif (X) sur la table.Unlike the BULK INSERT statement, which holds a less restrictive Bulk Update (BU) lock, INSERT INTO … SELECT with the TABLOCK hint holds an exclusive (X) lock on the table. Cela signifie que vous ne pouvez pas insérer de lignes à l’aide de plusieurs opérations Insert simultanément exécutées.This means that you cannot insert rows using multiple insert operations executing simultaneously.

Cependant, à partir de SQL Server 2016 (13.x) et du niveau de compatibilité de base de données 130, une instruction INSERT INTO … SELECT unique peut être exécutée en parallèle lors de l’insertion dans des segments de mémoire ou des index columnstore en cluster (ICC).However, starting with SQL Server 2016 (13.x) and database compatibility level 130, a single INSERT INTO … SELECT statement can be executed in parallel when inserting into heaps or clustered columnstore indexes (CCI). Les insertions parallèles sont possibles lors de l’utilisation de l’indicateur TABLOCK.Parallel inserts are possible when using the TABLOCK hint.

Le parallélisme de l’instruction ci-dessus présente les exigences suivantes, qui sont similaires aux conditions requises pour la journalisation minimale :Parallelism for the statement above has the following requirements, which are similar to the requirements for minimal logging:

  • La table cible est un segment de mémoire vide ou non vide.The target table is an empty or non-empty heap.
  • La table cible a un index columnstore en cluster (ICC), mais aucun index non cluster.The target table has a clustered columnstore index (CCI) but no non-clustered indexes.
  • La table cible n’a pas de colonne d’identité avec IDENTITY_INSERT défini sur OFF.The target table does not have an identity column with IDENTITY_INSERT set to OFF.
  • L'indicateur TABLOCK est spécifié pour la table cible.The TABLOCK hint is specified for the target table.

Dans les scénarios où les exigences relatives à la journalisation minimale et à l’insertion en parallèle sont satisfaites, les deux améliorations travaillent ensemble pour garantir un débit maximal de vos opérations de chargement de données.For scenarios where requirements for minimal logging and parallel insert are met, both improvements will work together to ensure maximum throughput of your data load operations.

Notes

Les insertions dans les tables temporaires locales (identifiées par le préfixe #) et les tables temporaires globales (identifiées par les préfixes ##) sont également activées pour le parallélisme à l’aide de l’indicateur TABLOCK.Inserts into local temporary tables (identified by the # prefix) and global temporary tables (identified by ## prefixes) are also enabled for parallelism using the TABLOCK hint.

Utilisation d'OPENROWSET et de BULK pour les données d'importation en blocUsing OPENROWSET and BULK to Bulk Import data

La fonction OPENROWSET peut accepter les indicateurs de table suivants, lesquels offrent des optimisations de chargement en masse avec l'instruction INSERT :The OPENROWSET function can accept the following table hints, which provide bulk-load optimizations with the INSERT statement:

  • L'indicateur TABLOCK peut réduire le nombre d'enregistrements de journal pour l'opération d'insertion.The TABLOCK hint can minimize the number of log records for the insert operation. Le mode de récupération de la base de données doit être le mode simple ou le mode de récupération utilisant les journaux de transactions ; par ailleurs, la table cible ne peut pas être utilisée dans la réplication.The recovery model of the database must be set to simple or bulk-logged and the target table cannot be used in replication. Pour plus d’informations, consultez Conditions requises pour une journalisation minimale dans l’importation en bloc.For more information, see Prerequisites for Minimal Logging in Bulk Import.
  • L’indicateur TABLOCK peut activer des opérations d’insertion parallèles.The TABLOCK hint can enable parallel insert operations. La table cible est un segment de mémoire ou un index columnstore en cluster (ICC) sans index non cluster, et la table cible ne peut pas avoir une colonne d’identité spécifiée.The target table is a heap or clustered columnstore index (CCI) with no non-clustered indexes, and the target table cannot have an identity column specified.
  • L'indicateur IGNORE_CONSTRAINTS peut désactiver temporairement la vérification des contraintes FOREIGN KEY et CHECK.The IGNORE_CONSTRAINTS hint can temporarily disable FOREIGN KEY and CHECK constraint checking.
  • L'indicateur IGNORE_TRIGGERS peut temporairement désactiver l'exécution des déclencheurs.The IGNORE_TRIGGERS hint can temporarily disable trigger execution.
  • L'indicateur KEEPDEFAULTS permet l'insertion la valeur par défaut éventuelle d'une colonne de table, à la place de la valeur NULL, lorsqu'il manque une valeur pour la colonne dans l'enregistrement de données.The KEEPDEFAULTS hint allows the insertion of a table column's default value, if any, instead of NULL when the data record lacks a value for the column.
  • L'indicateur KEEPIDENTITY permet que les valeurs d'identité figurant dans le fichier de données importé soient utilisées pour la colonne d'identité dans la table cible.The KEEPIDENTITY hint allows the identity values in the imported data file to be used for the identity column in the target table.

Ces optimisations sont similaires à celles disponibles avec la commande BULK INSERT.These optimizations are similar to those available with the BULK INSERT command. Pour plus d’informations, consultez Indicateurs de table (Transact-SQL).For more information, see Table Hints (Transact-SQL).

Types de donnéesData Types

Lorsque vous insérez des lignes, prenez en compte le comportement des types de données suivant :When you insert rows, consider the following data type behavior:

  • Si une valeur est chargée dans des colonnes ayant le type de données char, varchar ou varbinary, le remplissage ou la troncation des espaces blancs de fin (espaces pour char et varchar, zéros pour varbinary) est déterminé par le paramètre SET ANSI_PADDING défini pour la colonne lors de la création de la table.If a value is being loaded into columns with a char, varchar, or varbinary data type, the padding or truncation of trailing blanks (spaces for char and varchar, zeros for varbinary) is determined by the SET ANSI_PADDING setting defined for the column when the table was created. Pour plus d’informations, consultez SET ANSI_PADDING (Transact-SQL).For more information, see SET ANSI_PADDING (Transact-SQL).

    Le tableau suivant illustre l'opération par défaut pour SET ANSI_PADDING OFF.The following table shows the default operation for SET ANSI_PADDING OFF.

    Type de donnéesData type Opération par défautDefault operation
    charchar Remplit la valeur à l'aide d'espaces jusqu'à la largeur définie pour la colonne.Pad value with spaces to the defined width of column.
    varcharvarchar Supprime les espaces de fin jusqu’au dernier caractère différent d’un espace ou jusqu’au dernier caractère d’espacement simple pour les chaînes composées uniquement d’espaces.Remove trailing spaces to the last non-space character or to a single-space character for strings made up of only spaces.
    varbinaryvarbinary Supprime les zéros à droite.Remove trailing zeros.
  • Si une chaîne vide (' ') est chargée dans une colonne de type varchar ou text, l’opération par défaut consiste à charger une chaîne de longueur zéro.If an empty string (' ') is loaded into a column with a varchar or text data type, the default operation is to load a zero-length string.

  • L’insertion d’une valeur Null dans une colonne de type text ou image ne crée pas un pointeur de texte valide et ne préalloue pas une page texte de 8 Ko.Inserting a null value into a text or image column does not create a valid text pointer, nor does it preallocate an 8-KB text page.

  • Les colonnes créées à l’aide du type de données uniqueidentifier stockent les valeurs binaires au format spécial 16 octets.Columns created with the uniqueidentifier data type store specially formatted 16-byte binary values. Contrairement aux colonnes d’identité, le Moteur de base de donnéesDatabase Engine ne génère pas automatiquement de valeurs pour les colonnes comportant le type de données uniqueidentifier.Unlike with identity columns, the Moteur de base de donnéesDatabase Engine does not automatically generate values for columns with the uniqueidentifier data type. Lors d’une opération d’insertion, les variables dont le type de données est uniqueidentifier et les constantes de chaîne au format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (36 caractères, tirets inclus, où x correspond à un chiffre hexadécimal compris entre 0 et 9 ou a et f) peuvent être utilisées pour les colonnes uniqueidentifier.During an insert operation, variables with a data type of uniqueidentifier and string constants in the form xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (36 characters including hyphens, where x is a hexadecimal digit in the range 0-9 or a-f) can be used for uniqueidentifier columns. Par exemple, 6F9619FF-8B86-D011-B42D-00C04FC964FF est une valeur valide pour une colonne ou une variable uniqueidentifier.For example, 6F9619FF-8B86-D011-B42D-00C04FC964FF is a valid value for a uniqueidentifier variable or column. Utilisez la fonction NEWID() pour obtenir un GUID (identificateur global unique).Use the NEWID() function to obtain a globally unique ID (GUID).

Insertion de valeurs dans des colonnes de type défini par l'utilisateurInserting Values into User-Defined Type Columns

Vous pouvez insérer des valeurs dans des colonnes de type défini par l'utilisateur en procédant comme suit :You can insert values in user-defined type columns by:

  • En fournissant une valeur du type défini par l'utilisateur.Supplying a value of the user-defined type.

  • Fournir une valeur dans un type de données système SQL ServerSQL Server, à condition que le type défini par l'utilisateur prenne en charge la conversion de façon implicite ou explicite.Supplying a value in a SQL ServerSQL Server system data type, as long as the user-defined type supports implicit or explicit conversion from that type. L’exemple suivant montre comment insérer une valeur dans une colonne de type défini par l’utilisateurPoint, en effectuant la conversion explicite à partir d’une chaîne.The following example shows how to insert a value in a column of user-defined type Point, by explicitly converting from a string.

    INSERT INTO Cities (Location)  
    VALUES ( CONVERT(Point, '12.3:46.2') );  
    

    Une valeur binaire peut également être fournie sans effectuer de conversion explicite, car tous les types définis par l'utilisateur sont convertis implicitement à partir d'une valeur binaire.A binary value can also be supplied without performing explicit conversion, because all user-defined types are implicitly convertible from binary.

  • En appelant une fonction définie par l'utilisateur qui retourne une valeur du type défini par l'utilisateur.Calling a user-defined function that returns a value of the user-defined type. L'exemple suivant utilise une fonction définie par l'utilisateur CreateNewPoint() pour créer une valeur de type défini par l'utilisateur Point et insérer la valeur dans la table Cities.The following example uses a user-defined function CreateNewPoint() to create a new value of user-defined type Point and insert the value into the Cities table.

    INSERT INTO Cities (Location)  
    VALUES ( dbo.CreateNewPoint(x, y) );  
    

Gestion des erreursError Handling

Vous pouvez implémenter la gestion des erreurs pour l’instruction INSERT en spécifiant cette dernière dans une construction TRY...CATCH.You can implement error handling for the INSERT statement by specifying the statement in a TRY...CATCH construct.

Si une instruction INSERT enfreint une contrainte ou une règle, ou si elle comprend une valeur incompatible avec le type de données de la colonne, l'instruction échoue et un message d'erreur est retourné.If an INSERT statement violates a constraint or rule, or if it has a value incompatible with the data type of the column, the statement fails and an error message is returned.

Si INSERT charge plusieurs lignes à l'aide de SELECT ou EXECUTE, toute violation de règle ou de contrainte à partir des valeurs chargées met fin à l'instruction et aucune ligne n'est chargée.If INSERT is loading multiple rows with SELECT or EXECUTE, any violation of a rule or constraint that occurs from the values being loaded causes the statement to be stopped, and no rows are loaded.

Lorsqu'une instruction INSERT rencontre une erreur arithmétique (dépassement de capacité, division par zéro ou erreur de domaine) lors de l'évaluation de l'expression, le Moteur de base de donnéesDatabase Engine gère ces erreurs comme si SET ARITHABORT avait la valeur ON.When an INSERT statement encounters an arithmetic error (overflow, divide by zero, or a domain error) occurring during expression evaluation, the Moteur de base de donnéesDatabase Engine handles these errors as if SET ARITHABORT is set to ON. Le lot est arrêté et un message d'erreur est retourné.The batch is stopped, and an error message is returned. Si, au cours de l'évaluation de l'expression, une instruction INSERT, DELETE ou UPDATE rencontre une erreur arithmétique, un dépassement de capacité, une division par zéro ou une erreur de domaine alors que les options SET ARITHABORT et SET ANSI_WARNINGS ont la valeur OFF, SQL ServerSQL Server insère ou met à jour une valeur NULL.During expression evaluation when SET ARITHABORT and SET ANSI_WARNINGS are OFF, if an INSERT, DELETE or UPDATE statement encounters an arithmetic error, overflow, divide-by-zero, or a domain error, SQL ServerSQL Server inserts or updates a NULL value. Si la colonne cible ne peut pas prendre la valeur NULL, l'action d'insertion ou de mise à jour échoue et l'utilisateur reçoit une erreur.If the target column is not nullable, the insert or update action fails and the user receives an error.

InteropérabilitéInteroperability

Lorsqu'un déclencheur INSTEAD OF est défini sur des actions INSERT dans une table ou une vue, il est exécuté au lieu de l'instruction INSERT.When an INSTEAD OF trigger is defined on INSERT actions against a table or view, the trigger executes instead of the INSERT statement. Pour plus d’informations sur les déclencheurs INSTEAD OF, consultez CREATE TRIGGER (Transact-SQL).For more information about INSTEAD OF triggers, see CREATE TRIGGER (Transact-SQL).

Limitations et restrictionsLimitations and Restrictions

Lorsque vous insérez des valeurs dans des tables distantes et que toutes les valeurs des colonnes ne sont pas spécifiées, vous devez identifier les colonnes dans lesquelles les valeurs spécifiées doivent être insérées.When you insert values into remote tables and not all values for all columns are specified, you must identify the columns to which the specified values are to be inserted.

Lorsque TOP est utilisé avec INSERT, les lignes référencées ne sont pas réorganisées dans un ordre particulier et la clause ORDER BY ne peut pas être spécifiée directement dans ces instructions.When TOP is used with INSERT the referenced rows are not arranged in any order and the ORDER BY clause can not be directly specified in this statements. Si vous devez utiliser une clause TOP pour insérer des lignes dans un ordre chronologique significatif, vous devez associer à cette clause TOP une clause ORDER BY spécifiée dans une instruction de sous-sélection.If you need to use TOP to insert rows in a meaningful chronological order, you must use TOP together with an ORDER BY clause that is specified in a subselect statement. Consultez la section Exemples plus loin dans cette rubrique.See the Examples section that follows in this topic.

Les requêtes INSERT qui utilisent SELECT avec ORDER BY pour remplir les lignes garantissent la façon dont les valeurs d’identité sont calculées, mais pas l’ordre d’insertion des lignes.INSERT queries that use SELECT with ORDER BY to populate rows guarantees how identity values are computed but not the order in which the rows are inserted.

Dans Parallel Data Warehouse, la clause ORDER BY n'est pas valide dans VIEWS, CREATE TABLE AS SELECT, INSERT SELECT, les fonctions inline, les tables dérivées, les sous-requêtes et les expressions de table communes, sauf si TOP est également spécifié.In Parallel Data Warehouse, the ORDER BY clause is invalid in VIEWS, CREATE TABLE AS SELECT, INSERT SELECT, inline functions, derived tables, subqueries and common table expressions, unless TOP is also specified.

Comportement de journalisationLogging Behavior

L’instruction INSERT est toujours entièrement journalisée, sauf lors de l’utilisation de la fonction OPENROWSET avec le mot clé BULK ou lors de l’utilisation d’INSERT INTO <target_table> SELECT <columns> FROM <source_table>.The INSERT statement is always fully logged except when using the OPENROWSET function with the BULK keyword or when using INSERT INTO <target_table> SELECT <columns> FROM <source_table>. Ces opérations peuvent faire l'objet d'une journalisation minimale.These operations can be minimally logged. Pour plus d'informations, consultez la section « Recommandations pour le chargement en masse des données », précédemment dans cette rubrique.For more information, see the section "Best Practices for Bulk Loading Data" earlier in this topic.

SécuritéSecurity

Au cours d'une connexion à un serveur lié, le serveur émetteur fournit un nom et un mot de passe de connexion afin de se connecter au serveur récepteur.During a linked server connection, the sending server provides a login name and password to connect to the receiving server on its behalf. Pour que cette connexion fonctionne, vous devez créer un mappage de connexion entre les serveurs liés en utilisant sp_addlinkedsrvlogin.For this connection to work, you must create a login mapping between the linked servers by using sp_addlinkedsrvlogin.

Quand vous utilisez OPENROWSET(BULK…), il est important de bien comprendre comment SQL ServerSQL Server gère l’emprunt d’identité.When you use OPENROWSET(BULK...), it is important to understand how SQL ServerSQL Server handles impersonation. Pour plus d’informations, consultez « Considérations relatives à la sécurité » dans Importer des données en bloc à l’aide de BULK INSERT ou OPENROWSET(BULK...) (SQL Server).For more information, see "Security Considerations" in Import Bulk Data by Using BULK INSERT or OPENROWSET(BULK...) (SQL Server).

AutorisationsPermissions

L'autorisation INSERT est obligatoire sur la table cible.INSERT permission is required on the target table.

Les autorisations INSERT sont attribuées par défaut aux membres du rôle serveur fixe sysadmin, aux membres des rôles de base de données fixes db_owner et db_datawriter et au propriétaire de la table.INSERT permissions default to members of the sysadmin fixed server role, the db_owner and db_datawriter fixed database roles, and the table owner. Les membres des rôles sysadmin, db_owner et db_securityadmin ainsi que le propriétaire de la table peuvent transférer des autorisations à d’autres utilisateurs.Members of the sysadmin, db_owner, and the db_securityadmin roles, and the table owner can transfer permissions to other users.

Pour exécuter INSERT avec l'option BULK de la fonction OPENROWSET, vous devez être membre du rôle serveur fixe sysadmin ou bulkadmin.To execute INSERT with the OPENROWSET function BULK option, you must be a member of the sysadmin fixed server role or of the bulkadmin fixed server role.

ExemplesExamples

CategoryCategory Éléments syntaxiques proposésFeatured syntax elements
Syntaxe de baseBasic syntax INSERT • constructeur de valeurs de tableINSERT • table value constructor
Gestion de valeurs de colonnesHandling column values IDENTITY • NEWID • valeurs par défaut • types définis par l'utilisateurIDENTITY • NEWID • default values • user-defined types
Insertion de données à partir d’autres tablesInserting data from other tables INSERT...SELECT • INSERT...EXECUTE • WITH expression de table commune • TOP • OFFSET FETCHINSERT...SELECT • INSERT...EXECUTE • WITH common table expression • TOP • OFFSET FETCH
Spécification d’objets cibles autres que les tables standardSpecifying target objects other than standard tables Vues • variables de tableViews • table variables
Insertion de lignes dans une table distanteInserting rows into a remote table Serveur lié • fonction d'ensemble de lignes OPENQUERY • fonction d'ensemble de lignes OPENDATASOURCELinked server • OPENQUERY rowset function • OPENDATASOURCE rowset function
Chargement en masse de données à partir de tables ou de fichiers de donnéesBulk loading data from tables or data files INSERT...SELECT • fonction OPENROWSETINSERT...SELECT • OPENROWSET function
Remplacement du comportement par défaut de l’optimiseur de requête à l’aide d’indicateursOverriding the default behavior of the query optimizer by using hints Indicateurs de tableTable hints
Capture des résultats de l’instruction INSERTCapturing the results of the INSERT statement Clause OUTPUTOUTPUT clause

Syntaxe de baseBasic Syntax

Les exemples fournis dans cette section présentent les fonctionnalités de base de l'instruction INSERT en utilisant la syntaxe minimale requise.Examples in this section demonstrate the basic functionality of the INSERT statement using the minimum required syntax.

R.A. Insertion d'une seule ligne de donnéesInserting a single row of data

L'exemple suivant insère une ligne dans la table Production.UnitMeasure de la base de données AdventureWorks2012AdventureWorks2012.The following example inserts one row into the Production.UnitMeasure table in the AdventureWorks2012AdventureWorks2012 database. Les colonnes de cette table sont UnitMeasureCode, Name et ModifiedDate.The columns in this table are UnitMeasureCode, Name, and ModifiedDate. Étant donné que les valeurs de toutes les colonnes sont fournies et qu’elles sont répertoriées dans le même ordre que les colonnes de la table, il n’est pas nécessaire de spécifier les noms de colonnes dans la liste de colonnes .Because values for all columns are supplied and are listed in the same order as the columns in the table, the column names do not have to be specified in the column list .

INSERT INTO Production.UnitMeasure  
VALUES (N'FT', N'Feet', '20080414');  

B.B. Insertion de plusieurs lignes de donnéesInserting multiple rows of data

L’exemple suivant utilise le constructeur de valeurs de table pour insérer trois lignes dans la table Production.UnitMeasure de la base de données AdventureWorks2012AdventureWorks2012 en une seule instruction INSERT.The following example uses the table value constructor to insert three rows into the Production.UnitMeasure table in the AdventureWorks2012AdventureWorks2012 database in a single INSERT statement. Étant donné que les valeurs de toutes les colonnes sont fournies et qu'elles sont répertoriées dans le même ordre que les colonnes de la table, il n'est pas nécessaire de spécifier les noms de colonnes dans la liste de colonnes.Because values for all columns are supplied and are listed in the same order as the columns in the table, the column names do not have to be specified in the column list.

INSERT INTO Production.UnitMeasure  
VALUES (N'FT2', N'Square Feet ', '20080923'), (N'Y', N'Yards', '20080923')
    , (N'Y3', N'Cubic Yards', '20080923');  

C.C. Insertion de données qui ne sont pas dans le même ordre que les colonnes de la tableInserting data that is not in the same order as the table columns

L'exemple suivant utilise une liste de colonnes afin de spécifier de manière explicite les valeurs insérées dans chaque colonne.The following example uses a column list to explicitly specify the values that are inserted into each column. L’ordre des colonnes de la table Production.UnitMeasure de la base de données AdventureWorks2012AdventureWorks2012 est UnitMeasureCode, Name, ModifiedDate ; cependant, les colonnes ne sont pas répertoriées dans cet ordre dans column_list.The column order in the Production.UnitMeasure table in the AdventureWorks2012AdventureWorks2012 database is UnitMeasureCode, Name, ModifiedDate; however, the columns are not listed in that order in column_list.

INSERT INTO Production.UnitMeasure (Name, UnitMeasureCode,  
    ModifiedDate)  
VALUES (N'Square Yards', N'Y2', GETDATE());  

Gestion de valeurs de colonnesHandling Column Values

Les exemples fournis dans cette section présentent des méthodes d’insertion de valeurs dans des colonnes qui sont définies avec une propriété IDENTITY ou avec une valeur DEFAULT, ou qui sont définies avec des types de données tels que uniqueidentifer ou des colonnes d’un type défini par l’utilisateur.Examples in this section demonstrate methods of inserting values into columns that are defined with an IDENTITY property, DEFAULT value, or are defined with data types such as uniqueidentifer or user-defined type columns.

D.D. Insertion de données dans une table dont les colonnes ont des valeurs par défautInserting data into a table with columns that have default values

L'exemple suivant montre l'insertion de lignes dans une table dont les colonnes génèrent automatiquement une valeur ou possèdent une valeur par défaut.The following example shows inserting rows into a table with columns that automatically generate a value or have a default value. Column_1 est une colonne calculée qui génère automatiquement une valeur en concaténant une chaîne avec la valeur insérée dans column_2.Column_1 is a computed column that automatically generates a value by concatenating a string with the value inserted into column_2. Column_2 est définie avec une contrainte par défaut.Column_2 is defined with a default constraint. Si aucune valeur n'est spécifiée pour cette colonne, la valeur par défaut est utilisée.If a value is not specified for this column, the default value is used. Column_3 est défini avec le type de données rowversion, qui génère automatiquement un nombre binaire incrémentiel unique.Column_3 is defined with the rowversion data type, which automatically generates a unique, incrementing binary number. Column_4 ne génère pas automatiquement de valeur.Column_4 does not automatically generate a value. Lorsqu'aucune valeur n'est spécifiée pour cette colonne, NULL est inséré.When a value for this column is not specified, NULL is inserted. Les instructions INSERT insèrent des lignes qui contiennent des valeurs pour certaines colonnes, mais pas pour toutes.The INSERT statements insert rows that contain values for some of the columns but not all. Dans la dernière instruction INSERT, aucune colonne n'est spécifiée et seules les valeurs par défaut sont insérées à l'aide de la clause DEFAULT VALUES.In the last INSERT statement, no columns are specified and only the default values are inserted by using the DEFAULT VALUES clause.

CREATE TABLE dbo.T1   
(  
    column_1 AS 'Computed column ' + column_2,   
    column_2 varchar(30)   
        CONSTRAINT default_name DEFAULT ('my column default'),  
    column_3 rowversion,  
    column_4 varchar(40) NULL  
);  
GO  
INSERT INTO dbo.T1 (column_4)   
    VALUES ('Explicit value');  
INSERT INTO dbo.T1 (column_2, column_4)   
    VALUES ('Explicit value', 'Explicit value');  
INSERT INTO dbo.T1 (column_2)   
    VALUES ('Explicit value');  
INSERT INTO T1 DEFAULT VALUES;   
GO  
SELECT column_1, column_2, column_3, column_4  
FROM dbo.T1;  
GO  

E.E. Insertion de données dans une table qui comprend une colonne d'identitéInserting data into a table with an identity column

L'exemple suivant illustre différentes méthodes d'insertion de données dans une colonne d'identité.The following example shows different methods of inserting data into an identity column. Les deux premières instructions INSERT permettent la génération de valeurs d'identité pour les nouvelles lignes.The first two INSERT statements allow identity values to be generated for the new rows. La troisième instruction INSERT substitue la propriété IDENTITY de la colonne à l'aide de l'instruction SET IDENTITY_INSERT et insère une valeur explicite dans la colonne d'identité.The third INSERT statement overrides the IDENTITY property for the column with the SET IDENTITY_INSERT statement and inserts an explicit value into the identity column.

CREATE TABLE dbo.T1 ( column_1 int IDENTITY, column_2 VARCHAR(30));  
GO  
INSERT T1 VALUES ('Row #1');  
INSERT T1 (column_2) VALUES ('Row #2');  
GO  
SET IDENTITY_INSERT T1 ON;  
GO  
INSERT INTO T1 (column_1,column_2)   
    VALUES (-99, 'Explicit identity value');  
GO  
SELECT column_1, column_2  
FROM T1;  
GO  

F.F. Insertion de données dans une colonne uniqueidentifier en utilisant NEWID()Inserting data into a uniqueidentifier column by using NEWID()

L’exemple suivant utilise la fonction NEWID() pour obtenir un identificateur global unique (GUID) pour column_2.The following example uses the NEWID() function to obtain a GUID for column_2. Contrairement à ce qui se passe pour les colonnes d’identité, le Moteur de base de donnéesDatabase Engine ne génère pas automatiquement de valeurs pour les colonnes ayant le type de données uniqueidentifier, comme l’indique la deuxième instruction INSERT.Unlike for identity columns, the Moteur de base de donnéesDatabase Engine does not automatically generate values for columns with the uniqueidentifier data type, as shown by the second INSERT statement.

CREATE TABLE dbo.T1   
(  
    column_1 int IDENTITY,   
    column_2 uniqueidentifier,  
);  
GO  
INSERT INTO dbo.T1 (column_2)   
    VALUES (NEWID());  
INSERT INTO T1 DEFAULT VALUES;   
GO  
SELECT column_1, column_2  
FROM dbo.T1;  

G.G. Insertion de données dans des colonnes de type défini par l'utilisateurInserting data into user-defined type columns

Les instructions Transact-SQLTransact-SQL suivantes insèrent trois lignes dans la colonne PointValue de table Points.The following Transact-SQLTransact-SQL statements insert three rows into the PointValue column of the Points table. Cette colonne utilise un type CLR défini par l’utilisateur (UDT).This column uses a CLR user-defined type (UDT). Le type de données Point comprend des valeurs entières X et Y qui sont exposées en tant que propriétés du type UDT.The Point data type consists of X and Y integer values that are exposed as properties of the UDT. Vous devez utiliser la fonction CAST ou CONVERT pour effectuer une conversion de type (transtypage) des valeurs X et Y délimitées par des virgules en type Point.You must use either the CAST or CONVERT function to cast the comma-delimited X and Y values to the Point type. Les deux premières instructions utilisent la fonction CONVERT pour convertir une valeur de chaîne en type Point, et la troisième instruction utilise la fonction CAST.The first two statements use the CONVERT function to convert a string value to the Point type, and the third statement uses the CAST function. Pour plus d’informations, consultez Manipulation de données UDT.For more information, see Manipulating UDT Data.

INSERT INTO dbo.Points (PointValue) VALUES (CONVERT(Point, '3,4'));  
INSERT INTO dbo.Points (PointValue) VALUES (CONVERT(Point, '1,5'));  
INSERT INTO dbo.Points (PointValue) VALUES (CAST ('1,99' AS Point));  

Insertion de données à partir d’autres tablesInserting Data from Other Tables

Les exemples fournis dans cette section présentent des méthodes d'insertion de lignes d'une table dans une autre table.Examples in this section demonstrate methods of inserting rows from one table into another table.

H.H. Utilisation des options SELECT et EXECUTE pour insérer des données provenant d'autres tablesUsing the SELECT and EXECUTE options to insert data from other tables

L’exemple suivant montre comment insérer des données d’une table dans une autre table avec INSERT...SELECT ou INSERT...EXECUTE.The following example shows how to insert data from one table into another table by using INSERT...SELECT or INSERT...EXECUTE. Chaque méthode s'appuie sur une instruction SELECT basée sur plusieurs tables qui inclut une expression et une valeur littérale dans la liste des colonnes.Each is based on a multi-table SELECT statement that includes an expression and a literal value in the column list.

La première instruction INSERT utilise une instruction SELECT pour dériver les données des tables sources (Employee, SalesPerson et Person) dans la base de données AdventureWorks2012AdventureWorks2012 et stocker le jeu de résultats dans la table EmployeeSales.The first INSERT statement uses a SELECT statement to derive the data from the source tables (Employee, SalesPerson, and Person) in the AdventureWorks2012AdventureWorks2012 database and store the result set in the EmployeeSales table. La deuxième instruction INSERT utilise la clause EXECUTE pour appeler une procédure stockée qui contient l'instruction SELECT, et la troisième instruction INSERT utilise la clause EXECUTE pour référencer l'instruction SELECT en tant que chaîne littérale.The second INSERT statement uses the EXECUTE clause to call a stored procedure that contains the SELECT statement, and the third INSERT uses the EXECUTE clause to reference the SELECT statement as a literal string.

CREATE TABLE dbo.EmployeeSales  
( DataSource   varchar(20) NOT NULL,  
  BusinessEntityID   varchar(11) NOT NULL,  
  LastName     varchar(40) NOT NULL,  
  SalesDollars money NOT NULL  
);  
GO  
CREATE PROCEDURE dbo.uspGetEmployeeSales   
AS   
    SET NOCOUNT ON;  
    SELECT 'PROCEDURE', sp.BusinessEntityID, c.LastName,   
        sp.SalesYTD   
    FROM Sales.SalesPerson AS sp    
    INNER JOIN Person.Person AS c  
        ON sp.BusinessEntityID = c.BusinessEntityID  
    WHERE sp.BusinessEntityID LIKE '2%'  
    ORDER BY sp.BusinessEntityID, c.LastName;  
GO  
--INSERT...SELECT example  
INSERT INTO dbo.EmployeeSales  
    SELECT 'SELECT', sp.BusinessEntityID, c.LastName, sp.SalesYTD   
    FROM Sales.SalesPerson AS sp  
    INNER JOIN Person.Person AS c  
        ON sp.BusinessEntityID = c.BusinessEntityID  
    WHERE sp.BusinessEntityID LIKE '2%'  
    ORDER BY sp.BusinessEntityID, c.LastName;  
GO  
--INSERT...EXECUTE procedure example  
INSERT INTO dbo.EmployeeSales   
EXECUTE dbo.uspGetEmployeeSales;  
GO  
--INSERT...EXECUTE('string') example  
INSERT INTO dbo.EmployeeSales   
EXECUTE   
('  
SELECT ''EXEC STRING'', sp.BusinessEntityID, c.LastName,   
    sp.SalesYTD   
    FROM Sales.SalesPerson AS sp   
    INNER JOIN Person.Person AS c  
        ON sp.BusinessEntityID = c.BusinessEntityID  
    WHERE sp.BusinessEntityID LIKE ''2%''  
    ORDER BY sp.BusinessEntityID, c.LastName  
');  
GO  
--Show results.  
SELECT DataSource,BusinessEntityID,LastName,SalesDollars  
FROM dbo.EmployeeSales;  

I.I. Utilisation de l'expression de table commune WITH pour définir les données inséréesUsing WITH common table expression to define the data inserted

L'exemple suivant crée la table NewEmployee dans la base de données AdventureWorks2012AdventureWorks2012.The following example creates the NewEmployee table in the AdventureWorks2012AdventureWorks2012 database. Une expression de table commune (EmployeeTemp) définit les lignes d'une ou de plusieurs tables à insérer dans la table NewEmployee.A common table expression (EmployeeTemp) defines the rows from one or more tables to be inserted into the NewEmployee table. L'instruction INSERT référence les colonnes dans l'expression de table commune.The INSERT statement references the columns in the common table expression.

CREATE TABLE HumanResources.NewEmployee  
(  
    EmployeeID int NOT NULL,  
    LastName nvarchar(50) NOT NULL,  
    FirstName nvarchar(50) NOT NULL,  
    PhoneNumber Phone NULL,  
    AddressLine1 nvarchar(60) NOT NULL,  
    City nvarchar(30) NOT NULL,  
    State nchar(3) NOT NULL,   
    PostalCode nvarchar(15) NOT NULL,  
    CurrentFlag Flag  
);  
GO  
WITH EmployeeTemp (EmpID, LastName, FirstName, Phone,   
                   Address, City, StateProvince,   
                   PostalCode, CurrentFlag)  
AS (SELECT   
       e.BusinessEntityID, c.LastName, c.FirstName, pp.PhoneNumber,  
       a.AddressLine1, a.City, sp.StateProvinceCode,   
       a.PostalCode, e.CurrentFlag  
    FROM HumanResources.Employee e  
        INNER JOIN Person.BusinessEntityAddress AS bea  
        ON e.BusinessEntityID = bea.BusinessEntityID  
        INNER JOIN Person.Address AS a  
        ON bea.AddressID = a.AddressID  
        INNER JOIN Person.PersonPhone AS pp  
        ON e.BusinessEntityID = pp.BusinessEntityID  
        INNER JOIN Person.StateProvince AS sp  
        ON a.StateProvinceID = sp.StateProvinceID  
        INNER JOIN Person.Person as c  
        ON e.BusinessEntityID = c.BusinessEntityID  
    )  
INSERT INTO HumanResources.NewEmployee   
    SELECT EmpID, LastName, FirstName, Phone,   
           Address, City, StateProvince, PostalCode, CurrentFlag  
    FROM EmployeeTemp;  
GO  

J.J. Utilisation de TOP pour limiter les données insérées à partir de la table sourceUsing TOP to limit the data inserted from the source table

L'exemple suivant crée la table EmployeeSales et insère le nom et les données de ventes de l'année des 5 premiers employés aléatoires de la table HumanResources.Employee dans la base de données AdventureWorks2012AdventureWorks2012.The following example creates the table EmployeeSales and inserts the name and year-to-date sales data for the top 5 random employees from the table HumanResources.Employee in the AdventureWorks2012AdventureWorks2012 database. L'instruction INSERT choisit 5 lignes retournées par l'instruction SELECT.The INSERT statement chooses any 5 rows returned by the SELECT statement. La clause OUTPUT affiche les lignes insérées dans la table EmployeeSales.The OUTPUT clause displays the rows that are inserted into the EmployeeSales table. Notez que la clause ORDER BY dans l'instruction SELECT n'est pas utilisée pour déterminer les 5 premiers employés.Notice that the ORDER BY clause in the SELECT statement is not used to determine the top 5 employees.

CREATE TABLE dbo.EmployeeSales  
( EmployeeID   nvarchar(11) NOT NULL,  
  LastName     nvarchar(20) NOT NULL,  
  FirstName    nvarchar(20) NOT NULL,  
  YearlySales  money NOT NULL  
 );  
GO  
INSERT TOP(5)INTO dbo.EmployeeSales  
    OUTPUT inserted.EmployeeID, inserted.FirstName, 
        inserted.LastName, inserted.YearlySales  
    SELECT sp.BusinessEntityID, c.LastName, c.FirstName, sp.SalesYTD   
    FROM Sales.SalesPerson AS sp  
    INNER JOIN Person.Person AS c  
        ON sp.BusinessEntityID = c.BusinessEntityID  
    WHERE sp.SalesYTD > 250000.00  
    ORDER BY sp.SalesYTD DESC;  

Si vous devez utiliser une clause TOP pour insérer des lignes dans un ordre chronologique significatif, vous devez associer à cette clause TOP une clause ORDER BY dans une instruction de sous-sélection, comme illustré dans l'exemple suivant.If you have to use TOP to insert rows in a meaningful chronological order, you must use TOP together with ORDER BY in a subselect statement as shown in the following example. La clause OUTPUT affiche les lignes insérées dans la table EmployeeSales.The OUTPUT clause displays the rows that are inserted into the EmployeeSales table. Notez que les 5 premiers employés sont maintenant insérés selon les résultats de la clause ORDER BY au lieu de lignes aléatoires.Notice that the top 5 employees are now inserted based on the results of the ORDER BY clause instead of random rows.

INSERT INTO dbo.EmployeeSales  
    OUTPUT inserted.EmployeeID, inserted.FirstName, 
        inserted.LastName, inserted.YearlySales  
    SELECT TOP (5) sp.BusinessEntityID, c.LastName, c.FirstName, sp.SalesYTD   
    FROM Sales.SalesPerson AS sp  
    INNER JOIN Person.Person AS c  
        ON sp.BusinessEntityID = c.BusinessEntityID  
    WHERE sp.SalesYTD > 250000.00  
    ORDER BY sp.SalesYTD DESC;  

Spécification d’objets cibles autres que les tables standardSpecifying Target Objects Other Than Standard Tables

Les exemples présentés dans cette section montrent comment insérer des lignes en spécifiant une variable de table ou de vue.Examples in this section demonstrate how to insert rows by specifying a view or table variable.

K.K. Insertion de données en spécifiant une vueInserting data by specifying a view

L'exemple suivant spécifie un nom de vue comme objet cible ; cependant, la nouvelle ligne est insérée dans la table de base sous-jacente.The following example specifies a view name as the target object; however, the new row is inserted in the underlying base table. L'ordre des valeurs dans l'instruction INSERT doit correspondre à l'ordre des colonnes de la vue.The order of the values in the INSERT statement must match the column order of the view. Pour plus d’informations, consultez Modifier les données par l’intermédiaire d’une vue.For more information, see Modify Data Through a View.

CREATE TABLE T1 ( column_1 int, column_2 varchar(30));  
GO  
CREATE VIEW V1 AS   
SELECT column_2, column_1   
FROM T1;  
GO  
INSERT INTO V1   
    VALUES ('Row 1',1);  
GO  
SELECT column_1, column_2   
FROM T1;  
GO  
SELECT column_1, column_2  
FROM V1;  
GO  

L.L. Insertion de données dans une variable de tableInserting data into a table variable

L'exemple suivant spécifie une variable de table comme objet cible dans la base de données AdventureWorks2012AdventureWorks2012.The following example specifies a table variable as the target object in the AdventureWorks2012AdventureWorks2012 database.

-- Create the table variable.  
DECLARE @MyTableVar table(  
    LocationID int NOT NULL,  
    CostRate smallmoney NOT NULL,  
    NewCostRate AS CostRate * 1.5,  
    ModifiedDate datetime);  
  
-- Insert values into the table variable.  
INSERT INTO @MyTableVar (LocationID, CostRate, ModifiedDate)  
    SELECT LocationID, CostRate, GETDATE() 
    FROM Production.Location  
    WHERE CostRate > 0;  
  
-- View the table variable result set.  
SELECT * FROM @MyTableVar;  
GO  

Insertion de lignes dans une table distanteInserting Rows into a Remote Table

Les exemples présentés dans cette section montrent comment insérer des lignes dans une table cible distante en utilisant un serveur lié ou une fonction d’ensemble de lignes pour référencer la table distante.Examples in this section demonstrate how to insert rows into a remote target table by using a linked server or a rowset function to reference the remote table.

M.M. Insertion de données dans une table distante en utilisant un serveur liéInserting data into a remote table by using a linked server

L'exemple suivant insère des lignes dans la table distante.The following example inserts rows into a remote table. L’exemple commence par créer un lien vers la source de données distante en utilisant sp_addlinkedserver.The example begins by creating a link to the remote data source by using sp_addlinkedserver. Le nom du serveur lié, MyLinkServer, est ensuite spécifié comme partie du nom d’objet en quatre parties qui se présente sous la forme serveur.catalogue.schéma.objet.The linked server name, MyLinkServer, is then specified as part of the four-part object name in the form server.catalog.schema.object.

S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

USE master;  
GO  
-- Create a link to the remote data source.   
-- Specify a valid server name for @datasrc as 'server_name' 
-- or 'server_nameinstance_name'.  
  
EXEC sp_addlinkedserver @server = N'MyLinkServer',  
    @srvproduct = N' ',  
    @provider = N'SQLNCLI',   
    @datasrc = N'server_name',  
    @catalog = N'AdventureWorks2012';  
GO  
-- Specify the remote data source in the FROM clause using a four-part name   
-- in the form linked_server.catalog.schema.object.  
  
INSERT INTO MyLinkServer.AdventureWorks2012.HumanResources.Department (Name, GroupName)  
VALUES (N'Public Relations', N'Executive General and Administration');  
GO  

N.N. Insertion de données dans une table distante en utilisant la fonction OPENQUERYInserting data into a remote table by using the OPENQUERY function

L’exemple suivant insère une ligne dans une table distante en spécifiant la fonction d’ensemble de lignes OPENQUERY.The following example inserts a row into a remote table by specifying the OPENQUERY rowset function. Le nom de serveur lié créé dans l'exemple précédent est utilisé dans cet exemple.The linked server name created in the previous example is used in this example.

S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

INSERT OPENQUERY (MyLinkServer, 
    'SELECT Name, GroupName 
     FROM AdventureWorks2012.HumanResources.Department')  
VALUES ('Environmental Impact', 'Engineering');  
GO  

O.O. Insertion de données dans une table distante en utilisant la fonction OPENDATASOURCEInserting data into a remote table by using the OPENDATASOURCE function

L’exemple suivant insère une ligne dans une table distante en spécifiant la fonction d’ensemble de lignes OPENDATASOURCE.The following example inserts a row into a remote table by specifying the OPENDATASOURCE rowset function. Spécifiez un nom de serveur valide pour la source de données en utilisant le format server_name ou server_name\instance_name.Specify a valid server name for the data source by using the format server_name or server_name\instance_name.

S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

-- Use the OPENDATASOURCE function to specify the remote data source.  
-- Specify a valid server name for Data Source using the format 
-- server_name or server_nameinstance_name.  
  
INSERT INTO OPENDATASOURCE('SQLNCLI',  
    'Data Source= <server_name>; Integrated Security=SSPI')  
    .AdventureWorks2012.HumanResources.Department (Name, GroupName)  
    VALUES (N'Standards and Methods', 'Quality Assurance');  
GO  

P.P. Insertion dans une table externe créée à l’aide de PolyBaseInserting into an external table created using PolyBase

Exportez des données de SQL Server vers Hadoop ou le Stockage Azure.Export data from SQL Server to Hadoop or Azure Storage. Commencez par créer une table externe pointant vers le fichier ou le répertoire de destination.First, create an external table that points to the destination file or directory. Puis, utilisez INSERT INTO pour exporter les données d’une table SQL Server locale dans une source de données externe.Then, use INSERT INTO to export data from a local SQL Server table to an external data source. l’instruction INSERT INTO crée le fichier ou le répertoire de destination s’il n’existe pas, et les résultats de l’instruction SELECT sont exportés à l’emplacement et au format spécifiés.The INSERT INTO statement creates the destination file or directory if it does not exist and the results of the SELECT statement are exported to the specified location in the specified file format. Pour plus d’informations, consultez Prise en main de PolyBase.For more information, see Get started with PolyBase.

S'applique à: SQL Server 2019 (15.x)SQL Server 2019 (15.x).Applies to: SQL Server 2019 (15.x)SQL Server 2019 (15.x).

-- Create an external table.   
CREATE EXTERNAL TABLE [dbo].[FastCustomers2009] (  
        [FirstName] char(25) NOT NULL,   
        [LastName] char(25) NOT NULL,   
        [YearlyIncome] float NULL,   
        [MaritalStatus] char(1) NOT NULL  
)  
WITH (  
        LOCATION='/old_data/2009/customerdata.tbl',  
        DATA_SOURCE = HadoopHDP2,  
        FILE_FORMAT = TextFileFormat,  
        REJECT_TYPE = VALUE,  
        REJECT_VALUE = 0  
);  
  
-- Export data: Move old data to Hadoop while keeping 
-- it query-able via external table.  

INSERT INTO dbo.FastCustomer2009  
SELECT T.* FROM Insured_Customers T1 JOIN CarSensor_Data T2  
ON (T1.CustomerKey = T2.CustomerKey)  
WHERE T2.YearMeasured = 2009 and T2.Speed > 40;  

Chargement en masse de données à partir de tables ou de fichiers de donnéesBulk Loading Data from Tables or Data Files

Les exemples fournis dans cette section présentent deux méthodes permettant de charger en masse des données dans une table en utilisant l'instruction INSERT.Examples in this section demonstrate two methods to bulk load data into a table by using the INSERT statement.

Q.Q. Insertion de données dans un segment de mémoire avec une journalisation minimaleInserting data into a heap with minimal logging

L'exemple suivant crée une nouvelle table (un segment de mémoire) et y insère des données provenant d'une autre table en utilisant une journalisation minimale.The following example creates a new table (a heap) and inserts data from another table into it using minimal logging. L'exemple suppose que le mode de récupération de la base de données AdventureWorks2012 a la valeur FULL.The example assumes that the recovery model of the AdventureWorks2012 database is set to FULL. Pour obtenir une journalisation minimale, le mode de récupération de la base de données AdventureWorks2012 est défini sur BULK_LOGGED avant l’insertion des lignes ; il reprend ensuite la valeur FULL après l’instruction INSERT INTO...SELECT.To ensure minimal logging is used, the recovery model of the AdventureWorks2012 database is set to BULK_LOGGED before rows are inserted and reset to FULL after the INSERT INTO...SELECT statement. En outre, l'indicateur TABLOCK est spécifié pour la table cible Sales.SalesHistory.In addition, the TABLOCK hint is specified for the target table Sales.SalesHistory. Cela permet de garantir que l'instruction utilise un espace minimal dans le journal des transactions et qu'elle s'exécute de manière efficace.This ensures that the statement uses minimal space in the transaction log and performs efficiently.

-- Create the target heap.  
CREATE TABLE Sales.SalesHistory(  
    SalesOrderID int NOT NULL,  
    SalesOrderDetailID int NOT NULL,  
    CarrierTrackingNumber nvarchar(25) NULL,  
    OrderQty smallint NOT NULL,  
    ProductID int NOT NULL,  
    SpecialOfferID int NOT NULL,  
    UnitPrice money NOT NULL,  
    UnitPriceDiscount money NOT NULL,  
    LineTotal money NOT NULL,  
    rowguid uniqueidentifier ROWGUIDCOL  NOT NULL,  
    ModifiedDate datetime NOT NULL );  
GO  
-- Temporarily set the recovery model to BULK_LOGGED.  
ALTER DATABASE AdventureWorks2012  
SET RECOVERY BULK_LOGGED;  
GO  
-- Transfer data from Sales.SalesOrderDetail to Sales.SalesHistory  
INSERT INTO Sales.SalesHistory WITH (TABLOCK)  
    (SalesOrderID,   
     SalesOrderDetailID,  
     CarrierTrackingNumber,   
     OrderQty,   
     ProductID,   
     SpecialOfferID,   
     UnitPrice,   
     UnitPriceDiscount,  
     LineTotal,   
     rowguid,   
     ModifiedDate)  
SELECT * FROM Sales.SalesOrderDetail;  
GO  
-- Reset the recovery model.  
ALTER DATABASE AdventureWorks2012  
SET RECOVERY FULL;  
GO  

R.R. Utilisation de la fonction OPENROWSET avec BULK pour charger en masse des données dans une tableUsing the OPENROWSET function with BULK to bulk load data into a table

L'exemple suivant insère des lignes d'un fichier de données dans une table en spécifiant la fonction OPENROWSET.The following example inserts rows from a data file into a table by specifying the OPENROWSET function. L'indicateur de table IGNORE_TRIGGERS est spécifié en vue d'optimiser les performances.The IGNORE_TRIGGERS table hint is specified for performance optimization. Pour obtenir d’autres exemples, consultez Importer des données en bloc à l’aide de BULK INSERT ou OPENROWSET(BULK...) (SQL Server).For more examples, see Import Bulk Data by Using BULK INSERT or OPENROWSET(BULK...) (SQL Server).

S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieures.Applies to: SQL Server 2008SQL Server 2008 and later.

INSERT INTO HumanResources.Department WITH (IGNORE_TRIGGERS) (Name, GroupName)  
SELECT b.Name, b.GroupName   
FROM OPENROWSET (  
    BULK 'C:SQLFilesDepartmentData.txt',  
    FORMATFILE = 'C:SQLFilesBulkloadFormatFile.xml',  
    ROWS_PER_BATCH = 15000)AS b ;  

Remplacement du comportement par défaut de l’optimiseur de requête à l’aide d’indicateursOverriding the Default Behavior of the Query Optimizer by Using Hints

Les exemples présentés dans cette section montrent comment utiliser des indicateurs de table pour remplacer temporairement le comportement par défaut de l’optimiseur de requête lors du traitement de l’instruction INSERT.Examples in this section demonstrate how to use table hints to temporarily override the default behavior of the query optimizer when processing the INSERT statement.

Attention

Étant donné que l'optimiseur de requête SQL ServerSQL Server sélectionne généralement le meilleur plan d'exécution pour une requête, nous vous recommandons de ne recourir à ces conseils qu'en dernier ressort et seulement si vous êtes un développeur ou un administrateur de base de données expérimenté.Because the SQL ServerSQL Server query optimizer typically selects the best execution plan for a query, we recommend that hints be used only as a last resort by experienced developers and database administrators.

S.S. Utilisation de l'indicateur TABLOCK pour spécifier une méthode de verrouillageUsing the TABLOCK hint to specify a locking method

L'exemple suivant spécifie qu'un verrou exclusif (X) est appliqué sur la table Production.Location et est maintenu jusqu'à la fin de l'instruction INSERT.The following example specifies that an exclusive (X) lock is taken on the Production.Location table and is held until the end of the INSERT statement.

S’applique à : SQL ServerSQL Server, SQL DatabaseSQL Database.Applies to: SQL ServerSQL Server, SQL DatabaseSQL Database.

INSERT INTO Production.Location WITH (XLOCK)  
(Name, CostRate, Availability)  
VALUES ( N'Final Inventory', 15.00, 80.00);  

Capture des résultats de l’instruction INSERTCapturing the Results of the INSERT Statement

Les exemples présentés dans cette section montrent comment utiliser la clause OUTPUT pour retourner des informations à partir de chaque ligne affectée par une instruction INSERT, ou des expressions basées sur ces lignes.Examples in this section demonstrate how to use the OUTPUT Clause to return information from, or expressions based on, each row affected by an INSERT statement. Ces résultats peuvent être retournés à l'application en cours de traitement afin d'être utilisés notamment avec des messages de confirmation, des opérations d'archivage et d'autres spécifications d'application similaires.These results can be returned to the processing application for use in such things as confirmation messages, archiving, and other such application requirements.

T.T. Utilisation de OUTPUT avec une instruction INSERTUsing OUTPUT with an INSERT statement

L'exemple suivant insère une ligne dans la table ScrapReason et utilise la clause OUTPUT pour retourner les résultats de l'instruction à la variable de table @MyTableVar.The following example inserts a row into the ScrapReason table and uses the OUTPUT clause to return the results of the statement to the @MyTableVar table variable. Étant donné que la colonne ScrapReasonID est définie avec une propriété IDENTITY, aucune valeur n'est spécifiée dans l'instruction INSERT pour cette colonne.Because the ScrapReasonID column is defined with an IDENTITY property, a value is not specified in the INSERT statement for that column. Cependant, notez que la valeur générée par le Moteur de base de donnéesDatabase Engine pour cette colonne est retournée dans la clause OUTPUT de la colonne INSERTED.ScrapReasonID.However, note that the value generated by the Moteur de base de donnéesDatabase Engine for that column is returned in the OUTPUT clause in the INSERTED.ScrapReasonID column.

DECLARE @MyTableVar table( NewScrapReasonID smallint,  
                           Name varchar(50),  
                           ModifiedDate datetime);  
INSERT Production.ScrapReason  
    OUTPUT INSERTED.ScrapReasonID, INSERTED.Name, INSERTED.ModifiedDate  
        INTO @MyTableVar  
VALUES (N'Operator error', GETDATE());  
  
--Display the result set of the table variable.  
SELECT NewScrapReasonID, Name, ModifiedDate FROM @MyTableVar;  
--Display the result set of the table.  
SELECT ScrapReasonID, Name, ModifiedDate   
FROM Production.ScrapReason;  

U.U. Utilisation de OUTPUT avec des colonnes d'identité et des colonnes calculéesUsing OUTPUT with identity and computed columns

L'exemple suivant crée la table EmployeeSales, puis y insère plusieurs lignes à l'aide d'une instruction INSERT, avec une instruction SELECT pour récupérer les données des tables sources.The following example creates the EmployeeSales table and then inserts several rows into it using an INSERT statement with a SELECT statement to retrieve data from source tables. La table EmployeeSales contient une colonne d'identité (EmployeeID) et une colonne calculée (ProjectedSales).The EmployeeSales table contains an identity column (EmployeeID) and a computed column (ProjectedSales). Étant donné que ces valeurs sont générées par le Moteur de base de donnéesDatabase Engine lors de l'insertion, aucune de ces colonnes ne peut être définie dans @MyTableVar.Because these values are generated by the Moteur de base de donnéesDatabase Engine during the insert operation, neither of these columns can be defined in @MyTableVar.

CREATE TABLE dbo.EmployeeSales  
( EmployeeID   int IDENTITY (1,5)NOT NULL,  
  LastName     nvarchar(20) NOT NULL,  
  FirstName    nvarchar(20) NOT NULL,  
  CurrentSales money NOT NULL,  
  ProjectedSales AS CurrentSales * 1.10   
);  
GO  
DECLARE @MyTableVar table(  
  LastName     nvarchar(20) NOT NULL,  
  FirstName    nvarchar(20) NOT NULL,  
  CurrentSales money NOT NULL  
  );  
  
INSERT INTO dbo.EmployeeSales (LastName, FirstName, CurrentSales)  
  OUTPUT INSERTED.LastName,   
         INSERTED.FirstName,   
         INSERTED.CurrentSales  
  INTO @MyTableVar  
    SELECT c.LastName, c.FirstName, sp.SalesYTD  
    FROM Sales.SalesPerson AS sp  
    INNER JOIN Person.Person AS c  
        ON sp.BusinessEntityID = c.BusinessEntityID  
    WHERE sp.BusinessEntityID LIKE '2%'  
    ORDER BY c.LastName, c.FirstName;  
  
SELECT LastName, FirstName, CurrentSales  
FROM @MyTableVar;  
GO  
SELECT EmployeeID, LastName, FirstName, CurrentSales, ProjectedSales  
FROM dbo.EmployeeSales;  

V.V. Insertion de données retournées à partir d'une clause OUTPUTInserting data returned from an OUTPUT clause

L'exemple suivant capture les données retournées par la clause OUTPUT d'une instruction MERGE et insère ces données dans une autre table.The following example captures data returned from the OUTPUT clause of a MERGE statement, and inserts that data into another table. L’instruction MERGE met quotidiennement à jour la colonne Quantity dans la table ProductInventory, selon les commandes traitées dans la table SalesOrderDetail de la base de données AdventureWorks2012AdventureWorks2012.The MERGE statement updates the Quantity column of the ProductInventory table daily, based on orders that are processed in the SalesOrderDetail table in the AdventureWorks2012AdventureWorks2012 database. Elle supprime également les lignes correspondant aux produits dont le stock passe à 0.It also deletes rows for products whose inventories drop to 0. Cet exemple capture les lignes supprimées et les insère dans une autre table, ZeroInventory, qui effectue le suivi des produits en rupture de stock.The example captures the rows that are deleted and inserts them into another table, ZeroInventory, which tracks products with no inventory.

--Create ZeroInventory table.  
CREATE TABLE Production.ZeroInventory (DeletedProductID int, RemovedOnDate DateTime);  
GO  
  
INSERT INTO Production.ZeroInventory (DeletedProductID, RemovedOnDate)  
SELECT ProductID, GETDATE()  
FROM  
(   MERGE Production.ProductInventory AS pi  
    USING (SELECT ProductID, SUM(OrderQty) FROM Sales.SalesOrderDetail AS sod  
           JOIN Sales.SalesOrderHeader AS soh  
           ON sod.SalesOrderID = soh.SalesOrderID  
           AND soh.OrderDate = '20070401'  
           GROUP BY ProductID) AS src (ProductID, OrderQty)  
    ON (pi.ProductID = src.ProductID)  
    WHEN MATCHED AND pi.Quantity - src.OrderQty <= 0  
        THEN DELETE  
    WHEN MATCHED  
        THEN UPDATE SET pi.Quantity = pi.Quantity - src.OrderQty  
    OUTPUT $action, deleted.ProductID) AS Changes (Action, ProductID)  
WHERE Action = 'DELETE';  
IF @@ROWCOUNT = 0  
PRINT 'Warning: No rows were inserted';  
GO  
SELECT DeletedProductID, RemovedOnDate FROM Production.ZeroInventory;  

Heure standardW. Insertion de données à l’aide de l’option SELECTInserting data using the SELECT option

L’exemple suivant montre comment insérer plusieurs lignes de données à l’aide d’une instruction INSERT avec une option SELECT.The following example shows how to insert multiple rows of data using an INSERT statement with a SELECT option. La première instruction INSERT utilise une instruction SELECT directement pour récupérer des données à partir de la table source, puis stocke le jeu de résultats dans la table EmployeeTitles.The first INSERT statement uses a SELECT statement directly to retrieve data from the source table, and then to store the result set in the EmployeeTitles table.

CREATE TABLE EmployeeTitles  
( EmployeeKey   INT NOT NULL,  
  LastName     varchar(40) NOT NULL,  
  Title      varchar(50) NOT NULL  
);  
INSERT INTO EmployeeTitles  
    SELECT EmployeeKey, LastName, Title   
    FROM ssawPDW.dbo.DimEmployee  
    WHERE EndDate IS NULL;  

X.X. Spécification d’une étiquette avec l’instruction INSERTSpecifying a label with the INSERT statement

L’exemple suivant illustre l’utilisation d’une étiquette avec une instruction INSERT.The following example shows the use of a label with an INSERT statement.

-- Uses AdventureWorks  
  
INSERT INTO DimCurrency   
VALUES (500, N'C1', N'Currency1')  
OPTION ( LABEL = N'label1' );  

Y.Y. Utilisation d’une étiquette et d’un indicateur de requête avec l’instruction INSERTUsing a label and a query hint with the INSERT statement

Cette requête présente la syntaxe de base pour utiliser une étiquette et un indicateur de jointure de requête avec l’instruction INSERT.This query shows the basic syntax for using a label and a query join hint with the INSERT statement. Une fois la requête soumise au nœud de contrôle, SQL ServerSQL Server, en cours d’exécution sur les nœuds de calcul, applique la stratégie de jointure hachée quand il génère le plan de requête SQL ServerSQL Server.After the query is submitted to the Control node, SQL ServerSQL Server, running on the Compute nodes, will apply the hash join strategy when it generates the SQL ServerSQL Server query plan. Pour plus d’informations sur les indicateurs de jointure et sur l’utilisation de la clause OPTION, consultez OPTION (SQL Server PDW).For more information on join hints and how to use the OPTION clause, see OPTION (SQL Server PDW).

-- Uses AdventureWorks  
  
INSERT INTO DimCustomer (CustomerKey, CustomerAlternateKey, 
    FirstName, MiddleName, LastName )   
SELECT ProspectiveBuyerKey, ProspectAlternateKey, 
    FirstName, MiddleName, LastName  
FROM ProspectiveBuyer p JOIN DimGeography g ON p.PostalCode = g.PostalCode  
WHERE g.CountryRegionCode = 'FR'  
OPTION ( LABEL = 'Add French Prospects', HASH JOIN);  

Voir aussiSee Also

BULK INSERT (Transact-SQL) BULK INSERT (Transact-SQL)
DELETE (Transact-SQL) DELETE (Transact-SQL)
EXECUTE (Transact-SQL) EXECUTE (Transact-SQL)
FROM (Transact-SQL) FROM (Transact-SQL)
IDENTITY, propriété (Transact-SQL) IDENTITY (Property) (Transact-SQL)
NEWID (Transact-SQL) NEWID (Transact-SQL)
SELECT (Transact-SQL) SELECT (Transact-SQL)
UPDATE (Transact-SQL) UPDATE (Transact-SQL)
MERGE (Transact-SQL) MERGE (Transact-SQL)
OUTPUT, clause (Transact-SQL) OUTPUT Clause (Transact-SQL)
Utiliser les tables inserted et deletedUse the inserted and deleted Tables