SELECT - Clause INTO (Transact-SQL)SELECT - INTO Clause (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

SELECT...INTO crée une table dans le groupe de fichiers par défaut et y insère les lignes résultantes de la requête.SELECT...INTO creates a new table in the default filegroup and inserts the resulting rows from the query into it. Pour afficher la syntaxe SELECT complète, consultez SELECT (Transact-SQL).To view the complete SELECT syntax, see SELECT (Transact-SQL).

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

SyntaxeSyntax

[ INTO new_table ]
[ ON filegroup ]

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

nouvelle_table new_table
Spécifie le nom d'une table à créer en fonction des colonnes de la liste de sélection et des lignes choisies à partir de la source de données.Specifies the name of a new table to be created, based on the columns in the select list and the rows chosen from the data source.

Le format de new_table est déterminé par l’évaluation des expressions de la liste de sélection.The format of new_table is determined by evaluating the expressions in the select list. Les colonnes de new_table sont créées dans l’ordre spécifié par la liste de sélection.The columns in new_table are created in the order specified by the select list. Chaque colonne de new_table a le même nom, le même type de données, la même possibilité de valeur Null et la même valeur que l’expression correspondante dans la liste de sélection.Each column in new_table has the same name, data type, nullability, and value as the corresponding expression in the select list. La propriété IDENTITY d'une colonne est transférée sauf dans les conditions définies dans « Utilisation des colonnes d'identité » dans la section Remarques.The IDENTITY property of a column is transferred except under the conditions defined in "Working with Identity Columns" in the Remarks section.

Pour créer la table dans une autre base de données de la même instance de SQL ServerSQL Server, spécifiez new_table comme nom complet sous la forme database.schema.table_name.To create the table in another database on the same instance of SQL ServerSQL Server, specify new_table as a fully qualified name in the form database.schema.table_name.

Vous ne pouvez pas créer new_table sur un serveur distant, mais vous pouvez remplir new_table à partir d’une source de données distante.You cannot create new_table on a remote server; however, you can populate new_table from a remote data source. Pour créer new_table à partir d’une table source distante, spécifiez la table source par un nom en quatre parties sous la forme linked_server.catalog.schema.object dans la clause FROM de l’instruction SELECT.To create new_table from a remote source table, specify the source table using a four-part name in the form linked_server.catalog.schema.object in the FROM clause of the SELECT statement. Vous pouvez aussi utiliser la fonction OPENQUERY ou la fonction OPENDATASOURCE dans la clause FROM pour spécifier la source de données distante.Alternatively, you can use the OPENQUERY function or the OPENDATASOURCE function in the FROM clause to specify the remote data source.

groupe_fichiers filegroup
Spécifie le nom du groupe de fichiers dans lequel créer la table.Specifies the name of the filegroup in which new table will be created. Si le groupe de fichiers spécifié n’existe pas dans la base de données, le moteur SQL Server lève une erreur.The filegroup specified should exist on the database else the SQL Server engine throws an error.

S’applique à : SQL Server 2016 (13.x)SQL Server 2016 (13.x) SP2 et versions ultérieures.Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x) SP2 and later.

Types de donnéesData Types

L'attribut FILESTREAM n'est pas transféré dans la nouvelle table.The FILESTREAM attribute does not transfer to the new table. Les objets BLOB FILESTREAM sont copiés et stockés dans la nouvelle table en tant qu’objets BLOB varbinary(max) .FILESTREAM BLOBs are copied and stored in the new table as varbinary(max) BLOBs. Sans l’attribut FILESTREAM, le type de données varbinary(max) est limité à 2 Go.Without the FILESTREAM attribute, the varbinary(max) data type has a limitation of 2 GB. Si un objet BLOB FILESTREAM dépasse cette valeur, l'erreur 7119 se déclenche et l'instruction s'arrête.If a FILESTREAM BLOB exceeds this value, error 7119 is raised and the statement is stopped.

Lorsque vous sélectionnez une colonne d'identité existante dans une nouvelle table, la nouvelle colonne hérite de la propriété IDENTITY sauf si l'une des conditions suivantes est vraie :When an existing identity column is selected into a new table, the new column inherits the IDENTITY property, unless one of the following conditions is true:

  • L'instruction SELECT contient une jointure.The SELECT statement contains a join.

  • Plusieurs instructions SELECT sont reliées par UNION.Multiple SELECT statements are joined by using UNION.

  • La colonne d'identité est répertoriée plus d'une fois dans la liste de sélection.The identity column is listed more than one time in the select list.

  • La colonne d'identité fait partie d'une expression.The identity column is part of an expression.

  • La colonne d'identité fait partie d'une source de données distante.The identity column is from a remote data source.

Si l'une de ces conditions est vérifiée, la colonne est créée avec l'attribut NOT NULL au lieu d'hériter de la propriété IDENTITY.If any one of these conditions is true, the column is created NOT NULL instead of inheriting the IDENTITY property. Si une colonne d'identité est requise dans la nouvelle table et si ce type de colonne n'est pas disponible, ou si vous voulez une valeur initiale ou une valeur d'incrément différente de la colonne d'identité source, définissez la colonne dans la liste de sélection à l'aide de la fonction IDENTITY.If an identity column is required in the new table but such a column is not available, or you want a seed or increment value that is different than the source identity column, define the column in the select list using the IDENTITY function. Consultez « Création d'une colonne d'identité à l'aide de la fonction IDENTITY » dans la section Exemples ci-dessous.See "Creating an identity column using the IDENTITY function" in the Examples section below.

NotesRemarks

L’instruction SELECT...INTO s’exécute en deux temps : la nouvelle table est créée, puis les lignes sont insérées.The SELECT...INTO statement operates in two parts - the new table is created, and then rows are inserted. Cela signifie que, si les insertions échouent, elles sont toutes annulées, mais la nouvelle table (vide) est conservée.This means that if the inserts fail, they will all be rolled back, but the new (empty) table will remain. Si l’opération doit réussir ou échouer dans sa globalité, utilisez une transaction explicite.If you need the entire operation to succeed or fail as a whole, use an explicit transaction.

Limitations et restrictionsLimitations and Restrictions

Vous ne pouvez pas spécifier une variable de table ou un paramètre table en tant que nouvelle table.You cannot specify a table variable or table-valued parameter as the new table.

Vous ne pouvez pas utiliser SELECT...INTO pour créer une table partitionnée, même quand la table source est partitionnée.You cannot use SELECT...INTO to create a partitioned table, even when the source table is partitioned. SELECT...INTO n’utilise pas le schéma de partition de la table source ; à la place, la nouvelle table est créée dans le groupe de fichiers par défaut.SELECT...INTO does not use the partition scheme of the source table; instead, the new table is created in the default filegroup. Pour insérer des lignes dans une table partitionnée, vous devez d’abord créer la table partitionnée, puis utiliser l’instruction INSERT INTO...SELECT...FROM.To insert rows into a partitioned table, you must first create the partitioned table and then use the INSERT INTO...SELECT...FROM statement.

Les index, contraintes et déclencheurs définis dans la table source ne sont pas transférés dans la nouvelle table ; ils ne peuvent pas non plus être spécifiés dans l’instruction SELECT...INTO.Indexes, constraints, and triggers defined in the source table are not transferred to the new table, nor can they be specified in the SELECT...INTO statement. Si ces objets sont nécessaires, vous pouvez les créer après avoir exécuté l’instruction SELECT...INTO.If these objects are required, you can create them after executing the SELECT...INTO statement.

La spécification d’une clause ORDER BY ne garantit pas que les lignes soient insérées dans l’ordre spécifié.Specifying an ORDER BY clause does not guarantee the rows are inserted in the specified order.

Lorsqu'une colonne éparse est comprise dans la liste de sélection, la propriété de colonne éparse n'est pas transférée à la colonne de la nouvelle table.When a sparse column is included in the select list, the sparse column property does not transfer to the column in the new table. Si cette propriété est obligatoire dans la nouvelle table, modifiez la définition de colonne après avoir exécuté l'instruction SELECT...INTO afin d'inclure cette propriété.If this property is required in the new table, alter the column definition after executing the SELECT...INTO statement to include this property.

Lorsqu'une colonne calculée est comprise dans la liste de sélection, la colonne correspondante de la nouvelle table n'est pas une colonne calculée.When a computed column is included in the select list, the corresponding column in the new table is not a computed column. Les valeurs de la nouvelle colonne sont les valeurs calculées au moment de l’exécution de l’instruction SELECT...INTO.The values in the new column are the values that were computed at the time SELECT...INTO was executed.

Comportement de journalisationLogging Behavior

La quantité d’informations journalisées pour SELECT...INTO dépend du mode de récupération en vigueur pour la base de données.The amount of logging for SELECT...INTO depends on the recovery model in effect for the database. En mode de récupération simple ou en mode de récupération utilisant les journaux de transactions, les opérations de chargement en masse font l'objet d'une journalisation minimale.Under the simple recovery model or bulk-logged recovery model, bulk operations are minimally logged. Avec une journalisation minimale, l’utilisation de l’instruction SELECT...INTO peut s’avérer plus efficace que la création d’une table et son remplissage avec une instruction INSERT.With minimal logging, using the SELECT...INTO statement can be more efficient than creating a table and then populating the table with an INSERT statement. Pour plus d'informations, consultez Journal des transactions (SQL Server).For more information, see The Transaction Log (SQL Server).

Les instructions SELECT...INTO qui contiennent des fonctions définies par l’utilisateur (UDF) sont des opérations entièrement journalisées.SELECT...INTO statements that contain user-defined functions (UDFs) are fully logged operations. Si les fonctions définies par l’utilisateur utilisées dans l’instruction SELECT...INTO n’effectuent aucune opération d’accès aux données, vous pouvez spécifier la clause SCHEMABINDING pour les fonctions définies par l’utilisateur, qui définira la propriété UserDataAccess dérivée de ces fonctions définies par l’utilisateur sur 0.If the user-defined functions that are used in the SELECT...INTO statement don't perform any data access operations, you can specify the SCHEMABINDING clause for the user-defined functions, which will set the derived UserDataAccess property for those user-defined functions to 0. Après cette modification, les instructions SELECT...INTO sont journalisées de façon minimale.After this change, SELECT...INTO statements will be minimally logged. Si l’instruction SELECT...INTO fait toujours référence à au moins une fonction définie par l’utilisateur dont la propriété a la valeur 1, l’opération est entièrement journalisée.If the SELECT...INTO statement still references at least one user-defined function that has this property set to 1, the operation is fully logged.

AutorisationsPermissions

Requiert l'autorisation CREATE TABLE dans la base de données de destination.Requires CREATE TABLE permission in the destination database.

ExemplesExamples

R.A. Création d'une table en spécifiant des colonnes provenant de plusieurs sourcesCreating a table by specifying columns from multiple sources

L'exemple suivant crée la table dbo.EmployeeAddresses dans la base de données AdventureWorks2012AdventureWorks2012 en sélectionnant sept colonnes de diverses tables liées aux salariés et aux adresses.The following example creates the table dbo.EmployeeAddresses in the AdventureWorks2012AdventureWorks2012 database by selecting seven columns from various employee-related and address-related tables.

SELECT c.FirstName, c.LastName, e.JobTitle, a.AddressLine1, a.City,   
    sp.Name AS [State/Province], a.PostalCode  
INTO dbo.EmployeeAddresses  
FROM Person.Person AS c  
    JOIN HumanResources.Employee AS e   
    ON e.BusinessEntityID = c.BusinessEntityID  
    JOIN Person.BusinessEntityAddress AS bea  
    ON e.BusinessEntityID = bea.BusinessEntityID  
    JOIN Person.Address AS a  
    ON bea.AddressID = a.AddressID  
    JOIN Person.StateProvince as sp   
    ON sp.StateProvinceID = a.StateProvinceID;  
GO  

B.B. Insertion de lignes en utilisant une journalisation minimaleInserting rows using minimal logging

L'exemple suivant crée la table dbo.NewProducts et insère des lignes provenant de la table Production.Product.The following example creates the table dbo.NewProducts and inserts rows from the Production.Product table. L'exemple suppose que le mode de récupération de la base de données AdventureWorks2012AdventureWorks2012 a la valeur FULL.The example assumes that the recovery model of the AdventureWorks2012AdventureWorks2012 database is set to FULL. Pour garantir une journalisation minimale, le mode de récupération de la base de données AdventureWorks2012AdventureWorks2012 a la valeur BULK_LOGGED avant l'insertion des lignes ; il reprend ensuite la valeur FULL après l'utilisation de l'instruction SELECT...INTO.To ensure minimal logging is used, the recovery model of the AdventureWorks2012AdventureWorks2012 database is set to BULK_LOGGED before rows are inserted and reset to FULL after the SELECT...INTO statement. Ce processus permet de garantir que l'instruction SELECT...INTO utilise un espace minimal dans le journal des transactions et qu'elle s'exécute de manière efficace.This process ensures that the SELECT...INTO statement uses minimal space in the transaction log and performs efficiently.

ALTER DATABASE AdventureWorks2012 SET RECOVERY BULK_LOGGED;  
GO  
  
SELECT * INTO dbo.NewProducts  
FROM Production.Product  
WHERE ListPrice > $25   
AND ListPrice < $100;  
GO  
ALTER DATABASE AdventureWorks2012 SET RECOVERY FULL;  
GO  

C.C. Création d'une colonne d'identité à l'aide de la fonction IDENTITYCreating an identity column using the IDENTITY function

L'exemple suivant utilise la fonction IDENTITY pour créer une colonne d'identité dans la nouvelle table Person.USAddress de la base de données AdventureWorks2012AdventureWorks2012.The following example uses the IDENTITY function to create an identity column in the new table Person.USAddress in the AdventureWorks2012AdventureWorks2012 database. Cela est nécessaire, car l'instruction SELECT qui définit la table contient une jointure qui empêche le transfert de la propriété IDENTITY vers la nouvelle table.This is required because the SELECT statement that defines the table contains a join, which causes the IDENTITY property to not transfer to the new table. Notez que la valeur initiale et la valeur d'incrément spécifiées dans la fonction IDENTITY sont différentes de celles de la colonne AddressID dans la table source Person.Address.Notice that the seed and increment values specified in the IDENTITY function are different from those of the AddressID column in the source table Person.Address.

-- Determine the IDENTITY status of the source column AddressID.  
SELECT OBJECT_NAME(object_id) AS TableName, name AS column_name, 
  is_identity, seed_value, increment_value  
FROM sys.identity_columns  
WHERE name = 'AddressID';  
  
-- Create a new table with columns from the existing table Person.Address. 
-- A new IDENTITY column is created by using the IDENTITY function.  
SELECT IDENTITY (int, 100, 5) AS AddressID,   
       a.AddressLine1, a.City, b.Name AS State, a.PostalCode  
INTO Person.USAddress   
FROM Person.Address AS a  
INNER JOIN Person.StateProvince AS b 
  ON a.StateProvinceID = b.StateProvinceID  
WHERE b.CountryRegionCode = N'US';   
  
-- Verify the IDENTITY status of the AddressID columns in both tables.  
SELECT OBJECT_NAME(object_id) AS TableName, name AS column_name, 
  is_identity, seed_value, increment_value  
FROM sys.identity_columns  
WHERE name = 'AddressID';  

D.D. Création d'une table en spécifiant des colonnes provenant d'une source de données distanteCreating a table by specifying columns from a remote data source

L'exemple suivant illustre l'utilisation de trois méthodes de création d'une table sur le serveur local à partir d'une source de données distante.The following example demonstrates three methods of creating a new table on the local server from a remote data source. L'exemple commence par créer un lien vers la source de données distante.The example begins by creating a link to the remote data source. Le nom du serveur lié, MyLinkServer,, est ensuite spécifié dans la clause FROM de la première instruction SELECT...INTO, ainsi que dans la fonction OPENQUERY de la deuxième instruction SELECT...INTO.The linked server name, MyLinkServer, is then specified in the FROM clause of the first SELECT...INTO statement and in the OPENQUERY function of the second SELECT...INTO statement. La troisième instruction SELECT...INTO utilise la fonction OPENDATASOURCE, qui spécifie directement la source de données distante au lieu d'utiliser le nom du serveur lié.The third SELECT...INTO statement uses the OPENDATASOURCE function, which specifies the remote data source directly instead of using the linked server name.

S’applique à : SQL Server 2008SQL Server 2008 et versions ultérieuresApplies 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_name\instance_name'.  
EXEC sp_addlinkedserver @server = N'MyLinkServer',  
    @srvproduct = N' ',  
    @provider = N'SQLNCLI',   
    @datasrc = N'server_name',  
    @catalog = N'AdventureWorks2012';  
GO  

USE AdventureWorks2012;  
GO  
-- Specify the remote data source in the FROM clause using a four-part name   
-- in the form linked_server.catalog.schema.object.  
SELECT DepartmentID, Name, GroupName, ModifiedDate  
INTO dbo.Departments  
FROM MyLinkServer.AdventureWorks2012.HumanResources.Department  
GO  
-- Use the OPENQUERY function to access the remote data source.  
SELECT DepartmentID, Name, GroupName, ModifiedDate  
INTO dbo.DepartmentsUsingOpenQuery  
FROM OPENQUERY(MyLinkServer, 'SELECT *  
               FROM AdventureWorks2012.HumanResources.Department');   
GO  
-- 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_name\instance_name.  
SELECT DepartmentID, Name, GroupName, ModifiedDate  
INTO dbo.DepartmentsUsingOpenDataSource  
FROM OPENDATASOURCE('SQLNCLI',  
    'Data Source=server_name;Integrated Security=SSPI')  
    .AdventureWorks2012.HumanResources.Department;  
GO  

E.E. Importer à partir d’une table externe créée avec PolyBaseImport from an external table created with PolyBase

Importez des données de Hadoop ou d’Azure Storage dans SQL Server à des fins de stockage permanent.Import data from Hadoop or Azure Storage into SQL Server for persistent storage. Utilisez SELECT INTO pour importer des données référencées par une table externe en vue de leur stockage permanent dans SQL Server.Use SELECT INTO to import data referenced by an external table for persistent storage in SQL Server. Créez une table relationnelle à la volée, puis créez un index column-store en plus de la table.Create a relational table on-the-fly and then create a column-store index on top of the table in a second step.

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

-- Import data for car drivers into SQL Server to do more in-depth analysis.  
SELECT DISTINCT   
        Insured_Customers.FirstName, Insured_Customers.LastName,   
        Insured_Customers.YearlyIncome, Insured_Customers.MaritalStatus  
INTO Fast_Customers from Insured_Customers INNER JOIN   
(  
        SELECT * FROM CarSensor_Data where Speed > 35   
) AS SensorD  
ON Insured_Customers.CustomerKey = SensorD.CustomerKey  
ORDER BY YearlyIncome;  

F.F. Création d’une table en tant que copie d’une autre table et chargement de la table dans un groupe de fichiers spécifiéCreating a new table as a copy of another table and loading it a specified filegroup

L’exemple suivant illustre la création d’une table en tant que copie d’une autre table et son chargement dans un autre groupe de fichiers que le groupe de fichiers par défaut de l’utilisateur.The following example demonstrates creating a new table as a copy of another table and loading it into a specified filegroup different from the default filegroup of the user.

S’applique à : SQL Server 2016 (13.x)SQL Server 2016 (13.x) SP2 et versions ultérieures.Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x) SP2 and later.

ALTER DATABASE [AdventureWorksDW2016] ADD FILEGROUP FG2;
ALTER DATABASE [AdventureWorksDW2016]
ADD FILE
(
NAME='FG2_Data',
FILENAME = '/var/opt/mssql/data/AdventureWorksDW2016_Data1.mdf'
)
TO FILEGROUP FG2;
GO
SELECT * INTO [dbo].[FactResellerSalesXL] ON FG2 FROM [dbo].[FactResellerSales];

Voir aussiSee Also

SELECT (Transact-SQL) SELECT (Transact-SQL)
Exemples SELECT (Transact-SQL) SELECT Examples (Transact-SQL)
INSERT (Transact-SQL) INSERT (Transact-SQL)
IDENTITY (Function) (Transact-SQL)IDENTITY (Function) (Transact-SQL)