Integer GUID和Comb做主键的效率测试(Delphi+access)(三)

下面是测试数据

插入数据测试

1.       一次插入100条记录(单位:毫秒):

Integer   GUID   Comb  Comb2

60            90       30     40

70      80        81     50

60      90        50     50

60      80         80    70

70      81        80     80

61      80        80     60

30       40       40      30

 

在较多次情况下,Comb2<Integer<Comb<Guid

 

2.       一次插入1000条记录(单位:毫秒):

Integer   GUID   Comb  Comb2

  340       361      390    351

  451        340     341    320

  451       340      331    330

391       341     330     320

421       350     331     330

440      351      420     331

471       350     331     330

471      4086     571     420

 

在较多的情况下 Comb2<Comb<GUID<Integer

但是GUID的那个4086,不好解释,唯一的可能就是当时的我系统忙,我也没有做别的呀,仅运行这个测试用例而以.

 

3.        一次插入10000条记录(单位:毫秒):

Integer   GUID   Comb  Comb2

2954       3545   3405    3325

2984       3665   3505    3415

3035      3845     3676   3445

3114     3956    3575     3525

3505    8693     4316     3936

3305     4456    4216    3535

 

在较多的情况下 Integer<Comb2<Comb<Guid

 

4,补测1, 一次插入20000(单位:毫秒):

Integer   GUID   Comb  Comb2

16634    42051    45504  16444

17345    21541    19318  17555

15292    20349    34399  17716

 

已经说明情况了,GUIDComb(都是字符串)因为前面的字符没有序,且又是主键,才会出现这种情况,他们两个应该是第三和第四了

 Integer<Comb2

 

5补测1, 一次插入20记录(单位:毫秒):

Integer   GUID   Comb  Comb2

561       80       20     30

20        20       40       30

10       40         40      30

10      90         30       20

20      21          20     20

20      80           40    20

 

好了,比较稳定的还是integercomb2,在第一次启动的时候Integer耗时大了一些,基本上还是这个次序 Integer<Comb2<comb<guid

 

查询操作

1.       Count(*)(单位:毫秒):

 Integer   GUID   Comb  Comb2

 1703       80     40      1202

 10       20       20      10

 40       10       20      20

 10       20       10      10

10        10       20      20

10        20       10     20

以下数据,每行都代表程序程序重新启动

100      40        30     40

30      30          40    40

250     60          10     10

10       20         0      0   况然出现两个0!

20       20         30    40

以下数据是在程序进行补测之后的数据(多出了6W多条数据)

 

1361     832         140   12858

30        70         121     70

140       60         70      70

20        80         70      60

20        111        70      70

120       120        60     70

20        70         70      60

320      61          70      70

20      100           60     70

 

也显示出效果来了,虽然integer的表现有大起大落,不稳定,可是也拿第一了,对于GUIDcomb,comb2表现倒相差不多,特别是comb2,comb数据十分稳定,至于第一次耗时较多是因为更新数据之后在更新索引,在这方面integer也没有什么优势,虽然补测之comb2integer差了很大一块,可是guidcomb的数据确比integer好多了.

 

总体优势:Integer<Comb2<comb<GuID

 

2.       Count(单位:毫秒):

Integer   GUID   Comb  Comb2

 30        30      31      40

 10        20      10      20

10         20       20     10

40          20       10    20

 10        10       20     10

10         20       20     10

10         10       20     10

以下数据是在程序进行补测之后的数据(多出了6W多条数据)

30           60      80     70

290           71     60     70

20           70    60       70

20           111    60      70

30           100    71       70

20           110     70      71

311           60     70       80

211           170    60       70

20            120    60        70

总体来说还是integer比较有优势 comb,comb2,guid也相差不多,只不过不知道何故IntegerGUID在查询效率上不稳定.Comb,comb2确一直很稳定.

 

结论,Integer最好的情况下,comb2,comb,GuidInteger耗时的1~3,comb2,comb,guid三种情况里,也属comb2最为稳定,也最有效率.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

阅读更多
换一批

没有更多推荐了,返回首页