What data type is recommended for ID columns?

后端 未结 9 1662
既然无缘
既然无缘 2021-02-08 04:35

I realize this question is very likely to have been asked before, but I\'ve searched around a little among questions on StackOverflow, and I didn\'t really find an answer to

相关标签:
9条回答
  • 2021-02-08 05:09

    Follow Cletus's advice, with the additional caveat of it largely depends on what your storting. Never, ever, use a GUID. GUID's have a whole bundle of downsides, and only one or two upsides.

    0 讨论(0)
  • 2021-02-08 05:14

    Tell me what criteria you think are important.

    What's required is to be unique within the table.

    A GUID is a global probabilistically-unique identifier. It's also big. If you need your indices to be unique to within epsilon over every other database installation in the universe, it's a good choice. Otherwise, it's using lots of space unnecessarily.

    An autoincrement number is good; it's small, and sure to be unique within the table. On the other hand, it gives you no protection against duplication; two entries, identical except for the magic number, are easy to create.

    Using some value that is tied to the entity being describes avoids that, but you have the problem of dealing with uniqueness.

    0 讨论(0)
  • 2021-02-08 05:18

    Any integer type of sufficient size to store anticipated data ranges. Generally 32 bit ints are viewed as too small (rightly or wrongly) for tables with a lot of rows or changes. A 64 bit int is plenty. Many databases won't have or won't use that integer type but will use a NUMBER type with specified scale and precision. 10-15 digits is a fairly common size.

    The reason for choosing integer types is twofold:

    1. Size; and
    2. Speed.

    The size of an integer is:

    • 32 bit: 4 bytes;
    • 64 bit: 8 bytes;
    • Binary coded decimal: two digits per byte plus as much as a byte for sign, scale and/or precision.

    Compare that to a GUID, which is 128 bits or a normal string, which is at least one byte per character (more in certain character encodings) plus an overhead that might be as little as one byte (terminating null) or could be much more in some cases.

    Sorting integers is trivial and, assuming they are unique and the range is sufficiently small, can actually be done in O(n) time, compared to, at best, O(n log n).

    also, just as importantly, most databases can generate unique IDs by means of auto-increment columns and/or sequences. Guaranteeing uniqueness in an application is otherwise actually quite hard and tends to result in bloated keys.

    Plus auto-generated integer keys are typically either loosely or absolutely ordered (depending on database and configuration), which is a useful quality. Randomly generated GUIDs are basically unordered, which is far less useful.

    0 讨论(0)
  • 2021-02-08 05:18

    Popular databases allow for larger autoincrement fields for years now, so it's much less of an issue.

    As for what to use, it's always a choice. One is not clearly better than the other, they have different characteristics and each is good in different scenarios. I have used both over time, and the next schema I work with I'll consider both.

    Pros for GUID:

    • Should be unique across computers.
    • Random, unmemorable goo means people are likely to use this only for its intended purpose of an opaque identifier.

    Pros for autoincrement:

    • Human understandable.
    • Sequential assignment means you can use a clustered index and impact performance.
    • Suitable for data partitioning.
    0 讨论(0)
  • 2021-02-08 05:18

    A big disadvantage of using GUID keys is that it is difficult to perform "ad-hoc" queries by hand. Sometimes it is very useful that you can do this:

    SELECT * FROM User where UserID=452245

    With GUID keys this can become very annoying.

    I would recommend 64 bit integers

    0 讨论(0)
  • 2021-02-08 05:20

    If you use a long, you could create over 1000 a second and not run out of primary keys for 29 million years.

    Others have already mentioned some of the advantages of using an integer type instead of a UUID/GUID. One of the big advantages is the speed and compactness of the indexes.

    An application I was recently involved in where I did the database design, I needed UUIDs, but didn't want to give up the advantages of using longs for primary keys, so I had a "allIds" table that mapped every primary key in the system to a UUID. All my primary keys were generated from a single sequence, so they were all unique across all tables.

    0 讨论(0)
提交回复
热议问题