TrustRadius Insights for Liquibase are summaries of user sentiment data from TrustRadius reviews and, when necessary, third party data sources.
Pros
Seamless Integration with CI/CD: Users have praised Liquibase for seamlessly integrating with CI/CD pipelines, ensuring automated and consistent deployments by applying necessary database changes alongside code updates. This feature streamlines the development process and enhances overall efficiency in managing database modifications during software releases.
Support for Multiple Databases: Customers have appreciated Liquibase's ability to support multi-type target databases, allowing them to efficiently work across diverse database environments. This flexibility enables users to adapt their workflows to different database technologies without facing compatibility issues or constraints.
Versatile File Format Support: Reviewers highlighted Liquibase's support for multiple file formats like JSON, XML, YAML, and SQL, which enhances usability and versatility in different development environments. By accommodating various file types commonly used in software projects, Liquibase offers developers the freedom to choose the format that best suits their preferences and project requirements while maintaining consistency in database management practices.
In developing our application, we use Liquibase to maintain and build our database structures. We use it to apply changes and additions to our database and keep track of the changes being made. Liquibase has allowed us to better maintain control over the evolution of our data structures.
Pros
Keeps a change log of all change made.
Has the ability to rollback when needed.
Easily document changes.
Cons
Make it easier to roll back changes.
Add a GUI to examine the change logs.
Continue the good work.
Likelihood to Recommend
It enables the team to track all changes made to the database. These changes can be stored in a repository and easily tracked within the Liquibase ecosystem.
We are currently using Liquibase in our project for handling any database management and version control activity changes on MySQL database server. This involves creating any database user or any other DDL and DML database transactions involving table, index creations along with modifying or altering existing tables/views/indexes. As part of our DevOps automation strategy it is integrated into our CI/CD pipelines using github actions pipeline deployments to manage schema changes across multiple environments from Dev to Stage and then to Prod in a controlled and repeatable way. Liquibase is helping in solving our few business problems that includes reducing any database changes deployment time, human prone errors and manual efforts to add database changes on various environments and helps in tracking all database changes as part of a well defined version control system and Liquibase tracks all the database changes in DATABASELOGCHANGE table it helps in tracking and auditing purposes.
Pros
Liquibase allows us to track every change made to the database schema using changelog files (XML, YAML, or SQL) where this change is tracked, auditable, and can be rolled back if needed from DATABASECHANGELOG table which eventually helps in being compliant and trackable which are mandatory in my company as we are part of a healthcare organization.
It helps in supporting deploying the same changelog across multiple environments (dev, staging, prod) without any manual intervention from CI/CD github actions pipeline.
It helps in comparing two database schemas and generate changelogs automatically to bring one in sync with the other using "Liquibase diffChangeLog" command
Cons
diff and diffChangeLog commands are powerfu in Liquibase to make two database schema in sync but can produce noisy or incomplete results, especially when comparing across different database types or versions.
If two developers create changes with the same id in different files, Liquibase will throw a conflict even if they’re for different modules, along with this changelog files can become large and difficult to organize.
While Liquibase supports rollbacks, they often require manual intervention fgor complex changes for example in data migrations or multi-step schema changes, rollback logic can be hard to write and maintain.
Currently liquibase have less integration with IDE's like Intellij or VSCode which makes sometime hard to manage changesets and scripts
Likelihood to Recommend
Based on my experience so far on using Liquibase in my current project, I have seen that Liquibase changelogs are version control where multiple team members and developers can work together on database and deployed automatically via CI/CD Pipeline integration using github actions and it applies same changelogs to all enviroments to remain in sync and avoid any enviroment drift. Also as Liquibase stores changelog audits in DATABASECHANGELOG table it helps in tracking purposes and to easily rollback any change . Whereas in some scenarios I feel that Liquibase have some drawbacks where if complex transformation between tables is not optimized for bulk data operations which eventually degrades database performance.
Liquibase for version control of both Oracle Databases (version 12c to 19c) and Postgres. We are pairing it with Gitlab and our use so far has been leaps and bounds better than any previous solution we have used in the past. Version control on databases is always a pain, but with Liquibase, it has helped our team of over a dozen developers be able to control, validate, and not break each other's work in ways that no other tool has been able to do yet.
Pros
Amazing Documentation
Easy integration with existing CI/CD pipelines
Tags and snapshots make rollback a breeze.
Cons
for Linux installer, add to the script to add to PATH for executable
Reduce noise on CLI header and show on verbose flag
Likelihood to Recommend
Any Codebase that does schema or table changes all the time for development or where Development and code is mostly in the database or SQL liquibase is a must.
In a codebase where the database is pretty static or is just a place to dump data, liquibase is probably too much.
You also need to have a team for it to really make sense. Doing a solo or small team project doing full version control on the database is probably more overhead than it is worth.
Our enterprise database had only one main code base for a long while. That code base was able to handle its own schema changes. However, as we have expanded, we now have multiple applications and services reading and writing to the database. It was no longer practical to use the original code base to manage schema changes. Liquibase has become our centralized schema-management system and has worked very well for us. It is flexible and extensible with a simple and effective design that makes changes easy to track for the DBA. If you are familiar with CLI, the learning curve is small. We now use it to track and apply changes across individual developer database instances, as well as for shared testing and production environments.
Pros
Liquibase tracks changes in a metadata table contained directly in the target database, making easy administration for the DBA.
Liquibase handles many validation tests out of the box, making it easy to choose which ones you want to include, with options for writing your own if you choose. This makes it robust and flexible in terms of validation before deployment.
Liquibase provides easy integration into deployment pipelines for CI/CD. We use it with GitHub for source control and Circle CI for validation and deployment pipelines.
Cons
One thing that is missing and really needed is tracking of how long a particular changeset took to apply. There is only one date stamp in the metadata table, and it reflects the end time of the changeset command. While most changes run in milliseconds, it is often crucial to know how long it took to create an index, or for a change that locks a table. Right now, I just have to monitor myself. In some cases I can do some rough math based on the Liquibase update report, but only on the run as a whole, not each individual change. Perhaps Liquibase could write a beginning entry to the DATABASECHANGELOG, with a begin time, and then update that entry with an end time when the command has finished.
The "One change per changeset" policy check isn't robust enough to be adequately used with Liquibase-formatted mySQL changelogs. In mySQL, you must drop and recreate stored logic objects. There is no ALTER option, so either the DROP and CREATE must go into the same changeset (triggering the policy check), or they must be managed in two changesets (meaning two to manage for each logical change). It seems a DROP and CREATE could be made a special case for this policy check.
Likelihood to Recommend
Our enterprise database had only one main code base for a long while. That code base was able to handle its own schema changes through a built-in ORM. However, we have added multiple applications and services that read and write to the database, and therefore need schema changes to the database as well. It was no longer practical to use the original code base to manage schema changes.
Liquibase has become our centralized schema-management system and has worked very well for us. It is flexible and extensible with a simple and effective design that makes changes easy to track for the DBA. If you are familiar with CLI, the learning curve is small. We now use it to track and apply changes across individual developer database instances, as well as for shared testing and production environments.
In a modernization effort for a federal client, we leveraged Liquibase to improve visibility and automation with the database deployments. We have multiple AWS Aurora PostgreSQL databases that have to maintain consistency through each environment. Liquibase helps us to track what data is in each environment and allows us to build once and deploy many. This has helped us to make a major improvement in transparency for our client while also building a consistent and repeatable process going forward as the databases get updated. We also are utilizing Liquibase for a database reconciliation effort to deploy changes into a newly created schema to reconcile data after a migration. Liquibase allows us to make these deployments which will normally take months to minutes. Truly enjoy the service.
Pros
Liquibase provides a clear error log that allows us to pinpoint what to troubleshoot.
The service does not deploy bad data, which helps us keep our databases clean.
Liquibase works with GitHub Actions as well as AWS Codebuild and AWS Lambda. The flexibility allows us to deploy the service in many different ways.
Cons
I would like Liquibase to explore all errors in the changelog files compared to one at a time. We spent a lot of time troubleshooting one error at a time versus having a batch log of errors in each file.
Understanding where to get support on things. I spent a lot of time researching externally to learn what the best practices were. Although I found some of the youtube videos helpful, I would like a little more of a technical support. This may be a feature with the paid tier, however, we leveraged open source.
Seeing more examples of how others use Liquibase and their usecases will be helpful. That way we can learn from each other which may help us improve on our own deployments.
Likelihood to Recommend
It is well suited for modernization efforts where there are multiple environments and lots of change. The service thrives in an area where there are technically sound engineers specifically in the infrastructure space who can deploy the service and troubleshoot. If a team has only DBA's who do not understand infrastructure side of house, this service will be a pain to stand up and could be even more of a pain to troubleshoot as there will be a knowledge gap between infrastructure and code deployment.
We use Liquibase to manage database schema changes across environments in a controlled, versioned, and automated manner. It addresses business problems like inconsistent schema deployments, manual errors, and lack of traceability. Our use case includes CI/CD integration for automated rollouts, tracking changesets in source control, and ensuring database compliance and rollback capability for multiple Oracle and other DBs.
Pros
Version-Controlled Database Migrations
Rollback and Change Auditing
Environment-Agnostic Deployments with Contexts and Parameters
We have started to use Liquibase for managing non-production environments. This provides the ability to ensure that no developer changes are missed when refreshing lower environments
Pros
consistency in schemas
everyone is using the same method for deploying changes
ability to do comparison to ensure we know what we have deployed
Cons
too new to the product to make an accurate assessment at this time
Likelihood to Recommend
We have an Oracle database that is vendor supported and all changes come from them. The main schema for the vendor has given rise to lots of additional functionality that is implemented using additional schemas. We have started using Liquibase to do the changes for the additional schemas. This is not suitable for the vendor code at this time and that would be an area that Liquibase could partner with third-party vendors to support their code changes as well
VU
Verified User
Employee in Information Technology (10,001+ employees)
We use Liquibase to deploy schema changes to our databases. Liquibase addresses versioning issues with our schemas/databases. We use it on 2 databases. One which we own and another which has 2 schemas that we share with another team.
Pros
Versioning - it's easy to see change history of database schema
Deployments/Rollbacks - easy to make and undo changes
Cons
Better support for SQL changelogs. Not all features are available in SQL changelogs. SQL changelogs are easier to read
Likelihood to Recommend
Apply/rollback changes, view version history
VU
Verified User
Contributor in Information Technology (10,001+ employees)
We group database SQL changes by ticket and release, performing managed deployment across environments. The SQL is entered into the GUI tool. Once the scripts are entered, everything is checked into Git using the plugin. Once in Git, Jenkins stages the artifacts to be deployed by Ansible AAP using Hammer libraries provided by Liquibase. Using this we can determine which tickets have been deployed, which need to be deployed, and which may have been modified after initial deployment through checksum comparison.
Pros
Grouping environment configurations and ordering the deployment into a pipeline.
Tagging by release, requirement grouping.
Supporting drivers for all our different databases such as Oracle, PostgreSQL, MySQL, Greenplum.
Cons
The Git integration is kind of non-intuitive with the different view, and then separate cloning and project import processes.
If a single database fails to connect or resolve with TNS, sometimes the whole pipeline locks down and won't accept changes.
Transactional boundaries need to be manually managed in Oracle if a deployment fails and requires human intervention.
Likelihood to Recommend
It's mainly good for application-driven deployment of database changes requested by developers such as new tables, new columns, triggers. The user GUI interface combined with the automation libraries allows for a number of people to be able to push changes without needing to setup the developer tool locally. In my opinion, it shouldn't be used for management of internal table data or System configuration of the database itself.
VU
Verified User
Administrator in Information Technology (10,001+ employees)
We use Liquibase to automate deployments to all types of databases. It is very useful for deploying the same changes in different environments, recording everything that has been modified and, above all, being able to perform rollback and audit on uploads to production. We haven't encountered any issues so far. All of them have been resolved through the community or with the product's own documentation.
Pros
Keep a comprehensive record of changes
Facilitate rollbacks
Abstract the change of database type, achieving easy automation
Cons
Calculate the rollback automatically
Likelihood to Recommend
Liquibase is suitable for all the automatic database changes your organization wants to make.
