Миграции на база данни: Превръщане на гъсеници в пеперуди

Освен Oracle, Liquibase поддържа няколко други бази данни извън кутията.

Именуване на обекти на база данни

Всеки обект на база данни, който създавате, трябва да бъде наименуван. Не се изисква изрично да предоставяте име за някои видове обекти, например за ограничения и индекси. Но това не означава, че тези обекти няма да имат имена; техните имена така или иначе ще бъдат генерирани от базата данни. Проблемът възниква, когато трябва да се обърнете към този обект, за да го пуснете или промените. Затова е по-добре да им дадете изрични имена. Но има ли правила относно това кои имена да се дават? Отговорът е кратък: Бъдете последователни; например, ако сте решили да назовете индекси по този начин: CODE, тогава индекс за гореспоменатите IDX_PRODUCT_CODE колоната трябва да бъде наречена DATABASECHANGELOG.

Конвенциите за именуване са изключително противоречиви, така че няма да се допуснем да даваме изчерпателни инструкции тук. Бъдете последователни, спазвайте конвенциите на вашия екип или проект или просто ги измислете, ако няма такива.

Организиране на набори от промени

Първото нещо, за което трябва да вземете решение, е къде да съхранявате наборите промени. По принцип има два подхода:

1. Съхранявайте наборите за промени с кода на приложението. Удобно е да го направите, защото можете да ангажирате и преглеждате наборите от промени и кода на приложението заедно.
2. Дръжте наборите за промени и кода на приложението отделно , например в отделни хранилища на VCS. Този подход е подходящ, когато моделът от данни се споделя в няколко приложения и е по-удобно да се съхраняват всички набори от промени в специално хранилище и да не се разпръскват в множество хранилища, където кодът на приложението живее.

Където и да съхранявате наборите от промени, обикновено е разумно да ги разделите в следните категории:

1. Независими миграции, които не засягат работещата система. Обикновено е безопасно да създавате нови таблици, последователности и т.н., ако разгърнатото в момента приложение все още не ги знае.
2. Модификации на схемата, които променят структурата на магазина , например добавяне или пускане на колони и индекси. Тези промени не трябва да се прилагат, докато все още се използва по-стара версия на приложението, тъй като това може да доведе до заключвания или странно поведение поради промени в схемата.
3. Бързи миграции, които вмъкват или актуализират малки количества данни. Ако се разполагат множество приложения, наборите от тази категория могат да бъдат изпълнени едновременно, без да се влошава производителността на базата данни.
4. Потенциално бавни миграции, които вмъкват или актуализират много данни. Тези промени е по-добре да се прилагат, когато не се изпълняват други подобни миграции.

как да създадете консултативен съвет

Тези набори от миграции трябва да се изпълняват последователно, преди да се внедри по-нова версия на приложение. Този подход става още по-практичен, ако системата е съставена от няколко отделни приложения и някои от тях използват една и съща база данни. В противен случай си струва да отделите само тези набори от промени, които биха могли да бъдат приложени, без да се засягат работещите приложения, а останалите набори от промени могат да бъдат приложени заедно.

За по-прости приложения, пълният набор от необходими миграции може да се приложи при стартиране на приложението. В този случай всички набори от промени попадат в една категория и се изпълняват при всяко инициализиране на приложението.

На какъвто и етап да е избран да се приложи миграция, струва си да се спомене, че използването на една и съща база данни за множество приложения може да доведе до заключвания, когато се прилагат миграции. Liquibase (както много други подобни решения) използва две специални таблици за записване на своите метаданни: DATABASECHANGELOGLOCK и runOnChange='true'. Първият се използва за съхраняване на информация за приложени набори от промени, а вторият за предотвратяване на едновременни миграции в същата схема на базата данни. Така че, ако няколко приложения трябва да използват една и съща схема на базата данни по някаква причина, по-добре е да използвате имена, които не са по подразбиране за таблиците с метаданни, за да се избегнат заключвания.

Сега, когато структурата на високо ниво е ясна, трябва да решите как да организирате наборите от промени във всяка категория.

Това до голяма степен зависи от конкретните изисквания за приложение, но следните точки обикновено са разумни:

1. Съхранявайте регистрите на промените, групирани по версии на вашия продукт. Създайте нова директория за всяко издание и поставете в нея съответните файлове на промените. Имате root root дневник и включва дневници на промени, които съответстват на версии. В дневниците за промени на версията, включете други дневници с промени, съдържащи тази версия.
2. Имайте конвенция за именуване на файлове с променливи и идентификатори на набори от промени - и я следвайте, разбира се.
3. Избягвайте наборите от промени с много промени. Предпочитайте множество набори от промени пред един дълъг набор от промени.
4. Ако използвате съхранени процедури и трябва да ги актуализирате, помислете за използването на createTable атрибут на набора от промени, в който се добавя тази съхранена процедура. В противен случай всеки път, когато се актуализира, ще трябва да създадете нов набор от промени с нова версия на съхранената процедура. Изискванията варират, но често е приемливо да не се проследява такава история.
5. Помислете за смачкване на излишни промени преди обединяване на разклонения на функции. Понякога се случва, че в клон на функция (особено в дълготраен) по-късно наборите промени променят промените, направени в по-ранни набори промени. Например можете да създадете таблица и след това да решите да добавите още колони към нея. Струва си да добавите тези колони към първоначалните context='test' промяна, ако този клон на функцията все още не е обединен с основния клон.
6. Използвайте същите дневници за промени, за да създадете тестова база данни. Ако се опитате да го направите, скоро може да разберете, че не всеки набор от промени е приложим за тестовата среда или че са необходими допълнителни набори от промени за тази специфична тестова среда. С Liquibase този проблем се решава лесно с помощта контексти . Просто добавете test атрибут към наборите от промени, които трябва да бъдат изпълнени само с тестове, и след това инициализирайте Liquibase с rollback контекстът е активиран.

Въртене назад

Подобно на други подобни решения, Liquibase поддържа мигрираща схема „нагоре“ и „надолу“. Но бъдете предупредени: Отмяна на миграциите може да не е лесно и не винаги си струва усилията. Ако сте решили да поддържате отмяна на миграции за вашето приложение, бъдете последователни и го правете за всеки набор от промени, който трябва да бъде отменен. С Liquibase отмяната на набора от промени се извършва чрез добавяне на createTable таг, който съдържа промени, необходими за извършване на връщане назад. Обмислете следния пример:

Изричното връщане тук е излишно, защото Liquibase ще извърши същите действия за връщане. Liquibase може автоматично да върне повечето от поддържаните видове промени, например createIndex, DATABASECHANGELOG или DATABASECHANGELOG

Оправяне на миналото

Никой не е съвършен и всички грешим. Някои от тях могат да бъдат открити твърде късно, когато вече са приложени развалени промени. Нека да проучим какво би могло да се направи, за да спасим деня.

Ръчно актуализирайте базата данни

Включва бъркане с DATABASECHANGELOG и вашата база данни по следните начини:

1. Ако искате да коригирате лоши набори от промени и да ги изпълните отново:
   • Премахване на редове от MD5SUM които съответстват на наборите от промени.
   • Премахнете всички странични ефекти, които са били въведени от наборите от промени; напр. възстановяване на таблица, ако е била изпусната.
   • Коригирайте лошите набори от промени.
   • Стартирайте миграции отново.
2. Ако искате да коригирате лоши набори от промени, но пропуснете да ги прилагате отново:
   • Актуализация NULL чрез задаване на MD5SUM стойност на полето до runOnChange='true' за онези редове, които съответстват на лошите набори от промени.
   • Ръчно поправете грешката в базата данни. Например, ако е добавена колона с грешен тип, издайте заявка за модифициране на нейния тип.
   • Коригирайте лошите набори от промени.
   • Стартирайте миграции отново. Liquibase ще изчисли новата контролна сума и ще я запази в context. Коригираните набори от промени няма да се пускат отново.

Очевидно е лесно да се правят тези трикове по време на разработката, но става много по-трудно, ако промените се прилагат към множество бази данни.

дружество с ограничена отговорност c корпорация

Напишете коригиращи набори от промени

На практика този подход обикновено е по-подходящ. Може би се чудите, защо просто не редактирате оригиналния набор от промени? Истината е, че зависи от това какво трябва да се промени. Liquibase изчислява контролна сума за всеки набор от промени и отказва да приложи нови промени, ако контролната сума е нова за поне един от приложените по-рано набори от промени. Това поведение може да бъде персонализирано на база на промяна, като се посочи runOnChange атрибут. Контролната сума не се засяга, ако промените предпоставки или незадължителни атрибути на промяна (context, context='graveyard-changesets-never-run' и др.).

Сега, може би се чудите, как в крайна сметка коригирате наборите с грешки?

1. Ако искате тези промени да продължат да се прилагат за нови схеми, просто добавете коригиращи набори от промени. Например, ако е добавена колона с грешен тип, модифицирайте нейния тип в новия набор от промени.
2. Ако искате да се преструвате, че тези лоши набори от промени никога не са съществували, направете следното:
   • Премахнете наборите от промени или добавете changeSetExecuted атрибут със стойност, гарантираща, че никога повече няма да се опитате да приложите миграции с такъв контекст, например

   • Добавете нови набори от промени, които или ще върнат грешно направеното, или ще го поправят. Тези промени трябва да се прилагат само ако са били приложени лоши промени. Тя може да бъде постигната с предварителни условия, като например

     |_+_|

     . Не забравяйте да добавите коментар, обясняващ защо го правите.
   • Добавете нови набори от промени, които модифицират схемата по правилния начин.

Както виждате, поправянето на миналото е възможно, макар че не винаги може да е лесно.

Смекчаване на нарастващите болки

С напредването на възрастта на вашето приложение, неговият дневник на промени също се разраства, натрупвайки всяка промяна на схемата по пътя. Това е по дизайн и в това няма нищо по същество лошо. Дългите дневници на промените могат да бъдат съкратени чрез редовно смачкване на миграции, например след пускане на всяка версия на продукта. В някои случаи това би направило инициализирането на нова схема по-бързо.

Скуоширането не винаги е тривиално и може да предизвика регресии, без да носи много ползи. Друга чудесна възможност е използването на база данни за семена, за да се избегне изпълнението на всички набори от промени. Той е много подходящ за тестване на среди, ако трябва да имате база данни, подготвена възможно най-бързо, може би дори с някои тестови данни. Може да го възприемете като форма на смачкване за набори от промени: В даден момент (например след пускане на друга версия) правите дъмп на схемата. След възстановяване на сметището прилагате миграции както обикновено. Ще бъдат приложени само нови промени, защото по-старите вече са били приложени преди да направите сметката; следователно те бяха възстановени от сметището.

Заключение

Умишлено избягвахме да се впуснем по-дълбоко в характеристиките на Liquibase, за да доставим кратка и точна статия, фокусирана върху развиващите се схеми като цяло. Надяваме се, че е ясно какви ползи и проблеми води до автоматизираното прилагане на миграции на схеми на бази данни и доколко всичко това се вписва в Култура на DevOps . Важно е дори добрите идеи да не се превръщат в догма. Изискванията варират и като инженери на бази данни , нашите решения трябва да насърчават придвижването на продукта напред, а не просто да се придържаме към препоръките на някой в ​​интернет.

Разбиране на основите

Какво е значението на схемата в базата данни?

Схемата на базата данни описва как са организирани данните в базата данни.

Каква е разликата между база данни и схема?

Схемата е част от база данни. Базата данни обикновено се състои от една или повече схеми. Също така е доста често да се нарича СУБД база данни. Обикновено от контекста става ясно дали говорим за контейнера за данни или за системата, която управлява този контейнер.

Какво е пример за схема?

Ако изграждате приложение за управление на обиколки, неговата схема на база данни ще съдържа обекти като авиокомпания, полет или град. Освен дефинирани от потребителя схеми, СУБД обикновено има „информационна схема“, която може да се използва за заявки за настройките и метаданните.

как да стартирате фонд за търсене

Какви са различните видове бази данни?

Освен релационни бази данни съществуват обектни, ориентирани към документи и йерархични бази данни.

Има ли начин за ускоряване на заявката?

Можете да оптимизирате бавна заявка, като я преструктурирате или промените схемата. СУБД обикновено може да ви даде план за изпълнение и да помогне да познаете какво забавя вашата заявка (напр. Неизползване на индекси или избиране на твърде много данни в подзаявки). В PostgreSQL можете да използвате EXPLAIN или EXPLAIN ANALYZE, за да разберете какво не е наред.

Каква е схемата в PostgreSQL?

В PostgreSQL може да имате няколко бази данни в един и същ клъстер; схемата е структурен елемент на базата данни. Това е контейнерът за таблици, изгледи, процедури и др. Схемите могат да се считат за директории в базата данни, но схемите не могат да съдържат други схеми.

Дълбок поглед върху JSON срещу XML, част 1: Историята на всеки стандарт

Технология

Анализиране на ефекта от отрицателните лихвени проценти в пет икономики

Финансови Процеси