Tại sao các khóa GUID tuần tự thực hiện nhanh hơn các khóa INT tuần tự trong trường hợp thử nghiệm của tôi?


39

Sau khi đặt câu hỏi này để so sánh các GUID tuần tự và không tuần tự, tôi đã thử so sánh hiệu suất INSERT trên 1) một bảng với khóa chính GUID được khởi tạo tuần tự với newsequentialid()và 2) một bảng có khóa chính INT được khởi tạo tuần tự với identity(1,1). Tôi hy vọng cái sau sẽ nhanh nhất vì độ rộng của số nguyên nhỏ hơn và việc tạo một số nguyên tuần tự có vẻ đơn giản hơn so với GUID tuần tự. Nhưng thật ngạc nhiên, các INSERT trên bảng có khóa số nguyên chậm hơn đáng kể so với bảng GUID tuần tự.

Điều này cho thấy thời gian sử dụng trung bình (ms) cho các lần chạy thử:

NEWSEQUENTIALID()  1977
IDENTITY()         2223

Bất cứ ai có thể giải thích điều này?

Thí nghiệm sau đây đã được sử dụng:

SET NOCOUNT ON

CREATE TABLE TestGuid2 (Id UNIQUEIDENTIFIER NOT NULL DEFAULT NEWSEQUENTIALID() PRIMARY KEY,
SomeDate DATETIME, batchNumber BIGINT, FILLER CHAR(100))

CREATE TABLE TestInt (Id Int NOT NULL identity(1,1) PRIMARY KEY,
SomeDate DATETIME, batchNumber BIGINT, FILLER CHAR(100))

DECLARE @BatchCounter INT = 1
DECLARE @Numrows INT = 100000


WHILE (@BatchCounter <= 20)
BEGIN 
BEGIN TRAN

DECLARE @LocalCounter INT = 0

    WHILE (@LocalCounter <= @NumRows)
    BEGIN
    INSERT TestGuid2 (SomeDate,batchNumber) VALUES (GETDATE(),@BatchCounter)
    SET @LocalCounter +=1
    END

SET @LocalCounter = 0

    WHILE (@LocalCounter <= @NumRows)
    BEGIN
    INSERT TestInt (SomeDate,batchNumber) VALUES (GETDATE(),@BatchCounter)
    SET @LocalCounter +=1
    END

SET @BatchCounter +=1
COMMIT 
END

DBCC showcontig ('TestGuid2')  WITH tableresults
DBCC showcontig ('TestInt')  WITH tableresults

SELECT batchNumber,DATEDIFF(ms,MIN(SomeDate),MAX(SomeDate)) AS [NEWSEQUENTIALID()]
FROM TestGuid2
GROUP BY batchNumber

SELECT batchNumber,DATEDIFF(ms,MIN(SomeDate),MAX(SomeDate)) AS [IDENTITY()]
FROM TestInt
GROUP BY batchNumber

DROP TABLE TestGuid2
DROP TABLE TestInt

CẬP NHẬT: Sửa đổi tập lệnh để thực hiện các phần chèn thêm dựa trên bảng TEMP, như trong các ví dụ của Phil Sandler, Mitch Wheat và Martin bên dưới, tôi cũng thấy rằng IDENTITY nhanh hơn. Nhưng đó không phải là cách chèn hàng thông thường và tôi vẫn không hiểu tại sao thử nghiệm ban đầu bị sai: ngay cả khi tôi bỏ qua GETDATE () từ ví dụ ban đầu của mình, IDENTITY () vẫn chậm hơn. Vì vậy, có vẻ như cách duy nhất để làm cho IDENTITY () vượt trội hơn NEWSEQUENTIALID () là chuẩn bị các hàng để chèn vào một bảng tạm thời và thực hiện nhiều lần chèn dưới dạng chèn hàng loạt bằng cách sử dụng bảng tạm thời này. Nói chung, tôi không nghĩ rằng chúng tôi đã tìm thấy một lời giải thích cho hiện tượng này và IDENTITY () dường như vẫn chậm hơn đối với hầu hết các cách sử dụng thực tế. Bất cứ ai có thể giải thích điều này?


4
Chỉ có một suy nghĩ: Có thể thực hiện việc tạo GUID mới mà không cần liên quan đến bảng, trong khi nhận được giá trị nhận dạng có sẵn tiếp theo giới thiệu một số loại khóa tạm thời để đảm bảo hai luồng / kết nối sẽ không có cùng giá trị? Tôi chỉ đoán thực sự. Câu hỏi thú vị!
người tức giận

4
Ai nói họ làm gì ?? Có rất nhiều bằng chứng họ không có - xem không gian đĩa của Kimberly Tripp là rẻ - đó không phải là vấn đề! bài đăng trên blog - cô ấy thực hiện đánh giá khá rộng rãi và GUID luôn luôn rõ ràng đểINT IDENTITY
marc_s

2
Vâng, thí nghiệm trên cho thấy điều ngược lại, và kết quả có thể lặp lại.
someName

2
Sử dụng IDENTITYkhông yêu cầu khóa bảng. Về mặt khái niệm tôi có thể thấy bạn có thể mong đợi nó sẽ lấy MAX (id) + 1, nhưng trong thực tế, giá trị tiếp theo được lưu trữ. Nó thực sự nên nhanh hơn việc tìm kiếm GUID tiếp theo.

4
Ngoài ra, có lẽ cột phụ cho bảng TestGuid2 phải là CHAR (88) để tạo các hàng có kích thước bằng nhau
Mitch Wheat

Câu trả lời:


19

Tôi đã sửa đổi mã của @Phil Sandler để loại bỏ hiệu ứng gọi GETDATE () (có thể có các hiệu ứng / ngắt phần cứng liên quan ??) và tạo các hàng có cùng độ dài.

[Đã có một số bài viết kể từ SQL Server 2000 liên quan đến các vấn đề về thời gian và bộ định thời độ phân giải cao, vì vậy tôi muốn giảm thiểu hiệu ứng đó.]

Trong mô hình khôi phục đơn giản với dữ liệu và tệp nhật ký có kích thước theo yêu cầu, đây là thời gian (tính bằng giây): (Được cập nhật với kết quả mới dựa trên mã chính xác bên dưới)

       Identity(s)  Guid(s)
       ---------    -----
       2.876        4.060    
       2.570        4.116    
       2.513        3.786   
       2.517        4.173    
       2.410        3.610    
       2.566        3.726
       2.376        3.740
       2.333        3.833
       2.416        3.700
       2.413        3.603
       2.910        4.126
       2.403        3.973
       2.423        3.653
    -----------------------
Avg    2.650        3.857
StdDev 0.227        0.204

Mã được sử dụng:

SET NOCOUNT ON

CREATE TABLE TestGuid2 (Id UNIQUEIDENTIFIER NOT NULL DEFAULT NEWSEQUENTIALID() PRIMARY KEY,
SomeDate DATETIME, batchNumber BIGINT, FILLER CHAR(88))

CREATE TABLE TestInt (Id Int NOT NULL identity(1,1) PRIMARY KEY,
SomeDate DATETIME, batchNumber BIGINT, FILLER CHAR(100))

DECLARE @Numrows INT = 1000000

CREATE TABLE #temp (Id int NOT NULL Identity(1,1) PRIMARY KEY, rowNum int, adate datetime)

DECLARE @LocalCounter INT = 0

--put rows into temp table
WHILE (@LocalCounter < @NumRows)
BEGIN
    INSERT INTO #temp(rowNum, adate) VALUES (@LocalCounter, GETDATE())
    SET @LocalCounter += 1
END

--Do inserts using GUIDs
DECLARE @GUIDTimeStart DateTime = GETDATE()
INSERT INTO TestGuid2 (SomeDate, batchNumber) 
SELECT adate, rowNum FROM #temp
DECLARE @GUIDTimeEnd  DateTime = GETDATE()

--Do inserts using IDENTITY
DECLARE @IdTimeStart DateTime = GETDATE()
INSERT INTO TestInt (SomeDate, batchNumber) 
SELECT adate, rowNum FROM #temp
DECLARE @IdTimeEnd DateTime = GETDATE()

SELECT DATEDIFF(ms, @IdTimeStart, @IdTimeEnd) AS IdTime, DATEDIFF(ms, @GUIDTimeStart, @GUIDTimeEnd) AS GuidTime

DROP TABLE TestGuid2
DROP TABLE TestInt
DROP TABLE #temp
GO

Sau khi đọc điều tra của @ Martin, tôi đã chạy lại với TOP được đề xuất (@num) trong cả hai trường hợp, tức là

...
--Do inserts using GUIDs
DECLARE @num INT = 2147483647; 
DECLARE @GUIDTimeStart DATETIME = GETDATE(); 
INSERT INTO TestGuid2 (SomeDate, batchNumber) 
SELECT TOP(@num) adate, rowNum FROM #temp; 
DECLARE @GUIDTimeEnd DATETIME = GETDATE();

--Do inserts using IDENTITY
DECLARE @IdTimeStart DateTime = GETDATE()
INSERT INTO TestInt (SomeDate, batchNumber) 
SELECT TOP(@num) adate, rowNum FROM #temp;
DECLARE @IdTimeEnd DateTime = GETDATE()
...

và đây là kết quả thời gian:

       Identity(s)  Guid(s)
       ---------    -----
       2.436        2.656
       2.940        2.716
       2.506        2.633
       2.380        2.643
       2.476        2.656
       2.846        2.670
       2.940        2.913
       2.453        2.653
       2.446        2.616
       2.986        2.683
       2.406        2.640
       2.460        2.650
       2.416        2.720

    -----------------------
Avg    2.426        2.688
StdDev 0.010        0.032

Tôi không thể có được kế hoạch thực hiện thực tế, vì truy vấn không bao giờ trở lại! Có vẻ như một lỗi có khả năng. (Chạy Microsoft SQL Server 2008 R2 (RTM) - 10.50.1600.1 (X64))


7
Minh họa rõ ràng yếu tố quan trọng của điểm chuẩn tốt: Hãy chắc chắn rằng bạn chỉ đo từng thứ một.
Aaronaught

Bạn có kế hoạch gì ở đây? Nó có một SORTtoán tử cho GUID không?
Martin Smith

@Martin: Xin chào, tôi đã không kiểm tra các kế hoạch (thực hiện một số việc cùng một lúc :)). Tôi sẽ có một chút sau này ...
Mitch Wheat

@Mitch - Có phản hồi nào về điều này? Tôi khá nghi ngờ điều chính mà bạn đang đo ở đây là thời gian để sắp xếp các hướng dẫn cho các phần chèn lớn, trong khi thú vị không trả lời câu hỏi ban đầu của OP về việc đưa ra lời giải thích về lý do tại sao các trình tự tuần tự thực hiện tốt hơn các cột nhận dạng trên một cột hàng chèn trong thử nghiệm của OP.
Martin Smith

2
@Mitch - Mặc dù tôi càng nghĩ về nó, tôi càng không hiểu tại sao mọi người lại muốn sử dụng NEWSEQUENTIALID. Nó sẽ làm cho chỉ mục sâu hơn, sử dụng thêm 20% trang dữ liệu trong trường hợp của OP và chỉ được đảm bảo sẽ tăng lên cho đến khi máy được khởi động lại nên có rất nhiều nhược điểm so với identity. Có vẻ như trong trường hợp này, Kế hoạch truy vấn bổ sung thêm một điều không cần thiết!
Martin Smith

19

Trên cơ sở dữ liệu mới trong mô hình khôi phục đơn giản với tệp dữ liệu có kích thước 1GB và tệp nhật ký 3GB (máy tính xách tay, cả hai tệp trên cùng một ổ đĩa) và khoảng thời gian khôi phục được đặt thành 100 phút (để tránh điểm kiểm tra làm sai lệch kết quả) kết quả tương tự với bạn với hàng duy nhất inserts.

Tôi đã thử nghiệm ba trường hợp: Đối với mỗi trường hợp tôi đã thực hiện 20 lô chèn 100.000 hàng riêng lẻ vào các bảng sau. Các kịch bản đầy đủ có thể được tìm thấy trong lịch sử sửa đổi của câu trả lời này .

CREATE TABLE TestGuid
  (
     Id          UNIQUEIDENTIFIER NOT NULL DEFAULT NEWSEQUENTIALID() PRIMARY KEY,
     SomeDate    DATETIME, batchNumber BIGINT, FILLER CHAR(100)
  )

CREATE TABLE TestId
  (
     Id          Int NOT NULL identity(1, 1) PRIMARY KEY,
     SomeDate    DATETIME, batchNumber BIGINT, FILLER CHAR(100)
  )

CREATE TABLE TestInt
  (
     Id          Int NOT NULL PRIMARY KEY,
     SomeDate    DATETIME, batchNumber BIGINT, FILLER  CHAR(100)
  )  

Đối với bảng thứ ba, các hàng được chèn kiểm tra có Idgiá trị tăng dần nhưng điều này được tự tính bằng cách tăng giá trị của biến trong một vòng lặp.

Tính trung bình thời gian thực hiện trong 20 đợt đã cho kết quả như sau.

NEWSEQUENTIALID() IDENTITY()  INT
----------------- ----------- -----------
1999              2633        1878

Phần kết luận

Vì vậy, nó chắc chắn dường như là chi phí chung của identityquá trình tạo ra chịu trách nhiệm về kết quả. Đối với số nguyên tăng tự tính toán thì kết quả sẽ phù hợp hơn nhiều với những gì sẽ được dự kiến ​​sẽ thấy khi chỉ xem xét chi phí IO.

Khi tôi đặt mã chèn được mô tả ở trên vào các quy trình được lưu trữ và xem xét, sys.dm_exec_procedure_statsnó sẽ cho kết quả như sau

proc_name      execution_count      total_worker_time    last_worker_time     min_worker_time      max_worker_time      total_elapsed_time   last_elapsed_time    min_elapsed_time     max_elapsed_time     total_physical_reads last_physical_reads  min_physical_reads   max_physical_reads   total_logical_writes last_logical_writes  min_logical_writes   max_logical_writes   total_logical_reads  last_logical_reads   min_logical_reads    max_logical_reads
-------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- -------------------- --------------------
IdentityInsert 20                   45060360             2231067              2094063              2645079              45119362             2234067              2094063              2660080              0                    0                    0                    0                    32505                1626                 1621                 1626                 6268917              315377               276833               315381
GuidInsert     20                   34829052             1742052              1696051              1833055              34900053             1744052              1698051              1838055              0                    0                    0                    0                    35408                1771                 1768                 1772                 6316837              316766               298386               316774

Vì vậy, trong những kết quả đó total_worker_timelà cao hơn khoảng 30%. Điều này thể hiện

Tổng thời lượng CPU, tính bằng micrô giây, được sử dụng bởi các lần thực hiện quy trình được lưu trữ này kể từ khi nó được biên dịch.

Vì vậy, nó chỉ đơn giản xuất hiện như thể mã tạo ra IDENTITYgiá trị tốn nhiều CPU hơn so với mã tạo ra NEWSEQUENTIALID()(Sự khác biệt giữa 2 hình là 10231308, tính trung bình khoảng 5 cách mỗi lần chèn.) Và đối với bảng này định nghĩa chi phí CPU cố định này là đủ cao để vượt xa các lần đọc và ghi logic bổ sung phát sinh do độ rộng lớn hơn của khóa. (NB: Itzik Ben Gan đã thực hiện thử nghiệm tương tự ở đây và đã tìm thấy hình phạt 2 Lời cho mỗi lần chèn)

Vậy tại sao IDENTITYnhiều CPU hơn UuidCreateSequential?

Tôi tin rằng điều này được giải thích trong bài viết này . Đối với mỗi identitygiá trị thứ mười được tạo, SQL Server phải ghi thay đổi vào các bảng hệ thống trên đĩa

Điều gì về Chèn MultiRow?

Khi 100.000 hàng được chèn vào trong một tuyên bố, tôi thấy sự khác biệt biến mất có lẽ vẫn là một lợi ích nhỏ cho GUIDtrường hợp nhưng không có kết quả cắt rõ ràng. Trung bình cho 20 đợt trong thử nghiệm của tôi là

NEWSEQUENTIALID() IDENTITY()
----------------- -----------
1016              1088

Lý do nó không có hình phạt rõ ràng trong mã của Phil và tập kết quả đầu tiên của Mitch là vì nó đã xảy ra rằng mã tôi đã sử dụng để chèn nhiều hàng được sử dụng SELECT TOP (@NumRows). Điều này ngăn cản trình tối ưu hóa ước tính chính xác số lượng hàng sẽ được chèn.

Điều này có vẻ có ích vì có một điểm bùng phát nhất định mà tại đó nó sẽ thêm một hoạt động sắp xếp bổ sung cho (được cho là tuần tự!) GUID.

Sắp xếp GUID

Thao tác sắp xếp này không bắt buộc từ văn bản giải thích trong BOL .

Tạo GUID lớn hơn bất kỳ GUID nào được tạo bởi chức năng này trước đây trên một máy tính được chỉ định kể từ khi Windows được khởi động. Sau khi khởi động lại Windows, GUID có thể bắt đầu lại từ phạm vi thấp hơn, nhưng vẫn duy nhất trên toàn cầu.

Vì vậy, dường như tôi gặp lỗi hoặc thiếu tối ưu hóa mà SQL Server không nhận ra rằng đầu ra của vô hướng tính toán sẽ được sắp xếp trước như nó đã làm cho identitycột. ( Chỉnh sửa Tôi đã báo cáo vấn đề này và vấn đề sắp xếp không cần thiết hiện đã được khắc phục ở Denali )


Không phải là nó có nhiều tác động mà chỉ vì lợi ích của sự rõ ràng, con số Denny được trích dẫn, 20 giá trị nhận dạng được lưu trong bộ nhớ cache, là không chính xác - nên là 10.
Aaron Bertrand

@AaronBertrand - Cảm ơn. Bài viết mà bạn liên kết là thông tin nhất.
Martin Smith

8

Khá đơn giản: với GUID, việc tạo số tiếp theo trong dòng sẽ rẻ hơn so với IDENTITY (Giá trị hiện tại của GUID không phải được lưu trữ, phải có IDENTITY). Điều này đúng ngay cả với NEWSEQUENTIALGUID.

Bạn có thể làm cho bài kiểm tra công bằng hơn và sử dụng SEQUENCER với CACHE lớn - rẻ hơn IDENTITY.

Nhưng như MR nói, có một số lợi thế lớn đối với GUID. Như một vấn đề thực tế, chúng có khả năng mở rộng nhiều hơn các cột IDENTITY (nhưng chỉ khi chúng KHÔNG tuần tự).

Xem: http://blog.kejser.org/2011/10/05/boosting-insert-speed-by-generating-scalable-keys/


Tôi nghĩ rằng bạn đã bỏ lỡ rằng họ đang sử dụng các hướng dẫn tuần tự.
Martin Smith

Martin: đối số cũng đúng với GUID tuần tự. IDENTITY phải được lưu trữ (để trở về giá trị cũ của chúng sau khi khởi động lại), GUID tuần tự không có giới hạn này.
Thomas Kejser

2
Có nhận ra sau khi nhận xét của tôi, bạn đang nói về việc lưu trữ liên tục thay vì lưu trữ trong bộ nhớ. 2012 cũng sử dụng bộ đệm IDENTITY. do đó khiếu nại ở đây
Martin Smith

4

Tôi bị mê hoặc bởi loại câu hỏi này. Tại sao bạn phải đăng nó vào tối thứ Sáu? :)

Tôi nghĩ ngay cả khi bài kiểm tra của bạn CHỈ nhằm mục đích đo lường hiệu suất INSERT, bạn (có thể) đã đưa ra một số yếu tố có thể gây hiểu lầm (lặp, giao dịch dài hạn, v.v.)

Tôi không hoàn toàn thuyết phục phiên bản của mình chứng minh bất cứ điều gì, nhưng nhận dạng hoạt động tốt hơn GUID trong đó (3,2 giây so với 6,8 giây trên PC tại nhà):

SET NOCOUNT ON

CREATE TABLE TestGuid2 (Id UNIQUEIDENTIFIER NOT NULL DEFAULT NEWSEQUENTIALID() PRIMARY KEY,
SomeDate DATETIME, batchNumber BIGINT, FILLER CHAR(100))

CREATE TABLE TestInt (Id Int NOT NULL identity(1,1) PRIMARY KEY,
SomeDate DATETIME, batchNumber BIGINT, FILLER CHAR(100))

DECLARE @Numrows INT = 1000000

CREATE TABLE #temp (Id int NOT NULL Identity(1,1) PRIMARY KEY, rowNum int)

DECLARE @LocalCounter INT = 0

--put rows into temp table
WHILE (@LocalCounter < @NumRows)
BEGIN
    INSERT INTO #temp(rowNum) VALUES (@LocalCounter)
    SET @LocalCounter += 1
END

--Do inserts using GUIDs
DECLARE @GUIDTimeStart DateTime = GETDATE()
INSERT INTO TestGuid2 (SomeDate, batchNumber) 
SELECT GETDATE(), rowNum FROM #temp
DECLARE @GUIDTimeEnd  DateTime = GETDATE()

--Do inserts using IDENTITY
DECLARE @IdTimeStart DateTime = GETDATE()
INSERT INTO TestInt (SomeDate, batchNumber) 
SELECT GETDATE(), rowNum FROM #temp
DECLARE @IdTimeEnd DateTime = GETDATE()

SELECT DATEDIFF(ms, @IdTimeStart, @IdTimeEnd) AS IdTime
SELECT DATEDIFF(ms, @GUIDTimeStart, @GUIDTimeEnd) AS GuidTime

DROP TABLE TestGuid2
DROP TABLE TestInt
DROP TABLE #temp

Yếu tố khác mà không ai nhắc đến là mô hình phục hồi cơ sở dữ liệu và tăng trưởng tệp nhật ký ...
Mitch Wheat

@Mitch trên cơ sở dữ liệu mới trong mô hình khôi phục đơn giản với dữ liệu và tệp nhật ký có kích thước vượt quá những gì được yêu cầu Tôi nhận được kết quả tương tự với OP.
Martin Smith

Tôi chỉ có thời gian 2,560 giây cho Danh tính và 3,666 giây cho Guid (trong mô hình khôi phục đơn giản với dữ liệu và tệp nhật ký có kích thước vượt quá những gì được yêu cầu)
Mitch Wheat

@Mitch - Trên tất cả mã của OP trong cùng một giao dịch hoặc trên mã của Phil?
Martin Smith

trên mã áp phích này, đó là lý do tại sao tôi bình luận ở đây. Tôi cũng đã đăng mã tôi đã sử dụng ...
Mitch Wheat

3

Tôi đã chạy tập lệnh mẫu của bạn nhiều lần để thực hiện một vài điều chỉnh về số lượng và kích thước lô (và cảm ơn bạn rất nhiều vì đã cung cấp nó).

Trước tiên tôi sẽ nói rằng bạn chỉ đo một lần khía cạnh về hiệu suất của các phím - INSERTtốc độ. Vì vậy, trừ khi bạn đặc biệt chỉ quan tâm đến việc lấy dữ liệu vào các bảng càng nhanh càng tốt cho loài động vật này.

Những phát hiện của tôi nói chung tương tự như của bạn. Tuy nhiên, tôi muốn nhắc tới điều khác biệt trong INSERTtốc độ giữa GUIDIDENTITY(int) là hơi lớn hơn với GUIDso với IDENTITY- có thể +/- 10% trong giai đoạn chạy. Các lô được sử dụng IDENTITYthay đổi ít hơn 2 - 3% mỗi lần.

Cũng cần lưu ý, hộp kiểm tra của tôi rõ ràng là ít mạnh hơn của bạn nên tôi phải sử dụng số lượng hàng nhỏ hơn.


Khi PK là GUID, có thể động cơ không sử dụng chỉ mục mà là thuật toán băm để xác định vị trí vật lý của bản ghi tương ứng? Chèn vào một bảng thưa thớt với các khóa chính được băm luôn nhanh hơn chèn vào một bảng có chỉ mục trên khóa chính do không có phí chỉ mục. Đó chỉ là một câu hỏi - đừng bỏ phiếu cho tôi nếu câu trả lời là Không. Chỉ cần cung cấp liên kết cho chính quyền.

1

Tôi sẽ quay trở lại với một đối tượng khác về stackoverflow cho cùng chủ đề này - https://stackoverflow.com/questions/170346/what-are-the-performance-improference-of-fterential-guid-over-stiteria-guid

Một điều tôi biết là có GUID tuần tự là việc sử dụng chỉ mục tốt hơn do chuyển động của lá rất ít và do đó giảm tìm kiếm HD. Tôi nghĩ rằng vì điều này, các phần chèn cũng sẽ nhanh hơn, vì nó không phải phân phối các khóa trên một số lượng lớn các trang.

Kinh nghiệm cá nhân của tôi là khi bạn đang triển khai một DB lưu lượng truy cập lớn, tốt hơn là sử dụng GUID, vì nó giúp mở rộng hơn nhiều để tích hợp với các hệ thống khác. Điều đó áp dụng cho việc nhân rộng, cụ thể và giới hạn int / bigint .... không phải là bạn sẽ hết các vấn đề lớn, mà cuối cùng bạn sẽ, và quay trở lại.


1
Bạn không chạy ra khỏi BIGINTs, không bao giờ ... Xem cái này: sqlmag.com/blog/it-possible-run-out-bigint-values
Thomas Kejser
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.