Více

Existuje způsob auto_increment pro sloupec ID v QGIS

Existuje způsob auto_increment pro sloupec ID v QGIS


Vytvářím fiktivní mapu, a proto potřebuji vytvořit spoustu bodů, linií a pro jistotu mnohoúhelníků. Později exportuji svá data jako geojson. Ale předtím musím vždy jít a dát každému prvku jedinečné ID.

Nepotřebuji speciální třídění, protože největší polygon dostane nejmenší ID nebo tak nějak. já jen potřeba Všechno mnohoúhelníky s an ID na konci, bez dělá to ručně jako to teď musím udělat.

Bylo by skvělé, kdyby někdo věděl, jak to udělat.


Cesta polní kalkulačkou je způsob, jak jít:

Nebylo zadáno žádné ID

  1. Digitalizujte všechny funkce bez zadávání ID.
  2. Před exportem aktualizujte jedinečná ID pomocí výrazu „$ Id“ pomocí polní kalkulačky.

Některá ID jsou již uvedena v

  1. Pokud již máte ID, můžete použít '- $ Id'. Ujistěte se, že jste právě vybrali nové funkce, což znamená, že jsou v řádku id 'NULL'. Jednoduše to proveďte objednáním sloupce.
  2. Nyní proveďte kroky z obrázků:


Aleluja! Nebo Heuréka. Nebo cokoli jiného. Toho lze dosáhnout. S tvarovým souborem.

  1. Pokud ještě žádný neexistuje, přidejte pole, které bude obsahovat ID funkce, například „FID“, typu Celé číslo (celé číslo).
  2. Otevřeno Vlastnosti vrstvy (klikněte pravým tlačítkem na vrstvu a vyberte Vlastnosti… nebo poklepejte na vrstvu), klikněte na Atributy Form karta, poté pod Všeobecné zrušte zaškrtnutí Upravitelné a pod Výchozí nastavení v oboru Výchozí hodnota typmaximum („FID“) + 1.

Zrušením zaškrtnutí Upravitelné, nemůžete zadat jinou hodnotu nebo smazat, co tam je. Všimněte si, že pokud existují hodnoty bez ID, nebudou tyto hodnoty aktualizovány. V určitém okamžiku budu experimentovat s kontrolou Při aktualizaci použít výchozí hodnotu a revize mého vzorce pro kontrolu nulové nebo NULL hodnoty, aby se aktualizovaly pouze ty záznamy, když jsou editovány, ne žádný záznam s hodnotou větší než 1. (Dříve v tomto příspěvku bylo diskutováno, jak aktualizovat pole FID s jedinečnými hodnotami, což budete muset udělat, pokud jste pole přidali poté, co již byly v obrazci soubory.)

Všimněte si, že je to uloženo s aktuálním mapovým souborem, nikoli s obrazcem, takže přidání tohoto souboru s tvarem několikrát vyžaduje, abyste tuto část stylu vrstvy zkopírovali do nově přidané vrstvy. Chcete-li to provést, klepněte pravým tlačítkem na vrstvu a vyberte Styly> Kopírovat styl> Polea klikněte pravým tlačítkem na jinou vrstvu, vyberte Styly> Vložit styl> Všechny kategorie stylů (nebo pokračovat do Pole). Tuto část stylu můžete také zkopírovat do jakékoli jiné vrstvy na základě obrazce, ale pole ID musí mít stejný název jako vrstva, ze které kopírujete.


Chtěl bych přidat k příspěvku vinayan a krátce zmínit rownum funkce, protože je velmi podobná a v některých případech může být trochu pohodlnější.

id vrací ID funkce, což znamená, že to vždy začíná na nula.
rownum vrací číslo řádku, což znamená, že začíná na jeden.

V zásadě tedy, pokud chcete, aby automatický přírůstek začínal na 0, jděte na $ id, a pokud chcete, aby to začalo v 1, jděte na $ rownum.


Aktualizace pro QGIS 3

Vím, že jsem na to docela pozdě, ale vždy je dobré poskytovat jakékoli aktualizace:

V QGIS 3 nyní existuje nativní nástroj, který lze použít k provedení této přesné úlohy, a nazývá se „Přidat autoincrementální pole“

Není třeba používat výraz v polní kalkulačce ani provádět jakékoli kódování, ale přesto jsou všechny stále velmi užitečné a je dobré je vědět.


Přišlo toto téma: Vytvoření Shapefile s primárním klíčem automatického zvyšování v QGIS

Moje návrhy by byly:

1) Databáze SQLITE / SpatialLite podporují automatické zvyšování v poli nastaveném na INTEGER PRIMARY KEY:

Pokud na VLOŽCE není sloupci ROWID nebo INTEGER PRIMARY KEY explicitně dána hodnota, bude automaticky vyplněn nevyužitým celým číslem, obvykle o jeden větší než největší ROWID, který se aktuálně používá. To platí bez ohledu na to, zda se používá klíčové slovo AUTOINCREMENT.

Pokaždé, když upravujete / vytváříte polygony, můžete vyplnit jejich atributy a SQLITE mu dá přírůstkovou jedinečnou hodnotu v poli, které jste nastavili na typ INTEGER PRIMARY KEY.

Když jste připraveni exportovat do GEOJSONu, máte vše nastaveno na vaše UNIQUE ID.

2) Pokud používáte Shapefiles, vytvořte pole OBJECTID typu INTEGER a pomocí výrazu kalkulačky pole vyplňte toto pole pokaždé, když upravujete / vytváříte polygony a potřebujete je exportovat. Ztratíte původní ID, které kdysi polygon měl, ale toto je jediný způsob, jak toho dosáhnout pomocí .SHP. (Budu muset najít výraz polní kalkulačky).

PostGIS je další zdroj dat, který byste možná chtěli prozkoumat, i když je to spíše těžký výtah než SQLITE, můžete v takovém systému najít hodnotu, jak budete postupovat vpřed ...


Starý příspěvek, ale pro kohokoli jiného, ​​kdo hledá rychlé řešení, bylo vytvořit pole s $ ID + 1 a automaticky se vygeneruje počínaje 1!


Pokud nepotřebujete něco lidsky digestlible, nyní existuje snadná oprava: V poli vlastností vyberte „Generátor UUID“ a nechejte vše prázdné.

Tím se automaticky vytvoří UUID v poli. Ne tak přátelské jako jednoduché číslo (podle $ id nebo $ rownum), ale generuje UUID hned od začátku, takže žádné další kroky.


stačí smazat první sloupec (id) a vytvořit nový "Jako virtuální pole"


Jednoduše zkopírujte soubory a vytvořte kopii CSV a znovu zobrazte vytváření OID a exportujte jako nový tvarový soubor nebo třídu prvků.


tato řešení pro mě již v QGIS 2.01 Dufour nefungovala. Psaní na stroji$ idna novém nebo stávajícím poli s názvem 'id' ve vstupním poli výrazu se mi zobrazila chyba „Výraz je neplatný“

Co fungovalo, bylo napsat funkci$ rownuma poté klikněte na „OK“


Nejjednodušší způsob, jak to udělat, by bylo pravděpodobně pomocí skriptu pythonu nebo možná pomocí polní kalkulačky. Promiň, že pro tebe žádný nemám, možná někdo jiný bude. Mezitím jsem pro něj hledal pythonovský skript. Viděl jsem toho hodně pro ArcGIS, ale jsem si jist, že pro QGIS něco existuje.


Problém s automatickým přírůstkem v MYSQL

Chci ponechat JOB_NAME, SANDBOX, PARENT_JOB_NAME jako primární klíč a JOB_ID jako automatický přírůstek, protože používám „ON DUPLICATE KEY UPDATE“ a kvůli automatickému přírůstku vkládá nové řádky a vytváří duplikát v tabulce.

A při odstraňování job_id z primárního klíče. Zobrazuje se mi chyba „Nesprávná definice tabulky může být pouze jeden automatický sloupec a musí být definován jako klíč"


17 odpovědí 17

Nikdy není špatný nápad mít zaručený jedinečný identifikátor řádku. Myslím, že bych neměl říkat nikdy & ndash, ale pojďme s drtivou většinou času je to dobrý nápad.

Teoretické potenciální nevýhody zahrnují další index pro údržbu a další využitý úložný prostor. To pro mě nikdy nebylo dost důvodu, abych ho nepoužíval.

TLDR: Pokud ještě nemáte jedinečný způsob identifikace jednotlivých řádků, použijte místo automatického přírůstku UUID.

Nesouhlasím se všemi odpověďmi dříve. Existuje mnoho důvodů, proč není dobrý nápad přidat do všech tabulek pole automatického přírůstku.

Pokud máte tabulku, kde nejsou žádné zřejmé klíče, zdá se pole s automatickým přírůstkem jako dobrý nápad. Nakonec nechcete vybrat * z blogu, kde body = '[řetězec 10 000 znaků]'. Raději vyberete * z blogu, kde>. Tvrdil bych, že ve většině těchto případů to, co opravdu chcete, je jedinečný identifikátor, nikoli sekvenční jedinečný identifikátor. Pravděpodobně budete místo toho chtít použít univerzálně jedinečný identifikátor.

Ve většině databází existují funkce pro generování náhodných jedinečných identifikátorů (uuid v mysql, postgres. Newid v mssql). Ty vám umožňují generovat data do více databází, na různých počítačích, kdykoli, bez vzájemného síťového připojení, a stále slučovat data s nulovými konflikty. To vám umožní snadněji nastavit více serverů a dokonce i datových center, například pomocí mikroslužeb.

Tím se také zabrání tomu, aby útočníci hádali adresy URL stránek, ke kterým by neměli mít přístup. Pokud existuje https://example.com/user/1263, pravděpodobně existuje také https://example.com/user/1262. To by mohlo umožnit automatizaci zneužití zabezpečení na stránce profilu uživatele.

Existuje také spousta případů, kdy je uuid sloupec zbytečný nebo dokonce škodlivý. Řekněme, že máte sociální síť. K dispozici je tabulka uživatelů a tabulka přátel. Tabulka přátel obsahuje dva sloupce userid a pole s automatickým přírůstkem. Chcete, aby se 3 stali přáteli s 5, takže vložíte 3,5 do databáze. Databáze přidá ID automatického přírůstku a uloží 1,3,5. Uživatel 3 nějakým způsobem znovu klikne na tlačítko & quotadd přítel & quot. Vložíte 3,5 do databáze znovu, databáze přidá ID automatického přírůstku a vloží 2,3,5. Ale teď jsou 3 a 5 navzájem přátelé dvakrát! To je ztráta místa, a pokud o tom přemýšlíte, tak i sloupec s automatickým přírůstkem. Vše, co potřebujete zjistit, zda jsou a a b přátelé, je vybrat řádek s těmito dvěma hodnotami. Společně jsou jedinečným identifikátorem řádku. (Pravděpodobně byste chtěli napsat nějakou logiku, abyste se ujistili, že 3,5 a 5,3 jsou deduplikovány.)

Stále existují případy, kdy mohou být užitečná sekvenční ID, jako například při vytváření zkracovače adres URL, ale většinou (a dokonce i se zkracovačem adresy URL) je místo toho náhodně vygenerované jedinečné ID.

Klávesy s automatickým vkládáním mají většinou výhody.

Některé možné nevýhody však mohou být:

  • Pokud máte obchodní klíč, musíte také do tohoto sloupce (sloupců) přidat jedinečný index, abyste mohli prosazovat obchodní pravidla.
  • Při přenosu dat mezi dvěma databázemi, zejména pokud jsou data ve více než jedné tabulce (tj. Hlavní / podrobná), to není přímočaré, protože sekvence se mezi databázemi nesynchronizují a nejprve budete muset vytvořit tabulku ekvivalence pomocí obchodní klíč jako shoda pro zjištění, které ID z původní databáze odpovídá kterému ID v cílové databázi. To by však neměl být problém při přenosu dat z / do izolovaných tabulek.
  • Mnoho podniků má ad-hoc, grafické nástroje, nástroje pro vytváření zpráv typu point-and-click a drag-and-drop. Protože autoincrementální ID nemají smysl, bude pro tento typ uživatelů těžké pochopit data mimo & quotthe app & quot.
  • Pokud omylem upravíte obchodní klíč, je pravděpodobné, že tento řádek nikdy neobnovíte, protože již nemáte něco, co by ho lidé mohli identifikovat. To jednou způsobilo chybu na platformě BitCoin.
  • Někteří návrháři přidávají ID do tabulky spojení mezi dvěma tabulkami, když by PK měla být jednoduše složena ze dvou cizích ID. Je zřejmé, že pokud je tabulka spojení mezi třemi nebo více tabulkami, pak má autoincrementální ID smysl, ale pak musíte přidat jedinečný klíč, když se použije na kombinaci FK k vynucení obchodních pravidel.

Zde je část článku na Wikipedii o nevýhodách náhradních klíčů.

Jen pro opak, Ne, NEMUSÍTE mít vždy číselnou PK AutoInc.

Pokud pečlivě analyzujete svá data, často identifikujete přirozené klíče v datech. To je často případ, kdy mají data pro podnik vnitřní význam. Někdy jsou PK artefakty ze starodávných systémů, které obchodní uživatelé používají jako druhý jazyk k popisu atributů svého systému. Například jsem viděl čísla VIN vozidel použitá jako primární klíč tabulky „Vozidlo“ v systému správy vozového parku.

Jakkoli však vznikl, POKUD již máte jedinečný identifikátor, použijte jej. Nevytvářejte druhý nesmyslný primární klíč, který je zbytečný a může způsobit chyby.

Někdy můžete použít AutoInc PK ke generování smysluplné hodnoty pro zákazníka, např. Čísla zásad. Nastavit počáteční hodnotu na něco rozumného a aplikovat obchodní pravidla o vedení nul atd. Jedná se pravděpodobně o přístup „nejlepší z obou světů“.

Pokud máte malý počet hodnot, které jsou relativně statické, použijte hodnoty, které mají smysl pro uživatele systému. Proč používat 1,2,3, když můžete použít L, C, H, kde L, H a C představují život, auto a dům v kontextu typu „Pojištění“ pojištění, nebo, po návratu k příkladu VIN, co takhle „TO „pro Toyota? Všechna auta Toyata mají VIN, které začíná „TO“ Je to jedna menší věc, kterou si uživatelé pamatují, takže je pro ně méně pravděpodobné, že zavedou programovací a uživatelské chyby, a může být dokonce použitelnou náhradou za úplný popis ve správách, což zjednodušuje zprávy psát a možná rychleji generovat.

Další vývoj je pravděpodobně „most příliš daleko“ a obecně jej nedoporučuji, ale zahrnuji ho pro úplnost a můžete pro něj najít dobré využití. To znamená, že použijte popis jako primární klíč. Pro rychle se měnící data je to ohavnost. Pro velmi statická data, která se vykazují Po celou dobu, možná ne. Jen to zmíním, takže to tam sedí jako možnost.

Používám PK AutoInc, jen zapojím mozek a nejdříve hledám lepší alternativy. Umění návrhu databáze vytváří něco smysluplného, ​​na co se lze rychle dotazovat. Příliš mnoho připojení tomu brání.

EDIT Jedním dalším zásadním případem, kdy nepotřebujete automaticky generovanou PK, je případ tabulek, které představují průnik dvou dalších tabulek. Abychom se drželi analogie s autem, A Car má 0..n příslušenství, každé příslušenství najdete na mnoha automobilech. Abychom to představili, vytvoříte tabulku Car_Accessory obsahující PK z Car and Accessory a další relevantní informace o datech odkazu atd.

Co (obvykle) nepotřebujete, je AutoInc PK na tomto stole - bude k němu přístup pouze prostřednictvím automobilu „řekněte mi, jaké příslušenství je na tomto autě“ nebo z příslušenství „řekněte jim, která auta mají toto příslušenství“

Mnoho stolů již má přirozené jedinečné ID. Nepřidávejte do těchto tabulek další jedinečný sloupec id (automatický přírůstek nebo jinak). Místo toho použijte přirozené jedinečné ID. Pokud přidáte další jedinečné ID, máte v zásadě v datech redundanci (duplikaci nebo závislost). To je v rozporu s principy normalizace. Jedno jedinečné ID je kvůli přesnosti závislé na druhém. To znamená, že musí být dokonale synchronizovány vždy v každý systém který tyto řádky spravuje. Je to jen další křehkost v integritě dat, kterou opravdu nechcete dlouhodobě spravovat a ověřovat.

Většina dnešních tabulek opravdu nepotřebuje velmi malé zvýšení výkonu, které by dal další jedinečný sloupec id (a někdy to dokonce snižuje výkon). Jako obecné pravidlo v IT se vyvarujte nadbytečnosti jako mor! Odporujte všude tam, kde je vám navrženo. Je to anathema. A dejte si pozor na nabídku. Všechno by mělo být co nejjednodušší, ale ne jednodušší. Nemáte dvě jedinečná ID, kde vám bude stačit jedno, i když se vám přirozené bude zdát méně uklizené.

Na větších systémech je ID posilovačem konzistence, používejte ho téměř kdekoli. V tomto kontextu NEDOPORUČUJEME jednotlivé primární klíče, jsou ve spodním řádku drahé (přečtěte si proč).

Každé pravidlo má výjimku, takže možná nebudete potřebovat celočíselné ID automatického zvyšování na pracovní tabulky používané pro export / import a na podobné jednosměrné tabulky nebo dočasné tabulky. Také byste v distribuovaných systémech upřednostňovali identifikátory GUID namísto ID.

Mnoho odpovědí zde naznačuje, že je třeba použít stávající jedinečný klíč. I když má 150 znaků? Nemyslím si to.

Nyní můj hlavní bod:

Vypadá to, že odpůrci autoincrement integer ID mluví o malých databázích s až 20 tabulkami. Tam si mohou dovolit individuální přístup ke každému stolu.

ALE jakmile máte ERP s více než 400 tabulkami, které mají kdekoli celočíselné ID automatického zvyšování (kromě výše zmíněných případů) jen dává velký smysl. Nespoléháte na jiná jedinečná pole, i když jsou přítomna a zabezpečena pro jedinečnost.

  • Těžíte z univerzální konvence šetřící čas, úsilí a snadno zapamatovatelné konvence.
  • Ve většině případů PŘIPOJTE tabulky, aniž byste museli kontrolovat, jaké jsou klíče.
  • Se svým sloupcem s celočíselným automatickým zvyšováním můžete mít univerzální kódové rutiny.
  • Svůj systém můžete rozšířit o nové tabulky nebo uživatelské pluginy, které dříve nepředpokládali, jednoduše odkazem na ID existujících tabulek. Jsou tam již od začátku, žádné náklady na jejich přidání navíc.

Ve větších systémech může být užitečné ignorovat drobné výhody těchto jednotlivých primárních klíčů a ve většině případů důsledně používat ID celočíselného automatického zvyšování. Použití stávajících jedinečných polí jako primárních klíčů možná šetří některé bajty na záznam, ale představuje další úložiště nebo čas indexování žádný problém v dnešních databázových strojích. Ve skutečnosti ztrácíte mnohem více peněz a zdrojů na promarněný čas vývojářů / správců. Dnešní software by měl být optimalizován pro čas a úsilí programátorů - jaký přístup s konzistentními ID plní mnohem lépe.

Není nadbytečným designem nadbytečný design. Tj. - není dobrým zvykem mít vždy primární klíč s automatickým přírůstkem, pokud jeden není potřeba.

Podívejme se na příklad, kde jeden není potřeba.

Máte tabulku pro články - má primární klíč int id a sloupec varchar s názvem titul .

Máte také tabulku plnou kategorií článků - primární klíč id int, název varchar.

Jeden řádek v tabulce Články má id 5 a titul "Jak vařit husu s máslem". Chcete tento článek propojit s následujícími řádky v tabulce Kategorie: „Fowl“ (id: 20), "Husa" (id: 12), "Vaření" (id: 2), „Butter“ (id: 9).

Nyní máte 2 tabulky: články a kategorie. Jak vytvoříte vztah mezi těmito dvěma?

Můžete mít tabulku se 3 sloupci: id (primární klíč), article_id (cizí klíč), category_id (cizí klíč). Ale teď máte něco jako:

Lepším řešením je mít primární klíč, který se skládá ze 2 sloupců.

Toho lze dosáhnout provedením:

Dalším důvodem nepoužívat celé číslo s automatickým přírůstkem je, pokud používáte UUID pro primární klíč.

UUID jsou ze své definice jedinečné, čímž se dosahuje stejné věci jako při použití jedinečných celých čísel. Mají také vlastní přidané výhody (a nevýhody) oproti celým číslům. Například s UUID víte, že jedinečný řetězec, na který odkazujete, odkazuje na konkrétní datový záznam, což je užitečné v případech, kdy nemáte 1 centrální databázi nebo kde aplikace mají schopnost vytvářet datové záznamy offline ( a později je nahrajte do databáze).

Nakonec si nemusíte myslet na primární klíče jako na věc. Musíte si je představit jako funkci, kterou vykonávají. Proč potřebujete primární klíče? Být schopen jednoznačně identifikovat konkrétní sady dat z tabulky pomocí pole, které se v budoucnu nezmění. Potřebujete k tomu konkrétní sloupec s názvem id, nebo můžete tuto jedinečnou identifikaci založit na jiných (neměnných) datech?

Nebo existují scénáře, kdy takové pole přidat nechcete?

Nejdříve ze všeho jsou databáze, které nemají žádné autoinkrementy (např. Oracle, který rozhodně nepatří mezi nejmenší uchazeče). To by měl být první náznak, že ne každý je má rád nebo potřebuje.

Ještě důležitější je přemýšlet o tom, jaké je ID je - je to primární klíč pro vaše data. Pokud máte tabulku s jiným primárním klíčem, nepotřebujete ID a neměli byste jej mít. Například tabulka (EMPLOYEE_ID, TEAM_ID) (kde může být každý zaměstnanec současně v několika týmech) má jasně definovaný primární klíč skládající se z těchto dvou ID. Přidání sloupce ID automatického zvyšování, který je také primárním klíčem pro tuto tabulku, by nemělo vůbec smysl. Nyní vláčíte kolem sebe 2 primární klíče a první slovo v „primárním klíči“ by vám mělo naznačit, že byste opravdu měli mít pouze jeden.

Obvykle používám sloupec „identity“ (auto-incremennting integer) při definování nových tabulek pro „dlouhotrvající“ data (záznamy, které očekávám vložit jednou a udržovat je na neurčito, i když skončí „logicky smazané“ nastavením bitového pole ).

Existuje několik situací, na které si myslím, když je nechcete používat, z nichž většina se scvrkává na scénáře, kde jedna tabulka na jedné instanci DB nemůže být autoritativním zdrojem pro nové hodnoty ID:

  • Kdy by přírůstková ID byla pro potenciálního útočníka příliš mnoho informací. Použití sloupce identity pro „veřejné“ datové služby vás činí zranitelnými vůči „německému problému s tanky“, pokud existuje ID záznamu 10234, je logické, že existují záznamy 10233, 10232 atd., Alespoň na záznam 10001, a pak je snadné zkontrolovat záznam 1001, 101 a 1 a zjistit, kde začal sloupec identity. Identifikátory GU4 V4 složené převážně z náhodných dat přerušují toto přírůstkové chování záměrně, takže právě proto, že existuje jeden identifikátor GUID, identifikátor GUID vytvořený zvýšením nebo zmenšením bajtu identifikátoru GUID nemusí nutně existovat, což útočníkovi ztěžuje použití služby indtended pro vyhledávání jednoho záznamu jako nástroj pro výpis. Existují i ​​další bezpečnostní opatření, která mohou lépe omezit přístup, ale to pomáhá.
  • V tabulkách křížových odkazů M: M. Tohle je druh gimme, ale už jsem to viděl dělat. Pokud máte vztah mezi dvěma tabulkami ve vaší databázi, je řešením typu go-to tabulka křížových odkazů obsahující sloupce cizích klíčů odkazující na PK každé tabulky. PK této tabulky by měl být prakticky vždy složeným klíčem ze dvou cizích klíčů, aby bylo možné získat chování integrovaného indexu a zajistit jedinečnost odkazů.
  • Když plánujete hromadné vkládání a mazání v této tabulce. Pravděpodobně největší nevýhodou sloupců identity je extra hoopla, kterou musíte projít při vkládání řádků z jiné tabulky nebo dotazu, kde chcete zachovat klíčové hodnoty původní tabulky. Musíte zapnout „vložení identity“ (jakkoli je to provedeno ve vašem DBMS), pak se ručně ujistěte, že klíče, které vkládáte, jsou jedinečné, a poté, co skončíte s importem, musíte nastavit počítadlo identity v metadata tabulky na maximální přítomnou hodnotu. Pokud se tato operace v této tabulce stane hodně, zvažte jiné schéma PK.
  • Pro distribuované tabulky. Sloupce identity fungují skvěle pro databáze s jednou instancí, páry s podporou převzetí služeb při selhání a další scénáře, kdy jedna instance databáze je v daném okamžiku jediným orgánem celého schématu dat. Je však jen tak velký, že můžete jít a stále mít jeden počítač dostatečně rychlý. Replikace nebo zaslání protokolu transakcí vám mohou poskytnout další kopie jen pro čtení, ale existuje také omezení rozsahu tohoto řešení. Dříve nebo později budete potřebovat dvě nebo více instancí serveru, které zpracovávají vložení dat a pak se navzájem synchronizují. Když tato situace nastane, budete chtít místo přírůstkového pole GUID, protože většina databází DBMS je předkonfigurována tak, aby používala část identifikátorů GUID, které generují jako identifikátor specifický pro instanci, a poté zbytek identifikátoru vygenerujte náhodně nebo postupně. V obou případech je pravděpodobnost kolize mezi dvěma generátory GUID nulová, zatímco sloupec s celočíselnou identitou je noční můrou, kterou lze v této situaci spravovat (můžete jít sudý / lichý kompenzací semen a nastavením přírůstku na 2, ale pokud jeden server vidí více aktivity než ostatní, které ztrácíte ID).
  • Když musíte vynutit jedinečnost napříč více tabulkami v DB. V účetních systémech je například běžné spravovat hlavní knihu (s řádkem pro každý kredit nebo debet každého účtu, který kdy nastal, takže se velmi rychle zvětší) jako posloupnost tabulek, z nichž každá představuje jeden kalendářní měsíc / rok. Poté lze vytvořit pohledy, které je spojí pro účely vytváření přehledů. Logicky je to všechno jeden velmi velký stůl, ale jeho krájení usnadňuje úlohy údržby databáze. Představuje však problém, jak spravovat vložky do více tabulek (což vám umožní zahájit protokolování transakcí v příštím měsíci a zároveň zavírat poslední), aniž byste skončili s duplicitními klíči. Opět platí, že identifikátory GUID namísto sloupců celých čísel identity jsou řešením typu go-to, protože systém DBMS je navržen tak, aby je generoval skutečně jedinečným způsobem, takže jedna hodnota GUID bude viděna jednou a pouze jednou v celém systému DBMS.

Existují zástupná řešení, která v těchto situacích umožňují použití sloupců identity, jak jsem snad řekl, ale ve většině z nich je upgrade ze sloupce celé číslo identity na identifikátor GUID jednodušší a vyřeší problém úplněji.

Primární klíč s automatickým zvyšováním (identitou) je dobrý nápad, kromě toho, že je mimo rámec databáze a bezprostředních klientů této databáze bezvýznamný. Například pokud přenesete a uložíte některá data do jiné databáze, pak pokračujete v zápisu různých dat do obou databázových tabulek, ID se budou lišit - tj. Data s ID 42 v jedné databázi nemusí nutně odpovídat datům s ID 42 v druhém.

Vzhledem k tomu, pokud je nutné stále identifikovat řádky jednoznačně mimo databázi (a často je), musíte mít pro tento účel jiný klíč. Pečlivě vybraný obchodní klíč bude stačit, ale často skončíte na pozici velkého počtu sloupců potřebných k zajištění jedinečnosti. Jinou technikou je mít sloupec Id jako klastrovaný primární klíč s automatickým přírůstkem a další sloupec uniqueidentifier (guid) jako nekoustrovaný jedinečný klíč pro účely jedinečné identifikace řádku kdekoli na světě existuje. Důvod, proč v tomto případě stále máte klíč s automatickým zvyšováním, je ten, že je efektivnější seskupovat a indexovat klíč s automatickým zvyšováním, než je to udělat pro guid.

Jedním z případů, kdy možná nebudete chtít klíč s automatickým zvyšováním, by byla tabulka typu mnoho k mnoha, kde je primárním klíčem sloučenina sloupců Id dvou dalších tabulek (stále zde můžete mít klíč s automatickým zvyšováním, ale já nevidíte v tom smysl).

Další otázkou je datový typ klíče s automatickým zvyšováním. Použití Int32 vám dává velký, ale relativně omezený rozsah hodnot. Osobně pro Id často používám bigintové sloupce, abych se prakticky nikdy nemusel bát vyčerpání hodnot.

Jelikož ostatní lidé vytvořili důvod pro zvyšující se primární klíč, vytvořím jeden pro GUID:

  • Je zaručeno, že bude jedinečný
  • Do databáze můžete mít o jeden výlet méně údajů ve vaší aplikaci. (Například pro tabulku typů můžete v aplikaci uložit identifikátor GUID a použít jej k načtení záznamu. Pokud používáte identitu, musíte dotazovat databázi podle jména a viděl jsem mnoho aplikací, které to dělají, aby získaly PK a později to znovu vyhledá, aby získal všechny podrobnosti).
  • Je to užitečné pro skrytí dat. www.domain.com/Article/2 Dává mi vědět, že máte pouze dva články, zatímco www.domain.com/article/b08a91c5-67fc-449f-8a50-ffdf2403444a mi nic neříká.
  • Záznamy z různých databází můžete snadno sloučit.
  • MSFT používá GUIDY pro identitu.

Jako princip dobrého designu by každá tabulka měla mít spolehlivý způsob, jak jednoznačně identifikovat řádek. Ačkoli k tomu primární klíč slouží, nemusí vždy existovat primární klíč. Přidání primárního klíče do každé tabulky není špatným postupem, protože poskytuje jedinečnou identifikaci řádku, ale může být zbytečné.

Chcete-li zachovat spolehlivé vztahy mezi řádky dvou nebo více tabulek, musíte to udělat pomocí cizích klíčů, proto je potřeba alespoň v některých tabulkách primární klíče. Přidání primárního klíče do každé tabulky usnadňuje rozšíření návrhu databáze, když přijde čas přidat nové tabulky nebo vztahy ke stávajícím datům. Plánování dopředu je vždy dobrá věc.

Jako základní princip (možná tvrdé pravidlo) by se hodnota primárního klíče neměla nikdy měnit po celou dobu životnosti jeho řádku. Je rozumné předpokládat, že jakákoli obchodní data v řadě se mohou během své životnosti měnit, takže jakákoli obchodní data budou špatným kandidátem na primární klíč. Proto je často dobrý nápad něco abstraktního, jako je celé číslo s automatickým zvyšováním. Automaticky zvyšovaná celá čísla však mají svá omezení.

Pokud vaše data budou mít ve vaší databázi pouze život, automatická přírůstková celá čísla jsou v pořádku. Ale jak již bylo zmíněno v jiných odpovědích, pokud chcete, aby vaše data byla sdílena, synchronizována nebo jinak měla život mimo vaši databázi, automatická přírůstková celá čísla vytvářejí špatné primární klíče. Lepší volbou bude průvodce (aka uuid „univerzálně jedinečné ID“).

Otázka a mnoho odpovědí postrádá důležitý bod, že všechny přirozené klíče pro každou tabulku jsou umístěny pouze v logické schéma pro databázi a všechny náhradní klíče pro každou tabulku jsou umístěny pouze v souboru fyzické schéma pro databázi. další odpovědi pojednávají pouze o relativních výhodách náhradních klíčů celé číslo versus GUID, aniž bychom diskutovali o důvodech, proč jsou náhradní klíče správně používány a kdy.

BTW: Vyvarujme se používání špatně definovaného a nepřesného výrazu primární klíč. Jedná se o artefakt předrelačních datových modelů, který byl nejprve kooptován (nerozumně) do relačního modelu a poté kooptován zpět do fyzické domény různými prodejci RDBMS. Jeho použití slouží pouze ke zmatení sémantiky.

Poznámka od relační model že, aby databáze logické schéma být v první normální forma, každý stůl musí mít a uživatelsky viditelná sada polí, známá jako a přirozený klíč, který jednoznačně identifikuje každý řádek tabulky. Ve většině případů je takový přirozený klíč snadno identifikovatelný, ale občas musí být jeden vytvořen, ať už jako jistič pole nebo jinak. Takto vytvořený klíč je však vždy stále viditelný pro uživatele, a proto se vždy nachází v logické schéma databáze.

Naproti tomu jakýkoli náhradní klíč na stole sídlí čistě v fyzické schéma pro databázi (a proto musí být vždy, z bezpečnostních důvodů a pro zachování integrity databáze, pro uživatele databáze zcela neviditelní). Jediným důvodem pro zavedení a náhradní klíč je řešit problémy s výkonem v fyzická údržba a používání databáze, ať už jde o spojení, replikaci, více hardwarových zdrojů pro data nebo jiné.

Protože jediným důvodem pro zavedení náhradního klíče je výkon, předpokládejme, že si přejeme, aby byl výkonný. Pokud je problémem s výkonem spojení, pak si nutně přejeme, aby náš náhradní klíč byl co nejužší (aniž bychom se dostali do cesty hardwaru, takže krátká celá čísla a bajty jsou obvykle mimo). Výkon spojení se spoléhá na minimální výšku indexu, takže 4bajtové celé číslo je přirozeným řešením. Pokud je vaším problémem s výkonem míra vložení, může být přirozeným řešením také 4bajtové celé číslo (v závislosti na interních podmínkách vašeho RDBMS). Pokud je vaším problémem s výkonem u tabulky replikace nebo více zdrojů dat než u jiných náhradní klíč technologie, ať už je to GUID nebo dvoudílný klíč (ID hostitele + celé číslo), může být vhodnější. Osobně nejsem oblíbený GUID, ale jsou pohodlné.

Abychom to shrnuli, ne všechny tabulky budou vyžadovat a náhradní klíč (jakéhokoli typu) by se měly používat pouze tehdy, když je to považováno za nezbytné pro provedení uvažované tabulky. Bez ohledu na to běžné náhradní klíč technologii, kterou upřednostňujete, pečlivě si promyslete skutečné potřeby stolu, než provedete výběr změnou náhradní klíč volba technologie pro stůl bude vyčerpávající práce. Zdokumentujte klíčovou metriku výkonu svého stolu, aby vaši nástupci pochopili provedená rozhodnutí.

Speciální případy

Pokud vaše obchodní požadavky vyžadují postupné číslování transakcí pro účely auditu (nebo jiných), než je toto pole ne náhradní klíč je to přirozený klíč (s dalšími požadavky). Z dokumentace se automaticky vygeneruje celé číslo s automatickým zvyšováním náhradní klíče, takže najděte jiný mechanismus pro jeho generování. Obviously some sort of monitor will be necessary, and if you are sourcing your transactions from multiple sites then one site will be special, by virtue of being the designated host site for the monitor.

If your table will never be more than about a hundred rows then index height is irrelevant every access will be by a table scan. However string comparisons on long strings will still be much more expensive than comparison of a 4-byte integer, and more expensive than comparison of a GUID.

A table of code values keyed by a char(4) code field should be as performant as one with a 4-byte integer. Although I have no proof of this I use the assumption frequently and have never had reason to rue it.


Creating a table with auto-incrementing IDs in a SQL query

If you’re starting from scratch, you’ll need to create a table in your database that’s set up to auto-increment its primary keys.

➞ PostgreSQL

When creating an auto-incremented primary key in Postgres, you’ll need to use SERIAL to generate sequential unique IDs. Default start and increment are set to 1.

When applied to our example inventory data set, table creation looks like:

This first step is pretty straightforward. Just be sure to mark your item number column as the PRIMARY KEY .

Auto-incrementing in MySQL is pretty similar to SQL Server, except you don’t manually include the starting value and integer value. Instead, you use the AUTO_INCREMENT keyword, which has a default start and increment value of 1.

The basic syntax for creating this table in MySQL is:

In our example, here’s the table we’d want to create:

Like Postgres, you need to make sure that you’re using the PRIMARY KEY keyword for the column you want to generate your unique IDs from.

➞ SQL Server

In SQL Server, you’ll use the IDENTITY keyword to set your primary key (or item_number in our use case). By default, the starting value of IDENTITY is 1, and it will increment by 1 with each new entry unless you tell it otherwise.

To start, create a table. The basic syntax:

When applied to our inventory test case, table creation will look like:

Again—one last time—make sure to include PRIMARY KEY next to the SERIAL keyword, so you’re not just generating a useless list of sequential numbers.

Now, once you’ve created the framework of your table, you’ll need to decide if the default starting and increment values make sense for your use case.

Subscribe to the Retool monthly newsletter
Once a month we send out top stories (like this one) along with Retool tutorials, templates, and product releases.


6 Answers 6

You could use a CAML query and sort by the particular field, grab the highest value and add one. Should probably have a distinct check as well.

The query can be something like this :

I don't think your approach or the idea of performing a CAML query would work (. at least not consistently), primarily due to your inability to natively manage concurrency. It would be challenging enough to handle it in a single WFE environment, but if you have multiple WFEs you would most assuredly have multiple instances of an event receiver or query executing at the same time, returning the same "last ID" value and then all setting their LogIDNumber property to the same last+1 value.

I suppose you could create an ID list with one column (LogIDNumber), make it a Number type, and make sure Enforce unique values = Yes. You can then add an item to that list in your event receiver and if it chokes then you know another EV instance got there first and you need to requery the last ID until the insert into the ID list doesn't choke. If it doesn't choke then your EV instance owns the ID and can safely update the LogIDNumber property for that list item.

Can I ask what requirement(s) are causing you to create your own auto-icrement column versus using ID?


I had a similar issue, I solved it and since this comes up high on Google for what I was looking for it may help others.

I migrated several Wordpress databases from AWS RDS MySQL to MySQL running on an EC2 instance, using the database migration service. What I didn't know is it doesn't copy indexes, keys, auto increment, or really anything other than the basics. Of course the best approach would be to dump the database using mysqldump and import it manually, but one Wordpress install had significant changes and I didn't want to redo them. Instead I manually recreated the auto_increment values and indexes.

I've documented how I fixed Wordpress auto increment here on my website, here's a copy of what worked for me. It's possible I'll make further changes, I'll update the website but I may not remember to update this question.

  • You should check your tables and make sure to set your auto_increment to a value that makes sense for that table.
  • If you get the error “alter table causes auto_increment resequencing resulting in duplicate entry 1” (or 0, or something else). This is usually fixed by deleting the entry with the ID 0 or 1 in the table. Note that you should be careful doing this as it could delete an important row.

Proč se to stalo? Here's what went wrong for me:

If you exported your database using phpadmin and had an error on reimporting it, the code that adds the primary key doesn't run because it's at the end of the SQL file, not at its creation.

Before I figured this out, I updated to the phpmyadmin 5 beta and it imported the files with the key even though I still had the error.

Lesson one is, don't let your import crash, even if your tables are there. Mine crashed on table that began with wp_w so it came after user and rekt my auto increments.

If you look at the bottom of your SQL export, you will find the alter table for adding the Primary Key and the auto increment.

You don't need to specify the auto increment it automatically knows what the next increment is like so:

If you had admin activity since this happened, you have zeros in your key field, which will not allow you to set a primary key, and without that, you can't auto increment. So you need to run a delete script vs each table like so:

Here's a complete set of updates If your table has these, it will throw and error.


4 odpovědi 4

Tim, I had faced the same issue where I needed to restart the identity to the next value. I was using db2v9.1.

Unfortunately, there is no way to specify the next value automatically. As per DB2 documentation the value should be a 'numeric constant'. Hence I had to do a select max(id), get the value and replace it in the alter..restart stmt manually.

I don't remember if I tried this - but you can write an sp where max(id) is set in a variable and assign the variable in the alter. restart stmt. (I am unable to try as I dont hav access to any db2 database anymore). I doubt it'll work though. (If it works do let me know :))

DB2 reference:

RESTART or RESTART WITH numeric-constant

Resets the state of the sequence associated with the identity column. If WITH numeric-constant is not specified, the sequence for the identity column is restarted at the value that was specified, either implicitly or explicitly, as the starting value when the identity column was originally created. The column must exist in the specified table (SQLSTATE 42703), and must already be defined with the IDENTITY attribute (SQLSTATE 42837). RESTART does not change the original START WITH value.

The numeric-constant is an exact numeric constant that can be any positive or negative value that could be assigned to this column (SQLSTATE 42815), without non-zero digits existing to the right of the decimal point (SQLSTATE 428FA). The numeric-constant will be used as the next value for the column.


Frequently, we happen to need to fill tables with unique identifiers. Naturally, the first example of such identifiers is PRIMARY KEY data. These are usually integer values hidden from the user since their specific values are unimportant.

When adding a row to a table, you need to take this new key value from somewhere. You can set up your own process of generating a new identifier, but MySQL comes to the aid of the user with the AUTO_INCREMENT column setting. It is set as a column attribute and allows you to generate unique integer identifiers. As an example, consider the uživatelů table, the primary key includes an id column of type INT:

Inserting a NULL value into the id field leads to the generation of a unique value inserting 0 value is also possible unless the NO_AUTO_VALUE_ON_ZERO Server SQL Mode is enabled::

It is possible to omit the id column. The same result is obtained with:

The selection will provide the following result:

Select from users table shown in dbForge Studio

You can get the automatically generated value using the LAST_INSERT_ID() session function. This value can be used to insert a new row into a related table.

There are aspects to consider when using AUTO_INCREMENT, here are some:

  • In the case of rollback of a data insertion transaction, no data will be added to a table. However, the AUTO_INCREMENT counter will increase, and the next time you insert a row in the table, holes will appear in the table.
  • In the case of multiple data inserts with a single INSERT command, the LAST_INSERT_ID() function will return an automatically generated value for the first row.
  • The problem with the AUTO_INCREMENT counter value is described in Bug #199 – Innodb autoincrement stats los on restart.

For example, let’s consider several cases of using AUTO_INCREMENT for table1 :

Poznámka: The next AUTO_INCREMENT value for the table can be parsed from the SHOW CREATE TABLE result or read from the AUTO_INCREMENT field of the INFORMATION_SCHEMA TABLES table.

The rarer case is when the primary key is surrogate — it consists of two columns. The MyISAM engine has an interesting solution that provides the possibility of generating values for such keys. Let’s consider the example:

It is quite a convenient solution:

Special values auto generation

The possibilities of the AUTO_INCREMENT attribute are limited because it can be used only for generating simple integer values. But what about complex identifier values? For example, depending on the date/time or [A0001, A0002, B0150…]). To be sure, such values should not be used in primary keys, but they might be used for some auxiliary identifiers.

The generation of such unique values can be automated, but it will be necessary to write code for such purposes. We can use the BEFORE INSERT trigger to perform the actions we need.

Let’s consider a simple example. We have the sensors table for sensors registration. Each sensor in the table has its own name, location, and type: 1 –analog, 2 –discrete, 3 –valve. Moreover, each sensor should be marked with a unique label like [symbolic representation of the sensor type + a unique 4-digit number] where the symbolic representation corresponds to such values [AN, DS, VL].

In our case, it is necessary to form values like these [DS0001, DS0002…] and insert them into the label column.

When the trigger is executed, it is necessary to understand if any sensors of this type exist in the table. It is enough to assign number “1” to the first sensor of a certain type when it is added to the table.

In case such sensors already exist, it is necessary to find the maximum value of the identifier in this group and form a new one by incrementing the value by 1. Naturally, it is necessary to take into account that the label should start with the desired symbol and the number should be 4-digit.


3 odpovědi 3

Why are you creating something that SharePoint already does?

You can use the SharePoint default column ID in Workflows (as mentioned in the comments of the blogpost you refer to)

ID gets assigned po a New Item is created, so you can not use it in Calculated Column Formulas.

But Workflows are executed after the List Item is created so you can use ID in your workflow.

Only drawback might be, ID can not easily be reset, it will always increment

My new workflow is here here is working perfectly for me.

Event Handler approach can be used also for Autonumbering if you are in programming but I haven't tested it!

I'm trying to think of an alternate solution, but it seems you'll need to use a set of If conditions in the solution - that's if you want the preceding 000 prior to the ID value.

The workflow checks if the ID or the Next Number variable is within a certain range, and then append CaseOPT and the correct number of zeroes prior to the ID value.

Edit: The workflow would look something like this:

This is using the format "CaseOPT####" as the unique id.

I've arranged it this way assuming most of your entries will be in the 1000 - 100 range. Rearrange it depending on how much items you expect and how fast your list grows.


1 Odpověď 1

I read that uuid does not bring any security advantages

This entirely relative to a given context. So it's neither true or false.

Consider that right now the session id is encrypting the auto-increment id (no uuid is used). If someone manages to know how the session is encrypted, then he can impersonate all the users: encrypt "1" and set the value as sessionID, encrypts "2" and set the value as sessionID, etc.

Session identifiers work if they're long random pieces of information. They do not encode or encrypt any information, these tokens are used by the server to locate information pertaining the established session.

In a typical scenario, client A connects to server B for the first time. They have no information or session id at this point. Server generates a new session id and sends it to client. Potentially authentication occurs and some data is stored on the server pertaining that particular session. Every subsequent request from the client carries this identifier so that the server can match the data relevant to that particular client during this particular session. Notice the data is stored on the server, all the client does is issue requests of whatever kind and tack on the session identifier as a way to maintain state in a stateless system.

Simultaneously other clients are doing the same. The server can maintain multiple states since every client uses their own unique session identifier. If the sessions weren't random or easily guessable, then an attacker could calculate or guess them and hijack established sessions.

So a randomly generated UUID is no better or worse than a randomly generated session identifier for the same length of random data.


Is it good practice to keep 2 related tables (using auto_increment PK) to have the same Max of auto_increment ID when table1 got modified?

This question is about good design practice in programming.

Let see this example, we have 2 interrelated tables:

rID is auto_increment primary key & textID is foreign key

The relationship is that 1 rID will have 1 and only 1 textID but 1 textID can have a few rID .

So, when table1 got modification then table2 should be updated accordingly.

Ok, here is a fictitious example. You build a very complicated system. When you modify 1 record in table1, you need to keep track of the related record in table2. To keep track, you can do like this:

Option 1: When you modify a record in table1, you will try to modify a related record in table 2. This could be quite hard in term of programming expecially for a very very complicated system.

Option 2: instead of modifying a related record in table2, you decided to delete old record in table 2 & insert new one. This is easier for you to program.

For example, suppose you are using option2, then when you modify record 1,2,3. 100 in table1, the table2 will look like this:

This means the Max of auto_increment IDs in table1 is still the same (100) but the Max of auto_increment IDs in table2 already reached 200.

what if the user modify many times? if they do then the table2 may run out of records? we can use BigInt but that make the app run slower?

Note: If you spend time to program to modify records in table2 when table1 got modified then it will be very hard & thus it will be error prone. But if you just clear the old record & insert new records into table2 then it is much easy to program & thus your program is simpler & less error prone.

So, is it good practice to keep 2 related tables (using auto_increment PK) to have the same Max of auto_increment ID when table1 got modified?


Podívejte se na video: QGIS - Step by step No. 42. Creating signs in QGIS.