Unable to generate difference from liquibase gradle plugin
plugins {
id 'org.liquibase.gradle' version '2.0.1'
}
The Gradle liquibase plugin worked for me after I added built resources and classes to its runtime dependencies, as follows:
dependencies {
liquibaseRuntime 'org.liquibase:liquibase-core:3.5.3'
liquibaseRuntime 'org.liquibase:liquibase-groovy-dsl:2.0.1'
liquibaseRuntime 'mysql:mysql-connector-java:5.1.34'
liquibaseRuntime 'org.liquibase.ext:liquibase-hibernate4:3.6'
liquibaseRuntime 'javax.persistence:javax.persistence-api:2.2'
liquibaseRuntime files('build/classes/java/main')
liquibaseRuntime files('build/resources/main')
// Your other dependencies...
}
I defined its main activity as:
liquibase {
activities {
main {
changeLogFile 'build/liquibase_change_log.xml'
url 'jdbc:mysql://localhost/YOURDATABASE'
username 'YOURUSER'
password 'YOURPASSWORD'
driver 'com.mysql.jdbc.Driver'
referenceUrl 'hibernate:classic:/hibernate.cfg.xml'
}
}
}
Note that I'm just using a classic Hibernate configuration to define the source schema.
The hibernate4 integration of liquibase looks for /hibernate.cfg.xml in the classpath of the JVM that is running liquibase. It will also need to find your schema classes.
I also added this:
diffChangeLog.dependsOn build
With the following setup it can be used in conjunction with the liquibase-hibernate
and liquibase-gradle
extensions:
plugins {
id 'org.liquibase.gradle' version '2.0.1'
}
dependencies {
implementation 'org.liquibase:liquibase-core:3.8.0'
liquibaseRuntime 'org.liquibase.ext:liquibase-hibernate5:3.8'
liquibaseRuntime sourceSets.main.runtimeClasspath
liquibaseRuntime sourceSets.main.output
}
def props = new Properties()
file("src/main/resources/liquibase.properties").withInputStream { props.load(it) }
diff.dependsOn assemble
diffChangeLog.dependsOn assemble
liquibase {
activities {
main {
changeLogFile props.getProperty("liquibase.changelog.main")
referenceUrl props.getProperty("liquibase.changelog.referenceUrl")
url props.getProperty("spring.datasource.url")
username props.getProperty("spring.datasource.username")
password props.getProperty("spring.datasource.password")
referenceDriver "liquibase.ext.hibernate.database.connection.HibernateDriver"
}
}
}
This will generate a changelog in the specified changelog file. You can first generate an initial changelog with gradle generateChangelog
, run your application to apply these changes to the database and then after each change in your entity models run the gradle diffChangelog
task to get these changes in the chanlog file. These should then be applied to the database before running the diffChangeLog
task again to prevent duplicate operations in the changelog.
For this to work you will need the following properties in liquibase.properties
:
liquibase.changelog.main=src/main/resources/db/changelog/db.changelog-master.xml
liquibase.changelog.classpath=classpath:db/changelog/db.changelog-master.xml
liquibase.changelog.referenceUrl=hibernate:spring:<MODEL_PACKAGE>?dialect=org.hibernate.dialect.MySQL5Dialect
IMPORTANT: Be sure to replace <MODEL_PACKAGE>
with the package where your hibernate models are located.
The solutions is to write a gradle task which invokes liquibase diffChangeLog
Create a liquibase.gradle
file in the project root directory, add liquibase-hibernate extension and write a gradle task that invokes the liquibase diffChangeLog
command.
configurations {
liquibase
}
dependencies {
liquibase group: 'org.liquibase.ext', name: 'liquibase-hibernate4', version: 3.5
}
//loading properties file.
Properties liquibaseProps = new Properties()
liquibaseProps.load(new FileInputStream("src/main/resources/liquibase-task.properties"))
Properties applicationProps = new Properties()
applicationProps.load(new FileInputStream("src/main/resources/application.properties"))
task liquibaseDiffChangelog(type: JavaExec) {
group = "liquibase"
classpath sourceSets.main.runtimeClasspath
classpath configurations.liquibase
main = "liquibase.integration.commandline.Main"
args "--changeLogFile=" + liquibaseProps.getProperty('liquibase.changelog.path')+ buildTimestamp() +"_changelog.xml"
args "--referenceUrl=hibernate:spring:" + liquibaseProps.getProperty('liquibase.domain.package') + "?dialect=" + applicationProps.getProperty('spring.jpa.properties.hibernate.dialect')
args "--username=" + applicationProps.getProperty('spring.datasource.username')
args "--password=" + applicationProps.getProperty('spring.datasource.password')
args "--url=" + applicationProps.getProperty('spring.datasource.url')
args "--driver=com.mysql.jdbc.Driver"
args "diffChangeLog"
}
def buildTimestamp() {
def date = new Date()
def formattedDate = date.format('yyyyMMddHHmmss')
return formattedDate
}
NOTE: I have used properties files to pass arguments to the liquibase command, you could add the values directly, but that would not be a good practice.
Next, you would need to apply the liquibase.gradle
file from within the project's build.gradle
file. and add the liquibase dependency
apply from: 'liquibase.gradle'
//code omitted
dependencies {
compile (group: 'org.liquibase', name: 'liquibase-core', version: "3.4.2")
}
After this step liquibase would be setup completely.
You can now use
gradle liquibaseDiffChangeLog
to generate changelogs.