澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:多数据库有序GUID,集群数

2019-07-15 作者:数据库网络   |   浏览(58)

主题素材陈说

背景

广阔的一种数据库设计是使用三番五次的整数为做主键,当新的数目插入到数据库时,由数据库自动生成。但这种规划不自然符合全体场景。

乘机更多的施用Nhibernate、EntityFramework等ORM(对象关系映射)框架,应用程序被设计成为专门的工作单元(Unit Of Work)格局,必要在数据持久化此前生成主键,为了确认保障在八线程并发以及站点集群意况中主键的独一性,最简便最广大的法子是将主键设计成为GUID类型。

做事单元是数据库应用程序常常应用的一种设计形式,轻巧一点的话,正是对几个数据库操作进行打包,记录对象上的有所变化,并在结尾交给时一遍性将具备改变通过系统业务写入数据库。目标是为着减去数据库调用次数以及防止数据库长事务。关于专门的学业单元的学识能够在园子里面寻觅到相当多,在此间就不做详细的牵线了。

GUID(全世界独一标记符)也称为UUID,是一种由算法生成的二进制长度为1二十11个人的数字标记符。在杰出图景下,任何Computer和计算机集群都不会转移多个一律的GUID。GUID 的总和高达了2^128(3.4×10^38)个,所以随意生成两个同样GUID的恐怕一点都不大,但并不为0。GUID一词一时也专指微软对UUID规范的兑现。

RFC 41222陈说了创设标准GUID,近年来比很多GUID生成算法平日是一个不长的随便数,再结合一些像互联网MAC地址这种自由的本土组件新闻。

GUID的长处允许开垦人员随时创造新值,而没有须求从数据库服务器检查值的独一性,那就好像是多少个健全的化解方案。

无数数据库在创设主键时,为了充裕发挥数据库的习性,会活动在该列上创造聚集索引。大家先来讲一说什么样是聚集索引,。集索引鲜明表中数据的情理顺序。聚焦索引类似于电话簿,按姓氏排列数据。由于集中索引规定数额在表中的大要存储顺序,因而贰个表也只能分包四个聚焦索引。它亦可高效查找到数据,但是一旦插入数据库的主键不在列表的最终,向表中增多新行时就可怜缓慢。比如,看上边那一个事例,在表中已经存在三行数据(例子来自杰里米托德的博客GUIDs as fast primary keys under multiple databases:

ID Name
1 Holmes, S.
4 Watson, J.
7 Moriarty, J.

这时候特别轻易:数据行按对应ID列的各类储存。要是我们新扩展加一行ID为8的数量,不会时有产生其余难点,新行会追加的末尾。

ID Name
1 Holmes, S.
4 Watson, J.
7 Moriarty, J.
8 Lestrade, I.

但一旦我们想插队一行的ID为5的多寡:

ID Name
1 Holmes, S.
4 Watson, J.
5 Hudson, Mrs.
7 Moriarty, J.
8 Lestrade, I.

ID为7,8的数据行必须向下活动。就算在那算怎么事儿,但当你的数据量达到数百万行的等级之后,那正是个难点了。要是您还想要每秒管理上百次这种央求,那可真是难上加难了。

那就是GUID主键引发的主题材料:它是轻便产生的,所以在多少插入时,随时都会提到到多少的移动,导致插入会很缓慢,还大概会波及大气不必要的磁盘活动。总计果有两点:

  • 空中的萧疏以及因此拉动的读写效能的暴跌;
  • 更关键的,存款和储蓄的碎片化以及通过推动的读写功效严重下落。
  • 备注:摘自Crazy.Liu博客SQL SEKugaVE锐界下有序GUID和冬日GUID作为主键&集中索引的特性表现

GUID最入眼的标题就是它是专擅的。大家供给规划一种有准则的GUID生成方式,在事后生成的GUID类型总是比在此之前的要大,保障插入数据库的主键是在列表末尾追加的,这种大家誉为有序GUID

主键生成战略

系统独一ID是大家在筹算二个连串的时候常常会遇见的主题素材,上面介绍部分大范围的ID生成计谋。

  • Sequence ID
  • UUID
  • GUID
  • COMB
  • Snowflake

最最先的自增ID为了落实分库分其余须求,会在自增的前提下,使用分歧幅度(比如DB1 生成1,4,7,10,DB2生成2,5,8,11,DB3生成3,6,9,12),但要求做数据库举行时,非常麻烦。
  相比较自增ID,UUID生成唯一主键特别便利(数据量非常大的意况下,存在双重的大概),但出于UUID的冬季性,品质比不上自增ID,字符串积累,积存空间大,查询效用低。
  COMB相对于UUID,扩展了生成ID的有序性,插入与查询功效都有所升高。见Integer GUID和Comb做主键的功能测验(Delphi access)(三)
  Sonwflake是脸谱主键生成攻略,能够用作是COMB的一种革新,用63位的长整型代替1贰十九个人的字符串。ID构成:第一位0

  • 四十一位的岁月前缀 11位的节点标志 11人的sequence防止并发的数字。见脸谱-Snowflake(六九个人布满式ID算法)分析与JAVA实现

一、背景

     常见的一种数据库设计是应用延续的莫西干发型为做主键,当新的数码插入到数据库时,由数据库自动生成。但这种规划不自然符合全部场景。

     随着更多的选择Nhibernate、EntityFramework等ORM(对象关系映射)框架,应用程序被规划成为工作单元(Unit Of Work)格局,供给在数码持久化以前生成主键,为了保障在八线程并发以及站点集群蒙受中主键的独一性,最轻便易行最遍布的艺术是将主键设计成为GUID类型。

     (职业单元:是数据库应用程序平常选择的一种设计格局,轻便一点来讲,就是对几个数据库操作举行包装,记录对象上的有着改造,并在最终交给时一遍性将有所变化通过系统业务写入数据库。指标是为了减小数据库调用次数以及防止数据库长事务。

     GUID(全球独一标志符)也称为UUID,是一种由算法生成的二进制长度为1贰20人的数字标记符。在理想状态下,任何计算机和Computer集群都不会生成四个一律的GUID。GUID 的总和到达了2^128(3.4×10^38)个,所以随意生成多个同样GUID的只怕非常小,但并不为0。GUID一词一时也专指微软对UUID标准的落到实处。

     (RFC 41222陈说了创设规范GUID,这段时间大多GUID生成算法日常是二个十分短的人身自由数,再结合一些像网络MAC地址这种随便的地面组件消息。

     GUID的独到之处允许开采职员随时创设新值,而没有需求从数据库服务器检查值的独一性,这就像是三个完善的减轻方案。

     很非常多据库在开立主键时,为了充裕发挥数据库的性质,会活动在该列上创建聚焦索引。

     我们先来讲一说怎么着是聚焦索引。集索引鲜明表中数量的情理顺序。集中索引类似于电话簿,按姓氏排列数据。由于聚焦索引规定数额在表中的大意存储顺序,因而三个表也不得不分包一个集中索引。它亦可火速查找到数据,不过假诺插入数据库的主键不在列表的尾声,向表中增添新行时就出色缓慢。比如,看上边那么些事例,在表中已经存在三行数据:

     澳门新萄京官方网站 1

     此时非常轻易:数据行按对应ID列的相继积累。如果大家新扩大加一行ID为8的多寡,不会发出任何难点,新行会追加的最后。

      澳门新萄京官方网站 2

     但纵然大家想插队一行的ID为5的数额:

      澳门新萄京官方网站 3

     ID为7,8的数据行必须向下移动。纵然在那算怎么事情,但当您的数据量达到数百万行的品级之后,那正是个难题了。要是您还想要每秒管理上百次这种诉求,那可真是难上加难了。

     那正是GUID主键引发的标题:它是即兴发生的,所以在多少插入时,随时都会波及到多少的移位,导致插入会很缓慢,还有恐怕会提到大气不须求的磁盘活动。总括果有两点:

  • 空中的荒疏以及由此推动的读写功能的狂降;
  • 更首要的,存款和储蓄的碎片化以及通过推动的读写效用严重下跌。

      GUID最主要的题材正是它是不管三七二十一的。我们供给规划一种有准则的GUID生成格局,在其后生成的GUID类型总是比在此以前的要大,保证插入数据库的主键是在列表末尾追加的,这种大家誉为有序GUID

 

一、背景

     常见的一种数据库设计是利用延续的整数为做主键,当新的数额插入到数据库时,由数据库自动生成。但这种设计不确定符合全体场景。

     随着越来越多的利用Nhibernate、EntityFramework等ORM(对象关联映射)框架,应用程序被设计改为工作单元(Unit Of Work)方式,要求在多少长久化在此以前生成主键,为了确定保证在四线程并发以及站点集群景况中主键的独一性,最简便易行最常见的点子是将主键设计改为GUID类型。

     (行事单元:是数据库应用程序平时应用的一种设计格局,轻易一点以来,正是对四个数据库操作进行打包,记录对象上的享有变化,并在结尾交给时贰回性将具备改动通过系统业务写入数据库。指标是为着减少数据库调用次数以及制止数据库长事务。

     GUID(举世独一标志符)也称为UUID,是一种由算法生成的二进制长度为1贰拾10位的数字标志符。在精粹状态下,任何Computer和管理器集群都不会调换八个一样的GUID。GUID 的总额高达了2^128(3.4×10^38)个,所以随意生成七个一样GUID的恐怕十分小,但并不为0。GUID一词有时也专指微软对UUID标准的落到实处。

澳门新萄京官方网站:多数据库有序GUID,集群数据库的有序GUID。     (RFC 41222陈诉了创办规范GUID,方今多数GUID生成算法常常是二个不长的自由数,再组成一些像互连网MAC地址这种随便的本地组件音信。

     GUID的优点允许开拓人士随时创设新值,而无需从数据库服务器检查值的独一性,那就如是一个完美的解决方案。

     很多数据库在开创主键时,为了足够发挥数据库的天性,会自行在该列上创造聚焦索引。

     我们先来讲一说怎么是聚焦索引。集索引分明表中多少的物理顺序。聚焦索引类似于电话簿,按姓氏排列数据。由于集中索引规定数量在表中的情理存款和储蓄顺序,由此贰个表也只好分包一个集中索引。它能够快速查找到数据,可是一旦插入数据库的主键不在列表的最终,向表中加多新行时就十二分缓慢。比方,看下面那一个例子,在表中已经存在三行数据:

     澳门新萄京官方网站 4

     此时特别轻松:数据行按对应ID列的各样累积。即使大家新扩充一行ID为8的数额,不会生出其余难点,新行会追加的末尾。

      澳门新萄京官方网站 5

     但假如我们想插队一行的ID为5的数目:

      澳门新萄京官方网站 6

     ID为7,8的数据行必须向下活动。即使在那算怎么事儿,但当你的数据量达到数百万行的品级之后,那正是个难点了。如若您还想要每秒处理上百次这种诉求,那可真是难上加难了。

     那就是GUID主键引发的难题:它是自由爆发的,所以在多少插入时,随时都会提到到数量的移位,导致插入会很缓慢,还只怕会波及大气不须要的磁盘活动。总括果有两点:

  • 空中的荒凉以及通过推动的读写效能的降落;
  • 更首要的,存款和储蓄的碎片化以及通过带来的读写成效严重消沉。

      GUID最要紧的难题正是它是猖獗的。大家要求规划一种有平整的GUID生成方式,在之后生成的GUID类型总是比在此以前的要大,保险插入数据库的主键是在列表末尾追加的,这种我们称为有序GUID

 


GUID排序准绳

在执教有序GUID从前,大家必须先领会一下GUID在.Net中以及各类数据库中的排序准则,排序法则分裂等,生成有序GUID的法则也会跟着变动。

1二十12人的GUID首要有4片段构成:Data1, Data2, Data3, and Data4,你可以看作下边那样:

11111111-2222-3333-4444-444444444444

Data1 占4个字节, Data2 2个字节, Data3 2个字节加 Data47个字节。大家分别的对个字节编上序号:

序号 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Value 11 11 11 11 - 22 22 - 33 33 - 44 44 - 44 44 44 44 44 44

1. Sequence ID

数据库自拉长系列或字段,最常见的措施。由数据库维护,数据库独一。

二、GUID排序准绳

     在教师有序GUID从前,我们无法不先领悟一下GUID在.Net中以及种种数据库中的排序准则,排序规则不均等,生成有序GUID的条条框框也会随之转移。

     1贰二十位的GUID首要有4部分构成:Data1, Data2, Data3, and Data4,你能够用作下边那样:

style="font-family: Microsoft YaHei; font-size: 16px">11111111-2222-3333-4444-444444444444

     Data1占4个字节、Data2占2个字节、 Data3占2个字节、Data4占8个字节。我们独家的对个字节编上序号:

序号 1 2 3 4   5 6   7 8   9 10   11 12 13 14 15 16
Value 11 11 11 11 - 22 22 - 33 33 - 44 44 - 44 44 44 44 44 44

 

 

 

二、GUID排序法规

     在讲授有序GUID从前,大家无法不先掌握一下GUID在.Net中以及各样数据库中的排序法规,排序准绳不等同,生成有序GUID的平整也会随之转移。

     126个人的GUID首要有4有个别组成:Data1, Data2, Data3, and Data4,你能够作为上边那样:

style="font-family: Microsoft YaHei; font-size: 16px">11111111-2222-3333-4444-444444444444

     Data1占4个字节、Data2占2个字节、 Data3占2个字节、Data4占8个字节。大家分其余对个字节编上序号:

序号 1 2 3 4   5 6   7 8   9 10   11 12 13 14 15 16
Value 11 11 11 11 - 22 22 - 33 33 - 44 44 - 44 44 44 44 44 44

 

 

 

长期以来的GUID品质比较,堪比自增ID integer

GUID在.Net中的排序准则

在.Net中,GUID暗中同意的排序过段准绳是按左到右的,看下边那个示例。

    var list = new List<Guid> {
        new Guid("00000000-0000-0000-0000-010000000000"),
        new Guid("00000000-0000-0000-0000-000100000000"),
        new Guid("00000000-0000-0000-0000-000001000000"),
        new Guid("00000000-0000-0000-0000-000000010000"),
        new Guid("00000000-0000-0000-0000-000000000100"),
        new Guid("00000000-0000-0000-0000-000000000001"),
        new Guid("00000000-0000-0000-0100-000000000000"),
        new Guid("00000000-0000-0000-0010-000000000000"),
        new Guid("00000000-0000-0001-0000-000000000000"),
        new Guid("00000000-0000-0100-0000-000000000000"),
        new Guid("00000000-0001-0000-0000-000000000000"),
        new Guid("00000000-0100-0000-0000-000000000000"),
        new Guid("00000001-0000-0000-0000-000000000000"),
        new Guid("00000100-0000-0000-0000-000000000000"),
        new Guid("00010000-0000-0000-0000-000000000000"),
        new Guid("01000000-0000-0000-0000-000000000000")
    };
    list.Sort();

    foreach (Guid guid in list) {
        Console.WriteLine(guid.ToString());
    }

出口结果:

00000000-0000-0000-0000-000000000001
00000000-0000-0000-0000-000000000100
00000000-0000-0000-0000-000000010000
00000000-0000-0000-0000-000001000000
00000000-0000-0000-0000-000100000000
00000000-0000-0000-0000-010000000000
00000000-0000-0000-0010-000000000000
00000000-0000-0000-0100-000000000000
00000000-0000-0001-0000-000000000000
00000000-0000-0100-0000-000000000000
00000000-0001-0000-0000-000000000000
00000000-0100-0000-0000-000000000000
00000001-0000-0000-0000-000000000000
00000100-0000-0000-0000-000000000000
00010000-0000-0000-0000-000000000000
01000000-0000-0000-0000-000000000000

经过地方的输出结果,我们可以收获排序的权重如下:

序号 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
权重 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Value 11 11 11 11 - 22 22 - 33 33 - 44 44 - 44 44 44 44 44 44

那与数字排序法规同样,从右到左举行每一个举行排序(数字越小,权重越高,排序的先行级越高)。

优点:

  1. 简单,代码方便,品质能够承受。
  2. 数字ID天然排序,对分页也许须求排序的结果很有扶持。

     GUID在.Net中的排序法则

     在.Net中,GUID私下认可的排序过段准则是按左到右的,看上面这一个示例。

 1 var list = new List<Guid> {
 2         new Guid("00000000-0000-0000-0000-010000000000"),
 3         new Guid("00000000-0000-0000-0000-000100000000"),
 4         new Guid("00000000-0000-0000-0000-000001000000"),
 5         new Guid("00000000-0000-0000-0000-000000010000"),
 6         new Guid("00000000-0000-0000-0000-000000000100"),
 7         new Guid("00000000-0000-0000-0000-000000000001"),
 8         new Guid("00000000-0000-0000-0100-000000000000"),
 9         new Guid("00000000-0000-0000-0010-000000000000"),
10         new Guid("00000000-0000-0001-0000-000000000000"),
11         new Guid("00000000-0000-0100-0000-000000000000"),
12         new Guid("00000000-0001-0000-0000-000000000000"),
13         new Guid("00000000-0100-0000-0000-000000000000"),
14         new Guid("00000001-0000-0000-0000-000000000000"),
15         new Guid("00000100-0000-0000-0000-000000000000"),
16         new Guid("00010000-0000-0000-0000-000000000000"),
17         new Guid("01000000-0000-0000-0000-000000000000")
18     };
19     list.Sort();
20 
21     foreach (Guid guid in list) {
22         Console.WriteLine(guid.ToString());
23     }

     输出结果:

style="font-family: Microsoft YaHei; font-size: 16px">00000000-0000-0000-0000-000000000001

00000000-0000-0000-0000-000000000100

00000000-0000-0000-0000-000000010000

00000000-0000-0000-0000-000001000000

00000000-0000-0000-0000-000100000000

00000000-0000-0000-0000-010000000000

00000000-0000-0000-0010-000000000000

00000000-0000-0000-0100-000000000000

00000000-0000-0001-0000-000000000000

00000000-0000-0100-0000-000000000000

00000000-0001-0000-0000-000000000000

00000000-0100-0000-0000-000000000000

00000001-0000-0000-0000-000000000000

00000100-0000-0000-0000-000000000000

00010000-0000-0000-0000-000000000000

01000000-0000-0000-0000-000000000000

     通过上面的输出结果,大家得以拿走排序的权重如下:

序号 1 2 3 4   5 6   7 8   9 10   11 12 13 14 15 16
权重 1 2 3 4   5 6   7 8   9 10   11 12 13 14 15 16
Value 11 11 11 11 - 22 22 - 33 33 - 44 44 - 44 44 44 44 44 44

 

 

 

      这与数字排序准则一样,从右到左举行逐项打开排序(数字越小,权重越高,排序的优先级越高)。

     GUID在.Net中的排序准则

     在.Net中,GUID默许的排序过段法规是按左到右的,看上边这么些示例。

 1 var list = new List<Guid> {
 2         new Guid("00000000-0000-0000-0000-010000000000"),
 3         new Guid("00000000-0000-0000-0000-000100000000"),
 4         new Guid("00000000-0000-0000-0000-000001000000"),
 5         new Guid("00000000-0000-0000-0000-000000010000"),
 6         new Guid("00000000-0000-0000-0000-000000000100"),
 7         new Guid("00000000-0000-0000-0000-000000000001"),
 8         new Guid("00000000-0000-0000-0100-000000000000"),
 9         new Guid("00000000-0000-0000-0010-000000000000"),
10         new Guid("00000000-0000-0001-0000-000000000000"),
11         new Guid("00000000-0000-0100-0000-000000000000"),
12         new Guid("00000000-0001-0000-0000-000000000000"),
13         new Guid("00000000-0100-0000-0000-000000000000"),
14         new Guid("00000001-0000-0000-0000-000000000000"),
15         new Guid("00000100-0000-0000-0000-000000000000"),
16         new Guid("00010000-0000-0000-0000-000000000000"),
17         new Guid("01000000-0000-0000-0000-000000000000")
18     };
19     list.Sort();
20 
21     foreach (Guid guid in list) {
22         Console.WriteLine(guid.ToString());
23     }

     输出结果:

style="font-family: Microsoft YaHei; font-size: 16px">00000000-0000-0000-0000-000000000001

00000000-0000-0000-0000-000000000100

00000000-0000-0000-0000-000000010000

00000000-0000-0000-0000-000001000000

00000000-0000-0000-0000-000100000000

00000000-0000-0000-0000-010000000000

00000000-0000-0000-0010-000000000000

00000000-0000-0000-0100-000000000000

00000000-0000-0001-0000-000000000000

00000000-0000-0100-0000-000000000000

00000000-0001-0000-0000-000000000000

00000000-0100-0000-0000-000000000000

00000001-0000-0000-0000-000000000000

000001澳门新萄京官方网站:多数据库有序GUID,集群数据库的有序GUID。00-0000-0000-0000-000000000000

00010000-0000-0000-0000-000000000000

01000000-0000-0000-0000-000000000000

     通过地方的出口结果,咱们可以得到排序的权重如下:

序号 1 2 3 4   5 6   7 8   9 10   11 12 13 14 15 16
权重 1 2 3 4   5 6   7 8   9 10   11 12 13 14 15 16
Value 11 11 11 11 - 22 22 - 33 33 - 44 44 - 44 44 44 44 44 44

 

 

 

      那与数字排序法规平等,从右到左实行逐条进行排序(数字越小,权重越高,排序的事先级越高)。

澳门新萄京官方网站 7

GUID在依次数据库中的排序法则

在SQL Server数据库中,大家有一种特别简单的艺术来相比较七个GUID类型的大小值(其实在SQL Server数据库中称之为UniqueIdentifier类型):

With UIDs As (--                         0 1 2 3  4 5  6 7  8 9  A B C D E F
            Select ID =  1, UID = cast ('00000000-0000-0000-0000-010000000000' as uniqueidentifier)
    Union   Select ID =  2, UID = cast ('00000000-0000-0000-0000-000100000000' as uniqueidentifier)
    Union   Select ID =  3, UID = cast ('00000000-0000-0000-0000-000001000000' as uniqueidentifier)
    Union   Select ID =  4, UID = cast ('00000000-0000-0000-0000-000000010000' as uniqueidentifier)
    Union   Select ID =  5, UID = cast ('00000000-0000-0000-0000-000000000100' as uniqueidentifier)
    Union   Select ID =  6, UID = cast ('00000000-0000-0000-0000-000000000001' as uniqueidentifier)
    Union   Select ID =  7, UID = cast ('00000000-0000-0000-0100-000000000000' as uniqueidentifier)
    Union   Select ID =  8, UID = cast ('00000000-0000-0000-0010-000000000000' as uniqueidentifier)
    Union   Select ID =  9, UID = cast ('00000000-0000-0001-0000-000000000000' as uniqueidentifier)
    Union   Select ID = 10, UID = cast ('00000000-0000-0100-0000-000000000000' as uniqueidentifier)
    Union   Select ID = 11, UID = cast ('00000000-0001-0000-0000-000000000000' as uniqueidentifier)
    Union   Select ID = 12, UID = cast ('00000000-0100-0000-0000-000000000000' as uniqueidentifier)
    Union   Select ID = 13, UID = cast ('00000001-0000-0000-0000-000000000000' as uniqueidentifier)
    Union   Select ID = 14, UID = cast ('00000100-0000-0000-0000-000000000000' as uniqueidentifier)
    Union   Select ID = 15, UID = cast ('00010000-0000-0000-0000-000000000000' as uniqueidentifier)
    Union   Select ID = 16, UID = cast ('01000000-0000-0000-0000-000000000000' as uniqueidentifier)
)
Select * From UIDs Order By UID, ID

事例来自法拉利的博客How are GUIDs sorted by SQL Server?

查询结果:

ID UID
16 01000000-0000-0000-0000-000000000000
15 00010000-0000-0000-0000-000000000000
14 00000100-0000-0000-0000-000000000000
13 00000001-0000-0000-0000-000000000000
12 00000000-0100-0000-0000-000000000000
11 00000000-0001-0000-0000-000000000000
10 00000000-0000-0100-0000-000000000000
9 00000000-0000-0001-0000-000000000000
8 00000000-0000-0000-0010-000000000000
7 00000000-0000-0000-0100-000000000000
6 00000000-0000-0000-0000-000000000001
5 00000000-0000-0000-0000-000000000100
4 00000000-0000-0000-0000-000000010000
3 00000000-0000-0000-0000-000001000000
2 00000000-0000-0000-0000-000100000000
1 00000000-0000-0000-0000-010000000000

透过上边能够得于是之类结果:

  1. 先按每1-8从左到右进行排序;
  2. 随即按第9-11个人从右到左举办排序;
  3. 终极按后11-13人从右到左进行排序;

通过剖析,大家可得到如下放权力重列表:

序号 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
权重 16 15 14 13 12 11 10 9 7 8 1 2 3 4 5 6
Value 11 11 11 11 - 22 22 - 33 33 - 44 44 - 44 44 44 44 44 44

在Microsoft官方文档中,有一篇文书档案关于GUID与uniqueidentifier的值比较:
Comparing GUID and uniqueidentifier Values。

不等的数据库管理GUID的办法也是例外的。在SQL Server存在内置GUID类型,未有原生GUID辅助的数据库通过模拟来情势来贯彻的。在Oracle保存为raw bytes类型,具体项目为raw(16);在MySql中国和东瀛常将GUID储存为char(36)的字符串格局。

有关Oracle、MySql数据库的排序法则与.Net中排序法规,可是篇章的限定,这里不再坚实际的以身作则,不过本人在github上提供了演示SQL语句:,您能够本人开始展览测量检验。大家在此处只交付最后的结论:

小结:

  1. .Net中GUID的排序法规是从左到右依次实行排序,与数字排序法规同样;
  2. Sql Server数据库提供对GUID类型的支撑,在数据库中称之为UniqueIdentifier项目,可是排序法则比较复杂:
    • 先按每1-8从左到右进行排序;
    • 随着按第9-十一个人从右到左举办排序;
    • 最终按后11-17个人从右到左进行排序;
  3. Oracle数据库未提供对GUID类型的补助,使用的是raw bytes类型保存数据raw(16),具体品种为,排序法规与GUID在.Net中法规同样;
  4. MySql数据未提供对GUID类型的支撑,使用的是字符串的花色保存数据,使用是的char(36)体系,由于接纳的是字符串类型,排序法规与GUID在.Net中的准绳同样。

缺点:

  1. 昔不近来数据库语法和促成差别,数据库迁移的时候或超过约得其半据库版本援救的时候需求管理。
  2. 在单个数据库或读写分离或一主多从的图景下,独有三个主库能够转换。有单点故障的危机。
  3. 在质量达不到须要的情事下,比较难于扩张。
  4. 一旦遇见五个连串要求联合恐怕关联到多少迁移会一定优伤。
  5. 分表分库的时候会有麻烦。

     GUID在每家每户数据库中的排序法规

     在SQL Server数据库中,大家有一种非常轻巧的点子来相比三个GUID类型的大小值(其实在SQL Server数据库中称之为UniqueIdentifier类型):

 1 With UIDs As (--                         0 1 2 3  4 5  6 7  8 9  A B C D E F
 2             Select ID =  1, UID = cast ('00000000-0000-0000-0000-010000000000' as uniqueidentifier)
 3     Union   Select ID =  2, UID = cast ('00000000-0000-0000-0000-000100000000' as uniqueidentifier)
 4     Union   Select ID =  3, UID = cast ('00000000-0000-0000-0000-000001000000' as uniqueidentifier)
 5     Union   Select ID =  4, UID = cast ('00000000-0000-0000-0000-000000010000' as uniqueidentifier)
 6     Union   Select ID =  5, UID = cast ('00000000-0000-0000-0000-000000000100' as uniqueidentifier)
 7     Union   Select ID =  6, UID = cast ('00000000-0000-0000-0000-000000000001' as uniqueidentifier)
 8     Union   Select ID =  7, UID = cast ('00000000-0000-0000-0100-000000000000' as uniqueidentifier)
 9     Union   Select ID =  8, UID = cast ('00000000-0000-0000-0010-000000000000' as uniqueidentifier)
10     Union   Select ID =  9, UID = cast ('00000000-0000-0001-0000-000000000000' as uniqueidentifier)
11     Union   Select ID = 10, UID = cast ('00000000-0000-0100-0000-000000000000' as uniqueidentifier)
12     Union   Select ID = 11, UID = cast ('00000000-0001-0000-0000-000000000000' as uniqueidentifier)
13     Union   Select ID = 12, UID = cast ('00000000-0100-0000-0000-000000000000' as uniqueidentifier)
14     Union   Select ID = 13, UID = cast ('00000001-0000-0000-0000-000000000000' as uniqueidentifier)
15     Union   Select ID = 14, UID = cast ('00000100-0000-0000-0000-000000000000' as uniqueidentifier)
16     Union   Select ID = 15, UID = cast ('00010000-0000-0000-0000-000000000000' as uniqueidentifier)
17     Union   Select ID = 16, UID = cast ('01000000-0000-0000-0000-000000000000' as uniqueidentifier)
18 )
19 Select * From UIDs Order By UID, ID

     查询结果:

ID UID
16 01000000-0000-0000-0000-000000000000
15 00010000-0000-0000-0000-000000000000
14 00000100-0000-0000-0000-000000000000
13 00000001-0000-0000-0000-000000000000
12 00000000-0100-0000-0000-000000000000
11 00000000-0001-0000-0000-000000000000
10 00000000-0000-0100-0000-000000000000
9 00000000-0000-0001-0000-000000000000
8 00000000-0000-0000-0010-000000000000
7 00000000-0000-0000-0100-000000000000
6 00000000-0000-0000-0000-000000000001
5 00000000-0000-0000-0000-000000000100
4 00000000-0000-0000-0000-000000010000
3 00000000-0000-0000-0000-000001000000
2 00000000-0000-0000-0000-000100000000
1 00000000-0000-0000-0000-010000000000

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

     通过地点可以得于是之类结果:

  1. 先按每1-8从左到右进行排序;
  2. 继而按第9-九位从右到左进行排序;
  3. 最终按后11-14位从右到左实行排序;

     通过分析,大家可获得如下放权力重列表:

序号 1 2 3 4   5 6   7 8   9 10   11 12 13 14 15 16
权重 16 15 14 13   12 11   10 9   7 8   1 2 3 4 5 6
Value 11 11 11 11 - 22 22 - 33 33 - 44 44 - 44 44 44 44 44 44

 

 

 

     在Microsoft官方文书档案中,有一篇文书档案关于GUID与uniqueidentifier的值相比:Comparing GUID and uniqueidentifier Values。

     分歧的数据库处理GUID的章程也是分歧的:

          1)在SQL Server存在内置GUID类型,未有原生GUID辅助的数据库通过模拟格局来贯彻的;

          2)在Oracle保存为raw bytes类型,具体项目为raw(16)

          3)在MySql中常见将GUID积存为char(36)的字符串情势;

     关于Oracle、MySql数据库的排序准则与.Net中排序法规,可是篇章的限制,这里不再抓牢际的身体力行。在github上提供了示范SQL语句:。大家在此处只交给末了的定论:

style="font-size: 16px; font-family: Microsoft YaHei">小结:

  1. style="font-size: 16px; font-family: Microsoft YaHei">.Net中GUID的排序法规是从左到右依次进行排序,与数字排序法规平等;
  2. style="font-size: 16px">Sql Server数据库提供对GUID类型的帮助,在数据库中称之为UniqueIdentifier项目,可是排序准则相比复杂:Oracle数据库未提供对GUID类型的支持,使用的是raw bytes类型保存数据raw(16),具体品种为,排序准则与GUID在.Net中法则同样;
    • style="font-family: Microsoft YaHei; font-size: 16px">先按每1-8从左到右举办排序;
    • style="font-family: Microsoft YaHei; font-size: 16px">接着按第9-拾一个人从右到左进行排序;
    • style="font-family: Microsoft YaHei; font-size: 16px">最终按后11-十10位从右到左实行排序;
  3. style="font-size: 16px">Oracle数据库未提供对GUID类型的支撑,使用的是raw bytes类型保存数据raw(16),具体项目为,排序准绳与GUID在.Net中准则平等;
  4. style="font-size: 16px; font-family: Microsoft YaHei">MySql数据未提供对GUID类型的支撑,使用的是字符串的花色保存数据,使用是的char(36)品种,由于应用的是字符串类型,排序法规与GUID在.Net中的法规同样。

     GUID在各种数据库中的排序法规

     在SQL Server数据库中,我们有一种特别轻便的法子来比较三个GUID类型的大小值(其实在SQL Server数据库中称之为UniqueIdentifier类型):

 1 With UIDs As (--                         0 1 2 3  4 5  6 7  8 9  A B C D E F
 2             Select ID =  1, UID = cast ('00000000-0000-0000-0000-010000000000' as uniqueidentifier)
 3     Union   Select ID =  2, UID = cast ('00000000-0000-0000-0000-000100000000' as uniqueidentifier)
 4     Union   Select ID =  3, UID = cast ('00000000-0000-0000-0000-000001000000' as uniqueidentifier)
 5     Union   Select ID =  4, UID = cast ('00000000-0000-0000-0000-000000010000' as uniqueidentifier)
 6     Union   Select ID =  5, UID = cast ('00000000-0000-0000-0000-000000000100' as uniqueidentifier)
 7     Union   Select ID =  6, UID = cast ('00000000-0000-0000-0000-000000000001' as uniqueidentifier)
 8     Union   Select ID =  7, UID = cast ('00000000-0000-0000-0100-000000000000' as uniqueidentifier)
 9     Union   Select ID =  8, UID = cast ('00000000-0000-0000-0010-000000000000' as uniqueidentifier)
10     Union   Select ID =  9, UID = cast ('00000000-0000-0001-0000-000000000000' as uniqueidentifier)
11     Union   Select ID = 10, UID = cast ('00000000-0000-0100-0000-000000000000' as uniqueidentifier)
12     Union   Select ID = 11, UID = cast ('00000000-0001-0000-0000-000000000000' as uniqueidentifier)
13     Union   Select ID = 12, UID = cast ('00000000-0100-0000-0000-000000000000' as uniqueidentifier)
14     Union   Select ID = 13, UID = cast ('00000001-0000-0000-0000-000000000000' as uniqueidentifier)
15     Union   Select ID = 14, UID = cast ('00000100-0000-0000-0000-000000000000' as uniqueidentifier)
16     Union   Select ID = 15, UID = cast ('00010000-0000-0000-0000-000000000000' as uniqueidentifier)
17     Union   Select ID = 16, UID = cast ('01000000-0000-0000-0000-000000000000' as uniqueidentifier)
18 )
19 Select * From UIDs Order By UID, ID

     查询结果:

ID UID
16 01000000-0000-0000-0000-000000000000
15 00010000-0000-0000-0000-000000000000
14 00000100-0000-0000-0000-000000000000
13 00000001-0000-0000-0000-000000000000
12 00000000-0100-0000-0000-000000000000
11 00000000-0001-0000-0000-000000000000
10 00000000-0000-0100-0000-000000000000
9 00000000-0000-0001-0000-000000000000
8 00000000-0000-0000-0010-000000000000
7 00000000-0000-0000-0100-000000000000
6 00000000-0000-0000-0000-000000000001
5 00000000-0000-0000-0000-000000000100
4 00000000-0000-0000-0000-000000010000
3 00000000-0000-0000-0000-000001000000
2 00000000-0000-0000-0000-000100000000
1 00000000-0000-0000-0000-010000000000

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

     通过上面能够得于是之类结果:

  1. 先按每1-8从左到右实行排序;
  2. 随即按第9-十二位从右到左实行排序;
  3. 最终按后11-16人从右到左举行排序;

     通过分析,大家可获得如下放权力重列表:

序号 1 2 3 4   5 6   7 8   9 10   11 12 13 14 15 16
权重 16 15 14 13   12 11   10 9   7 8   1 2 3 4 5 6
Value 11 11 11 11 - 22 22 - 33 33 - 44 44 - 44 44 44 44 44 44

 

 

 

     在Microsoft官方文档中,有一篇文书档案关于GUID与uniqueidentifier的值相比:Comparing GUID and uniqueidentifier Values。

     不一样的数据库管理GUID的点子也是不相同的:

          1)在SQL Server存在内置GUID类型,未有原生GUID协理的数据库通过模拟格局来促成的;

          2)在Oracle保存为raw bytes类型,具体项目为raw(16)

          3)在MySql中国和日本常将GUID积攒为char(36)的字符串格局;

     关于Oracle、MySql数据库的排序法则与.Net中排序法则,可是篇章的范围,这里不再抓好际的示范。在github上提供了示范SQL语句:。大家在此地只交给最终的结论:

style="font-size: 16px; font-family: Microsoft YaHei">小结:

  1. style="font-size: 16px; font-family: Microsoft YaHei">.Net中GUID的排序法规是从左到右依次实行排序,与数字排序准则平等;
  2. style="font-size: 16px">Sql Server数据库提供对GUID类型的帮忙,在数据库中称之为UniqueIdentifier花色,不过排序准则比较复杂:Oracle数据库未提供对GUID类型的支撑,使用的是raw bytes类型保存数据raw(16),具体项目为,排序准则与GUID在.Net中法规平等;
    • style="font-family: Microsoft YaHei; font-size: 16px">先按每1-8从左到右进行排序;
    • style="font-family: Microsoft YaHei; font-size: 16px">接着按第9-11人从右到左进行排序;
    • style="font-family: Microsoft YaHei; font-size: 16px">最终按后11-15个人从右到左进行排序;
  3. style="font-size: 16px">Oracle数据库未提供对GUID类型的支撑,使用的是raw bytes类型保存数据raw(16),具体项目为,排序法规与GUID在.Net中准绳平等;
  4. style="font-size: 16px; font-family: Microsoft YaHei">MySql数据未提供对GUID类型的支撑,使用的是字符串的花色保存数据,使用是的char(36)品类,由于选取的是字符串类型,排序法规与GUID在.Net中的准则同样。

 

有序GUID

长期以来GUID是有平整的生成GUID,保存在之后生成的GUID类型总是比此前的要大。可是在上一节中,已经提到过各种数据库对GUID援助不等同,况且排序的平整也不等同,所以大家必要为每贰个数据库提供不平等的不改变GUID生成法则。

优化方案:

  1. 针对主库单点,假诺有多个Master库,则各种Master库设置的开头数字不一样等,步长同样,能够是Master的个数。
    举例:Master1 生成的是 1,4,7,10,Master2生成的是2,5,8,11 Master3生成的是 3,6,9,12。那样就足以有效生成集群中的唯一ID,也得以大大缩小ID生成数据库操作的载荷。

  2. UUID


常见的办法,1二十八人。能够利用数据库也能够选拔程序生成,一般的话满世界独一。

 

 

三个大神告诉作者NEWSEQUENTIALID() 在多少迁移的时候会有标题(感激大神辅导),所以作者就深挖一下这一个函数。

UuidCreateSequential函数

大家都领会SQL Server数据库有贰个NewSequentialId()函数,用于创制有序GUID。在创设表时,能够将它设置成为GUID类型字段的私下认可值,在插入新添多少时自动创立主键的值(该函数只好做为字段的暗中同意值,不能够直接在SQL中调用)。

示例:

Create Table TestTable
       (
         ID UniqueIdentifier Not Null Default ( NewSequentialId() ) ,
         Number Int
       );

NewSequentialId()函数只可以在数据库使用,可是在 Microsoft 的 MSDN 文书档案中有证实,NEWSEQUENTIALID 是对 Windows UuidCreateSequential 函数的包裹,。这样大家得以在C#透过非托管方法调用:

   [System.Runtime.InteropServices.DllImport("rpcrt4.dll", SetLastError = true)]
   private static extern int UuidCreateSequential(out Guid guid);

   public static Guid NewSequentialGuid()
   {
       const int RPC_S_OK = 0;

       int result = UuidCreateSequential(out var guid);
       if (result != RPC_S_OK) {
           throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error());
       }

       return guid;
   }

不那些法子也设有四个问题:

  1. 本条点子涉及到安全主题素材,UuidCreateSequential函数注重的总结硬件,该格局的后十一位其实是网卡的MAC地址。那是本身Computer生成的一组有序GUID。

    {A2A93393-C8DC-11E7-B133-2C56DC497A97}
    {A2A93394-C8DC-11E7-B133-2C56DC497A97}
    {A2A93395-C8DC-11E7-B133-2C56DC497A97}
    {A2A93396-C8DC-11E7-B133-2C56DC497A97}
    {A2A93397-C8DC-11E7-B133-2C56DC497A97}
    {A2A93398-C8DC-11E7-B133-2C56DC497A97}
    {A2A93399-C8DC-11E7-B133-2C56DC497A97}
    {A2A9339A-C8DC-11E7-B133-2C56DC497A97}
    {A2A9339B-C8DC-11E7-B133-2C56DC497A97}
    {A2A9339C-C8DC-11E7-B133-2C56DC497A97}

    那是本人计算机的网卡的MAC地址:
    澳门新萄京官方网站 8

  2. 由于UuidCreateSequential函数生成的雷打不动GUID中包含MAC地址,所以一旦在服务器集群碰到中,断定期存款在一台服务器A上扭转的稳步GUID总比另一台服务器B生成要更加小,服务器A爆发的数量插入到数据库时,由于集中索引的主题材料,总是会活动服务器B已经长久化到数据库中的数据。集群的服务器越来越多,爆发的IO难点更严重。在服务器会集情况中,需求活动实现稳步GUID。

  3. UuidCreateSequential函数生成的GUID准则与SQL Server中排序的平整存在差异,那样还是会招致惨重的IO难点,所以须求将GUID重新排序后再长久化到数据库。比如地方列出转换的GUID列表,依次生成的多少年足球以看看,是第2位字节在自增加,在那与别的贰个数据库的排序法则都不雷同;关于该函数生成的条条框框,能够见此链接:。

上面包车型地铁法子是将扭转的GUID调治成为适合Sql Server使用的雷打不动GUID(针对别的数据库匡助,您能够按排序法则自行修改):

[System.Runtime.InteropServices.DllImport("rpcrt4.dll", SetLastError = true)]
static extern int UuidCreateSequential(byte[] buffer);

static Guid NewSequentialGuid() {

    byte[] raw = new byte[16];
    if (UuidCreateSequential(raw) != 0)
        throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error());

    byte[] fix = new byte[16];

    // reverse 0..3
    fix[0x0] = raw[0x3];
    fix[0x1] = raw[0x2];
    fix[0x2] = raw[0x1];
    fix[0x3] = raw[0x0];

    // reverse 4 & 5
    fix[0x4] = raw[0x5];
    fix[0x5] = raw[0x4];

    // reverse 6 & 7
    fix[0x6] = raw[0x7];
    fix[0x7] = raw[0x6];

    // all other are unchanged
    fix[0x8] = raw[0x8];
    fix[0x9] = raw[0x9];
    fix[0xA] = raw[0xA];
    fix[0xB] = raw[0xB];
    fix[0xC] = raw[0xC];
    fix[0xD] = raw[0xD];
    fix[0xE] = raw[0xE];
    fix[0xF] = raw[0xF];

    return new Guid(fix);
}

小结:
UuidCreateSequential函数存在隐秘的题材,不吻合集群情形,况兼供给再行排序后再交给到数据库;

优点:

  1. 简单的说,代码方便。
  2. 全世界独一,在蒙受数据迁移,系统数据统一,或许数据库更动等情景下,能够从容应对。

三、有序GUID

     有序GUID是有准则的生成GUID,保存在之后生成的GUID类型总是比从前的要大。然而在上一节中,已经涉及过各样数据库对GUID帮助差异等,并且排序的条条框框也分歧等,所以大家须要为每一个数据库提供不均等的静止GUID生成法则。

三、有序GUID

     有序GUID是有平整的生成GUID,保存在之后生成的GUID类型总是比在此之前的要大。可是在上一节中,已经提到过各类数据库对GUID协助不均等,並且排序的平整也差异样,所以大家必要为每二个数据库提供不雷同的不改变GUID生成准绳。

    关于NEWSEQUENTIALID() 的用法 参照  NEWSEQUENTIALID()

COMB消除方案

COMB 类型的GUID 是由Jimmy Nilsson在他的“The Cost of GUIDs as Primary Keys”一文中规划出来的。
着力布置思路是这么的:既然GUID数据变化是即兴的诱致索引功用低下,影响了系统的习性,那么能否通过结合的方法,保留GUID的前13个字节,用后6个字节表示GUID生成的时刻(DateTime),那样大家将时刻新闻与GUID组合起来,在保留GUID的独一性的同一时候扩大了有序性,以此来升高索引功能(这是本着Sql Server数据库来规划的)。

在NHibernate框架中早就完毕该作用,能够在github上看看完成格局:。

在EF以及EF Core也一律实现了左近的减轻方案,EF Core的落实情势:

在这里介绍一下使用的艺术,由EF Core框架自动生成有序GUID的艺术:

    public class SampleDbContext : DbContext
    {
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<GuidEntity>(b =>
            {
                b.Property(e => e.Id).HasValueGenerator<SequentialGuidValueGenerator>();
            });
        }
    }

然则请当心,那三个ORM的减轻方案只针对Sql Server数据库,因为只保障了最后二位字节是按梯次来扭转的。

缺点:

  1. 从未有过排序,不能确定保证趋势递增。
  2. UUID往往是运用字符串存款和储蓄,查询的功效比异常的低。
  3. 仓库储存空间极大,假设是海量数据库,就须求考虑存款和储蓄量的难题。
  4. 传输数据量大
  5. 不可读。

     UuidCreateSequential函数

     大家都明白SQL Server数据库有贰个NewSequentialId()函数,用于制造有序GUID。在开创表时,能够将它设置成为GUID类型字段的私下认可值,在插入新增加多少时自动创立主键的值(该函数只可以做为字段的暗中认可值,无法平素在SQL中调用)。

     示例:

1 Create Table TestTable
2        (
3          ID UniqueIdentifier Not Null Default ( NewSequentialId() ) ,
4          Number Int
5        );

NewSequentialId()函数只好在数据库使用,不过在 Microsoft 的 MSDN 文书档案中有证实,NEWSEQUENTIALID 是对 Windows UuidCreateSequential 函数的包裹,。那样咱们能够在C#透过非托管方法调用:

 1 [System.Runtime.InteropServices.DllImport("rpcrt4.dll", SetLastError = true)]
 2    private static extern int UuidCreateSequential(out Guid guid);
 3 
 4    public static Guid NewSequentialGuid()
 5    {
 6        const int RPC_S_OK = 0;
 7 
 8        int result = UuidCreateSequential(out var guid);
 9        if (result != RPC_S_OK) {
10            throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error());
11        }
12 
13        return guid;
14    }

     不那些法子也设有八个难题:

  1. 本条点子涉及到平安主题材料,UuidCreateSequential函数依赖的测算硬件,该格局的后11人其实是网卡的MAC地址。这是本人计算机生成的一组有序GUID。

style="font-family: Microsoft YaHei; font-size: 16px">{A2A93393-C8DC-11E7-B133-2C56DC497A97}

{A2A93394-C8DC-11E7-B133-2C56DC497A97}

{A2A93395-C8DC-11E7-B133-2C56DC497A97}

{A2A93396-C8DC-11E7-B133-2C56DC497A97}

{A2A93397-C8DC-11E7-B133-2C56DC497A97}

{A2A93398-C8DC-11E7-B133-2C56DC497A97}

{A2A93399澳门新萄京官方网站,-C8DC-11E7-B133-2C56DC497A97}

{A2A9339A-C8DC-11E7-B133-2C56DC497A97}

{A2A9339B-C8DC-11E7-B133-2C56DC497A97}

{A2A9339C-C8DC-11E7-B133-2C56DC497A97}

     那是本人Computer的网卡的MAC地址:

     澳门新萄京官方网站 9

  1. 由于UuidCreateSequential函数生成的不改变GUID中包涵MAC地址,所以一旦在服务器集群情形中,确定期存款在一台服务器A上扭转的雷打不动GUID总比另一台服务器B生成要越来越小,服务器A发生的数据插入到数据库时,由于集中索引的标题,总是会活动服务器B已经长久化到数据库中的数据。集群的服务器越多,发生的IO难点更严重。在服务器集结景况中,必要活动达成平稳GUID。

  2. UuidCreateSequential函数生成的GUID法规与SQL Server中排序的法规存在不雷同,那样还是会促成严重的IO难点,所以必要将GUID重新排序后再悠久化到数据库。举个例子地点列出调换的GUID列表,依次生成的数目足以见到,是首位字节在自增加,在那与别的二个数据库的排序准则都不均等;关于该函数生成的法则,能够见此链接:。

     上面包车型地铁法门是将转移的GUID调解成为适合Sql Server使用的有序GUID(针对别的数据库帮助,您能够按排序法则自行修改):

 1 [System.Runtime.InteropServices.DllImport("rpcrt4.dll", SetLastError = true)]
 2 static extern int UuidCreateSequential(byte[] buffer);
 3 
 4 static Guid NewSequentialGuid() {
 5 
 6     byte[] raw = new byte[16];
 7     if (UuidCreateSequential(raw) != 0)
 8         throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error());
 9 
10     byte[] fix = new byte[16];
11 
12     // reverse 0..3
13     fix[0x0] = raw[0x3];
14     fix[0x1] = raw[0x2];
15     fix[0x2] = raw[0x1];
16     fix[0x3] = raw[0x0];
17 
18     // reverse 4 & 5
19     fix[0x4] = raw[0x5];
20     fix[0x5] = raw[0x4];
21 
22     // reverse 6 & 7
23     fix[0x6] = raw[0x7];
24     fix[0x7] = raw[0x6];
25 
26     // all other are unchanged
27     fix[0x8] = raw[0x8];
28     fix[0x9] = raw[0x9];
29     fix[0xA] = raw[0xA];
30     fix[0xB] = raw[0xB];
31     fix[0xC] = raw[0xC];
32     fix[0xD] = raw[0xD];
33     fix[0xE] = raw[0xE];
34     fix[0xF] = raw[0xF];
35 
36     return new Guid(fix);
37 }

style="font-family: Microsoft YaHei; font-size: 16px"> 小结:
style="font-family: Microsoft YaHei; font-size: 16px"> style="font-family: Microsoft YaHei; font-size: 16px">     UuidCreateSequential函数存在隐秘的难点,不适合集群景况,並且须求再度排序后再付出到数据库;

     UuidCreateSequential函数

     大家都清楚SQL Server数据库有三个NewSequentialId()函数,用于创造有序GUID。在开创表时,能够将它设置成为GUID类型字段的暗许值,在插入新添多少时自动创立主键的值(该函数只好做为字段的暗许值,无法一贯在SQL中调用)。

     示例:

1 Create Table TestTable
2        (
3          ID UniqueIdentifier Not Null Default ( NewSequentialId() ) ,
4          Number Int
5        );

NewSequentialId()函数只能在数据库使用,可是在 Microsoft 的 MSDN 文书档案中有证实,NEWSEQUENTIALID 是对 Windows UuidCreateSequential 函数的包裹,。那样大家得以在C#经过非托管方法调用:

 1 [System.Runtime.InteropServices.DllImport("rpcrt4.dll", SetLastError = true)]
 2    private static extern int UuidCreateSequential(out Guid guid);
 3 
 4    public static Guid NewSequentialGuid()
 5    {
 6        const int RPC_S_OK = 0;
 7 
 8        int result = UuidCreateSequential(out var guid);
 9        if (result != RPC_S_OK) {
10            throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error());
11        }
12 
13        return guid;
14    }

     不这些点子也设有七个难题:

  1. 以此艺术涉及到安全主题素材,UuidCreateSequential函数重视的乘除硬件,该措施的后十二人其实是网卡的MAC地址。那是自己计算机生成的一组有序GUID。

style="font-family: Microsoft YaHei; font-size: 16px">{A2A93393-C8DC-11E7-B133-2C56DC497A97}

{A2A93394-C8DC-11E7-B133-2C56DC497A97}

{A2A93395-C8DC-11E7-B133-2C56DC497A97}

{A2A93396-C8DC-11E7-B133-2C56DC497A97}

{A2A93397-C8DC-11E7-B133-2C56DC497A97}

{A2A93398-C8DC-11E7-B133-2C56DC497A97}

{A2A93399-C8DC-11E7-B133-2C56DC497A97}

{A2A9339A-C8DC-11E7-B133-2C56DC497A97}

{A2A9339B-C8DC-11E7-B133-2C56DC497A97}

{A2A9339C-C8DC-11E7-B133-2C56DC497A97}

     那是作者计算机的网卡的MAC地址:

     澳门新萄京官方网站 10

  1. 由于UuidCreateSequential函数生成的有序GUID中归纳MAC地址,所以一旦在服务器集群情状中,料定存在一台服务器A上转移的静止GUID总比另一台服务器B生成要越来越小,服务器A产生的数量插入到数据库时,由于聚焦索引的难题,总是会移动服务器B已经长久化到数据库中的数据。集群的服务器越多,发生的IO难点更要紧。在服务器会集意况中,供给活动落成有序GUID。

  2. UuidCreateSequential函数生成的GUID法则与SQL Server中排序的准则存在不等同,那样依旧会招致惨恻的IO难题,所以须求将GUID重新排序后再悠久化到数据库。例如地点列出变换的GUID列表,依次生成的数额足以看来,是第1位字节在自增进,在那与其余三个数据库的排序法则都不平等;关于该函数生成的法则,能够见此链接:。

     下边包车型大巴艺术是将转换的GUID调治成为适合Sql Server使用的平稳GUID(针对任何数据库支持,您能够按排序法则自行修改):

 1 [System.Runtime.InteropServices.DllImport("rpcrt4.dll", SetLastError = true)]
 2 static extern int UuidCreateSequential(byte[] buffer);
 3 
 4 static Guid NewSequentialGuid() {
 5 
 6     byte[] raw = new byte[16];
 7     if (UuidCreateSequential(raw) != 0)
 8         throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error());
 9 
10     byte[] fix = new byte[16];
11 
12     // reverse 0..3
13     fix[0x0] = raw[0x3];
14     fix[0x1] = raw[0x2];
15     fix[0x2] = raw[0x1];
16     fix[0x3] = raw[0x0];
17 
18     // reverse 4 & 5
19     fix[0x4] = raw[0x5];
20     fix[0x5] = raw[0x4];
21 
22     // reverse 6 & 7
23     fix[0x6] = raw[0x7];
24     fix[0x7] = raw[0x6];
25 
26     // all other are unchanged
27     fix[0x8] = raw[0x8];
28     fix[0x9] = raw[0x9];
29     fix[0xA] = raw[0xA];
30     fix[0xB] = raw[0xB];
31     fix[0xC] = raw[0xC];
32     fix[0xD] = raw[0xD];
33     fix[0xE] = raw[0xE];
34     fix[0xF] = raw[0xF];
35 
36     return new Guid(fix);
37 }

style="font-family: Microsoft YaHei; font-size: 16px"> 小结:
style="font-family: Microsoft YaHei; font-size: 16px"> style="font-family: Microsoft YaHei; font-size: 16px">     UuidCreateSequential函数存在隐秘的主题素材,不切合集群情况,而且要求再行排序后再交由到数据库;

NEWSEQUENTIALID 是对 Windows UuidCreateSequential 函数的包装。

SequentialGuid框架

SequentialGuid框架也是自己要推荐给您,因为它提供了常见数据库生成有序Guid的消除方案。

关于该框架的宏图思路以及针对各类数据库的性质测量试验,见链接:。

运用方法,提出您仿照效法ABP框架,在ABP中选取SequentialGuid框架来扭转有序GUID,关键代码链接:。

优化方案:

  1. 为了缓和UUID不可读,能够应用UUID to Int64的不二法门。

  2. GUID


GUID:是微软对UUID那么些标准的兑现。UUID还会有别的种种实现,不仅仅GUID一种。优劣势同UUID。

     COMB化解方案

     COMB 类型的GUID 是由Jimmy Nilsson在他的“The Cost of GUIDs as Primary Keys”一文中规划出来的。
     基本布署思路是那样的:既然GUID数据变动是私下的导致索引作用低下,影响了系统的属性,那么能否经过整合的法子,保留GUID的前12个字节,用后6个字节表示GUID生成的日子(DateTime),这样大家将时间新闻与GUID组合起来,在保留GUID的独一性的相同的时候扩大了有序性,以此来拉长索引功用(那是指向Sql Server数据库来设计的)。

     在NHibernate框架中早已落到实处该意义,可以在github上收看落成情势:。

     在EF以及EF Core也一致完成了看似的减轻方案,EF Core的达成格局:

     在此处介绍一下施用的不二等秘书籍,由EF Core框架自动生成有序GUID的必须要经过的路:

 1 public class SampleDbContext : DbContext
 2 {
 3     protected override void OnModelCreating(ModelBuilder modelBuilder)
 4     {
 5         modelBuilder.Entity<GuidEntity>(b =>
 6         {
 7             b.Property(e => e.Id).HasValueGenerator<SequentialGuidValueGenerator>();
 8         });
 9     }
10 }

 唯独请留神,那多个ORM的缓慢解决方案只针对Sql Server数据库,因为只保险了最终四位字节是按顺序来扭转的。

     COMB消除方案

     COMB 类型的GUID 是由Jimmy Nilsson在他的“The Cost of GUIDs as Primary Keys”一文中筹算出来的。
     基本安插思路是这么的:既然GUID数据变化是轻便的诱致索引效用低下,影响了系统的质量,那么能或无法通过结合的措施,保留GUID的前十个字节,用后6个字节表示GUID生成的岁月(DateTime),那样我们将时刻消息与GUID组合起来,在保留GUID的独一性的同一时候扩充了有序性,以此来加强索引效用(那是针对Sql Server数据库来规划的)。

     在NHibernate框架中已经达成该功用,可以在github上见到完结格局:。

     在EF以及EF Core也同样达成了就像的化解方案,EF Core的落到实处际意况势:

     在此间介绍一下采用的主意,由EF Core框架自动生成有序GUID的秘诀:

 1 public class SampleDbContext : DbContext
 2 {
 3     protected override void OnModelCreating(ModelBuilder modelBuilder)
 4     {
 5         modelBuilder.Entity<GuidEntity>(b =>
 6         {
 7             b.Property(e => e.Id).HasValueGenerator<SequentialGuidValueGenerator>();
 8         });
 9     }
10 }

 不过请留意,那七个ORM的化解方案只针对Sql Server数据库,因为独有限支撑了最终三个人字节是按顺序来变化的。

https://msdn.microsoft.com/zh-cn/library/ms189786(v=sql.120).aspx.aspx)

总结

大家来缓和一下:

  1. 在数据库中最佳永不选拔随机的GUID,它会影响属性;
  2. 在SQL Server中提供了NewSequentialId函数来变化有序GUID;
  3. 各种数据库对GUID接济的不均等,并且排序的平整也不一致样;
  4. UuidCreateSequential函数存在隐衷的标题,不吻合集群情形,并且需求再行排序后再交给到数据库;
  5. 各ORM框架提供了平稳GUID的辅助,然则其实只是指向Sql Server数据库设计的;
  6. 推荐你使用SequentialGuid框架,它化解了大多数据库以及集群境况的难题。

4. COMB

COMB(combine)型是数据库特有的一种设计思想,可以知道为一种立异的GUID,它经过整合GUID和连串时间,以使其在目录和找寻事有更优的性质。
  数据库中从不COMB类型,它是吉姆my Nilsson在他的“The Cost of GUIDs as Primary Keys”一文中安顿出来的。
  COMB数据类型的基本安顿思路是这么的:既然UniqueIdentifier数据因并非规律可言造成索引成效低下,影响了系统的性质,那么大家能否通过结合的章程,保留UniqueIdentifier的前十二个字节,用后6个字节表示GUID生成的大运(DateTime),那样我们将时间音信与UniqueIdentifier组合起来,在保留UniqueIdentifier的独一性的还要增添了有序性,以此来巩固索引作用。

     SequentialGuid框架

     SequentialGuid框架也是自己要引入给您,因为它提供了周边数据库生成有序Guid的缓和方案。

     关于该框架的宏图思路以及针对各类数据库的性质测量检验,见链接:。

     使用方法,提出你参谋ABP框架,在ABP中动用SequentialGuid框架来扭转有序GUID,关键代码链接:。

总结

style="font-family: Microsoft YaHei; font-size: 16px">大家来总结一下:

  1. style="font-family: Microsoft YaHei; font-size: 16px">在数据库中最好永不采用随机的GUID,它会影响属性;
  2. 在SQL Server中提供了NewSequentialId函数来变化有序GUID;
  3. style="font-family: Microsoft YaHei; font-size: 16px">种种数据库对GUID援助的不雷同,何况排序的条条框框也不相同;
  4. style="font-family: Microsoft YaHei; font-size: 16px">UuidCreateSequential函数存在隐秘的主题材料,不切合集群遭受,何况必要再行排序后再交由到数据库;
  5. style="font-family: Microsoft YaHei; font-size: 16px">各ORM框架提供了平稳GUID的协助,可是实际只是对准Sql Server数据库设计的;
  6. style="font-family: Microsoft YaHei; font-size: 16px">推荐你使用SequentialGuid框架,它消除了半数以上据库以及集群蒙受的难题。

 

 转发链接:

     SequentialGuid框架

     SequentialGuid框架也是自家要引入给您,因为它提供了宽广数据库生成有序Guid的消除方案。

     关于该框架的希图思路以及针对性种种数据库的性质测验,见链接:。

     使用格局,建议你仿照效法ABP框架,在ABP中利用SequentialGuid框架来变化有序GUID,关键代码链接:。

总结

style="font-family: Microsoft YaHei; font-size: 16px">大家来总括一下:

  1. style="font-family: Microsoft YaHei; font-size: 16px">在数据库中最佳永不采取随机的GUID,它会影响属性;
  2. 在SQL Server中提供了NewSequentialId函数来变化有序GUID;
  3. style="font-family: Microsoft YaHei; font-size: 16px">各样数据库对GUID支持的不雷同,并且排序的法则也分化样;
  4. style="font-family: Microsoft YaHei; font-size: 16px">UuidCreateSequential函数存在隐秘的主题素材,不吻合集群意况,何况须要再行排序后再交给到数据库;
  5. style="font-family: Microsoft YaHei; font-size: 16px">各ORM框架提供了稳步GUID的帮衬,不过事实上只是本着Sql Server数据库设计的;
  6. style="font-family: Microsoft YaHei; font-size: 16px">推荐您使用SequentialGuid框架,它化解了绝大多数据库以及集群情况的主题材料。

 

 转发链接:

大家系统中对UuidCreateSequential 方法的庞大是如此写的,代码如下:

优点:

  1. 杀鸡取蛋UUID冬辰的标题,在其主键生成情势中提供了Comb算法(combined guid/timestamp)。保留GUID的13个字节,用另6个字节表示GUID生成的时间(DateTime)。
  2. 属性优于UUID。

  3. Twitter的snowflake算法


snowflake是推特(TWTR.US)开源的布满式ID生成算法,结果是一个long型的ID。其核心理想是:使用41bit用作飞秒数,10bit看成机器的ID(5个bit是数额主题,5个bit的机器ID),12bit看成微秒内的流水号(意味着各个节点在每纳秒可以生出 4096 个 ID),最终还应该有三个符号位,永世是0。snowflake算法能够依据我项目标供给进行一定的修改。譬喻推断今后的数量基本个数,每一个数据主导的机器数以及统一阿秒能够能的并发数来调动在算法中所须求的bit数。

 

优点:

  1. 不借助于于数据库,灵活方便,且品质优于数据库。
  2. ID依据时间在单机上是雨后春笋的。
    public static class GuidExtension
    {
        [DllImport("rpcrt4.dll", SetLastError = true)]
        public static extern int UuidCreateSequential(out Guid guid);
        private const int RPC_S_OK = 0;

        public static Guid CreateRpcrt4Guid()
        {
            Guid guid;
            int result = UuidCreateSequential(out guid);
            if (result == RPC_S_OK)
            {
                byte[] guidBytes = guid.ToByteArray();
                Array.Reverse(guidBytes, 0, 4);
                Array.Reverse(guidBytes, 4, 2);
                Array.Reverse(guidBytes, 6, 2);

                return new Guid(guidBytes);
            }
            else
                return Guid.NewGuid();
        }

    }

缺点:

  1. 在单机上是多如牛毛的,不过出于涉及到分布式意况,每台机器上的时钟不恐怕完全同步,也会有时候也会冒出不是大局递增的动静。

 

参考:

  1. 布满式系统独一ID生成方案汇总
  2. UUID 、GUID、COMB 的区分与联系
  3. UUID 和 GUID 的区别
  4. The Cost of GUIDs as Primary Keys
  5. Integer GUID和Comb做主键的功效测量检验(Delphi access)(三)
  6. Instagram-Snowflake项目地址(Tags:snowflake-二〇一〇)
  7. 哪些在高并发布满式系统中生成全局独一Id
  8. Twitter-Snowflake(陆十三位布满式ID算法)深入分析与JAVA达成

转载注解出处,作者就不和你争持。
by Donney Young
http://www.jianshu.com/p/a0a3aa888a49

  有以下几个破绽:

  1、暴漏MAC地址:NEWSEQUENTIALID函数最终6个字符是网卡的MAC地址

  能够实践看一下

create table #t
(
    id uniqueidentifier not null  default newsequentialid()
    ,name varchar(100)
)
go

insert into #t(name)
output inserted.id
values('a')

 

  2、假设举行数量迁移,到另一台机器上,MAC地址更动就能够引起页的争用。

    因为GUID在的SQL Server的值大小的比对是这么的:

with uids as (
            select id =  1, uuid = cast ('00000000-0000-0000-0000-010000000000' as uniqueidentifier)
    union   select id =  2, uuid = cast ('00000000-0000-0000-0000-000100000000' as uniqueidentifier)
    union   select id =  3, uuid = cast ('00000000-0000-0000-0000-000001000000' as uniqueidentifier)
    union   select id =  4, uuid = cast ('00000000-0000-0000-0000-000000010000' as uniqueidentifier)
    union   select id =  5, uuid = cast ('00000000-0000-0000-0000-000000000100' as uniqueidentifier)
    union   select id =  6, uuid = cast ('00000000-0000-0000-0000-000000000001' as uniqueidentifier)
    union   select id =  7, uuid = cast ('00000000-0000-0000-0100-000000000000' as uniqueidentifier)
    union   select id =  8, uuid = cast ('00000000-0000-0000-0010-000000000000' as uniqueidentifier)
    union   select id =  9, uuid = cast ('00000000-0000-0001-0000-000000000000' as uniqueidentifier)
    union   select id = 10, uuid = cast ('00000000-0000-0100-0000-000000000000' as uniqueidentifier)
    union   select id = 11, uuid = cast ('00000000-0001-0000-0000-000000000000' as uniqueidentifier)
    union   select id = 12, uuid = cast ('00000000-0100-0000-0000-000000000000' as uniqueidentifier)
    union   select id = 13, uuid = cast ('00000001-0000-0000-0000-000000000000' as uniqueidentifier)
    union   select id = 14, uuid = cast ('00000100-0000-0000-0000-000000000000' as uniqueidentifier)
    union   select id = 15, uuid = cast ('00010000-0000-0000-0000-000000000000' as uniqueidentifier)
    union   select id = 16, uuid = cast ('01000000-0000-0000-0000-000000000000' as uniqueidentifier)
)
select * from uids order by uuid desc

 

出口结果:

澳门新萄京官方网站 11  类似 汉字的三点水偏旁(为了好记)


从此处可以看到,MAC地址对GUID的高低有那最高的决定性,那就变成在多少迁移的时候出难题。

 

COMB化解方案


 

 COMB 类型的GUID 基本安顿思路是那样的:既然GUID数据变动是不管三七二十一的导致索引效能低下,影响了系统的天性,那么能还是不可能由此结合的艺术,保留GUID的前11个字节,用后6个字节表示GUID生成的小时(DateTime),这样大家将时刻新闻与GUID组合起来,在保留GUID的独一性的还要扩展了有序性,以此来升高索引功能。

 

前13个字节是经过随机数变化

private static readonly RNGCryptoServiceProvider RandomGenerator = new RNGCryptoServiceProvider();

      byte[] randomBytes = new byte[10];
      RandomGenerator.GetBytes(randomBytes);

 

 

后四个字节用时间变化

      long timestamp = DateTime.UtcNow.Ticks / 10000L;
      byte[] timestampBytes = BitConverter.GetBytes(timestamp);

      if (BitConverter.IsLittleEndian)
      {
        Array.Reverse(timestampBytes);
      }

 

 

说起底结合起来

    byte[] guidBytes = new byte[16];
    Buffer.BlockCopy(randomBytes, 0, guidBytes, 0, 10);
    Buffer.BlockCopy(timestampBytes, 2, guidBytes, 10, 6); 

    return new Guid(guidBytes);

 

 

其一消除办法是被世家所认同的,独一感到倒霉的地方是,在连忙获得相当多的GUID的时候,时间是完全一样的,加上自由变化的多寡,这一组数据是大小不一的。假设数据Curry有不计其数数目,这一组数据确定比她们都大,品质应该没非常。

github地址:

 

本人的缓慢解决方法


 

小结地点的不二法门,UuidCreateSequential 前面十二个字节有序,后6个是MAC地址。COMBO消除方案是眼下13个随机,后五个是光阴。作者是将那三个组成起来

前拾二个去UuidCreateSequential 方法的值,后6个取时间

代码:

public static Guid NewSequentialGuid()
    {
        const int RPC_S_OK = 0;
        Guid guid;
        int result = UuidCreateSequential(out  guid);

        if (result != RPC_S_OK)
        {
            throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error());
        }
        else
        {
       //这里把UuidCreateSequential函数返回的数据做处理
            byte[] guidBytes = guid.ToByteArray();
            Array.Reverse(guidBytes, 0, 4);
            Array.Reverse(guidBytes, 4, 2);
            Array.Reverse(guidBytes, 6, 2);

       //这里用时间
            long timestamp = DateTime.UtcNow.Ticks / 10000L;
            byte[] timestampBytes = BitConverter.GetBytes(timestamp);

            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(timestampBytes);
            }
       //最后把时间赋值给后6位
            Buffer.BlockCopy(timestampBytes, 2, guidBytes, 10, 6);
            return new Guid(guidBytes);
        }


    }

    [System.Runtime.InteropServices.DllImport("rpcrt4.dll", SetLastError = true)]
    private static extern int UuidCreateSequential(out Guid guid);

 

此间能够在程序调用,作为DBA在数据库使用的话能够将这一个办法增添到程序集里,须要多少改换

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlTypes;

public class FunctionNewGuid
{
  //这里需要添加SqlFunction属性
  //返回类型是数据库类型

    [Microsoft.SqlServer.Server.SqlFunction]
    public static SqlGuid NewSequentialGuid()
    {
        const int RPC_S_OK = 0;
        Guid guid;
        int result = UuidCreateSequential(out  guid);

        if (result != RPC_S_OK)
        {
            throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error());
        }
        else
        {
            byte[] guidBytes = guid.ToByteArray();
            Array.Reverse(guidBytes, 0, 4);
            Array.Reverse(guidBytes, 4, 2);
            Array.Reverse(guidBytes, 6, 2);

            long timestamp = DateTime.UtcNow.Ticks / 10000L;
            byte[] timestampBytes = BitConverter.GetBytes(timestamp);

            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(timestampBytes);
            }
            Buffer.BlockCopy(timestampBytes, 2, guidBytes, 10, 6);
            return new SqlGuid(guidBytes);
        }


    }

    [System.Runtime.InteropServices.DllImport("rpcrt4.dll", SetLastError = true)]
    private static extern int UuidCreateSequential(out Guid guid);
}

 

编写翻译生成DLL后,注册到数据库

--设置数据库是可信任
 ALTER DATABASE TEST SET TRUSTWORTHY ON

 --创建程序集
 CREATE ASSEMBLY SQLCLR FROM 'D:SQLCLR.DLL'
 WITH PERMISSION_SET = UNSAFE


 --用程序集方法创建函数
 CREATE FUNCTION func_NewSequentialGuid()
    RETURNS uniqueidentifier
AS external name SQLCLR.FunctionNewGuid.NewSequentialGuid

 

    

测量试验代码:

 批量乞求:


 

select dbo.func_NewSequentialGuid() 
union
select dbo.func_NewSequentialGuid() 
union
select dbo.func_NewSequentialGuid() 
union
select dbo.func_NewSequentialGuid() 
union
select dbo.func_NewSequentialGuid() 

 结果:

 澳门新萄京官方网站 12

 

 数十次呼吁:


 

create table #t
(
    uuid uniqueidentifier 
    ,id int identity
)
go

insert into #t(uuid)
values(dbo.func_NewSequentialGuid())
go 10

select * from #t

 

 澳门新萄京官方网站 13

 

git地址

https://gitee.com/wangzhanbo/cms/tree/master/Library

 

设若有标题,希望大家指正。。。

 

 

本文由澳门新萄京官方网站发布于数据库网络,转载请注明出处:澳门新萄京官方网站:多数据库有序GUID,集群数

关键词: