devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

flyway实战

作者：我家小花儿 | 2024-03-07 01:28:30

赞

踩

flyway实战

flyway是一款用来管理数据库版本的工具框架

一, 添加依赖

  1. <dependency>
  2.   <groupId>org.flywaydb</groupId>
  3.   <artifactId>flyway-core</artifactId>
  4. </dependency>
  5. <dependency>
  6.   <groupId>org.springframework</groupId>
  7.   <artifactId>spring-jdbc</artifactId>
  8. </dependency>

二, 编写配置类

MySQLDatabase

  1. /*
  2.  * Copyright (C) Red Gate Software Ltd 2010-2021
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *         http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. package org.flywaydb.core.internal.database.mysql;
  17.  
  18. import lombok.CustomLog;
  19. import lombok.extern.slf4j.Slf4j;
  20. import org.flywaydb.core.api.FlywayException;
  21. import org.flywaydb.core.api.MigrationType;
  22. import org.flywaydb.core.api.MigrationVersion;
  23. import org.flywaydb.core.api.configuration.Configuration;
  24. import org.flywaydb.core.internal.database.base.Database;
  25. import org.flywaydb.core.internal.database.base.BaseDatabaseType;
  26. import org.flywaydb.core.internal.database.base.Table;
  27. import org.flywaydb.core.internal.database.mysql.mariadb.MariaDBDatabaseType;
  28. import org.flywaydb.core.internal.jdbc.JdbcConnectionFactory;
  29. import org.flywaydb.core.internal.jdbc.JdbcTemplate;
  30. import org.flywaydb.core.internal.jdbc.StatementInterceptor;
  31.  
  32. import java.sql.Connection;
  33. import java.sql.SQLException;
  34. import java.util.regex.Matcher;
  35. import java.util.regex.Pattern;
  36.  
  37. @Slf4j
  38. public class MySQLDatabase extends Database<MySQLConnection> {
  39.   // See https://mariadb.com/kb/en/version/
  40.   private static final Pattern MARIADB_VERSION_PATTERN = Pattern.compile("(\\d+\\.\\d+)\\.\\d+(-\\d+)*-MariaDB(-\\w+)*");
  41.   private static final Pattern MARIADB_WITH_MAXSCALE_VERSION_PATTERN = Pattern.compile("(\\d+\\.\\d+)\\.\\d+(-\\d+)* (\\d+\\.\\d+)\\.\\d+(-\\d+)*-maxscale(-\\w+)*");
  42.   private static final Pattern MYSQL_VERSION_PATTERN = Pattern.compile("(\\d+\\.\\d+)\\.\\d+\\w*");
  43.   /**
  44.    * Whether this is a Percona XtraDB Cluster in strict mode.
  45.    */
  46.   private final boolean pxcStrict;
  47.   /**
  48.    * Whether this database is enforcing GTID consistency.
  49.    */
  50.   private final boolean gtidConsistencyEnforced;
  51.   /**
  52.    * Whether the event scheduler table is queryable.
  53.    */
  54.   final boolean eventSchedulerQueryable;
  55.  
  56.   public MySQLDatabase(Configuration configuration, JdbcConnectionFactory jdbcConnectionFactory, StatementInterceptor statementInterceptor) {
  57.     super(configuration, jdbcConnectionFactory, statementInterceptor);
  58.  
  59.     JdbcTemplate jdbcTemplate = new JdbcTemplate(rawMainJdbcConnection, databaseType);
  60.     pxcStrict = isMySQL() && isRunningInPerconaXtraDBClusterWithStrictMode(jdbcTemplate);
  61.     gtidConsistencyEnforced = isMySQL() && isRunningInGTIDConsistencyMode(jdbcTemplate);
  62.     eventSchedulerQueryable = false;
  63.   }
  64.  
  65.   private static boolean isEventSchedulerQueryable(JdbcTemplate jdbcTemplate) {
  66.     try {
  67.       // Attempt query
  68.       jdbcTemplate.queryForString("SELECT event_name FROM information_schema.events LIMIT 1");
  69.       return true;
  70.     } catch (SQLException e) {
  71.       log.debug("Detected unqueryable MariaDB event scheduler, most likely due to it being OFF or DISABLED.");
  72.       return false;
  73.     }
  74.   }
  75.  
  76.   static boolean isRunningInPerconaXtraDBClusterWithStrictMode(JdbcTemplate jdbcTemplate) {
  77.     try {
  78.       String pcx_strict_mode = jdbcTemplate.queryForString(
  79.           "select VARIABLE_VALUE from performance_schema.global_variables"
  80.               + " where variable_name = 'pxc_strict_mode'");
  81.       if ("ENFORCING".equals(pcx_strict_mode) || "MASTER".equals(pcx_strict_mode)) {
  82.         log.debug("Detected Percona XtraDB Cluster in strict mode");
  83.         return true;
  84.       }
  85.     } catch (SQLException e) {
  86.       log.debug("Unable to detect whether we are running in a Percona XtraDB Cluster. Assuming not to be.");
  87.     }
  88.  
  89.     return false;
  90.   }
  91.  
  92.   static boolean isRunningInGTIDConsistencyMode(JdbcTemplate jdbcTemplate) {
  93.     try {
  94.       String gtidConsistency = jdbcTemplate.queryForString("SELECT @@GLOBAL.ENFORCE_GTID_CONSISTENCY");
  95.       if ("ON".equals(gtidConsistency)) {
  96.         log.debug("Detected GTID consistency being enforced");
  97.         return true;
  98.       }
  99.     } catch (SQLException e) {
  100.       log.debug("Unable to detect whether database enforces GTID consistency. Assuming not.");
  101.     }
  102.  
  103.     return false;
  104.   }
  105.  
  106.   boolean isMySQL() {
  107.     return databaseType instanceof MySQLDatabaseType;
  108.   }
  109.  
  110.   boolean isMariaDB() {
  111.     return databaseType instanceof MariaDBDatabaseType;
  112.   }
  113.  
  114.   boolean isPxcStrict() {
  115.     return pxcStrict;
  116.   }
  117.  
  118.   /*
  119.    * CREATE TABLE ... AS SELECT ... cannot be used in three scenarios:
  120.    * - Percona XtraDB Cluster in strict mode doesn't support it
  121.    * - TiDB doesn't support it (overridden elsewhere)
  122.    * - When GTID consistency is being enforced. Note that if GTID_MODE is ON, then ENFORCE_GTID_CONSISTENCY is
  123.    * necessarily ON as well.
  124.    */
  125.   protected boolean isCreateTableAsSelectAllowed() {
  126.     return !pxcStrict && !gtidConsistencyEnforced;
  127.   }
  128.  
  129.   @Override
  130.   public String getRawCreateScript(Table table, boolean baseline) {
  131.     String tablespace =
  132.  
  133.  
  134.  
  135.         configuration.getTablespace() == null
  136.             ? ""
  137.             : " TABLESPACE \"" + configuration.getTablespace() + "\"";
  138.  
  139.     String baselineMarker = "";
  140.     if (baseline) {
  141.       if (isCreateTableAsSelectAllowed()) {
  142.         baselineMarker = " AS SELECT" +
  143.             "     1 as \"installed_rank\"," +
  144.             "     '" + configuration.getBaselineVersion() + "' as \"version\"," +
  145.             "     '" + configuration.getBaselineDescription() + "' as \"description\"," +
  146.             "     '" + MigrationType.BASELINE + "' as \"type\"," +
  147.             "     '" + configuration.getBaselineDescription() + "' as \"script\"," +
  148.             "     NULL as \"checksum\"," +
  149.             "     '" + getInstalledBy() + "' as \"installed_by\"," +
  150.             "     CURRENT_TIMESTAMP as \"installed_on\"," +
  151.             "     0 as \"execution_time\"," +
  152.             "     TRUE as \"success\"\n";
  153.       } else {
  154.         // Revert to regular insert, which unfortunately is not safe in concurrent scenarios
  155.         // due to MySQL implicit commits after DDL statements.
  156.         baselineMarker = ";\n" + getBaselineStatement(table);
  157.       }
  158.     }
  159.  
  160.     return "CREATE TABLE " + table + " (\n" +
  161.         "    `installed_rank` INT NOT NULL,\n" +
  162.         "    `version` VARCHAR(50),\n" +
  163.         "    `description` VARCHAR(200) NOT NULL,\n" +
  164.         "    `type` VARCHAR(20) NOT NULL,\n" +
  165.         "    `script` VARCHAR(1000) NOT NULL,\n" +
  166.         "    `checksum` INT,\n" +
  167.         "    `installed_by` VARCHAR(100) NOT NULL,\n" +
  168.         "    `installed_on` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,\n" +
  169.         "    `execution_time` INT NOT NULL,\n" +
  170.         "    `success` BOOL NOT NULL,\n" +
  171.         "    CONSTRAINT " + getConstraintName(table.getName()) + " PRIMARY KEY (`installed_rank`)\n" +
  172.         ")" + tablespace + " ENGINE=InnoDB" +
  173.         baselineMarker +
  174.         ";\n" +
  175.         "CREATE INDEX `" + table.getName() + "_s_idx` ON " + table + " (`success`);";
  176.   }
  177.  
  178.   protected String getConstraintName(String tableName) {
  179.     return "`" + tableName + "_pk`";
  180.   }
  181.  
  182.   @Override
  183.   protected MySQLConnection doGetConnection(Connection connection) {
  184.     return new MySQLConnection(this, connection);
  185.   }
  186.  
  187.   @Override
  188.   protected MigrationVersion determineVersion() {
  189.     // Ignore the version from the JDBC metadata and use the version returned by the database since proxies such as
  190.     // Azure or ProxySQL return incorrect versions
  191.     String selectVersionOutput = BaseDatabaseType.getSelectVersionOutput(rawMainJdbcConnection);
  192.     if (databaseType instanceof MariaDBDatabaseType) {
  193.       return extractMariaDBVersionFromString(selectVersionOutput);
  194.     }
  195.     return extractMySQLVersionFromString(selectVersionOutput);
  196.   }
  197.  
  198.   static MigrationVersion extractMySQLVersionFromString(String selectVersionOutput) {
  199.     return extractVersionFromString(selectVersionOutput, MYSQL_VERSION_PATTERN);
  200.   }
  201.  
  202.   static MigrationVersion extractMariaDBVersionFromString(String selectVersionOutput) {
  203.     return extractVersionFromString(selectVersionOutput, MARIADB_VERSION_PATTERN, MARIADB_WITH_MAXSCALE_VERSION_PATTERN);
  204.   }
  205.  
  206.   /*
  207.    * Given a version string that may contain unwanted text, extract out the version part.
  208.    */
  209.   private static MigrationVersion extractVersionFromString(String versionString, Pattern... patterns) {
  210.     for (Pattern pattern : patterns) {
  211.       Matcher matcher = pattern.matcher(versionString);
  212.       if (matcher.find()) {
  213.         return MigrationVersion.fromVersion(matcher.group(1));
  214.       }
  215.     }
  216.     throw new FlywayException("Unable to determine version from '" + versionString + "'");
  217.   }
  218.  
  219.  
  220.  
  221.  
  222.  
  223.  
  224.  
  225.  
  226.  
  227.  
  228.  
  229.  
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238.  
  239.  
  240.  
  241.  
  242.   @Override
  243.   public final void ensureSupported() {
  244.     ensureDatabaseIsRecentEnough("5.1");
  245.     if (databaseType instanceof MariaDBDatabaseType) {
  246.  
  247.       ensureDatabaseNotOlderThanOtherwiseRecommendUpgradeToFlywayEdition("10.3", org.flywaydb.core.internal.license.Edition.ENTERPRISE);
  248.  
  249.       recommendFlywayUpgradeIfNecessary("10.6");
  250.     } else {
  251.  
  252.       ensureDatabaseNotOlderThanOtherwiseRecommendUpgradeToFlywayEdition("8.0", org.flywaydb.core.internal.license.Edition.ENTERPRISE);
  253.  
  254.       recommendFlywayUpgradeIfNecessary("8.0");
  255.     }
  256.   }
  257.  
  258.   @Override
  259.   protected String doGetCurrentUser() throws SQLException {
  260.     return getMainConnection().getJdbcTemplate().queryForString("SELECT SUBSTRING_INDEX(USER(),'@',1)");
  261.   }
  262.  
  263.   @Override
  264.   public boolean supportsDdlTransactions() {
  265.     return false;
  266.   }
  267.  
  268.   @Override
  269.   public boolean supportsChangingCurrentSchema() {
  270.     return true;
  271.   }
  272.  
  273.   @Override
  274.   public String getBooleanTrue() {
  275.     return "1";
  276.   }
  277.  
  278.   @Override
  279.   public String getBooleanFalse() {
  280.     return "0";
  281.   }
  282.  
  283.   @Override
  284.   public String doQuote(String identifier) {
  285.     return "`" + identifier + "`";
  286.   }
  287.  
  288.   @Override
  289.   public boolean catalogIsSchema() {
  290.     return true;
  291.   }
  292.  
  293.   @Override
  294.   public boolean useSingleConnection() {
  295.     return !pxcStrict;
  296.   }
  297. }

MySQLNamedLockTemplate

  1. /*
  2.  * Copyright (C) Red Gate Software Ltd 2010-2021
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *         http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. package org.flywaydb.core.internal.database.mysql;
  17.  
  18. import java.sql.SQLException;
  19. import java.util.concurrent.Callable;
  20. import lombok.extern.slf4j.Slf4j;
  21. import org.flywaydb.core.api.FlywayException;
  22. import org.flywaydb.core.internal.exception.FlywaySqlException;
  23. import org.flywaydb.core.internal.jdbc.JdbcTemplate;
  24.  
  25. /**
  26.  * Spring-like template for executing with MySQL named locks.
  27.  */
  28. @Slf4j
  29. public class MySQLNamedLockTemplate {
  30.  
  31.   /**
  32.    * The connection for the named lock.
  33.    */
  34.   private final JdbcTemplate jdbcTemplate;
  35.  
  36.   private final String lockName;
  37.  
  38.   /**
  39.    * Creates a new named lock template for this connection.
  40.    *
  41.    * @param jdbcTemplate  The jdbcTemplate for the connection.
  42.    * @param discriminator A number to discriminate between locks.
  43.    */
  44.   MySQLNamedLockTemplate(JdbcTemplate jdbcTemplate, int discriminator) {
  45.     this.jdbcTemplate = jdbcTemplate;
  46.     lockName = "Flyway-" + discriminator;
  47.   }
  48.  
  49.   /**
  50.    * Executes this callback with a named lock.
  51.    *
  52.    * @param callable The callback to execute.
  53.    * @return The result of the callable code.
  54.    */
  55.   public <T> T execute(Callable<T> callable) {
  56.     try {
  57.       lock();
  58.       return callable.call();
  59.     } catch (SQLException e) {
  60.       throw new FlywaySqlException("Unable to acquire MySQL named lock: " + lockName, e);
  61.     } catch (Exception e) {
  62.       RuntimeException rethrow;
  63.       if (e instanceof RuntimeException) {
  64.         rethrow = (RuntimeException) e;
  65.       } else {
  66.         rethrow = new FlywayException(e);
  67.       }
  68.       throw rethrow;
  69.     } finally {
  70.       try {
  71.         //FIXME ocean base 没有GET_LOCK 需要通过其他方式来实现flyway锁
  72.         if (1 == 1) {
  73.         } else {
  74.           jdbcTemplate.execute("SELECT RELEASE_LOCK('" + lockName + "')");
  75.         }
  76.       } catch (SQLException e) {
  77.         log.error("Unable to release MySQL named lock: " + lockName, e);
  78.       }
  79.     }
  80.   }
  81.  
  82.   private void lock() throws SQLException {
  83.     while (!tryLock()) {
  84.       try {
  85.         Thread.sleep(100L);
  86.       } catch (InterruptedException e) {
  87.         throw new FlywayException(
  88.             "Interrupted while attempting to acquire MySQL named lock: " + lockName, e);
  89.       }
  90.     }
  91.   }
  92.  
  93.   private boolean tryLock() throws SQLException {
  94.     //FIXME ocean base 没有GET_LOCK 需要通过其他方式来实现flyway锁
  95.     if (1 == 1) {
  96.       return true;
  97.     }
  98.     return jdbcTemplate.queryForInt("SELECT GET_LOCK(?,10)", lockName) == 1;
  99.   }
  100. }

Databse类

  1. /*
  2.  * Copyright (C) Red Gate Software Ltd 2010-2021
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *         http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. package org.flywaydb.core.internal.database.base;
  17.  
  18. import lombok.CustomLog;
  19. import lombok.extern.slf4j.Slf4j;
  20. import org.flywaydb.core.api.MigrationType;
  21. import org.flywaydb.core.api.MigrationVersion;
  22. import org.flywaydb.core.api.configuration.Configuration;
  23. import org.flywaydb.core.internal.database.DatabaseType;
  24. import org.flywaydb.core.internal.exception.FlywayDbUpgradeRequiredException;
  25. import org.flywaydb.core.internal.exception.FlywaySqlException;
  26. import org.flywaydb.core.internal.jdbc.JdbcConnectionFactory;
  27. import org.flywaydb.core.internal.jdbc.JdbcTemplate;
  28. import org.flywaydb.core.internal.jdbc.StatementInterceptor;
  29. import org.flywaydb.core.internal.license.Edition;
  30. import org.flywaydb.core.internal.license.FlywayEditionUpgradeRequiredException;
  31. import org.flywaydb.core.internal.resource.StringResource;
  32. import org.flywaydb.core.internal.sqlscript.Delimiter;
  33. import org.flywaydb.core.internal.sqlscript.SqlScript;
  34. import org.flywaydb.core.internal.sqlscript.SqlScriptFactory;
  35. import org.flywaydb.core.internal.util.AbbreviationUtils;
  36.  
  37. import java.io.Closeable;
  38. import java.sql.DatabaseMetaData;
  39. import java.sql.SQLException;
  40.  
  41. /**
  42.  * Abstraction for database-specific functionality.
  43.  */
  44. @Slf4j
  45. public abstract class Database<C extends Connection> implements Closeable {
  46.   protected final DatabaseType databaseType;
  47.   protected final Configuration configuration;
  48.   protected final StatementInterceptor statementInterceptor;
  49.   protected final JdbcConnectionFactory jdbcConnectionFactory;
  50.   protected final DatabaseMetaData jdbcMetaData;
  51.   protected JdbcTemplate jdbcTemplate;
  52.   private C migrationConnection;
  53.   private C mainConnection;
  54.   /**
  55.    * The main JDBC connection, without any wrapping.
  56.    */
  57.   protected final java.sql.Connection rawMainJdbcConnection;
  58.   /**
  59.    * The 'major.minor' version of this database.
  60.    */
  61.   private MigrationVersion version;
  62.   /**
  63.    * The user who applied the migrations.
  64.    */
  65.   private String installedBy;
  66.  
  67.   public Database(Configuration configuration, JdbcConnectionFactory jdbcConnectionFactory, StatementInterceptor statementInterceptor) {
  68.     this.databaseType = jdbcConnectionFactory.getDatabaseType();
  69.     this.configuration = configuration;
  70.     this.rawMainJdbcConnection = jdbcConnectionFactory.openConnection();
  71.     try {
  72.       this.jdbcMetaData = rawMainJdbcConnection.getMetaData();
  73.     } catch (SQLException e) {
  74.       throw new FlywaySqlException("Unable to get metadata for connection", e);
  75.     }
  76.     this.jdbcTemplate = new JdbcTemplate(rawMainJdbcConnection, databaseType);
  77.     this.jdbcConnectionFactory = jdbcConnectionFactory;
  78.     this.statementInterceptor = statementInterceptor;
  79.   }
  80.  
  81.   /**
  82.    * Retrieves a Flyway Connection for this JDBC connection.
  83.    */
  84.   private C getConnection(java.sql.Connection connection) {
  85.     return doGetConnection(connection);
  86.   }
  87.  
  88.   /**
  89.    * Retrieves a Flyway Connection for this JDBC connection.
  90.    */
  91.   protected abstract C doGetConnection(java.sql.Connection connection);
  92.  
  93.   /**
  94.    * Ensure Flyway supports this version of this database.
  95.    */
  96.   public abstract void ensureSupported();
  97.  
  98.   /**
  99.    * @return The 'major.minor' version of this database.
  100.    */
  101.   public final MigrationVersion getVersion() {
  102.     if (version == null) {
  103.       version = determineVersion();
  104.     }
  105.     return version;
  106.   }
  107.  
  108.   protected final void ensureDatabaseIsRecentEnough(String oldestSupportedVersion) {
  109.   /*  if (!getVersion().isAtLeast(oldestSupportedVersion)) {
  110.       throw new FlywayDbUpgradeRequiredException(
  111.           databaseType,
  112.           computeVersionDisplayName(getVersion()),
  113.           computeVersionDisplayName(MigrationVersion.fromVersion(oldestSupportedVersion)));
  114.     }*/
  115.   }
  116.  
  117.   /**
  118.    * Ensure this database it at least as recent as this version otherwise suggest upgrade to this higher edition of
  119.    * Flyway.
  120.    */
  121.   protected final void ensureDatabaseNotOlderThanOtherwiseRecommendUpgradeToFlywayEdition(String oldestSupportedVersionInThisEdition,
  122.       Edition editionWhereStillSupported) {
  123.   /*  if (!getVersion().isAtLeast(oldestSupportedVersionInThisEdition)) {
  124.       throw new FlywayEditionUpgradeRequiredException(
  125.           editionWhereStillSupported,
  126.           databaseType,
  127.           computeVersionDisplayName(getVersion()));
  128.     }*/
  129.   }
  130.  
  131.   protected final void recommendFlywayUpgradeIfNecessary(String newestSupportedVersion) {
  132.     if (getVersion().isNewerThan(newestSupportedVersion)) {
  133.       recommendFlywayUpgrade(newestSupportedVersion);
  134.     }
  135.   }
  136.  
  137.   protected final void recommendFlywayUpgradeIfNecessaryForMajorVersion(String newestSupportedVersion) {
  138.     if (getVersion().isMajorNewerThan(newestSupportedVersion)) {
  139.       recommendFlywayUpgrade(newestSupportedVersion);
  140.     }
  141.   }
  142.  
  143.   protected final void notifyDatabaseIsNotFormallySupported() {
  144.     String message = "Support for " + databaseType + " is provided only on a community-led basis, and is not formally supported by Redgate";
  145.  
  146.     log.warn(message);
  147.   }
  148.  
  149.   private void recommendFlywayUpgrade(String newestSupportedVersion) {
  150.     String message = "Flyway upgrade recommended: " + databaseType + " " + computeVersionDisplayName(getVersion())
  151.         + " is newer than this version of Flyway and support has not been tested."
  152.         + " The latest supported version of " + databaseType + " is " + newestSupportedVersion + ".";
  153.     log.warn(message);
  154.   }
  155.  
  156.   /**
  157.    * Compute the user-friendly display name for this database version.
  158.    */
  159.   protected String computeVersionDisplayName(MigrationVersion version) {
  160.     return version.getVersion();
  161.   }
  162.  
  163.   public Delimiter getDefaultDelimiter() {
  164.     return Delimiter.SEMICOLON;
  165.   }
  166.  
  167.   /**
  168.    * @return The name of the database, by default as determined by JDBC.
  169.    */
  170.   public final String getCatalog() {
  171.     try {
  172.       return doGetCatalog();
  173.     } catch (SQLException e) {
  174.       throw new FlywaySqlException("Error retrieving the database name", e);
  175.     }
  176.   }
  177.  
  178.   protected String doGetCatalog() throws SQLException {
  179.     return getMainConnection().getJdbcConnection().getCatalog();
  180.   }
  181.  
  182.   public final String getCurrentUser() {
  183.     try {
  184.       return doGetCurrentUser();
  185.     } catch (SQLException e) {
  186.       throw new FlywaySqlException("Error retrieving the database user", e);
  187.     }
  188.   }
  189.  
  190.   protected String doGetCurrentUser() throws SQLException {
  191.     return jdbcMetaData.getUserName();
  192.   }
  193.  
  194.   public abstract boolean supportsDdlTransactions();
  195.  
  196.   public abstract boolean supportsChangingCurrentSchema();
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203.  
  204.   /**
  205.    * @return The representation of the value {@code true} in a boolean column.
  206.    */
  207.   public abstract String getBooleanTrue();
  208.  
  209.   /**
  210.    * @return The representation of the value {@code false} in a boolean column.
  211.    */
  212.   public abstract String getBooleanFalse();
  213.  
  214.   /**
  215.    * Quotes these identifiers for use in SQL queries. Multiple identifiers will be quoted and separated by a dot.
  216.    */
  217.   public final String quote(String... identifiers) {
  218.     StringBuilder result = new StringBuilder();
  219.  
  220.     boolean first = true;
  221.     for (String identifier : identifiers) {
  222.       if (!first) {
  223.         result.append(".");
  224.       }
  225.       first = false;
  226.       result.append(doQuote(identifier));
  227.     }
  228.  
  229.     return result.toString();
  230.   }
  231.  
  232.   /**
  233.    * Quotes this identifier for use in SQL queries.
  234.    */
  235.   protected abstract String doQuote(String identifier);
  236.  
  237.   /**
  238.    * @return {@code true} if this database uses a catalog to represent a schema, or {@code false} if a schema is
  239.    * simply a schema.
  240.    */
  241.   public abstract boolean catalogIsSchema();
  242.  
  243.   /**
  244.    * @return Whether to use a single connection for both schema history table management and applying migrations.
  245.    */
  246.   public boolean useSingleConnection() {
  247.     return false;
  248.   }
  249.  
  250.   public DatabaseMetaData getJdbcMetaData() {
  251.     return jdbcMetaData;
  252.   }
  253.  
  254.   /**
  255.    * @return The main connection used to manipulate the schema history.
  256.    */
  257.   public final C getMainConnection() {
  258.     if (mainConnection == null) {
  259.       this.mainConnection = getConnection(rawMainJdbcConnection);
  260.     }
  261.     return mainConnection;
  262.   }
  263.  
  264.   /**
  265.    * @return The migration connection used to apply migrations.
  266.    */
  267.   public final C getMigrationConnection() {
  268.     if (migrationConnection == null) {
  269.       if (useSingleConnection()) {
  270.         this.migrationConnection = getMainConnection();
  271.       } else {
  272.         this.migrationConnection = getConnection(jdbcConnectionFactory.openConnection());
  273.       }
  274.     }
  275.     return migrationConnection;
  276.   }
  277.  
  278.   /**
  279.    * @return The major and minor version of the database.
  280.    */
  281.   protected MigrationVersion determineVersion() {
  282.     try {
  283.       return MigrationVersion.fromVersion(jdbcMetaData.getDatabaseMajorVersion() + "." + jdbcMetaData.getDatabaseMinorVersion());
  284.     } catch (SQLException e) {
  285.       throw new FlywaySqlException("Unable to determine the major version of the database", e);
  286.     }
  287.   }
  288.  
  289.   /**
  290.    * Retrieves the script used to create the schema history table.
  291.    *
  292.    * @param sqlScriptFactory The factory used to create the SQL script.
  293.    * @param table            The table to create.
  294.    * @param baseline         Whether to include the creation of a baseline marker.
  295.    */
  296.   public final SqlScript getCreateScript(SqlScriptFactory sqlScriptFactory, Table table, boolean baseline) {
  297.     return sqlScriptFactory.createSqlScript(new StringResource(getRawCreateScript(table, baseline)), false, null);
  298.   }
  299.  
  300.   public abstract String getRawCreateScript(Table table, boolean baseline);
  301.  
  302.   public String getInsertStatement(Table table) {
  303.     return "INSERT INTO " + table
  304.         + " (" + quote("installed_rank")
  305.         + ", " + quote("version")
  306.         + ", " + quote("description")
  307.         + ", " + quote("type")
  308.         + ", " + quote("script")
  309.         + ", " + quote("checksum")
  310.         + ", " + quote("installed_by")
  311.         + ", " + quote("execution_time")
  312.         + ", " + quote("success")
  313.         + ")"
  314.         + " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";
  315.   }
  316.  
  317.   public final String getBaselineStatement(Table table) {
  318.     return String.format(getInsertStatement(table).replace("?", "%s"),
  319.         1,
  320.         "'" + configuration.getBaselineVersion() + "'",
  321.         "'" + AbbreviationUtils.abbreviateDescription(configuration.getBaselineDescription()) + "'",
  322.         "'" + MigrationType.BASELINE + "'",
  323.         "'" + AbbreviationUtils.abbreviateScript(configuration.getBaselineDescription()) + "'",
  324.         "NULL",
  325.         "'" + installedBy + "'",
  326.         0,
  327.         getBooleanTrue()
  328.     );
  329.   }
  330.  
  331.   public String getSelectStatement(Table table) {
  332.     return "SELECT " + quote("installed_rank")
  333.         + "," + quote("version")
  334.         + "," + quote("description")
  335.         + "," + quote("type")
  336.         + "," + quote("script")
  337.         + "," + quote("checksum")
  338.         + "," + quote("installed_on")
  339.         + "," + quote("installed_by")
  340.         + "," + quote("execution_time")
  341.         + "," + quote("success")
  342.         + " FROM " + table
  343.         + " WHERE " + quote("installed_rank") + " > ?"
  344.         + " ORDER BY " + quote("installed_rank");
  345.   }
  346.  
  347.   public final String getInstalledBy() {
  348.     if (installedBy == null) {
  349.       installedBy = configuration.getInstalledBy() == null ? getCurrentUser() : configuration.getInstalledBy();
  350.     }
  351.     return installedBy;
  352.   }
  353.  
  354.   public void close() {
  355.     if (!useSingleConnection() && migrationConnection != null) {
  356.       migrationConnection.close();
  357.     }
  358.     if (mainConnection != null) {
  359.       mainConnection.close();
  360.     }
  361.   }
  362.  
  363.   public DatabaseType getDatabaseType() {
  364.     return databaseType;
  365.   }
  366.  
  367.   public boolean supportsEmptyMigrationDescription() { return true; }
  368.  
  369.   public boolean supportsMultiStatementTransactions() { return true; }
  370.  
  371.   /**
  372.    * Cleans all the objects in this database that need to be cleaned before each schema.
  373.    */
  374.   public void cleanPreSchemas() {
  375.     try {
  376.       doCleanPreSchemas();
  377.     } catch (SQLException e) {
  378.       throw new FlywaySqlException("Unable to clean database " + this, e);
  379.     }
  380.   }
  381.  
  382.   /**
  383.    * Cleans all the objects in this database that need to be cleaned before each schema.
  384.    *
  385.    * @throws SQLException when the clean failed.
  386.    */
  387.   protected void doCleanPreSchemas() throws SQLException { }
  388.  
  389.   /**
  390.    * Cleans all the objects in this database that need to be cleaned after each schema.
  391.    *
  392.    * @param schemas The list of schemas managed by Flyway.
  393.    */
  394.   public void cleanPostSchemas(Schema[] schemas) {
  395.     try {
  396.       doCleanPostSchemas(schemas);
  397.     } catch (SQLException e) {
  398.       throw new FlywaySqlException("Unable to clean schema " + this, e);
  399.     }
  400.   }
  401.  
  402.   /**
  403.    * Cleans all the objects in this database that need to be cleaned after each schema.
  404.    *
  405.    * @param schemas The list of schemas managed by Flyway.
  406.    * @throws SQLException when the clean failed.
  407.    */
  408.   protected void doCleanPostSchemas(Schema[] schemas) throws SQLException { }
  409.  
  410.   public Schema[] getAllSchemas() {
  411.     throw new UnsupportedOperationException("Getting all schemas not supported for " + getDatabaseType().getName());
  412.   }
  413. }

Schema类

  1. /*
  2.  * Copyright (C) Red Gate Software Ltd 2010-2021
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *         http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. package org.flywaydb.core.internal.database.base;
  17.  
  18. import lombok.CustomLog;
  19. import lombok.extern.slf4j.Slf4j;
  20. import org.flywaydb.core.internal.exception.FlywaySqlException;
  21. import org.flywaydb.core.internal.jdbc.JdbcTemplate;
  22. import org.flywaydb.core.internal.jdbc.JdbcUtils;
  23.  
  24. import java.sql.ResultSet;
  25. import java.sql.SQLException;
  26. import java.util.ArrayList;
  27. import java.util.List;
  28.  
  29. @Slf4j
  30. public abstract class Schema<D extends Database, T extends Table> {
  31.   protected final JdbcTemplate jdbcTemplate;
  32.   protected final D database;
  33.   protected final String name;
  34.  
  35.   /**
  36.    * @param jdbcTemplate The Jdbc Template for communicating with the DB.
  37.    * @param database     The database-specific support.
  38.    * @param name         The name of the schema.
  39.    */
  40.   public Schema(JdbcTemplate jdbcTemplate, D database, String name) {
  41.     this.jdbcTemplate = jdbcTemplate;
  42.     this.database = database;
  43.     this.name = name;
  44.   }
  45.  
  46.   public String getName() {
  47.     return name;
  48.   }
  49.  
  50.   public boolean exists() {
  51.     try {
  52.       return doExists();
  53.     } catch (SQLException e) {
  54.       throw new FlywaySqlException("Unable to check whether schema " + this + " exists", e);
  55.     }
  56.   }
  57.  
  58.   /**
  59.    * Checks whether this schema exists.
  60.    *
  61.    * @throws SQLException when the check failed.
  62.    */
  63.   protected abstract boolean doExists() throws SQLException;
  64.  
  65.   public boolean empty() {
  66.     try {
  67.       return  doEmpty();
  68.     } catch (SQLException e) {
  69.       throw new FlywaySqlException("Unable to check whether schema " + this + " is empty", e);
  70.     }
  71.   }
  72.  
  73.   /**
  74.    * Checks whether this schema is empty.
  75.    *
  76.    * @throws SQLException when the check failed.
  77.    */
  78.   protected abstract boolean doEmpty() throws SQLException;
  79.  
  80.   /**
  81.    * Creates this schema in the database.
  82.    */
  83.   public void create() {
  84.     try {
  85.       log.info("Creating schema " + this + " ...");
  86.       doCreate();
  87.     } catch (SQLException e) {
  88.       throw new FlywaySqlException("Unable to create schema " + this, e);
  89.     }
  90.   }
  91.  
  92.   /**
  93.    * Creates this schema in the database.
  94.    *
  95.    * @throws SQLException when the creation failed.
  96.    */
  97.   protected abstract void doCreate() throws SQLException;
  98.  
  99.   /**
  100.    * Drops this schema from the database.
  101.    */
  102.   public void drop() {
  103.     try {
  104.       doDrop();
  105.     } catch (SQLException e) {
  106.       throw new FlywaySqlException("Unable to drop schema " + this, e);
  107.     }
  108.   }
  109.  
  110.   /**
  111.    * Drops this schema from the database.
  112.    *
  113.    * @throws SQLException when the drop failed.
  114.    */
  115.   protected abstract void doDrop() throws SQLException;
  116.  
  117.   /**
  118.    * Cleans all the objects in this schema.
  119.    */
  120.   public void clean() {
  121.     try {
  122.       doClean();
  123.     } catch (SQLException e) {
  124.       throw new FlywaySqlException("Unable to clean schema " + this, e);
  125.     }
  126.   }
  127.  
  128.   /**
  129.    * Cleans all the objects in this schema.
  130.    *
  131.    * @throws SQLException when the clean failed.
  132.    */
  133.   protected abstract void doClean() throws SQLException;
  134.  
  135.   /**
  136.    * Retrieves all the tables in this schema.
  137.    */
  138.   public T[] allTables() {
  139.     try {
  140.       return doAllTables();
  141.     } catch (SQLException e) {
  142.       throw new FlywaySqlException("Unable to retrieve all tables in schema " + this, e);
  143.     }
  144.   }
  145.  
  146.   /**
  147.    * Retrieves all the tables in this schema.
  148.    *
  149.    * @throws SQLException when the retrieval failed.
  150.    */
  151.   protected abstract T[] doAllTables() throws SQLException;
  152.  
  153.   /**
  154.    * Retrieves all the types in this schema.
  155.    */
  156.   protected final Type[] allTypes() {
  157.     ResultSet resultSet = null;
  158.     try {
  159.       resultSet = database.jdbcMetaData.getUDTs(null, name, null, null);
  160.  
  161.       List<Type> types = new ArrayList<>();
  162.       while (resultSet.next()) {
  163.         types.add(getType(resultSet.getString("TYPE_NAME")));
  164.       }
  165.  
  166.       return types.toArray(new Type[0]);
  167.     } catch (SQLException e) {
  168.       throw new FlywaySqlException("Unable to retrieve all types in schema " + this, e);
  169.     } finally {
  170.       JdbcUtils.closeResultSet(resultSet);
  171.     }
  172.   }
  173.  
  174.   /**
  175.    * Retrieves the type with this name in this schema.
  176.    */
  177.   protected Type getType(String typeName) {
  178.     return null;
  179.   }
  180.  
  181.   /**
  182.    * Retrieves the table with this name in this schema.
  183.    */
  184.   public abstract Table getTable(String tableName);
  185.  
  186.   /**
  187.    * Retrieves the function with this name in this schema.
  188.    */
  189.   public Function getFunction(String functionName, String... args) {
  190.     throw new UnsupportedOperationException("getFunction()");
  191.   }
  192.  
  193.   /**
  194.    * Retrieves all the functions in this schema.
  195.    */
  196.   protected final Function[] allFunctions() {
  197.     try {
  198.       return doAllFunctions();
  199.     } catch (SQLException e) {
  200.       throw new FlywaySqlException("Unable to retrieve all functions in schema " + this, e);
  201.     }
  202.   }
  203.  
  204.   /**
  205.    * Retrieves all the functions in this schema.
  206.    *
  207.    * @throws SQLException when the retrieval failed.
  208.    */
  209.   protected Function[] doAllFunctions() throws SQLException {
  210.     return new Function[0];
  211.   }
  212.  
  213.   /**
  214.    * @return The quoted name of this schema.
  215.    */
  216.   @Override
  217.   public String toString() {
  218.     return database.quote(name);
  219.   }
  220.  
  221.   @Override
  222.   public boolean equals(Object o) {
  223.     if (this == o) return true;
  224.     if (o == null || getClass() != o.getClass()) return false;
  225.  
  226.     Schema schema = (Schema) o;
  227.     return name.equals(schema.name);
  228.   }
  229.  
  230.   @Override
  231.   public int hashCode() {
  232.     return name.hashCode();
  233.   }
  234. }

三, flyway配置参数

  1. spring.flyway.enabled=true
  2. spring.flyway.url=jdbc:mysql://172.16.1.187:2883/ob_test?userSSL=false&useUnicode=true&characterEncoding=UTF-8&sslMode=DISABLED&serverTimeZone=GMT%2B8
  3. spring.flyway.user=${spring.r2dbc.username}
  4. spring.flyway.driver-class-name=com.mysql.jdbc.Driver
  5. spring.flyway.password=${spring.r2dbc.password}
  6.  
  7. # ??sql???????????db/migration
  8. spring.flyway.locations=classpath:db/migration
  9. # ??sql????????????V
  10. spring.flyway.sql-migration-prefix=V
  11. # ??sql?????????????2????__
  12. spring.flyway.sql-migration-separator=__
  13. # ??sql?????????
  14. spring.flyway.sql-migration-suffixes=.sql
  15. # ????????????true
  16. spring.flyway.validate-on-migrate=true
  17. # ?????????????????????????????????schema_version?
  18. spring.flyway.baseline-on-migrate=true

四, 在resources目录下创建db.migration目录并在该目录下创建sql文件, V1.0.1__init.sql

  1. CREATE TABLE `QLFieldTest` (
  2.                                 `id` bigint(20) NOT NULL AUTO_INCREMENT,
  3.                                 `longText` text DEFAULT NULL,
  4.                                 `updateTime` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
  5.                                 `createBy` varchar(100) NOT NULL,
  6.                                 `createTime` datetime DEFAULT NULL
  7. ) AUTO_INCREMENT = 1 DEFAULT CHARSET = utf8mb4 ROW_FORMAT = COMPACT COMPRESSION = 'zstd_1.3.8' REPLICA_NUM = 1 BLOCK_SIZE = 16384 USE_BLOOM_FILTER = FALSE TABLET_SIZE = 134217728 PCTFREE = 0;

类似的其他sql文件同理

启动项目后,会生成一张表: flyway_schema_history

参考:

Flyway快速上手教程 - 简书

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/202747
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号