인덱스를 다시 구성하거나 다시 빌드하여 인덱스 조각화 해결Resolve index fragmentation by reorganizing or rebuilding indexes

적용 대상:Applies to: 예SQL ServerSQL Server(지원되는 모든 버전)yesSQL ServerSQL Server (all supported versions) 예Azure SQL DatabaseAzure SQL DatabaseYesAzure SQL DatabaseAzure SQL Database 예Azure SQL Managed InstanceAzure SQL Managed InstanceYesAzure SQL Managed InstanceAzure SQL Managed Instance 예Azure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics 예병렬 데이터 웨어하우스Parallel Data Warehouseyes병렬 데이터 웨어하우스Parallel Data Warehouse적용 대상:Applies to: 예SQL ServerSQL Server(지원되는 모든 버전)yesSQL ServerSQL Server (all supported versions) 예Azure SQL DatabaseAzure SQL DatabaseYesAzure SQL DatabaseAzure SQL Database 예Azure SQL Managed InstanceAzure SQL Managed InstanceYesAzure SQL Managed InstanceAzure SQL Managed Instance 예Azure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics 예병렬 데이터 웨어하우스Parallel Data Warehouseyes병렬 데이터 웨어하우스Parallel Data Warehouse

이 문서에서는 인덱스 조각 모음이 수행되는 방식과 이것이 쿼리 성능에 미치는 영향에 대해 설명합니다.This article describes how index defragmentation occurs and discusses its impact on query performance. 하나의 인덱스에 대해 존재하는 조각화의 양을 확인한 후에는 원하는 도구에서 Transact-SQL 명령을 실행하거나 SQL Server Management Studio를 사용하여 인덱스를 다시 빌드하거나 인덱스를 다시 빌드하여 인덱스를 조각 모음할 수 있습니다.Once you determine the amount of fragmentation that exists for an index, you can defragment an index by either reorganizing an index or rebuilding an index by running Transact-SQL commands in your tool of choice or by using SQL Server Management Studio.

인덱스 조각화 개요Index fragmentation overview

인덱스 조각화 정의 및 인덱스 조각화가 중요한 이유는 다음과 같습니다.What is index fragmentation and why should I care about it:

  • 조각화는 인덱스의 키 값을 기준으로 하는 인덱스 내의 논리적 순서가 인덱스 페이지 내의 물리적 순서와 일치하지 않는 인덱스 페이지가 있는 경우에 발생합니다.Fragmentation exists when indexes have pages in which the logical ordering within the index, based on the key value of the index, does not match the physical ordering inside the index pages.
  • 데이터베이스 엔진Database Engine에서는 기본 데이터에 삽입, 업데이트 또는 삭제 작업을 수행할 때마다 인덱스를 자동으로 수정합니다.The 데이터베이스 엔진Database Engine automatically modifies indexes whenever insert, update, or delete operations are made to the underlying data. 예를 들어 테이블에 행을 추가하는 경우 새로운 키 값의 삽입 공간을 확보하기 위해 rowstore 인덱스의 기존 페이지가 분할될 수 있습니다.For example, the addition of rows in a table may cause existing pages in rowstore indexes to split to make room for the insertion of new key values. 이러한 수정이 거듭되면 시간이 흐름에 따라 인덱스의 정보가 조각화되어 데이터베이스 내에 흩어지게 될 수 있습니다.Over time these modifications can cause the information in the index to become scattered in the database (fragmented). 조각화는 키 값을 기준으로 하는 인덱스의 논리적 페이지 순서가 데이터 파일 내의 물리적 순서와 일치하지 않을 때 나타납니다.Fragmentation exists when indexes have pages in which the logical ordering, based on the key value, does not match the physical ordering inside the data file.
  • 인덱스가 심하게 조각화된 경우 인덱스가 가리키는 데이터를 찾기 위해 추가 I/O가 필요하므로 쿼리 성능이 저하될 수 있습니다.Heavily fragmented indexes can degrade query performance because additional I/O is required to locate data to which the index points. I/O가 많을수록, 특히 검사 작업이 포함된 경우 애플리케이션이 느리게 응답합니다.More I/O causes your application to respond slowly, especially when scan operations are involved.

조각화의 양 검색Detecting the amount of fragmentation

사용할 인덱스 조각 모음 방법을 결정하기 위한 첫 번째 단계는 인덱스를 분석하여 조각화 수준을 확인하는 것입니다.The first step in deciding which index defragmentation method to use is to analyze the index to determine the degree of fragmentation. rowstore 인덱스와 columnstore 인덱스의 조각화는 각각 다른 방법으로 검색됩니다.You detect fragmentation differently for rowstore indexes and columnstore indexes.

참고

대량의 데이터가 삭제된 후에 인덱스 또는 힙 조각화를 검토하는 것이 특히 중요합니다.It's especially important to review index or heap fragmentation after large amounts of data are deleted. 힙의 경우, 업데이트가 자주 이루어지면 전달하는 레코드의 확산을 방지하기 위해 조각화를 검토해야 할 수도 있습니다.For heaps, if there are frequent updates, it may also be needed to review fragmentation to avoid proliferation of forwarding records. 힙에 대한 자세한 내용은 힙(클러스터형 인덱스가 없는 테이블)을 참조하세요.For more information about heaps, see Heaps (Tables without Clustered Indexes).

rowstore 인덱스의 조각화 검색Detecting fragmentation of rowstore indexes

sys.dm_db_index_physical_stats를 사용하면 특정 인덱스, 테이블이나 인덱싱된 뷰의 모든 인덱스, 데이터베이스의 모든 인덱스 또는 모든 데이터베이스 내 모든 인덱스에서 조각화를 검색할 수 있습니다.By using sys.dm_db_index_physical_stats, you can detect fragmentation in a specific index, all indexes on a table or indexed view, all indexes in a database, or all indexes in all databases. 분할된 인덱스의 경우 sys.dm_db_index_physical_stats 에서도 각 파티션의 조각화 정보를 제공합니다.For partitioned indexes, sys.dm_db_index_physical_stats also provides fragmentation information for each partition.

sys.dm_db_index_physical_stats에서 반환된 결과 집합은 다음 열을 포함합니다.The result set returned by sys.dm_db_index_physical_stats includes the following columns:

Column DescriptionDescription
avg_fragmentation_in_percentavg_fragmentation_in_percent 논리적 조각화(인덱스에서 순서가 잘못된 페이지) 비율The percent of logical fragmentation (out-of-order pages in the index).
fragment_countfragment_count 인덱스의 조각(물리적으로 연속되는 리프 페이지) 수The number of fragments (physically consecutive leaf pages) in the index.
avg_fragment_size_in_pagesavg_fragment_size_in_pages 인덱스 한 조각의 평균 페이지 수Average number of pages in one fragment in an index.

조각화 수준을 파악한 후에는 다음 표를 참고하여 인덱스 다시 구성 또는 인덱스 다시 빌드 중에서 조각화를 제거하기에 적합한 방법을 확인합니다.After the degree of fragmentation is known, use the following table to determine the best method to remove the fragmentation: INDEX REORGANIZE or INDEX.

avg_fragmentation_in_percentavg_fragmentation_in_percent value 수정문Corrective statement
> 5% 및 < = 30% 1> 5% and < = 30% 1 ALTER INDEX REORGANIZEALTER INDEX REORGANIZE
> 30% 1> 30% 1 ALTER INDEX REBUILD WITH (ONLINE = ON) 2ALTER INDEX REBUILD WITH (ONLINE = ON) 2

1 이러한 값은 ALTER INDEX REORGANIZEALTER INDEX REBUILD를 전환해야 하는 시점을 확인하기 위한 대략적인 지침을 제공합니다.1 These values provide a rough guideline for determining the point at which you should switch between ALTER INDEX REORGANIZE and ALTER INDEX REBUILD. 그러나 실제 값은 경우에 따라 달라질 수 있습니다.However, the actual values may vary from case to case. 실험을 통해 환경에 맞는 임계값을 확인하는 것이 중요합니다.It is important that you experiment to determine the best threshold for your environment.

예를 들어 지정된 인덱스가 주로 스캔 작업에 사용되는 경우 조각화를 제거하면 해당 작업의 성능을 개선할 수 있습니다.For example, if a given index is used mainly for scan operations, removing fragmentation can improve performance of these operations. 검색 작업에 주로 사용되는 인덱스의 경우 성능상 장점이 눈에 띄지 않을 수 있습니다.The performance benefit may not be noticeable for indexes that are used primarily for seek operations.
마찬가지로 힙(클러스터형 인덱스가 없는 테이블)에서 조각화를 제거하는 기능은 비클러스터형 인덱스 검색 작업에 특히 유용하지만 조회 작업에는 거의 영향을 주지 않습니다.Similarly, removing fragmentation in a heap (a table with no clustered index) is especially useful for nonclustered index scan operations, but has little effect in lookup operations.

2 온라인 또는 오프라인으로 인덱스를 다시 작성할 수 있습니다.2 Rebuilding an index can be executed online or offline. 인덱스를 다시 구성하는 과정은 항상 온라인으로 실행됩니다.Reorganizing an index is always executed online. 다시 구성할 때와 비슷한 가용성을 얻으려면 온라인으로 인덱스를 다시 작성해야 합니다.To achieve availability similar to the reorganize option, you should rebuild indexes online. 자세한 내용은 인덱스 다시 빌드온라인으로 인덱스 작업 수행을 참조하세요.For more information, see INDEX and Perform Index Operations Online.

대체로 적은 양의 조각화를 제거할 경우 얻게 되는 이점보다 인덱스를 다시 구성하거나 다시 빌드하는 데 필요한 CPU 비용이 훨씬 크기 때문에, 조각화가 5% 미만인 인덱스는 조각 모음을 수행할 필요가 없습니다.Indexes with fragmentation or less than 5 percent do not need to be defragmented because the benefit from removing such a small amount of fragmentation is almost always vastly outweighed by the CPU cost incurred to reorganize or rebuild the index. 또한, 작은 rowstore 인덱스는 다시 빌드하거나 다시 구성해도 실제 조각화가 줄어들지 않는 경우가 많습니다.Also, rebuilding or reorganizing small rowstore indexes generally does not reduce actually fragmentation. SQL Server 2014(12.x)SQL Server 2014 (12.x)까지는, SQL Server 데이터베이스 엔진SQL Server Database Engine이 혼합 익스텐트를 사용하여 공간을 할당합니다.Up to, and including, SQL Server 2014(12.x)SQL Server 2014 (12.x), the SQL Server 데이터베이스 엔진SQL Server Database Engine allocates space using mixed extents. 따라서 작은 인덱스의 페이지는 종종 혼합 익스텐트에 저장됩니다.Therefore, pages of small indexes are sometimes stored on mixed extents. 혼합 익스텐트는 최대 8개의 개체가 공유할 수 있으므로 인덱스를 다시 작성하거나 다시 구성한 후에도 작은 인덱스의 조각화가 줄어들지 않을 수 있습니다.Mixed extents are shared by up to eight objects, so the fragmentation in a small index might not be reduced after reorganizing or rebuilding it. rowstore 인덱스 다시 빌드 관련 고려 사항도 참조하세요.See also Considerations specific to rebuilding rowstore indexes. 익스텐트에 대한 자세한 내용은 페이지 및 익스텐트 아키텍처 가이드를 참조하세요.For more information about extents, see the Pages and Extents Architecture Guide.

columnstore 인덱스의 조각화 검색Detecting fragmentation of columnstore indexes

sys.dm_db_column_store_row_group_physical_stats를 사용하면 인덱스에서 삭제된 행의 백분율을 확인할 수 있으며, 이 백분율은 columnstore 인덱스에서 행 그룹의 조각화를 잘 보여 주는 측정값입니다.By using sys.dm_db_column_store_row_group_physical_stats, you can determine the percentage of deleted rows in an index, which is a reasonable measure for fragmentation in a rowgroup of a columnstore index. 이 정보를 사용하여 특정 인덱스, 테이블의 모든 인덱스, 데이터베이스의 모든 인덱스 또는 모든 데이터베이스의 모든 인덱스에서 조각화를 계산할 수 있습니다.Use this information to compute the fragmentation in a specific index, all indexes on a table, all indexes in a database, or all indexes in all databases.

_Db_column_store_row_group_physical_stats에서 반환된 결과 집합은 다음 열을 포함합니다.The result set returned by sys.dm_db_column_store_row_group_physical_stats includes the following columns:

Column DescriptionDescription
total_rowstotal_rows 행 그룹에 실제 저장된 행의 수입니다.Number of rows physical stored in the row group. 압축된 행 그룹의 경우 여기에 삭제된 것으로 표시된 행이 포함됩니다.For compressed row groups, this includes the rows that are marked as deleted.
deleted_rowsdeleted_rows 삭제되도록 표시된 압축된 행 그룹에 물리적으로 저장된 행의 수입니다.Number of rows physically stored in a compressed row group that are marked for deletion. 델타 저장소에 있는 행 그룹의 경우 0입니다.0 for row groups that are in the delta store.

이 반환된 정보를 사용하여 다음 수식으로 인덱스 조각화를 계산할 수 있습니다.Use this information returned to compute index fragmentation using this formula:

100*(ISNULL(deleted_rows,0))/NULLIF(total_rows,0)

인덱스 조각화 수준을 파악한 후에는 다음 표를 참고하여 인덱스 다시 구성 또는 인덱스 다시 빌드 중에서 조각화를 제거하기에 적합한 방법을 확인합니다.After the degree of index fragmentation is known, use the following table to determine the best method to remove the fragmentation: INDEX REORGANIZE or INDEX.

계산된 조각화(백분율)computed fragmentation in percent value 버전에 적용Applies to version 수정문Corrective statement
> = 20%> = 20% SQL Server 2012(11.x)SQL Server 2012 (11.x) SQL Server 2014(12.x)SQL Server 2014 (12.x)and SQL Server 2014(12.x)SQL Server 2014 (12.x) ALTER INDEX REBUILDALTER INDEX REBUILD
> = 20%> = 20% SQL Server 2016(13.x)SQL Server 2016 (13.x)로 시작Starting with SQL Server 2016(13.x)SQL Server 2016 (13.x) ALTER INDEX REORGANIZEALTER INDEX REORGANIZE

Transact-SQLTransact-SQL을 사용하여 rowstore 인덱스의 조각화 확인To check the fragmentation of a rowstore index using Transact-SQLTransact-SQL

다음 예에서는 AdventureWorks2016 데이터베이스의 HumanResources.Employee 테이블에 있는 모든 인덱스의 평균 조각화 백분율을 찾습니다.The following example finds the average fragmentation percentage of all indexes in the HumanResources.Employee table in the AdventureWorks2016 database.

SELECT a.object_id, object_name(a.object_id) AS TableName,
    a.index_id, name AS IndedxName, avg_fragmentation_in_percent
FROM sys.dm_db_index_physical_stats
    (DB_ID (N'AdventureWorks2016_EXT')
        , OBJECT_ID(N'HumanResources.Employee')
        , NULL
        , NULL
        , NULL) AS a
INNER JOIN sys.indexes AS b
    ON a.object_id = b.object_id
    AND a.index_id = b.index_id;
GO

앞의 문은 다음과 비슷한 결과 세트를 반환합니다.The previous statement returns a result set similar to the following.

object_id   TableName    index_id    IndexName                                             avg_fragmentation_in_percent
----------- ------------ ----------- ----------------------------------------------------- ------------------------------
1557580587  Employee     1           PK_Employee_BusinessEntityID                          0
1557580587  Employee     2           IX_Employee_OrganizationalNode                        0
1557580587  Employee     3           IX_Employee_OrganizationalLevel_OrganizationalNode    0
1557580587  Employee     5           AK_Employee_LoginID                                   66.6666666666667
1557580587  Employee     6           AK_Employee_NationalIDNumber                          50
1557580587  Employee     7           AK_Employee_rowguid                                   0

(6 row(s) affected)

자세한 내용은 sys.dm_db_index_physical_stats를 참조하세요.For more information, see sys.dm_db_index_physical_stats.

Transact-SQLTransact-SQL을 사용하여 columnstore 인덱스의 조각화 확인To check the fragmentation of a columnstore index using Transact-SQLTransact-SQL

다음 예에서는 AdventureWorksDW2016 데이터베이스의 dbo.FactResellerSalesXL_CCI 테이블에 있는 모든 인덱스의 평균 조각화 백분율을 찾습니다.The following example finds the average fragmentation percentage of all indexes in the dbo.FactResellerSalesXL_CCI table in the AdventureWorksDW2016 database.

SELECT i.object_id,
    object_name(i.object_id) AS TableName,
    i.index_id,
    i.name AS IndexName,
    100*(ISNULL(SUM(CSRowGroups.deleted_rows),0))/NULLIF(SUM(CSRowGroups.total_rows),0) AS 'Fragmentation'
FROM sys.indexes AS i  
INNER JOIN sys.dm_db_column_store_row_group_physical_stats AS CSRowGroups
    ON i.object_id = CSRowGroups.object_id
    AND i.index_id = CSRowGroups.index_id
WHERE object_name(i.object_id) = 'FactResellerSalesXL_CCI'
GROUP BY i.object_id, i.index_id, i.name
ORDER BY object_name(i.object_id), i.name;

앞의 문은 다음과 비슷한 결과 세트를 반환합니다.The previous statement returns a result set similar to the following.

object_id   TableName                   index_id    IndexName                       Fragmentation
----------- --------------------------- ----------- ------------------------------- ---------------
114099447   FactResellerSalesXL_CCI     1           IndFactResellerSalesXL_CCI      0

(1 row(s) affected)

SQL Server Management Studio를 사용하여 인덱스 조각화 확인Check index fragmentation using SQL Server Management Studio

참고

Management StudioManagement Studio는 SQL Server에서 columnstore 인덱스의 조각화를 컴퓨팅하는 데 사용할 수 없으며 Azure SQL Database에서 인덱스의 조각화를 컴퓨팅하는 데 사용할 수 없습니다.cannot be used to compute fragmentation of columnstore indexes in SQL Server and cannot be used to compute fragmentation of any indexes in Azure SQL Database. 이러한 시나리오에는 앞에 나온 Transact-SQLTransact-SQL 예제를 사용하세요.Use the preceding Transact-SQLTransact-SQL example for these scenarios.

  1. 개체 탐색기에서 인덱스의 조각화를 확인할 테이블이 포함된 데이터베이스를 확장합니다.In Object Explorer, Expand the database that contains the table on which you want to check an index's fragmentation.
  2. 테이블 폴더를 확장합니다.Expand the Tables folder.
  3. 인덱스의 조각화를 확인할 테이블을 확장합니다.Expand the table on which you want to check an index's fragmentation.
  4. 인덱스 폴더를 확장합니다.Expand the Indexes folder.
  5. 조각화를 확인할 인덱스를 마우스 오른쪽 단추로 클릭하고 속성을 선택합니다.Right-click the index of which you want to check the fragmentation and select Properties.
  6. 페이지 선택아래에서 조각화를 선택합니다.Under Select a page, select Fragmentation.

조각화 페이지에서 다음 정보를 사용할 수 있습니다.The following information is available on the Fragmentation page:

Value DescriptionDescription
페이지 사용률Page fullness 인덱스 페이지의 평균 사용률(%)을 나타냅니다.Indicates average fullness of the index pages, as a percentage. 즉, 인덱스 페이지가 모두 사용되고 있는 경우 100%로 표시되며,100% means the index pages are completely full. 50%인 경우 평균적으로 각 인덱스 페이지가 절반 정도 사용되고 있는 것입니다.50% means that, on average, each index page is half full.
총 조각화Total fragmentation 논리적 조각화 비율입니다.The logical fragmentation percentage. 이 값은 인덱스에서 순서대로 저장되어 있지 않은 페이지의 수를 나타냅니다.This indicates the number of pages in an index that are not stored in order.
평균 행 크기Average row size 리프 수준 행의 평균 크기입니다.The average size of a leaf-level row.
깊이Depth 리프 수준을 포함한 인덱스의 수준 수입니다.The number of levels in the index, including the leaf-level.
전달된 레코드Forwarded records 다른 데이터 위치로의 전달 포인터가 있는 힙의 레코드 수입니다.The number of records in a heap that have forward pointers to another data location. 이 상태는 업데이트하는 동안 원본 위치에 새 행을 저장할 공간이 충분하지 않은 경우에 발생합니다.(This state occurs during an update, when there is not enough room to store the new row in the original location.)
삭제할 행Ghost rows 삭제하도록 표시되어 있지만 아직 제거되지 않은 행의 수입니다.The number of rows that are marked as deleted but not yet removed. 이러한 행은 서버 사용량이 적을 때 정리 스레드에 의해 제거됩니다.These rows will be removed by a clean-up thread, when the server is not busy. 처리 중인 스냅샷 격리 트랜잭션으로 인해 보유된 행은 이 값에 포함되지 않습니다.This value does not include rows that are being retained due to an outstanding snapshot isolation transaction.
인덱스 유형Index type 인덱스의 유형입니다.The type of index. 가능한 값은 클러스터형 인덱스, 비클러스터형 인덱스기본 XML입니다.Possible values are Clustered index, Nonclustered index, and Primary XML. 테이블을 인덱스가 없는 힙으로 저장할 수도 있지만, 그러한 경우 이 인덱스 속성 페이지를 열 수 없습니다.Tables can also be stored as a heap (without indexes), but then this Index Properties page cannot be opened.
리프 수준 행Leaf-level rows 리프 수준 행의 수입니다.The number of leaf-level rows.
최대 행 크기Maximum row size 리프 수준 행의 최대 크기입니다.The maximum leaf-level row size.
최소 행 크기Minimum row size 리프 수준 행의 최소 크기입니다.The minimum leaf-level row size.
페이지Pages 총 데이터 페이지 수입니다.The total number of data pages.
파티션 IDPartition ID 인덱스를 포함하는 B-트리의 파티션 ID입니다.The partition ID of the b-tree containing the index.
버전 삭제할 행Version ghost rows 처리 중인 스냅샷 격리 트랜잭션으로 인해 보유하고 있는 삭제할 레코드 수입니다.The number of ghost records that are being retained due to an outstanding snapshot isolation transaction.

인덱스 다시 빌드 또는 다시 구성을 통한 인덱스 조각 모음Defragmenting indexes by rebuilding or reorganizing the index

조각화된 인덱스는 다음 방법 중 하나를 사용하여 조각 모음합니다.You defragment a fragmented index by using one of the following methods:

  • 인덱스 다시 구성Index reorganization
  • 인덱스 다시 빌드Index rebuild

참고

파티션 구성표에 빌드한 분할된 인덱스의 경우 전체 인덱스나 인덱스의 단일 파티션에서 다음 방법 중 하나를 사용할 수 있습니다.For partitioned indexes built on a partition scheme, you can use either of the following methods on a complete index or a single partition of an index.

인덱스 재구성Reorganize an index

인덱스 재구성은 최소한의 시스템 리소스를 사용하는 온라인 작업입니다.Reorganizing an index uses minimal system resources and is an online operation. 즉, 장기간 차단 테이블 잠금이 유지되지 않으며 ALTER INDEX REORGANIZE 트랜잭션 중 기본 테이블에 대한 쿼리나 업데이트를 계속할 수 있습니다.This means long-term blocking table locks are not held and queries or updates to the underlying table can continue during the ALTER INDEX REORGANIZE transaction.

  • rowstore 인덱스의 경우 데이터베이스 엔진Database Engine이 리프 노드의 논리적 순서(왼쪽에서 오른쪽)에 맞게 리프 수준 페이지를 물리적으로 다시 정렬하여 테이블과 뷰에 대한 리프 수준의 클러스터형 및 비클러스터형 인덱스를 조각 모음합니다.For rowstore indexes, the 데이터베이스 엔진Database Engine defragments the leaf level of clustered and nonclustered indexes on tables and views by physically reordering the leaf-level pages to match the logical order of the leaf nodes (left to right). 또한 재구성을 통해 인덱스 페이지가 인덱스의 채우기 비율 값에 따라 압축됩니다.Reorganizing also compacts the index pages based on the index's fill factor value. 채우기 비율 설정을 보려면 sys.indexes를 사용하세요.To view the fill factor setting, use sys.indexes. 구문 예제는 예제: Rowstore 재구성을 참조하세요.For syntax examples, see Examples: Rowstore reorganize.

  • columnstore 인덱스를 사용하는 경우 시간 경과에 따라 데이터를 삽입, 업데이트 및 삭제함으로써 델타 저장소가 여러 개의 작은 행 그룹으로 분할될 수 있습니다.When using columnstore indexes, the delta store may end up with multiple small rowgroups after inserting, updating, and deleting data over time. columnstore 인덱스를 재구성하면 모든 행 그룹이 columnstore에 강제로 포함되고, 행 그룹이 더 많은 행을 포함하는 소수의 행 그룹으로 결합됩니다.Reorganizing a columnstore index forces all of the rowgroups into the columnstore, and then combines the rowgroups into fewer rowgroups with more rows. 또한 재구성 작업은 columnstore에서 삭제된 행을 제거합니다.The reorganize operation also removes rows that have been deleted from the columnstore. 처음 재구성하는 경우 데이터 압축을 위해 추가 CPU 리소스가 필요하므로 전반적인 시스템 성능이 느려질 수 있습니다.Reorganizing initially requires additional CPU resources to compress the data, which may slow overall system performance. 하지만 데이터가 압축되는 즉시 쿼리 성능이 향상됩니다.However, as soon as the data is compressed, query performance improves. 구문 예제는 예제: ColumnStore 재구성을 참조하세요.For syntax examples, see Examples: ColumnStore reorganize.

인덱스 다시 작성Rebuild an index

인덱스를 다시 작성하면 이 인덱스가 삭제된 다음 다시 생성됩니다.Rebuilding an index drops and re-creates the index. 인덱스 유형 및 데이터베이스 엔진Database Engine 버전에 따라 온라인이나 오프라인에서 다시 빌드 작업을 수행할 수 있습니다.Depending on the type of index and 데이터베이스 엔진Database Engine version, a rebuild operation can be done online or offline. T-SQL 구문에 대한 자세한 내용은 ALTER INDEX REBUILD를 참조하세요.For the T-SQL syntax, see ALTER INDEX REBUILD

  • rowstore 인덱스의 경우 다시 빌드하면 조각화가 제거되고, 지정된 채우기 비율 또는 기존 채우기 비율 설정을 기준으로 페이지를 압축하여 디스크 공간이 회수되며, 인덱스 행이 연속된 페이지로 다시 정렬됩니다.For rowstore indexes, rebuilding removes fragmentation, reclaims disk space by compacting the pages based on the specified or existing fill factor setting, and reorders the index rows in contiguous pages. ALL을 지정하면 테이블의 모든 인덱스가 단일 트랜잭션으로 삭제되고 다시 작성됩니다.When ALL is specified, all indexes on the table are dropped and rebuilt in a single transaction. 외래 키 제약 조건은 미리 삭제하지 않아도 됩니다.Foreign key constraints do not have to be dropped in advance. 익스텐트가 128개 이상인 인덱스를 다시 작성하면 데이터베이스 엔진Database Engine에서 실제 페이지 할당 취소와 해당 관련 잠금이 트랜잭션 커밋 후까지 지연됩니다.When indexes with 128 extents or more are rebuilt, the 데이터베이스 엔진Database Engine defers the actual page deallocations, and their associated locks, until after the transaction commits. 구문 예제는 예제: Rowstore 재구성을 참조하세요.For syntax examples, see Examples: Rowstore reorganize.

  • columnstore 인덱스의 경우 다시 빌드하면 조각화가 제거되고, 모든 행이 columnstore로 이동되며, 테이블에서 논리적으로 삭제된 행을 물리적으로 삭제하여 디스크 공간이 회수됩니다.For columnstore indexes, rebuilding removes fragmentation, moves all rows into the columnstore, and reclaims disk space by physically deleting rows that have been logically deleted from the table.

    SQL Server 2016(13.x)SQL Server 2016 (13.x)부터는 온라인 작업과 같이 REORGANIZE가 백그라운드에서 필수 재빌드를 수행하므로 columnstore 인덱스를 다시 빌드할 필요가 없습니다.Starting with SQL Server 2016(13.x)SQL Server 2016 (13.x), rebuilding the columnstore index is usually not needed since REORGANIZE performs the essentials of a rebuild in the background as an online operation.

    구문 예제는 예제: ColumnStore rebuild(ColumnStore 다시 빌드)를 참조하세요.For syntax examples, see Examples: ColumnStore rebuild.

권한Permissions

테이블 또는 보기에 대한 ALTER 권한이 필요합니다.Requires ALTER permission on the table or view. 사용자는 다음 역할 중 하나 이상의 멤버여야 합니다.User must be a member of at least one of the following roles:

  • db_ddladmin 데이터베이스 역할 1db_ddladmin database role 1
  • db_owner 데이터베이스 역할db_owner database role
  • sysadmin 서버 역할sysadmin server role

1db_ddladmin 데이터베이스 역할은 최소 권한입니다.1db_ddladmin database role is the least privileged.

SQL Server Management StudioSQL Server Management Studio를 사용하여 조각화 제거Remove fragmentation using SQL Server Management StudioSQL Server Management Studio

인덱스를 다시 구성하거나 다시 작성하려면To reorganize or rebuild an index

  1. 개체 탐색기에서 인덱스를 다시 구성할 테이블이 포함된 데이터베이스를 확장합니다.In Object Explorer, Expand the database that contains the table on which you want to reorganize an index.
  2. 테이블 폴더를 확장합니다.Expand the Tables folder.
  3. 인덱스를 다시 구성할 테이블을 확장합니다.Expand the table on which you want to reorganize an index.
  4. 인덱스 폴더를 확장합니다.Expand the Indexes folder.
  5. 다시 구성할 인덱스를 마우스 오른쪽 단추로 클릭하고 다시 구성을 선택합니다.Right-click the index you want to reorganize and select Reorganize.
  6. 인덱스 다시 구성 대화 상자에서 다시 구성할 인덱스 표에 올바른 인덱스가 있는지 확인한 다음 확인을 클릭합니다.In the Reorganize Indexes dialog box, verify that the correct index is in the Indexes to be reorganized grid and click OK.
  7. 큰 개체 열 데이터 압축 확인란을 선택하여 LOB(Large Object) 데이터가 포함된 모든 페이지도 압축되도록 지정합니다.Select the Compact large object column data check box to specify that all pages that contain large object (LOB) data are also compacted.
  8. 확인.Click OK.

테이블의 모든 인덱스를 다시 구성하려면To reorganize all indexes in a table

  1. 개체 탐색기에서 인덱스를 다시 구성할 테이블이 포함된 데이터베이스를 확장합니다.In Object Explorer, Expand the database that contains the table on which you want to reorganize the indexes.
  2. 테이블 폴더를 확장합니다.Expand the Tables folder.
  3. 인덱스를 다시 구성할 테이블을 확장합니다.Expand the table on which you want to reorganize the indexes.
  4. 인덱스 폴더를 마우스 오른쪽 단추로 클릭하고 모두 다시 구성을 선택합니다.Right-click the Indexes folder and select Reorganize All.
  5. 인덱스 다시 구성 대화 상자에서 다시 구성할 인덱스에 올바른 인덱스가 있는지 확인합니다.In the Reorganize Indexes dialog box, verify that the correct indexes are in the Indexes to be reorganized. 다시 구성할 인덱스 표에서 인덱스를 제거하려면 인덱스를 선택한 다음 Delete 키를 누릅니다.To remove an index from the Indexes to be reorganized grid, select the index and then press the Delete key.
  6. 큰 개체 열 데이터 압축 확인란을 선택하여 LOB(Large Object) 데이터가 포함된 모든 페이지도 압축되도록 지정합니다.Select the Compact large object column data check box to specify that all pages that contain large object (LOB) data are also compacted.
  7. 확인.Click OK.

인덱스를 다시 작성하려면To rebuild an index

  1. 개체 탐색기에서 인덱스를 다시 구성할 테이블이 포함된 데이터베이스를 확장합니다.In Object Explorer, Expand the database that contains the table on which you want to reorganize an index.
  2. 테이블 폴더를 확장합니다.Expand the Tables folder.
  3. 인덱스를 다시 구성할 테이블을 확장합니다.Expand the table on which you want to reorganize an index.
  4. 인덱스 폴더를 확장합니다.Expand the Indexes folder.
  5. 다시 구성할 인덱스를 마우스 오른쪽 단추로 클릭하고 다시 작성을 선택합니다.Right-click the index you want to reorganize and select Rebuild.
  6. 인덱스 다시 작성 대화 상자에서 다시 작성할 인덱스 표에 올바른 인덱스가 있는지 확인한 다음 확인을 클릭합니다.In the Rebuild Indexes dialog box, verify that the correct index is in the Indexes to be rebuilt grid and click OK.
  7. 큰 개체 열 데이터 압축 확인란을 선택하여 LOB(Large Object) 데이터가 포함된 모든 페이지도 압축되도록 지정합니다.Select the Compact large object column data check box to specify that all pages that contain large object (LOB) data are also compacted.
  8. 확인.Click OK.

Transact-SQLTransact-SQL를 사용하여 조각화 제거Remove fragmentation using Transact-SQLTransact-SQL

참고

Transact-SQLTransact-SQL을 사용하여 인덱스를 다시 빌드하거나 다시 구성하는 방법에 대한 예를 알아보려면 ALTER 인덱스 예: Columnstore 인덱스ALTER 인덱스 예: Rowstore 인덱스를 참조하세요.For more examples about using Transact-SQLTransact-SQL to rebuild or reorganize indexes, see ALTER INDEX Examples: Columnstore Indexes and ALTER INDEX Examples: Rowstore Indexes.

조각난 인덱스를 다시 구성하려면To reorganize a fragmented index

다음 예에서는 AdventureWorks2016 데이터베이스에서 HumanResources.Employee 테이블의 IX_Employee_OrganizationalLevel_OrganizationalNode 인덱스를 다시 구성합니다.The following example reorganizes the IX_Employee_OrganizationalLevel_OrganizationalNode index on the HumanResources.Employee table in the AdventureWorks2016 database.

ALTER INDEX IX_Employee_OrganizationalLevel_OrganizationalNode
    ON HumanResources.Employee
    REORGANIZE;

다음 예에서는 AdventureWorksDW2016 데이터베이스의 dbo.FactResellerSalesXL_CCI 테이블에서 IndFactResellerSalesXL_CCI columnstore 인덱스를 다시 구성합니다.The following example reorganizes the IndFactResellerSalesXL_CCI columnstore index on the dbo.FactResellerSalesXL_CCI table in the AdventureWorksDW2016 database.

-- This command will force all CLOSED and OPEN rowgroups into the columnstore.
ALTER INDEX IndFactResellerSalesXL_CCI
    ON FactResellerSalesXL_CCI
    REORGANIZE WITH (COMPRESS_ALL_ROW_GROUPS = ON);

테이블의 모든 인덱스를 다시 구성하려면To reorganize all indexes in a table

다음 예에서는 AdventureWorks2016 데이터베이스의 HumanResources.Employee 테이블에 있는 모든 인덱스를 다시 구성합니다.The following example reorganizes all indexes on the HumanResources.Employee table in the AdventureWorks2016 database.

ALTER INDEX ALL ON HumanResources.Employee
   REORGANIZE;

조각난 인덱스를 다시 작성하려면To rebuild a fragmented index

다음 예에서는 AdventureWorks2016 데이터베이스에 있는 Employee 테이블의 단일 인덱스를 다시 작성합니다.The following example rebuilds a single index on the Employee table in the AdventureWorks2016 database.

ALTER INDEX PK_Employee_BusinessEntityID ON HumanResources.Employee
REBUILD
;

테이블에서 모든 인덱스를 다시 작성하려면To rebuild all indexes in a table

다음 예에서는 ALL 키워드를 사용하여 AdventureWorks2016 데이터베이스의 테이블과 연결된 모든 인덱스를 다시 빌드합니다.The following example rebuilds all indexes associated with the table in the AdventureWorks2016 database using the ALL keyword. 3개의 옵션이 지정됩니다.Three options are specified.

ALTER INDEX ALL ON Production.Product
REBUILD WITH (FILLFACTOR = 80, SORT_IN_TEMPDB = ON,
              STATISTICS_NORECOMPUTE = ON)
;

자세한 내용은 ALTER INDEX(Transact-SQL)를 참조하세요.For more information, see ALTER INDEX (Transact-SQL).

자동 인덱스 및 통계 관리Automatic index and statistics management

Adaptive Index Defrag와 같은 솔루션을 사용하여 하나 이상의 데이터베이스에 대한 인덱스 조각 모음 및 통계 업데이트를 자동으로 관리합니다.Leverage solutions such as Adaptive Index Defrag to automatically manage index defragmentation and statistics updates for one or more databases. 이 절차는 다른 매개 변수 사이에서 조각화 수준에 따라 인덱스를 다시 작성하거나 다시 구성할지 여부를 자동으로 선택하고 통계를 선형 임계값으로 업데이트합니다.This procedure automatically chooses whether to rebuild or reorganize an index according to its fragmentation level, amongst other parameters, and update statistics with a linear threshold.

rowstore 인덱스 다시 빌드 관련 고려 사항Considerations specific to rebuilding rowstore indexes

클러스터형 인덱스를 다시 빌드할 경우 비클러스터형 인덱스 레코드에 포함된 물리적 또는 논리적 식별자를 변경해야 하면 클러스터링 키를 참조하는 비클러스터형 인덱스가 자동으로 다시 빌드됩니다.Rebuilding a clustered index automatically rebuilds any nonclustered index that reference the clustering key, if the physical or logical identifiers contained in the nonclustered index records need to change.

다음 시나리오에서는 테이블의 모든 rowstore 비클러스터형 인덱스가 자동으로 다시 빌드되도록 강제 적용합니다.The following scenarios force all rowstore nonclustered indexes on a table to be automatically rebuilt:

  • 테이블에서 클러스터형 인덱스 만들기Creating a clustered index on a table
  • 클러스터형 인덱스를 제거하면 테이블이 힙으로 저장됨Removing a clustered index, which causes the table to be stored as a heap
  • 열을 포함하거나 제외하도록 클러스터링 키 변경Changing the clustering key to include or exclude columns

다음 시나리오에서는 테이블의 모든 rowstore 비클러스터형 인덱스가 자동으로 다시 빌드되도록 요구하지 않습니다.The following scenarios do not require all rowstore nonclustered indexes to be automatically rebuilt on a table:

  • 고유한 클러스터형 인덱스 다시 작성Rebuilding a unique clustered index
  • 고유하지 않은 클러스터형 인덱스 다시 작성Rebuilding a non-unique clustered index
  • 인덱스 스키마 변경(예: 클러스터형 인덱스에 파티션 구성표 적용 또는 클러스터형 인덱스를 다른 파일 그룹으로 이동)Changing the index schema, such as applying a partitioning scheme to a clustered index or moving the clustered index to a different filegroup

중요

인덱스가 위치한 파일 그룹이 오프라인이거나 읽기 전용으로 설정되어 있으면 인덱스를 다시 구성할 수 없습니다.An index cannot be reorganized or rebuilt if the filegroup in which it is located is offline or set to read-only. ALL 키워드를 지정하면 하나 이상의 인덱스가 오프라인 또는 읽기 전용 파일 그룹에 있을 경우 해당 문이 실패합니다.When the keyword ALL is specified and one or more indexes are in an offline or read-only filegroup, the statement fails.

인덱스를 다시 빌드하는 동안 물리적 미디어에는 인덱스의 두 복사본을 저장할 수 있는 충분한 공간이 있어야 합니다.While an index rebuild occurs, the physical media must have enough space to store two copies of the index. 다시 빌드 작업이 끝나면 데이터베이스 엔진Database Engine이 원래 인덱스를 삭제합니다.When the rebuild is finished, the 데이터베이스 엔진Database Engine deletes the original index.

ALLALTER INDEX 문으로 지정하면 테이블에서 관계형 인덱스, 클러스터형 및 비클러스터형 인덱스 모두와 XML 인덱스가 다시 구성됩니다.When ALL is specified with the ALTER INDEX statement, relational indexes, both clustered and nonclustered, and XML indexes on the table are reorganized.

Columnstore 인덱스 다시 빌드 관련 고려 사항Considerations specific to rebuilding a columnstore index

Columnstore 인덱스를 다시 빌드하는 경우 데이터베이스 엔진Database Engine는 델타 저장소를 비롯하여 원래 columnstore 인덱스에서 모든 데이터를 읽습니다.When rebuilding a columnstore index, the 데이터베이스 엔진Database Engine reads all data from the original columnstore index, including the delta store. 데이터를 새 행 그룹으로 결합하고 행 그룹을 columnstore로 압축합니다.It combines the data into new rowgroups, and compresses the rowgroups into the columnstore. 데이터베이스 엔진Database Engine은 테이블에서 논리적으로 삭제된 행을 물리적으로 삭제하여 columnstore를 조각 모음합니다.The 데이터베이스 엔진Database Engine defragments the columnstore by physically deleting rows that have been logically deleted from the table. 삭제된 바이트는 디스크에서 회수됩니다.The deleted bytes are reclaimed on the disk.

참고

Management StudioManagement Studio를 사용하여 columnstore 인덱스를 다시 구성하면 COMPRESSED 행 그룹이 함께 결합되지만 모든 행 그룹이 columnstore로 강제 압축되는 것은 아닙니다.Reorganizing a columnstore index using Management StudioManagement Studio will combine COMPRESSED rowgroups together, but does not force all rowgroups to be compressed into the columnstore. CLOSED 행 그룹은 압축되지만 OPEN 행 그룹은 columnstore로 압축되지 않습니다.CLOSED rowgroups will be compressed but OPEN rowgroups will not be compressed into the columnstore. 모든 행 그룹을 강제 압축하려면 아래Transact-SQLTransact-SQL 예를 사용하세요.To forcibly compress all rowgroups, use the Transact-SQLTransact-SQL example below.

참고

SQL Server 2019 (15.x)SQL Server 2019 (15.x)부터는 내부 임계값에 따라 특정 시간 동안 존재하던 더 작은 OPEN 델타 행 그룹을 자동으로 압축하거나 다수의 행이 삭제된 위치에서 COMPRESSED 행 그룹을 병합하는 백그라운드 병합 작업이 튜플 이동기를 지원합니다.Starting with SQL Server 2019 (15.x)SQL Server 2019 (15.x), the tuple-mover is helped by a background merge task that automatically compresses smaller OPEN delta rowgroups that have existed for some time as determined by an internal threshold, or merges COMPRESSED rowgroups from where a large number of rows has been deleted. 이번 변경 덕분에 지속적으로 columnstore 인덱스 품질이 향상됩니다.This improves the columnstore index quality over time.
columnstore 용어 및 개념에 대한 자세한 내용은 columnstore 인덱스: 개요를 참조하세요.For more information about columnstore terms and concepts, see Columnstore indexes: Overview.

전체 테이블 대신 파티션 다시 빌드Rebuild a partition instead of the entire table

  • 인덱스가 큰 경우 전체 테이블을 다시 작성하려면 많은 시간이 소요되고 다시 작성 중에 인덱스의 추가 복사본을 저장할 수 있는 충분한 디스크 공간이 필요합니다.Rebuilding the entire table takes a long time if the index is large, and it requires enough disk space to store an additional copy of the index during the rebuild. 일반적으로 가장 최근에 사용한 파티션만 다시 작성하면 됩니다.Usually it is only necessary to rebuild the most recently used partition.
  • 분할된 테이블의 경우 최근 수정된 파티션에서만 주로 조각화가 발생하므로 전체 columnstore 인덱스를 다시 작성할 필요는 없습니다.For partitioned tables, you do not need to rebuild the entire columnstore index because fragmentation is likely to occur in only the partitions that have been modified recently. 팩트 테이블 및 대규모 차원 테이블은 일반적으로 테이블 청크에서 백업 및 관리 작업을 수행하기 위해 분할됩니다.Fact tables and large dimension tables are usually partitioned in order to perform backup and management operations on chunks of the table.

리소스 사용량이 많은 DML 작업 후 파티션 다시 빌드Rebuild a partition after heavy DML operations

파티션을 다시 빌드하면 파티션을 조각 모음하고 디스크 스토리지를 줄일 수 있습니다.Rebuilding a partition defragments the partition and reduces disk storage. 다시 빌드하면 columnstore에서 삭제 표시된 모든 행이 삭제되고, 델타 저장소의 모든 행 그룹이 columnstore로 이동됩니다.Rebuilding deletes all rows from the columnstore that are marked for deletion and moves all rowgroups from the delta store into the columnstore. 델타 저장소에는 1백만 개 미만의 행을 포함하는 여러 행 그룹이 있을 수 있습니다.There can be multiple rowgroups in the delta store that have less than one million rows.

데이터를 로드한 후 파티션 다시 빌드Rebuild a partition after loading data

데이터를 로드한 후 파티션을 다시 빌드하면 모든 데이터가 columnstore에 저장됩니다.Rebuilding a partition after loading date ensures all data is stored in the columnstore. 동시에 동일한 파티션으로 100,000행 미만을 로드하는 각 동시 프로세스의 경우 파티션에는 여러 델타 저장소가 있을 수 있습니다.When concurrent processes each load less than 100,000 rows into the same partition at the same time, the partition can end up with multiple delta stores. 다시 빌드하면 델타 저장소의 모든 행이 columnstore로 이동됩니다.Rebuilding moves all delta store rows into the columnstore.

Columnstore 인덱스 다시 구성 관련 고려 사항Considerations specific to reorganizing a columnstore index

columnstore 인덱스를 다시 구성하는 경우 데이터베이스 엔진Database Engine는 압축된 행 그룹으로 CLOSED 각 델타 행 그룹을 columnstore로 압축합니다.When reorganizing a columnstore index, the 데이터베이스 엔진Database Engine compresses each CLOSED delta rowgroup into the columnstore as a compressed rowgroup. SQL Server 2016(13.x)SQL Server 2016 (13.x)부터 및 Azure SQL DatabaseAzure SQL Database에서 REORGANIZE 명령은 다음과 같은 추가 조각 모음 최적화를 온라인으로 수행합니다.Starting with SQL Server 2016(13.x)SQL Server 2016 (13.x) and in Azure SQL DatabaseAzure SQL Database, the REORGANIZE command performs the following additional defragmentation optimizations online:

  • 행의 10% 이상이 논리적으로 삭제된 경우 rowgroup에서 행을 물리적으로 제거합니다.Physically removes rows from a rowgroup when 10% or more of the rows have been logically deleted. 삭제된 바이트는 물리적 미디어에서 회수됩니다.The deleted bytes are reclaimed on the physical media. 예를 들어 행 1백만 개의 압축된 행 그룹이 삭제된 행 10만 개를 포함하는 경우, SQL ServerSQL Server는 삭제된 행을 제거하고 행이 90만 개인 rowgroup을 다시 압축합니다.For example, if a compressed row group of 1 million rows has 100K rows deleted, SQL ServerSQL Server will remove the deleted rows and recompress the rowgroup with 900k rows. 즉, 삭제된 행을 제거하여 스토리지를 절약합니다.It saves on the storage by removing deleted rows.

  • 하나 이상의 압축된 rowgroup을 결합하여 rowgroup당 행 수를 최대 1,048,576개로 증가시킵니다.Combines one or more compressed rowgroups to increase rows per rowgroup up to the maximum of 1,048,576 rows. 예를 들어 행 102,400개의 대량 가져오기 5회를 수행하면 압축된 rowgroup 5개를 얻습니다.For example, if you bulk import 5 batches of 102,400 rows you will get 5 compressed rowgroups. REORGANIZE를 실행하면 이러한 rowgroup이 크기 512,000행의 압축된 rowgroup 1개로 병합됩니다.If you run REORGANIZE, these rowgroups will get merged into 1 compressed rowgroup of size 512,000 rows. 이때 사전 크기 또는 메모리 제한이 없는 것으로 가정합니다.This assumes there were no dictionary size or memory limitations.

  • 행의 10% 이상이 논리적으로 삭제된 행 그룹의 경우 데이터베이스 엔진Database Engine는 이 행 그룹을 하나 이상의 행 그룹과 결합하려고 시도합니다.For rowgroups in which 10% or more of the rows have been logically deleted, the 데이터베이스 엔진Database Engine tries to combine this rowgroup with one or more rowgroups. 예를 들어 rowgroup 1이 행 500,000개를 사용하여 압축된다면 rowgroup 21은 최대 1,048,576개의 행을 사용하여 압축됩니다.For example, rowgroup 1 is compressed with 500,000 rows and rowgroup 21 is compressed with the maximum of 1,048,576 rows. 즉, rowgroup 21은 삭제된 행 60%와 남은 행 409,830개를 포함합니다.Rowgroup 21 has 60% of the rows deleted which leaves 409,830 rows. 데이터베이스 엔진Database Engine는 이러한 두 행 그룹을 결합하여 909,830개의 행을 포함한 새 행 그룹을 압축하는 방법을 선호합니다.The 데이터베이스 엔진Database Engine favors combining these two rowgroups to compress a new rowgroup that has 909,830 rows.

데이터 로드를 수행하면 델타 저장소에 여러 개의 작은 행 그룹을 포함할 수 있습니다.After performing data loads, you can have multiple small rowgroups in the delta store. ALTER INDEX REORGANIZE를 사용하여 모든 rowgroup을 columnstore로 강제한 후 rowgroup을 열이 더 많은 소수의 rowgroup으로 결합합니다.You can use ALTER INDEX REORGANIZE to force all of the rowgroups into the columnstore, and then to combine the rowgroups into fewer rowgroups with more rows. 또한, 재구성 작업은 columnstore에서 삭제된 행도 제거합니다.The reorganize operation will also remove rows that have been deleted from the columnstore.

제한 사항Limitations and restrictions

128 익스텐트가 넘는 Rowstore 인덱스는 논리적 단계와 물리적 단계로 나누어 다시 빌드합니다.Rowstore indexes with more than 128 extents are rebuilt in two separate phases: logical and physical. 논리적 단계에서는 인덱스에 의해 사용되는 기존 할당 단위가 할당 취소 상태로 표시되며 데이터 행이 복사되어 정렬된 후 다시 작성된 인덱스를 저장하기 위해 생성된 새 할당 단위로 옮겨집니다.In the logical phase, the existing allocation units used by the index are marked for deallocation, the data rows are copied and sorted, then moved to new allocation units created to store the rebuilt index. 물리적 단계에서는 이전에 할당 취소 상태로 표시된 할당 단위가 백그라운드로 실행되는 짧은 트랜잭션을 통해 물리적으로 삭제됩니다. 이 단계는 잠금을 많이 필요로 하지 않습니다.In the physical phase, the allocation units previously marked for deallocation are physically dropped in short transactions that happen in the background, and do not require many locks. 익스텐트에 대한 자세한 내용은 페이지 및 익스텐트 아키텍처 가이드를 참조하세요.For more information about extents, see Pages and Extents Architecture Guide.

ALTER INDEX REORGANIZE 문을 사용하려는 경우 작업에서 파일 그룹 내의 다른 파일이 아닌 동일한 파일에만 임시 작업 페이지를 할당할 수 있으므로 인덱스가 포함된 데이터 파일에 사용 가능한 공간이 있어야 합니다.The ALTER INDEX REORGANIZE statement requires the data file containing the index to have space available, because the operation can only allocate temporary work pages on the same file, not in another file within the filegroup. 따라서 파일 그룹에 사용 가능한 페이지가 있을 수 있지만 사용자는 여전히 오류 1105: Could not allocate space for object '###' in database '###' because the '###' filegroup is full. Create disk space by deleting unneeded files, dropping objects in the filegroup, adding additional files to the filegroup, or setting autogrowth on for existing files in the filegroup.이 발생할 수 있습니다.So although the filegroup might have free pages available, the user can still encounter error 1105: Could not allocate space for object '###' in database '###' because the '###' filegroup is full. Create disk space by deleting unneeded files, dropping objects in the filegroup, adding additional files to the filegroup, or setting autogrowth on for existing files in the filegroup.

경고

파티션 수가 1,000개를 초과하는 테이블에서 정렬되지 않은 인덱스를 만들거나 다시 작성할 수 있지만 해당 인덱스는 지원되지 않습니다.Creating and rebuilding nonaligned indexes on a table with more than 1,000 partitions is possible, but is not supported. 그러면 작업 중에 성능이 저하되거나 메모리가 과도하게 소비될 수 있습니다.Doing so may cause degraded performance or excessive memory consumption during these operations. 파티션 수가 1,000개를 초과하는 경우 정렬된 인덱스만 사용하는 것이 좋습니다.Microsoft recommends using only aligned indexes when the number of partitions exceed 1,000.

인덱스가 있는 파일 그룹이 오프라인이거나 읽기 전용으로 설정되어 있으면 인덱스를 다시 구성하거나 빌드할 수 없습니다.An index cannot be reorganized or rebuilt if the filegroup in which it is located is offline or set to read-only. ALL 키워드를 지정하면 하나 이상의 인덱스가 오프라인 또는 읽기 전용 파일 그룹에 있을 경우 해당 문이 실패합니다.When the keyword ALL is specified and one or more indexes are in an offline or read-only filegroup, the statement fails.

통계:Statistics:

  • 인덱스를 생성하거나 다시 빌드하는 경우 테이블의 모든 행을 검사하여 통계가 생성되거나 업데이트됩니다.When an index is created or rebuilt, statistics are created or updated by scanning all the rows in the table. 하지만 SQL Server 2012(11.x)SQL Server 2012 (11.x)부터 분할된 인덱스를 만들거나 다시 작성할 때 테이블의 모든 행을 검사하여 통계를 만들거나 업데이트하지 않습니다.However, starting with SQL Server 2012(11.x)SQL Server 2012 (11.x), statistics are not created or updated by scanning all the rows in the table when a partitioned index is created or rebuilt. 대신 쿼리 최적화 프로그램에서 기본 샘플링 알고리즘을 사용하여 이러한 통계를 생성합니다.Instead, the Query Optimizer uses the default sampling algorithm to generate these statistics. 테이블의 모든 행을 검사하여 분할된 인덱스에 대한 통계를 얻으려면 FULLSCAN 절에서 CREATE STATISTICS 또는 UPDATE STATISTICS를 사용합니다.To obtain statistics on partitioned indexes by scanning all the rows in the table, use CREATE STATISTICS or UPDATE STATISTICS with the FULLSCAN clause.

  • 인덱스를 재구성하는 경우에는 통계가 업데이트되지 않습니다.When an index is reorganized, statistics are not updated.

ALLOW_PAGE_LOCKS가 OFF로 설정되면 인덱스를 다시 구성할 수 없습니다.An index cannot be reorganized when ALLOW_PAGE_LOCKS is set to OFF.

SQL Server 2017(14.x)SQL Server 2017 (14.x)까지는 클러스터형 columnstore 인덱스를 다시 빌드하는 것은 오프라인 작업입니다.Up to SQL Server 2017(14.x)SQL Server 2017 (14.x), rebuilding a clustered columnstore index is an offline operation. 다시 빌드하는 동안 데이터베이스 엔진이 테이블 또는 파티션에 대한 배타적 잠금을 획득해야 합니다.The database engine has to acquire an exclusive lock on the table or partition while the rebuild occurs. 데이터는 오프라인 상태이며 NOLOCK, RCSI(읽기 커밋된 스냅숏 격리) 또는 스냅숏 격리를 사용하는 경우에도 다시 빌드하는 동안에는 사용할 수 없습니다.The data is offline and unavailable during the rebuild even when using NOLOCK, Read-committed Snapshot Isolation (RCSI), or Snapshot Isolation. SQL Server 2019 (15.x)SQL Server 2019 (15.x)부터 ONLINE = ON 옵션을 사용하여 클러스터형 columnstore 인덱스를 다시 빌드할 수 있습니다.Starting with SQL Server 2019 (15.x)SQL Server 2019 (15.x), a clustered columnstore index can be rebuilt using the ONLINE = ON option.

순서가 지정된 클러스터형 columnstore 인덱스가 포함된 Azure Synapse Analytics(이전의 Azure Synapse Analytics(SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse)) 테이블에 대해 ALTER INDEX REBUILD를 실행하는 경우 TempDB를 사용하여 데이터가 다시 정렬됩니다.For an Azure Synapse Analytics (formerly Azure Synapse Analytics(SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse)) table with an ordered clustered columnstore index, ALTER INDEX REBUILD will re-sort the data using TempDB. 다시 빌드 작업 중에 TempDB를 모니터링합니다.Monitor TempDB during rebuild operations. TempDB 공간이 더 필요하면 데이터 웨어하우스를 통해 규모를 확장할 수 있습니다.If you need more TempDB space, scale up the data warehouse. 인덱스 다시 빌드가 완료되면 다시 크기를 줄입니다.Scale back down once the index rebuild is complete.

순서가 지정된 클러스터형 columnstore 인덱스가 포함된 Azure Synapse Analytics(이전의 Azure Synapse Analytics(SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse)) 테이블에 대해 ALTER INDEX REORGANIZE가 데이터를 다시 정렬하지 않습니다.For an Azure Synapse Analytics (formerly Azure Synapse Analytics(SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse)) table with an ordered clustered columnstore index, ALTER INDEX REORGANIZE does not re-sort the data. 데이터를 다시 정렬하려면 ALTER INDEX REBUILD를 사용하세요.To resort the data use ALTER INDEX REBUILD.

INDEX REBUILD를 사용하여 하드웨어 오류 복구Using INDEX REBUILD to recover from hardware failures

이전 버전의 SQL ServerSQL Server에서는 rowstore 비클러스터형 인덱스를 다시 빌드하여 하드웨어 오류로 인한 불일치를 해결할 수 있는 경우도 있습니다.In earlier versions of SQL ServerSQL Server, you could sometimes rebuild a rowstore nonclustered index to correct inconsistencies caused by hardware failures. SQL Server 2008SQL Server 2008 이상에서도 비클러스터형 인덱스를 오프라인으로 다시 빌드하여 인덱스와 클러스터형 인덱스 간의 불일치를 복구할 수 있습니다.Starting with SQL Server 2008SQL Server 2008, you may still be able to repair such inconsistencies between the index and the clustered index by rebuilding a nonclustered index offline. 그러나 인덱스를 온라인으로 다시 빌드하는 경우에는 비클러스터형 인덱스 간의 불일치를 해결할 수 없습니다. 온라인으로 다시 빌드하는 경우 기존의 비클러스터형 인덱스를 사용하므로 불일치가 계속 남아 있게 됩니다.However, you cannot repair nonclustered index inconsistencies by rebuilding the index online, because the online rebuild mechanism uses the existing nonclustered index as the basis for the rebuild and thus persist the inconsistency. 경우에 따라 오프라인으로 인덱스를 다시 작성하면 클러스터형 인덱스 검색 또는 힙 검색이 수행되어 불일치가 제거됩니다.Rebuilding the index offline can sometimes force a scan of the clustered index (or heap) and so remove the inconsistency. 클러스터형된 인덱스에서 다시 빌드되도록 하려면 비클러스터형 인덱스를 삭제한 후 다시 만드세요.To assure a rebuild from the clustered index, drop and recreate the nonclustered index. 이전 버전의 경우처럼 영향을 받은 데이터를 백업한 후 복원하여 불일치를 제거하는 것이 좋습니다. 비클러스터형 인덱스의 경우에는 오프라인으로 인덱스를 다시 작성하여 인덱스 간 불일치를 해결할 수 있습니다.As with earlier versions, we recommend recovering from inconsistencies by restoring the affected data from a backup; however, you may be able to repair the index inconsistencies by rebuilding the nonclustered index offline. 자세한 내용은 DBCC CHECKDB(Transact-SQL)를 참조하세요.For more information, see DBCC CHECKDB (Transact-SQL).

참고 항목See also