proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/InsertOrUpdateGeneratorMySQL.java
|
InsertOrUpdateGeneratorMySQL
|
getInsertStatement
|
class InsertOrUpdateGeneratorMySQL extends InsertOrUpdateGenerator {
@Override
public boolean supports(InsertOrUpdateStatement statement, Database database) {
return database instanceof MySQLDatabase;
}
@Override
protected String getInsertStatement(InsertOrUpdateStatement insertOrUpdateStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
protected String getUpdateStatement(InsertOrUpdateStatement insertOrUpdateStatement, Database database, String whereClause, SqlGeneratorChain sqlGeneratorChain) throws LiquibaseException {
if (insertOrUpdateStatement.getOnlyUpdate()) {
return super.getUpdateStatement(insertOrUpdateStatement, database, whereClause, sqlGeneratorChain);
} else {
return "";
}
}
@Override
protected String getRecordCheck(InsertOrUpdateStatement insertOrUpdateStatement, Database database, String whereClause) {
return "";
}
@Override
protected String getElse(Database database) {
return "";
}
}
|
StringBuilder sql = new StringBuilder(super.getInsertStatement(insertOrUpdateStatement, database, sqlGeneratorChain));
sql.deleteCharAt(sql.lastIndexOf(";"));
StringBuilder updateClause = new StringBuilder("ON DUPLICATE KEY UPDATE ");
String[] pkFields=insertOrUpdateStatement.getPrimaryKey().split(",");
HashSet<String> hashPkFields = new HashSet<>(Arrays.asList(pkFields));
boolean hasFields = false;
for(String columnKey:insertOrUpdateStatement.getColumnValues().keySet())
{
if (!hashPkFields.contains(columnKey) && insertOrUpdateStatement.getAllowColumnUpdate(columnKey)) {
hasFields = true;
updateClause.append(database.escapeObjectName(columnKey, Column.class)).append(" = ");
Object columnValue = insertOrUpdateStatement.getColumnValue(columnKey);
updateClause.append(DataTypeFactory.getInstance().fromObject(columnValue, database).objectToSql(columnValue, database));
updateClause.append(",");
}
}
if(hasFields) {
// append the updateClause onto the end of the insert statement
updateClause.deleteCharAt(updateClause.lastIndexOf(","));
sql.append(updateClause);
} else {
// insert IGNORE keyword into insert statement
sql.insert(sql.indexOf("INSERT ")+"INSERT ".length(), "IGNORE ");
}
return sql.toString();
| 254
| 385
| 639
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.InsertOrUpdateStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public int getPriority() ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.InsertOrUpdateStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/InsertOrUpdateGeneratorOracle.java
|
InsertOrUpdateGeneratorOracle
|
getPostUpdateStatements
|
class InsertOrUpdateGeneratorOracle extends InsertOrUpdateGenerator {
@Override
public boolean supports(InsertOrUpdateStatement statement, Database database) {
return database instanceof OracleDatabase;
}
@Override
protected String getRecordCheck(InsertOrUpdateStatement insertOrUpdateStatement, Database database, String whereClause) {
return String.format("DECLARE\n" +
"\tv_reccount NUMBER := 0;\n" +
"BEGIN\n" +
"\tSELECT COUNT(*) INTO v_reccount FROM %s WHERE %s;\n" +
"\tIF v_reccount = 0 THEN\n",
database.escapeTableName(insertOrUpdateStatement.getCatalogName(), insertOrUpdateStatement.getSchemaName(), insertOrUpdateStatement.getTableName()),
whereClause
);
}
@Override
protected String getElse(Database database){
return "\tELSIF v_reccount = 1 THEN\n";
}
@Override
protected String getPostUpdateStatements(Database database){<FILL_FUNCTION_BODY>}
}
|
StringBuilder endStatements = new StringBuilder();
endStatements.append("END IF;\n");
endStatements.append("END;\n");
if (Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", database) instanceof LoggingExecutor) {
endStatements.append("/\n");
}
return endStatements.toString();
| 276
| 99
| 375
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.InsertOrUpdateStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public int getPriority() ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.InsertOrUpdateStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/InsertOrUpdateGeneratorPostgres.java
|
InsertOrUpdateGeneratorPostgres
|
generateSql
|
class InsertOrUpdateGeneratorPostgres extends InsertOrUpdateGenerator {
@Override
public boolean supports(InsertOrUpdateStatement statement, Database database) {
if (database instanceof CockroachDatabase) {
return false;
}
if (database instanceof PostgresDatabase) {
try {
return database.getDatabaseMajorVersion() >= 9;
} catch (DatabaseException e) {
return true;
}
}
return false;
}
@Override
public Sql[] generateSql(InsertOrUpdateStatement insertOrUpdateStatement,
Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
protected String getElse(Database arg0) {
throw new UnsupportedOperationException();
}
@Override
protected String getRecordCheck(InsertOrUpdateStatement arg0,
Database arg1, String arg2) {
throw new UnsupportedOperationException();
}
}
|
StringBuilder generatedSql = new StringBuilder();
generatedSql.append("DO\n");
generatedSql.append("$$\n");
generatedSql.append("BEGIN\n");
try {
generatedSql.append(getUpdateStatement(insertOrUpdateStatement,
database, getWhereClause(insertOrUpdateStatement, database),
sqlGeneratorChain));
} catch (LiquibaseException e) {
// The perform keyword can be used here as an alternative as it does not return a value.
generatedSql.append("perform * from "
+ database.escapeTableName(insertOrUpdateStatement.getCatalogName(), insertOrUpdateStatement.getSchemaName(),
insertOrUpdateStatement.getTableName()) + " WHERE " + getWhereClause(insertOrUpdateStatement, database) + ";\n");
}
// if we don't want to only update, then add the INSERT statement
if (!insertOrUpdateStatement.getOnlyUpdate()) {
generatedSql.append("IF not found THEN\n");
generatedSql.append(getInsertStatement(insertOrUpdateStatement,
database, sqlGeneratorChain));
generatedSql.append("END IF;\n");
}
generatedSql.append("END;\n");
generatedSql.append("$$\n");
generatedSql.append("LANGUAGE plpgsql;\n");
return new Sql[] { new UnparsedSql(generatedSql.toString(), getAffectedTable(insertOrUpdateStatement)) };
| 233
| 371
| 604
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.InsertOrUpdateStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public int getPriority() ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.InsertOrUpdateStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/InsertOrUpdateGeneratorSybaseASA.java
|
InsertOrUpdateGeneratorSybaseASA
|
getInsertStatement
|
class InsertOrUpdateGeneratorSybaseASA extends InsertOrUpdateGenerator {
@Override
public boolean supports(InsertOrUpdateStatement statement, Database database) {
return database instanceof SybaseASADatabase;
}
@Override
protected String getInsertStatement(InsertOrUpdateStatement insertOrUpdateStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
protected String getUpdateStatement(InsertOrUpdateStatement insertOrUpdateStatement, Database database, String whereClause, SqlGeneratorChain sqlGeneratorChain) {
return "";
}
@Override
protected String getRecordCheck(InsertOrUpdateStatement insertOrUpdateStatement, Database database, String whereClause) {
return "";
}
@Override
protected String getElse(Database database) {
return "";
}
}
|
StringBuilder sql = new StringBuilder(super.getInsertStatement(insertOrUpdateStatement, database, sqlGeneratorChain));
int pos = sql.indexOf("VALUES (", 0);
sql.insert(pos, " ON EXISTING UPDATE ");
return sql.toString();
| 208
| 71
| 279
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.InsertOrUpdateStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public int getPriority() ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.InsertOrUpdateStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/InsertSetGenerator.java
|
InsertSetGenerator
|
generateSql
|
class InsertSetGenerator extends AbstractSqlGenerator<InsertSetStatement> {
@Override
public ValidationErrors validate(InsertSetStatement insertStatementSet, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", insertStatementSet.peek().getTableName());
validationErrors.checkRequiredField("columns", insertStatementSet.peek().getColumnValues());
return validationErrors;
}
@Override
public Sql[] generateSql(InsertSetStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
private Sql completeStatement(InsertSetStatement statement, StringBuilder sql) {
sql.deleteCharAt(sql.lastIndexOf(","));
sql.append(";\n");
return new UnparsedSql(sql.toString(), getAffectedTable(statement));
}
public void generateHeader(StringBuilder sql,InsertSetStatement statement, Database database) {
InsertStatement insert=statement.peek();
getInsertGenerator(database).generateHeader(sql, insert, database);
}
protected InsertGenerator getInsertGenerator(Database database) {
SortedSet<SqlGenerator> generators = SqlGeneratorFactory.getInstance().getGenerators(new InsertStatement(null, null, null), database);
if ((generators == null) || generators.isEmpty()) {
return null;
}
return (InsertGenerator) generators.iterator().next();
}
protected Relation getAffectedTable(InsertSetStatement statement) {
return new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
if (statement.peek() == null) {
return new UnparsedSql[0];
}
StringBuilder sql = new StringBuilder();
generateHeader(sql, statement, database);
ArrayList<Sql> result = new ArrayList<>();
int index = 0;
for (InsertStatement sttmnt : statement.getStatements()) {
index++;
getInsertGenerator(database).generateValues(sql, sttmnt, database);
sql.append(",");
if (index > statement.getBatchThreshold()) {
result.add(completeStatement(statement, sql));
index = 0;
sql.setLength(0);
generateHeader(sql, statement, database);
}
}
if (index > 0) {
result.add(completeStatement(statement, sql));
}
return result.toArray(new UnparsedSql[0]);
| 419
| 233
| 652
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.InsertSetStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.InsertSetStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.InsertSetStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/LockDatabaseChangeLogGenerator.java
|
LockDatabaseChangeLogGenerator
|
generateSql
|
class LockDatabaseChangeLogGenerator extends AbstractSqlGenerator<LockDatabaseChangeLogStatement> {
@Override
public ValidationErrors validate(LockDatabaseChangeLogStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return new ValidationErrors();
}
protected static final String hostname;
protected static final String hostaddress;
protected static final String hostDescription = (System.getProperty("liquibase.hostDescription") == null) ? "" :
("#" + System.getProperty("liquibase.hostDescription"));
static {
try {
hostname = NetUtil.getLocalHostName();
hostaddress = NetUtil.getLocalHostAddress();
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
}
@Override
public Sql[] generateSql(LockDatabaseChangeLogStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
String liquibaseSchema = database.getLiquibaseSchemaName();
String liquibaseCatalog = database.getLiquibaseCatalogName();
// use LEGACY quoting since we're dealing with system objects
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
String dateValue = database.getCurrentDateTimeFunction();
UpdateStatement updateStatement = new UpdateStatement(liquibaseCatalog, liquibaseSchema, database.getDatabaseChangeLogLockTableName());
updateStatement.addNewColumnValue("LOCKED", true);
updateStatement.addNewColumnValue("LOCKGRANTED", new DatabaseFunction(dateValue));
updateStatement.addNewColumnValue("LOCKEDBY", hostname + hostDescription + " (" + hostaddress + ")");
updateStatement.setWhereClause(database.escapeColumnName(liquibaseCatalog, liquibaseSchema, database.getDatabaseChangeLogTableName(), "ID") + " = 1 AND " + database.escapeColumnName(liquibaseCatalog, liquibaseSchema, database.getDatabaseChangeLogTableName(), "LOCKED") + " = "+ DataTypeFactory.getInstance().fromDescription("boolean", database).objectToSql(false, database));
return SqlGeneratorFactory.getInstance().generateSql(updateStatement, database);
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
| 237
| 356
| 593
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.LockDatabaseChangeLogStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.LockDatabaseChangeLogStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.LockDatabaseChangeLogStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/MarkChangeSetRanGenerator.java
|
MarkChangeSetRanGenerator
|
generateSql
|
class MarkChangeSetRanGenerator extends AbstractSqlGenerator<MarkChangeSetRanStatement> {
private static final String COMMENTS = "COMMENTS";
private static final String CONTEXTS = "CONTEXTS";
private static final String LABELS = "LABELS";
@Override
public ValidationErrors validate(MarkChangeSetRanStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("changeSet", statement.getChangeSet());
return validationErrors;
}
@Override
public Sql[] generateSql(MarkChangeSetRanStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
public static String getTagFromChangeset(ChangeSet changeSet) {
if (changeSet != null) {
for (Change change : changeSet.getChanges()) {
if (change instanceof TagDatabaseChange) {
TagDatabaseChange tagChange = (TagDatabaseChange) change;
return tagChange.getTag();
}
}
}
return null;
}
public static String getLiquibaseBuildVersion() {
return StringUtil.limitSize(LiquibaseUtil.getBuildVersion()
.replace("SNAPSHOT", "SNP")
.replace("beta", "b")
.replace("alpha", "b"), 20);
}
private String getCommentsColumn(ChangeSet changeSet) {
return StringUtil.limitSize(StringUtil.trimToEmpty(changeSet.getComments()), 250);
}
protected String getContextsColumn(ChangeSet changeSet) {
return changeSet.buildFullContext();
}
protected String getLabelsColumn(ChangeSet changeSet) {
return changeSet.buildFullLabels();
}
}
|
String dateValue = database.getCurrentDateTimeFunction();
ChangeSet changeSet = statement.getChangeSet();
SqlStatement runStatement;
// use LEGACY quoting since we're dealing with system objects
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
try {
if (statement.getExecType().equals(ChangeSet.ExecType.FAILED) || statement.getExecType().equals(ChangeSet.ExecType.SKIPPED)) {
return EMPTY_SQL; //don't mark
}
final String tag = getTagFromChangeset(changeSet);
final int orderExecuted = Scope.getCurrentScope().getSingleton(ChangeLogHistoryServiceFactory.class).getChangeLogService(database).getNextSequenceValue();
final DatabaseFunction dateExecuted = new DatabaseFunction(dateValue);
final String liquibaseVersion = getLiquibaseBuildVersion();
final String description = StringUtil.limitSize(changeSet.getDescription(), 250);
final String md5Sum = changeSet.generateCheckSum(ChecksumVersion.latest()).toString();
final String execType = statement.getExecType().value;
final String deploymentId = Scope.getCurrentScope().getSingleton(ChangeLogHistoryServiceFactory.class).getChangeLogService(database).getDeploymentId();
if (statement.getExecType().ranBefore) {
runStatement = new UpdateStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogTableName())
.addNewColumnValue("DATEEXECUTED", dateExecuted)
.addNewColumnValue("ORDEREXECUTED", orderExecuted)
.addNewColumnValue("MD5SUM", md5Sum)
.addNewColumnValue("EXECTYPE", execType)
.addNewColumnValue("DEPLOYMENT_ID", deploymentId)
.addNewColumnValue(COMMENTS, getCommentsColumn(changeSet))
.addNewColumnValue(CONTEXTS, getContextsColumn(changeSet))
.addNewColumnValue(LABELS, getLabelsColumn(changeSet))
.addNewColumnValue("LIQUIBASE", liquibaseVersion)
.addNewColumnValue("DESCRIPTION", description)
.setWhereClause(database.escapeObjectName("ID", LiquibaseColumn.class) + " = ? " +
"AND " + database.escapeObjectName("AUTHOR", LiquibaseColumn.class) + " = ? " +
"AND " + database.escapeObjectName("FILENAME", LiquibaseColumn.class) + " = ?")
.addWhereParameters(changeSet.getId(), changeSet.getAuthor(), changeSet.getFilePath());
if (tag != null) {
((UpdateStatement) runStatement).addNewColumnValue("TAG", tag);
}
} else {
runStatement = new InsertStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogTableName())
.addColumnValue("ID", changeSet.getId())
.addColumnValue("AUTHOR", changeSet.getAuthor())
.addColumnValue("FILENAME", changeSet.getFilePath())
.addColumnValue("DATEEXECUTED", dateExecuted)
.addColumnValue("ORDEREXECUTED", orderExecuted)
.addColumnValue("MD5SUM", md5Sum)
.addColumnValue("DESCRIPTION", description)
.addColumnValue(COMMENTS, getCommentsColumn(changeSet))
.addColumnValue("EXECTYPE", execType)
.addColumnValue(CONTEXTS, getContextsColumn(changeSet))
.addColumnValue(LABELS, getLabelsColumn(changeSet))
.addColumnValue("LIQUIBASE", liquibaseVersion)
.addColumnValue("DEPLOYMENT_ID", deploymentId);
if (tag != null) {
((InsertStatement) runStatement).addColumnValue("TAG", tag);
}
}
} catch (LiquibaseException e) {
throw new UnexpectedLiquibaseException(e);
}
return SqlGeneratorFactory.getInstance().generateSql(runStatement, database);
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
| 467
| 1,112
| 1,579
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.MarkChangeSetRanStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.MarkChangeSetRanStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.MarkChangeSetRanStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/ModifyDataTypeGenerator.java
|
ModifyDataTypeGenerator
|
generateSql
|
class ModifyDataTypeGenerator extends AbstractSqlGenerator<ModifyDataTypeStatement> {
@Override
public boolean supports(ModifyDataTypeStatement statement, Database database) {
if (database instanceof SQLiteDatabase || database instanceof Db2zDatabase) {
return false;
}
return super.supports(statement, database);
}
@Override
public Warnings warn(ModifyDataTypeStatement modifyDataTypeStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
Warnings warnings = super.warn(modifyDataTypeStatement, database, sqlGeneratorChain);
if (database instanceof MySQLDatabase) {
((MySQLDatabase) database).warnAboutAlterColumn("modifyDataType", warnings);
}
return warnings;
}
@Override
public ValidationErrors validate(ModifyDataTypeStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", statement.getTableName());
validationErrors.checkRequiredField("columnName", statement.getColumnName());
validationErrors.checkRequiredField("newDataType", statement.getNewDataType());
return validationErrors;
}
@Override
public Sql[] generateSql(ModifyDataTypeStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Relation getAffectedTable(ModifyDataTypeStatement statement) {
return new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
/**
* @return either "MODIFY" or "ALTER COLUMN" depending on the current db
*/
protected String getModifyString(Database database) {
if ((database instanceof SybaseASADatabase) || (database instanceof SybaseDatabase) || (database instanceof
MySQLDatabase) || (database instanceof OracleDatabase) || (database instanceof InformixDatabase)
) {
return "MODIFY";
} else {
return "ALTER COLUMN";
}
}
/**
* @return the string that comes before the column type
* definition (like 'set data type' for derby or an open parentheses for Oracle)
*/
protected String getPreDataTypeString(Database database) {
if ((database instanceof DerbyDatabase) || (database instanceof AbstractDb2Database)) {
return " SET DATA TYPE ";
} else if ((database instanceof SybaseASADatabase) || (database instanceof SybaseDatabase) || (database
instanceof MSSQLDatabase) || (database instanceof MySQLDatabase) || (database instanceof HsqlDatabase) ||
(database instanceof H2Database) || (database instanceof OracleDatabase) || (database instanceof
InformixDatabase)) {
return " ";
} else {
return " TYPE ";
}
}
}
|
String alterTable = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName());
// add "MODIFY"
alterTable += " " + getModifyString(database) + " ";
// add column name
String columnName = database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName());
alterTable += columnName;
alterTable += getPreDataTypeString(database); // adds a space if nothing else
// add column type
DatabaseDataType newDataType = DataTypeFactory.getInstance().fromDescription(statement.getNewDataType(), database).toDatabaseDataType(database);
alterTable += newDataType;
if (database instanceof PostgresDatabase) {
alterTable += " USING ("+columnName+"::"+newDataType+")";
}
return new Sql[]{new UnparsedSql(alterTable, getAffectedTable(statement))};
| 700
| 254
| 954
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.ModifyDataTypeStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.ModifyDataTypeStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.ModifyDataTypeStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/RawParameterizedSqlGenerator.java
|
RawParameterizedSqlGenerator
|
validate
|
class RawParameterizedSqlGenerator extends AbstractSqlGenerator<RawParameterizedSqlStatement> {
@Override
public ValidationErrors validate(RawParameterizedSqlStatement statement, Database database, SqlGeneratorChain<RawParameterizedSqlStatement> sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(RawParameterizedSqlStatement statement, Database database, SqlGeneratorChain<RawParameterizedSqlStatement> sqlGeneratorChain) {
return new Sql[] {new UnparsedSql(statement.getSql())};
}
}
|
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("sql", statement.getSql());
validationErrors.checkRequiredField("parameters", statement.getParameters(), false);
return validationErrors;
| 132
| 56
| 188
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.RawParameterizedSqlStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.RawParameterizedSqlStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.RawParameterizedSqlStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/RawSqlGenerator.java
|
RawSqlGenerator
|
validate
|
class RawSqlGenerator extends AbstractSqlGenerator<RawSqlStatement> {
@Override
public ValidationErrors validate(RawSqlStatement rawSqlStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(RawSqlStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return new Sql[] {
new UnparsedSql(statement.getSql(), statement.getEndDelimiter())
};
}
}
|
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("sql", rawSqlStatement.getSql());
return validationErrors;
| 123
| 40
| 163
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.RawSqlStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.RawSqlStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.RawSqlStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/ReindexGeneratorSQLite.java
|
ReindexGeneratorSQLite
|
generateSql
|
class ReindexGeneratorSQLite extends AbstractSqlGenerator<ReindexStatement> {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(ReindexStatement statement, Database database) {
return (database instanceof SQLiteDatabase);
}
@Override
public ValidationErrors validate(ReindexStatement reindexStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", reindexStatement.getTableName());
return validationErrors;
}
@Override
public Sql[] generateSql(ReindexStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
return new Sql[] {
new UnparsedSql("REINDEX "+database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()), new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName()))
};
| 193
| 78
| 271
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.ReindexStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.ReindexStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.ReindexStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/RemoveChangeSetRanStatusGenerator.java
|
RemoveChangeSetRanStatusGenerator
|
validate
|
class RemoveChangeSetRanStatusGenerator extends AbstractSqlGenerator<RemoveChangeSetRanStatusStatement> {
@Override
public ValidationErrors validate(RemoveChangeSetRanStatusStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(RemoveChangeSetRanStatusStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ChangeSet changeSet = statement.getChangeSet();
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
return SqlGeneratorFactory.getInstance().generateSql(new DeleteStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogTableName())
.setWhere(database.escapeObjectName("ID", LiquibaseColumn.class) + " = ? " +
"AND " + database.escapeObjectName("AUTHOR", LiquibaseColumn.class) + " = ? " +
"AND " + database.escapeObjectName("FILENAME", LiquibaseColumn.class) + " = ?")
.addWhereParameters(changeSet.getId(), changeSet.getAuthor(), changeSet.getStoredFilePath())
, database);
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
}
}
|
ValidationErrors errors = new ValidationErrors();
errors.checkRequiredField("changeSet", statement.getChangeSet());
return errors;
| 347
| 37
| 384
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.RemoveChangeSetRanStatusStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.RemoveChangeSetRanStatusStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.RemoveChangeSetRanStatusStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/RenameColumnGenerator.java
|
RenameColumnGenerator
|
generateSql
|
class RenameColumnGenerator extends AbstractSqlGenerator<RenameColumnStatement> {
@Override
public boolean supports(RenameColumnStatement statement, Database database) {
if(database instanceof SQLiteDatabase) {
try {
if(database.getDatabaseMajorVersion() <= 3 && database.getDatabaseMinorVersion() < 25) {
return false;
}
}
catch (DatabaseException e) {
throw new RuntimeException(e);
}
}
return true;
}
@Override
public ValidationErrors validate(RenameColumnStatement renameColumnStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", renameColumnStatement.getTableName());
validationErrors.checkRequiredField("oldColumnName", renameColumnStatement.getOldColumnName());
validationErrors.checkRequiredField("newColumnName", renameColumnStatement.getNewColumnName());
if (database instanceof MySQLDatabase) {
validationErrors.checkRequiredField("columnDataType", StringUtil.trimToNull(renameColumnStatement.getColumnDataType()));
}
return validationErrors;
}
@Override
public Sql[] generateSql(RenameColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Column getAffectedOldColumn(RenameColumnStatement statement) {
return new Column().setName(statement.getOldColumnName()).setRelation(new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName()));
}
protected Column getAffectedNewColumn(RenameColumnStatement statement) {
return new Column().setName(statement.getNewColumnName()).setRelation(new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName()));
}
}
|
String sql;
if (database instanceof MSSQLDatabase) {
// do no escape the new column name. Otherwise it produce "exec sp_rename '[dbo].[person].[usernae]', '[username]'"
sql = "exec sp_rename '" + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + "." + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName()) + "', '" + statement.getNewColumnName() + "', 'COLUMN'";
} else if (database instanceof MySQLDatabase) {
sql ="ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " CHANGE " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName()) + " " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getNewColumnName()) + " " + DataTypeFactory.getInstance().fromDescription(statement.getColumnDataType(), database).toDatabaseDataType(database);
} else if (database instanceof SybaseDatabase) {
sql = "exec sp_rename '" + statement.getTableName() + "." + statement.getOldColumnName() + "', '" + statement.getNewColumnName() + "'";
} else if ((database instanceof HsqlDatabase) || (database instanceof H2Database)) {
sql ="ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " ALTER COLUMN " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName()) + " RENAME TO " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getNewColumnName());
} else if (database instanceof FirebirdDatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " ALTER COLUMN " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName()) + " TO " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getNewColumnName());
} else if (
// supported in Derby from version 10.3.1.4 (see "http://issues.apache.org/jira/browse/DERBY-1490")
(database instanceof DerbyDatabase)
|| (database instanceof InformixDatabase)) {
sql = "RENAME COLUMN " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + "." + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName()) + " TO " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getNewColumnName());
} else if (database instanceof SybaseASADatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " RENAME " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName()) + " TO " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getNewColumnName());
} else if (database instanceof AbstractDb2Database) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " RENAME COLUMN " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName()) + " TO " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getNewColumnName());
} else {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " RENAME COLUMN " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getOldColumnName()) + " TO " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getNewColumnName());
}
if((database instanceof MySQLDatabase) && (statement.getRemarks() != null)) {
sql += " COMMENT '" + statement.getRemarks() +"' ";
}
return new Sql[] {
new UnparsedSql(sql, getAffectedOldColumn(statement), getAffectedNewColumn(statement))
};
| 476
| 1,253
| 1,729
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.RenameColumnStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.RenameColumnStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.RenameColumnStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/RenameSequenceGenerator.java
|
RenameSequenceGenerator
|
supports
|
class RenameSequenceGenerator extends AbstractSqlGenerator<RenameSequenceStatement> {
@Override
public boolean supports(RenameSequenceStatement statement, Database database) {<FILL_FUNCTION_BODY>}
@Override
public ValidationErrors validate(RenameSequenceStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("newSequenceName", statement.getNewSequenceName());
validationErrors.checkRequiredField("oldSequenceName", statement.getOldSequenceName());
return validationErrors;
}
@Override
public Sql[] generateSql(RenameSequenceStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
String sql;
if (database instanceof PostgresDatabase) {
sql = "ALTER SEQUENCE " + database.escapeSequenceName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldSequenceName()) + " RENAME TO " + database.escapeObjectName(statement.getNewSequenceName(), Sequence.class);
} else if (database instanceof OracleDatabase) {
sql = "RENAME " + database.escapeObjectName(statement.getOldSequenceName(), Sequence.class) + " TO " + database.escapeObjectName(statement.getNewSequenceName(), Sequence.class);
} else if( database instanceof MSSQLDatabase){
sql = "sp_rename " + database.escapeObjectName(statement.getOldSequenceName(), Sequence.class) + " ," + database.escapeObjectName(statement.getNewSequenceName(),Sequence.class);
} else {
sql = "ALTER SEQUENCE " + database.escapeSequenceName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldSequenceName()) + " RENAME TO " + database.escapeObjectName(statement.getNewSequenceName(), Sequence.class);
}
return new Sql[]{
new UnparsedSql(sql,
getAffectedOldSequence(statement),
getAffectedNewSequence(statement)
)
};
}
protected Sequence getAffectedNewSequence(RenameSequenceStatement statement) {
return new Sequence().setName(statement.getNewSequenceName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
protected Sequence getAffectedOldSequence(RenameSequenceStatement statement) {
return new Sequence().setName(statement.getOldSequenceName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
return database.supports(Sequence.class)
// TODO: following are not implemented/tested currently
&& !(database instanceof AbstractDb2Database)
&& !(database instanceof FirebirdDatabase)
&& !(database instanceof H2Database)
&& !(database instanceof HsqlDatabase)
&& !(database instanceof InformixDatabase)
&& !(database instanceof SQLiteDatabase);
| 611
| 95
| 706
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.RenameSequenceStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.RenameSequenceStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.RenameSequenceStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/RenameTableGenerator.java
|
RenameTableGenerator
|
generateSql
|
class RenameTableGenerator extends AbstractSqlGenerator<RenameTableStatement> {
@Override
public boolean supports(RenameTableStatement statement, Database database) {
return !(database instanceof FirebirdDatabase);
}
@Override
public ValidationErrors validate(RenameTableStatement renameTableStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("newTableName", renameTableStatement.getNewTableName());
validationErrors.checkRequiredField("oldTableName", renameTableStatement.getOldTableName());
return validationErrors;
}
@Override
public Sql[] generateSql(RenameTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Relation getAffectedNewTable(RenameTableStatement statement) {
return new Table().setName(statement.getNewTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
protected Relation getAffectedOldTable(RenameTableStatement statement) {
return new Table().setName(statement.getOldTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
String sql;
if (database instanceof MSSQLDatabase) {
sql = "exec sp_rename '" + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldTableName()) + "', '" + statement.getNewTableName() + '\'';
} else if (database instanceof SybaseDatabase) {
sql = "exec sp_rename '" + statement.getOldTableName() + "', '" + statement.getNewTableName() + '\'';
} else if (database instanceof MySQLDatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldTableName()) + " RENAME " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getNewTableName());
} else if (database instanceof PostgresDatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldTableName()) + " RENAME TO " + database.escapeObjectName(statement.getNewTableName(), Table.class);
} else if (database instanceof SybaseASADatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldTableName()) + " RENAME " + database.escapeObjectName(statement.getNewTableName(), Table.class);
} else if ((database instanceof DerbyDatabase) || (database instanceof InformixDatabase)) {
sql = "RENAME TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldTableName()) + " TO " + database.escapeObjectName(statement.getNewTableName(), Table.class);
} else if ((database instanceof HsqlDatabase) || (database instanceof H2Database)) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldTableName()) + " RENAME TO " + database.escapeObjectName(statement.getNewTableName(), Table.class);
} else if (database instanceof OracleDatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldTableName()) + " RENAME TO " + database.escapeObjectName(statement.getNewTableName(), Table.class);
} else if (database instanceof AbstractDb2Database) {
sql = "RENAME " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldTableName()) + " TO " + database.escapeObjectName(statement.getNewTableName(), Table.class);//db2 doesn't allow specifying new schema name
} else if (database instanceof SQLiteDatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldTableName()) + " RENAME TO " + database.escapeObjectName(statement.getNewTableName(), Table.class);
} else {
sql = "RENAME " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldTableName()) + " TO " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getNewTableName());
}
return new Sql[]{
new UnparsedSql(sql,
getAffectedOldTable(statement),
getAffectedNewTable(statement)
)
};
| 307
| 857
| 1,164
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.RenameTableStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.RenameTableStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.RenameTableStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/RenameViewGenerator.java
|
RenameViewGenerator
|
generateSql
|
class RenameViewGenerator extends AbstractSqlGenerator<RenameViewStatement> {
@Override
public boolean supports(RenameViewStatement statement, Database database) {
return !((database instanceof DerbyDatabase) || (database instanceof HsqlDatabase) || (database instanceof
H2Database) || (database instanceof AbstractDb2Database) || (database instanceof FirebirdDatabase) || (database
instanceof InformixDatabase) || (database instanceof SybaseASADatabase));
}
@Override
public ValidationErrors validate(RenameViewStatement renameViewStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("oldViewName", renameViewStatement.getOldViewName());
validationErrors.checkRequiredField("newViewName", renameViewStatement.getNewViewName());
validationErrors.checkDisallowedField("schemaName", renameViewStatement.getSchemaName(), database, OracleDatabase.class);
return validationErrors;
}
@Override
public Sql[] generateSql(RenameViewStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Relation getAffectedNewView(RenameViewStatement statement) {
return new View().setName(statement.getNewViewName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
protected Relation getAffectedOldView(RenameViewStatement statement) {
return new View().setName(statement.getOldViewName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
String sql;
if (database instanceof MSSQLDatabase) {
sql = "exec sp_rename '" + database.escapeViewName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldViewName()) + "', '" + statement.getNewViewName() + '\'';
} else if (database instanceof MySQLDatabase) {
sql = "RENAME TABLE " + database.escapeViewName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldViewName()) + " TO " + database.escapeViewName(statement.getCatalogName(), statement.getSchemaName(), statement.getNewViewName());
} else if (database instanceof PostgresDatabase) {
sql = "ALTER TABLE " + database.escapeViewName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldViewName()) + " RENAME TO " + database.escapeObjectName(statement.getNewViewName(), View.class);
} else if (database instanceof OracleDatabase) {
sql = "RENAME " + database.escapeObjectName(statement.getOldViewName(), View.class) + " TO " + database.escapeObjectName(statement.getNewViewName(), View.class);
} else {
sql = "RENAME " + database.escapeViewName(statement.getCatalogName(), statement.getSchemaName(), statement.getOldViewName()) + " TO " + database.escapeObjectName(statement.getNewViewName(), View.class);
}
return new Sql[]{
new UnparsedSql(sql,
getAffectedOldView(statement),
getAffectedNewView(statement)
)
};
| 394
| 397
| 791
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.RenameViewStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.RenameViewStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.RenameViewStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/ReorganizeTableGeneratorDB2.java
|
ReorganizeTableGeneratorDB2
|
generateSql
|
class ReorganizeTableGeneratorDB2 extends AbstractSqlGenerator<ReorganizeTableStatement> {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(ReorganizeTableStatement statement, Database database) {
return database instanceof DB2Database;
}
@Override
public ValidationErrors validate(ReorganizeTableStatement reorganizeTableStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", reorganizeTableStatement.getTableName());
return validationErrors;
}
@Override
public Sql[] generateSql(ReorganizeTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Relation getAffectedTable(ReorganizeTableStatement statement) {
return new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
if (!GlobalConfiguration.AUTO_REORG.getCurrentValue()) {
return null;
}
try {
if (database.getDatabaseMajorVersion() >= 9) {
return new Sql[]{
new UnparsedSql("CALL SYSPROC.ADMIN_CMD ('REORG TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + "')",
getAffectedTable(statement))
};
} else {
return null;
}
} catch (DatabaseException e) {
throw new RuntimeException(e);
}
| 260
| 160
| 420
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.ReorganizeTableStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.ReorganizeTableStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.ReorganizeTableStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/SelectFromDatabaseChangeLogGenerator.java
|
SelectFromDatabaseChangeLogGenerator
|
generateSql
|
class SelectFromDatabaseChangeLogGenerator extends AbstractSqlGenerator<SelectFromDatabaseChangeLogStatement> {
@Override
public ValidationErrors validate(SelectFromDatabaseChangeLogStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors errors = new ValidationErrors();
errors.checkRequiredField("columnToSelect", statement.getColumnsToSelect());
return errors;
}
@Override
public Sql[] generateSql(SelectFromDatabaseChangeLogStatement statement, final Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
List<ColumnConfig> columnsToSelect = Arrays.asList(statement.getColumnsToSelect());
// use LEGACY quoting since we're dealing with system objects
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
String sql = "SELECT " + (database instanceof MSSQLDatabase && statement.getLimit() != null ? "TOP "+statement.getLimit()+" " : "") + StringUtil.join(columnsToSelect, ",", (StringUtil.StringUtilFormatter<ColumnConfig>) column -> {
if ((column.getComputed() != null) && column.getComputed()) {
return column.getName();
} else {
return database.escapeColumnName(null, null, null, column.getName());
}
}).toUpperCase() + " FROM " +
database.escapeTableName(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogTableName());
SelectFromDatabaseChangeLogStatement.WhereClause whereClause = statement.getWhereClause();
if (whereClause != null) {
if (whereClause instanceof SelectFromDatabaseChangeLogStatement.ByTag) {
sql += " WHERE "+database.escapeColumnName(null, null, null, "TAG")+"='" + ((SelectFromDatabaseChangeLogStatement.ByTag) whereClause).getTagName() + "'";
} else if (whereClause instanceof SelectFromDatabaseChangeLogStatement.ByNotNullCheckSum) {
sql += " WHERE "+database.escapeColumnName(null, null, null, "MD5SUM")+" IS NOT NULL";
} else {
throw new UnexpectedLiquibaseException("Unknown where clause type: " + whereClause.getClass().getName());
}
}
if ((statement.getOrderByColumns() != null) && (statement.getOrderByColumns().length > 0)) {
sql += " ORDER BY ";
Iterator<String> orderBy = Arrays.asList(statement.getOrderByColumns()).iterator();
while (orderBy.hasNext()) {
String orderColumn = orderBy.next();
String[] orderColumnData = orderColumn.split(" ");
sql += database.escapeColumnName(null, null, null, orderColumnData[0]);
if (orderColumnData.length == 2) {
sql += " ";
sql += orderColumnData[1].toUpperCase();
}
if (orderBy.hasNext()) {
sql += ", ";
}
}
}
if (statement.getLimit() != null) {
if (database instanceof OracleDatabase) {
if (whereClause == null) {
sql += " WHERE ROWNUM="+statement.getLimit();
} else {
sql += " AND ROWNUM="+statement.getLimit();
}
} else if ((database instanceof MySQLDatabase) || (database instanceof PostgresDatabase)) {
sql += " LIMIT "+statement.getLimit();
} else if (database instanceof AbstractDb2Database) {
sql += " FETCH FIRST "+statement.getLimit()+" ROWS ONLY";
}
}
return new Sql[]{
new UnparsedSql(sql)
};
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
| 140
| 846
| 986
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.SelectFromDatabaseChangeLogStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.SelectFromDatabaseChangeLogStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.SelectFromDatabaseChangeLogStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/SelectFromDatabaseChangeLogLockGenerator.java
|
SelectFromDatabaseChangeLogLockGenerator
|
generateSql
|
class SelectFromDatabaseChangeLogLockGenerator extends AbstractSqlGenerator<SelectFromDatabaseChangeLogLockStatement> {
@Override
public ValidationErrors validate(SelectFromDatabaseChangeLogLockStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors errors = new ValidationErrors();
errors.checkRequiredField("columnToSelect", statement.getColumnsToSelect());
return errors;
}
@Override
public Sql[] generateSql(SelectFromDatabaseChangeLogLockStatement statement, final Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
String liquibaseSchema;
liquibaseSchema = database.getLiquibaseSchemaName();
// use LEGACY quoting since we're dealing with system objects
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
String sql = "SELECT " + StringUtil.join(statement.getColumnsToSelect(), ",", (StringUtil.StringUtilFormatter<ColumnConfig>) col -> {
if ((col.getComputed() != null) && col.getComputed()) {
return col.getName();
} else {
return database.escapeColumnName(null, null, null, col.getName());
}
}) + " FROM " +
database.escapeTableName(database.getLiquibaseCatalogName(), liquibaseSchema, database.getDatabaseChangeLogLockTableName()) +
" WHERE " + database.escapeColumnName(database.getLiquibaseCatalogName(), liquibaseSchema, database.getDatabaseChangeLogLockTableName(), "ID") + "=1";
if (database instanceof OracleDatabase) {
sql += " FOR UPDATE";
}
return new Sql[] {
new UnparsedSql(sql)
};
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
| 144
| 339
| 483
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.SelectFromDatabaseChangeLogLockStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.SelectFromDatabaseChangeLogLockStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.SelectFromDatabaseChangeLogLockStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/SetColumnRemarksGenerator.java
|
SetColumnRemarksGenerator
|
generateSql
|
class SetColumnRemarksGenerator extends AbstractSqlGenerator<SetColumnRemarksStatement> {
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
@Override
public boolean supports(SetColumnRemarksStatement statement, Database database) {
return (database instanceof OracleDatabase) || (database instanceof PostgresDatabase) || (database instanceof
AbstractDb2Database) || (database instanceof MSSQLDatabase) || (database instanceof H2Database) || (database
instanceof SybaseASADatabase) || (database instanceof MySQLDatabase);
}
@Override
public ValidationErrors validate(SetColumnRemarksStatement setColumnRemarksStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", setColumnRemarksStatement.getTableName());
validationErrors.checkRequiredField("columnName", setColumnRemarksStatement.getColumnName());
validationErrors.checkDisallowedField("catalogName", setColumnRemarksStatement.getCatalogName(), database, MSSQLDatabase.class);
if (database instanceof MySQLDatabase) {
validationErrors.checkRequiredField("columnDataType", StringUtil.trimToNull(setColumnRemarksStatement.getColumnDataType()));
}
return validationErrors;
}
@Override
public Warnings warn(SetColumnRemarksStatement statementType, Database database, SqlGeneratorChain<SetColumnRemarksStatement> sqlGeneratorChain) {
final Warnings warnings = super.warn(statementType, database, sqlGeneratorChain);
if (database instanceof MySQLDatabase) {
((MySQLDatabase) database).warnAboutAlterColumn("setColumnRemarks", warnings);
}
return warnings;
}
@Override
public Sql[] generateSql(SetColumnRemarksStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Column getAffectedColumn(SetColumnRemarksStatement statement) {
return new Column().setName(statement.getColumnName()).setRelation(new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName()));
}
}
|
String remarksEscaped = database.escapeStringForDatabase(StringUtil.trimToEmpty(statement.getRemarks()));
if (database instanceof MySQLDatabase) {
// generate mysql sql ALTER TABLE cat.user MODIFY COLUMN id int DEFAULT 1001 COMMENT 'A String'
return new Sql[]{new UnparsedSql("ALTER TABLE " + database.escapeTableName(
statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " MODIFY COLUMN "
+ database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " "
+ DataTypeFactory.getInstance().fromDescription(statement.getColumnDataType(), database).toDatabaseDataType(database)
+ " COMMENT '" + remarksEscaped + "'", getAffectedColumn(statement))};
} else if (database instanceof MSSQLDatabase) {
String schemaName = statement.getSchemaName();
if (schemaName == null) {
schemaName = database.getDefaultSchemaName() != null ? database.getDefaultSchemaName() : "dbo";
}
String tableName = statement.getTableName();
String qualifiedTableName = String.format("%s.%s", schemaName, statement.getTableName());
String columnName = statement.getColumnName();
String targetObject = "TABLE";
if (statement.getColumnParentType() != null && statement.getColumnParentType() == ColumnParentType.VIEW) {
targetObject = "VIEW";
}
Sql[] generatedSql = {new UnparsedSql("IF EXISTS( " +
" SELECT extended_properties.value" +
" FROM sys.extended_properties" +
" WHERE major_id = OBJECT_ID('" + qualifiedTableName + "')" +
" AND name = N'MS_DESCRIPTION'" +
" AND minor_id = (" +
" SELECT column_id" +
" FROM sys.columns" +
" WHERE name = '" + columnName + "'" +
" AND object_id = OBJECT_ID('" + qualifiedTableName + "'))" +
" )" +
" BEGIN " +
" EXEC sys.sp_updateextendedproperty @name = N'MS_Description'" +
" , @value = N'" + remarksEscaped + "'" +
" , @level0type = N'SCHEMA'" +
" , @level0name = N'" + schemaName + "'" +
" , @level1type = N'" + targetObject + "'" +
" , @level1name = N'" + tableName + "'" +
" , @level2type = N'COLUMN'" +
" , @level2name = N'" + columnName + "'" +
" END " +
" ELSE " +
" BEGIN " +
" EXEC sys.sp_addextendedproperty @name = N'MS_Description'" +
" , @value = N'" + remarksEscaped + "'" +
" , @level0type = N'SCHEMA'" +
" , @level0name = N'" + schemaName + "'" +
" , @level1type = N'" + targetObject + "'" +
" , @level1name = N'" + tableName + "'" +
" , @level2type = N'COLUMN'" +
" , @level2name = N'" + columnName + "'" +
" END")};
return generatedSql;
} else {
return new Sql[]{new UnparsedSql("COMMENT ON COLUMN " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
+ "." + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " IS '"
+ remarksEscaped + "'", getAffectedColumn(statement))};
}
| 531
| 981
| 1,512
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.SetColumnRemarksStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.SetColumnRemarksStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.SetColumnRemarksStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/SetTableRemarksGenerator.java
|
SetTableRemarksGenerator
|
generateSql
|
class SetTableRemarksGenerator extends AbstractSqlGenerator<SetTableRemarksStatement> {
@Override
public boolean supports(SetTableRemarksStatement statement, Database database) {
return (database instanceof MySQLDatabase) || (database instanceof OracleDatabase) || (database instanceof
PostgresDatabase) || (database instanceof AbstractDb2Database) || (database instanceof MSSQLDatabase) ||
(database instanceof H2Database) || (database instanceof SybaseASADatabase);
}
@Override
public ValidationErrors validate(SetTableRemarksStatement setTableRemarksStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", setTableRemarksStatement.getTableName());
return validationErrors;
}
@Override
public Sql[] generateSql(SetTableRemarksStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Relation getAffectedTable(SetTableRemarksStatement statement) {
return new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
String sql;
String remarksEscaped = database.escapeStringForDatabase(StringUtil.trimToEmpty(statement.getRemarks()));
if (database instanceof MySQLDatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " COMMENT = '" + remarksEscaped
+ "'";
} else if (database instanceof MSSQLDatabase) {
String schemaName = statement.getSchemaName();
if (schemaName == null) {
schemaName = database.getDefaultSchemaName() != null ? database.getDefaultSchemaName() : "dbo";
}
String tableName = statement.getTableName();
String qualifiedTableName = String.format("%s.%s", schemaName, statement.getTableName());
sql = "IF EXISTS( " +
" SELECT extended_properties.value" +
" FROM sys.extended_properties" +
" WHERE major_id = OBJECT_ID('" + qualifiedTableName + "')" +
" AND name = N'MS_DESCRIPTION'" +
" AND minor_id = 0" +
" )" +
" BEGIN " +
" EXEC sys.sp_updateextendedproperty @name = N'MS_Description'" +
" , @value = N'" + remarksEscaped + "'" +
" , @level0type = N'SCHEMA'" +
" , @level0name = N'" + schemaName + "'" +
" , @level1type = N'TABLE'" +
" , @level1name = N'" + tableName + "'" +
" END " +
" ELSE " +
" BEGIN " +
" EXEC sys.sp_addextendedproperty @name = N'MS_Description'" +
" , @value = N'" + remarksEscaped + "'" +
" , @level0type = N'SCHEMA'" +
" , @level0name = N'" + schemaName + "'" +
" , @level1type = N'TABLE'" +
" , @level1name = N'" + tableName + "'" +
" END";
} else {
sql = "COMMENT ON TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " IS '"
+ remarksEscaped + "'";
}
return new Sql[] { new UnparsedSql(sql, getAffectedTable(statement)) };
| 282
| 619
| 901
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.SetTableRemarksStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.SetTableRemarksStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.SetTableRemarksStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/SetViewRemarksGenerator.java
|
SetViewRemarksGenerator
|
generateSql
|
class SetViewRemarksGenerator extends AbstractSqlGenerator<SetViewRemarksStatement> {
@Override
public boolean supports(SetViewRemarksStatement statement, Database database) {
return (database instanceof OracleDatabase) || (database instanceof PostgresDatabase) || (database instanceof MSSQLDatabase) || (database instanceof DB2Database)
|| (database instanceof SybaseASADatabase);
}
@Override
public ValidationErrors validate(SetViewRemarksStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("viewName", statement.getViewName());
return validationErrors;
}
@Override
public Sql[] generateSql(SetViewRemarksStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Relation getAffectedTable(SetViewRemarksStatement statement) {
return new View().setName(statement.getViewName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
String sql = "";
String remarksEscaped = database.escapeStringForDatabase(StringUtil.trimToEmpty(statement.getRemarks()));
if (database instanceof OracleDatabase || database instanceof PostgresDatabase || database instanceof DB2Database || database instanceof SybaseASADatabase) {
String sqlPlaceholder = "COMMENT ON %s %s IS '%s'";
String targetNameEscaped = database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getViewName());
String targetObject;
if (database instanceof OracleDatabase || database instanceof DB2Database) {
//Oracle and DB2 consider views as tables for their comment syntax
targetObject = "TABLE";
} else {
targetObject = "VIEW";
}
sql = String.format(sqlPlaceholder, targetObject, targetNameEscaped, remarksEscaped);
} else if (database instanceof MSSQLDatabase) {
String schemaName = statement.getSchemaName();
if (schemaName == null) {
schemaName = database.getDefaultSchemaName() != null ? database.getDefaultSchemaName() : "dbo";
}
String viewName = statement.getViewName();
String qualifiedTableName = String.format("%s.%s", schemaName, statement.getViewName());
sql = "IF EXISTS( " +
" SELECT extended_properties.value" +
" FROM sys.extended_properties" +
" WHERE major_id = OBJECT_ID('" + qualifiedTableName + "')" +
" AND name = N'MS_DESCRIPTION'" +
" AND minor_id = 0" +
" )" +
" BEGIN " +
" EXEC sys.sp_updateextendedproperty @name = N'MS_Description'" +
" , @value = N'" + remarksEscaped + "'" +
" , @level0type = N'SCHEMA'" +
" , @level0name = N'" + schemaName + "'" +
" , @level1type = N'VIEW'" +
" , @level1name = N'" + viewName + "'" +
" END " +
" ELSE " +
" BEGIN " +
" EXEC sys.sp_addextendedproperty @name = N'MS_Description'" +
" , @value = N'" + remarksEscaped + "'" +
" , @level0type = N'SCHEMA'" +
" , @level0name = N'" + schemaName + "'" +
" , @level1type = N'VIEW'" +
" , @level1name = N'" + viewName + "'" +
" END";
}
return new Sql[]{new UnparsedSql(sql, getAffectedTable(statement))};
| 261
| 674
| 935
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.SetViewRemarksStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.SetViewRemarksStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.SetViewRemarksStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/StoredProcedureGenerator.java
|
StoredProcedureGenerator
|
generateSql
|
class StoredProcedureGenerator extends AbstractSqlGenerator<StoredProcedureStatement> {
@Override
public ValidationErrors validate(StoredProcedureStatement storedProcedureStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("procedureName", storedProcedureStatement.getProcedureName());
return validationErrors;
}
@Override
public Sql[] generateSql(StoredProcedureStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
StringBuilder string = new StringBuilder();
string.append("exec ").append(statement.getProcedureName()).append("(");
for (String param : statement.getParameters()) {
string.append(" ").append(param).append(",");
}
String sql = string.toString().replaceFirst(",$", "")+")";
if (database instanceof OracleDatabase) {
sql = sql.replaceFirst("exec ", "BEGIN ").replaceFirst("\\)$", "); END;");
}
return new Sql[] { new UnparsedSql(sql)};
| 143
| 144
| 287
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.StoredProcedureStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.StoredProcedureStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.StoredProcedureStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/TableIsEmptyGenerator.java
|
TableIsEmptyGenerator
|
generateCountSql
|
class TableIsEmptyGenerator extends AbstractSqlGenerator<TableIsEmptyStatement> {
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
@Override
public boolean supports(TableIsEmptyStatement statement, Database database) {
return true;
}
@Override
public ValidationErrors validate(TableIsEmptyStatement tableIsEmptyStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", tableIsEmptyStatement.getTableName());
return validationErrors;
}
protected String generateCountSql(TableIsEmptyStatement statement, Database database) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(TableIsEmptyStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return new Sql[] { new UnparsedSql(generateCountSql(statement, database)) };
}
}
|
String tableName = database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName());
if (database instanceof HsqlDatabase || database instanceof DB2Database) {
return String.format("SELECT COUNT(1) FROM (VALUES(0)) WHERE EXISTS (SELECT * FROM %s)", tableName);
}
if (database instanceof Db2zDatabase) {
return String.format("SELECT COUNT(1) FROM SYSIBM.SYSDUMMY1 WHERE EXISTS (SELECT * FROM %s)", tableName);
}
if (database instanceof OracleDatabase || database instanceof MySQLDatabase) {
return String.format("SELECT COUNT(1) FROM DUAL WHERE EXISTS (SELECT * FROM %s)", tableName);
}
if (database instanceof FirebirdDatabase) {
return String.format("SELECT COUNT(1) FROM RDB$DATABASE WHERE EXISTS (SELECT * FROM %s)", tableName);
}
return String.format("SELECT COUNT(1) WHERE EXISTS (SELECT * FROM %s)", tableName);
| 237
| 255
| 492
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.TableIsEmptyStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.TableIsEmptyStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.TableIsEmptyStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/TableRowCountGenerator.java
|
TableRowCountGenerator
|
validate
|
class TableRowCountGenerator extends AbstractSqlGenerator<TableRowCountStatement> {
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
@Override
public boolean supports(TableRowCountStatement statement, Database database) {
return true;
}
@Override
public ValidationErrors validate(TableRowCountStatement dropColumnStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected String generateCountSql(TableRowCountStatement statement, Database database) {
return "SELECT COUNT(*) FROM "+database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName());
}
@Override
public Sql[] generateSql(TableRowCountStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return new Sql[] { new UnparsedSql(generateCountSql(statement, database)) };
}
}
|
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", dropColumnStatement.getTableName());
return validationErrors;
| 233
| 42
| 275
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.TableRowCountStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.TableRowCountStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.TableRowCountStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/TagDatabaseGenerator.java
|
TagDatabaseGenerator
|
generateSql
|
class TagDatabaseGenerator extends AbstractSqlGenerator<TagDatabaseStatement> {
@Override
public ValidationErrors validate(TagDatabaseStatement tagDatabaseStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tag", tagDatabaseStatement.getTag());
return validationErrors;
}
@Override
public Sql[] generateSql(TagDatabaseStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
String tableNameEscaped = database.escapeTableName(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogTableName());
String orderColumnNameEscaped = database.escapeObjectName("ORDEREXECUTED", Column.class);
String dateColumnNameEscaped = database.escapeObjectName("DATEEXECUTED", Column.class);
String tagColumnNameEscaped = database.escapeObjectName("TAG", Column.class);
String tagEscaped = DataTypeFactory.getInstance().fromObject(statement.getTag(), database).objectToSql(statement.getTag(), database);
if (database instanceof MySQLDatabase) {
return new Sql[]{
new UnparsedSql(
"UPDATE " + tableNameEscaped + " AS C " +
"INNER JOIN (" +
"SELECT " + orderColumnNameEscaped + ", " + dateColumnNameEscaped + " " +
"FROM " + tableNameEscaped +
" order by " + dateColumnNameEscaped + " desc, " + orderColumnNameEscaped + " desc limit 1) AS D " +
"ON C." + orderColumnNameEscaped + " = D." + orderColumnNameEscaped + " " +
"SET C." + tagColumnNameEscaped + " = " + tagEscaped)
};
} else if (database instanceof PostgresDatabase) {
return new Sql[]{
new UnparsedSql(
"UPDATE " + tableNameEscaped + " t SET TAG=" + tagEscaped +
" FROM (SELECT " + dateColumnNameEscaped + ", " + orderColumnNameEscaped + " FROM " + tableNameEscaped + " ORDER BY " + dateColumnNameEscaped + " DESC, " + orderColumnNameEscaped + " DESC LIMIT 1) sub " +
"WHERE t." + dateColumnNameEscaped + "=sub." + dateColumnNameEscaped + " AND t." + orderColumnNameEscaped + "=sub." + orderColumnNameEscaped)
};
} else if (database instanceof InformixDatabase) {
String tempTableNameEscaped = database.escapeObjectName("max_order_temp", Table.class);
return new Sql[]{
new UnparsedSql(
"SELECT MAX(" + dateColumnNameEscaped + ") AS " + dateColumnNameEscaped +
", MAX(" + orderColumnNameEscaped + ") AS " + orderColumnNameEscaped + " " +
"FROM " + tableNameEscaped + " " +
"INTO TEMP " + tempTableNameEscaped + " WITH NO LOG"),
new UnparsedSql(
"UPDATE " + tableNameEscaped + " " +
"SET TAG = " + tagEscaped + " " +
"WHERE " + dateColumnNameEscaped + " = (" +
"SELECT " + dateColumnNameEscaped + " " +
"FROM " + tempTableNameEscaped +
") AND " +
orderColumnNameEscaped + " = (" +
"SELECT " + orderColumnNameEscaped + " " +
"FROM " + tempTableNameEscaped +
");"),
new UnparsedSql(
"DROP TABLE " + tempTableNameEscaped + ";")
};
} else if (database instanceof MSSQLDatabase) {
String changelogAliasEscaped = database.escapeObjectName("changelog", Table.class);
String latestAliasEscaped = database.escapeObjectName("latest", Table.class);
String idColumnEscaped = database.escapeObjectName("ID", Column.class);
String authorColumnEscaped = database.escapeObjectName("AUTHOR", Column.class);
String filenameColumnEscaped = database.escapeObjectName("FILENAME", Column.class);
String topClause = "TOP (1)";
return new Sql[] {
new UnparsedSql(
"UPDATE " + changelogAliasEscaped + " " +
"SET " + tagColumnNameEscaped + " = " + tagEscaped + " " +
"FROM " + tableNameEscaped + " AS " + changelogAliasEscaped + " " +
"INNER JOIN (" +
"SELECT " + topClause + " " + idColumnEscaped + ", " + authorColumnEscaped + ", " + filenameColumnEscaped + " " +
"FROM " + tableNameEscaped + " " +
"ORDER BY " + dateColumnNameEscaped + " DESC, " + orderColumnNameEscaped + " DESC" +
") AS " + latestAliasEscaped + " " +
"ON " + latestAliasEscaped + "." + idColumnEscaped + " = " + changelogAliasEscaped + "." + idColumnEscaped + " " +
"AND " + latestAliasEscaped + "." + authorColumnEscaped + " = " + changelogAliasEscaped + "." + authorColumnEscaped + " " +
"AND " + latestAliasEscaped + "." + filenameColumnEscaped + " = " + changelogAliasEscaped + "." + filenameColumnEscaped)
};
} else if ((database instanceof OracleDatabase) || (database instanceof DB2Database)) {
String selectClause = "SELECT";
String endClause = ")";
String delimiter = "";
if (database instanceof OracleDatabase) {
selectClause = "SELECT * FROM (SELECT";
endClause = ") where rownum=1)";
} else if (database instanceof AbstractDb2Database) {
endClause = " FETCH FIRST 1 ROWS ONLY)";
}
return new Sql[]{
new UnparsedSql("MERGE INTO " + tableNameEscaped + " a " +
"USING (" + selectClause + " " + orderColumnNameEscaped + ", " + dateColumnNameEscaped + " from " + tableNameEscaped + " order by " + dateColumnNameEscaped + " desc, " + orderColumnNameEscaped + " desc" + endClause + " b " +
"ON ( a." + dateColumnNameEscaped + " = b." + dateColumnNameEscaped + " and a." + orderColumnNameEscaped + "=b." + orderColumnNameEscaped + " ) " +
"WHEN MATCHED THEN " +
"UPDATE SET a.tag=" + tagEscaped + delimiter)
};
} else {
//Only uses dateexecuted as a default. Depending on the timestamp resolution, multiple rows may be tagged which normally works fine but can cause confusion and some issues.
//We cannot use orderexecuted alone because it is only guaranteed to be incrementing per update call.
//TODO: Better handle other databases to use dateexecuted desc, orderexecuted desc.
UpdateStatement updateStatement = new UpdateStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogTableName())
.addNewColumnValue("TAG", statement.getTag())
.setWhereClause(
dateColumnNameEscaped + " = (" +
"SELECT MAX(" + dateColumnNameEscaped + ") " +
"FROM " + tableNameEscaped +
")");
return SqlGeneratorFactory.getInstance().generateSql(updateStatement, database);
}
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
| 129
| 1,820
| 1,949
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.TagDatabaseStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.TagDatabaseStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.TagDatabaseStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/UnlockDatabaseChangeLogGenerator.java
|
UnlockDatabaseChangeLogGenerator
|
generateSql
|
class UnlockDatabaseChangeLogGenerator extends AbstractSqlGenerator<UnlockDatabaseChangeLogStatement> {
@Override
public ValidationErrors validate(UnlockDatabaseChangeLogStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return new ValidationErrors();
}
@Override
public Sql[] generateSql(UnlockDatabaseChangeLogStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
String liquibaseSchema = database.getLiquibaseSchemaName();
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
UpdateStatement releaseStatement = new UpdateStatement(database.getLiquibaseCatalogName(), liquibaseSchema, database.getDatabaseChangeLogLockTableName());
releaseStatement.addNewColumnValue("LOCKED", false);
releaseStatement.addNewColumnValue("LOCKGRANTED", null);
releaseStatement.addNewColumnValue("LOCKEDBY", null);
releaseStatement.setWhereClause(database.escapeColumnName(database.getLiquibaseCatalogName(), liquibaseSchema, database.getDatabaseChangeLogTableName(), "ID")+" = 1");
return SqlGeneratorFactory.getInstance().generateSql(releaseStatement, database);
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
| 110
| 235
| 345
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.UnlockDatabaseChangeLogStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.UnlockDatabaseChangeLogStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.UnlockDatabaseChangeLogStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/UpdateChangeSetChecksumGenerator.java
|
UpdateChangeSetChecksumGenerator
|
generateSql
|
class UpdateChangeSetChecksumGenerator extends AbstractSqlGenerator<UpdateChangeSetChecksumStatement> {
@Override
public ValidationErrors validate(UpdateChangeSetChecksumStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("changeSet", statement.getChangeSet());
return validationErrors;
}
@Override
public Sql[] generateSql(UpdateChangeSetChecksumStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
private String getFilePath(ChangeSet changeSet) {
if (StringUtil.isNotEmpty(changeSet.getStoredFilePath())) {
return changeSet.getStoredFilePath();
}
return changeSet.getFilePath();
}
}
|
ChangeSet changeSet = statement.getChangeSet();
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
SqlStatement runStatement = null;
runStatement = new UpdateStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogTableName())
.addNewColumnValue("MD5SUM", changeSet.generateCheckSum(ChecksumVersion.latest()).toString())
.setWhereClause(database.escapeObjectName("ID", LiquibaseColumn.class) + " = ? " +
"AND " + database.escapeObjectName("AUTHOR", LiquibaseColumn.class) + " = ? " +
"AND " + database.escapeObjectName("FILENAME", LiquibaseColumn.class) + " = ?")
.addWhereParameters(changeSet.getId(), changeSet.getAuthor(), this.getFilePath(changeSet));
return SqlGeneratorFactory.getInstance().generateSql(runStatement, database);
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
| 207
| 289
| 496
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.UpdateChangeSetChecksumStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.UpdateChangeSetChecksumStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.UpdateChangeSetChecksumStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/UpdateDataChangeGenerator.java
|
UpdateDataChangeGenerator
|
validate
|
class UpdateDataChangeGenerator extends AbstractSqlGenerator<UpdateExecutablePreparedStatement> {
@Override
public ValidationErrors validate(UpdateExecutablePreparedStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(UpdateExecutablePreparedStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return EMPTY_SQL;
}
}
|
ValidationErrors validationErrors = new ValidationErrors();
if ((statement.getWhereParameters() != null) && !statement.getWhereParameters().isEmpty() && (statement
.getWhereClause() == null)) {
validationErrors.addError("whereParams set but no whereClause");
}
return validationErrors;
| 111
| 81
| 192
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.UpdateExecutablePreparedStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.UpdateExecutablePreparedStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.UpdateExecutablePreparedStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/UpdateGenerator.java
|
UpdateGenerator
|
validate
|
class UpdateGenerator extends AbstractSqlGenerator<UpdateStatement> {
@Override
public ValidationErrors validate(UpdateStatement updateStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(UpdateStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
StringBuilder sql = new StringBuilder("UPDATE ")
.append(database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()))
.append(" SET");
for (String column : statement.getNewColumnValues().keySet()) {
sql.append(" ")
.append(database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), column))
.append(" = ")
.append(convertToString(statement.getNewColumnValues().get(column), database))
.append(",");
}
int lastComma = sql.lastIndexOf(",");
if (lastComma >= 0) {
sql.deleteCharAt(lastComma);
}
if (statement.getWhereClause() != null) {
sql.append(" WHERE ").append(replacePredicatePlaceholders(database, statement.getWhereClause(), statement.getWhereColumnNames(), statement.getWhereParameters()));
}
return new Sql[] {
new UnparsedSql(sql.toString(), getAffectedTable(statement))
};
}
protected Relation getAffectedTable(UpdateStatement statement) {
return new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
private String convertToString(Object newValue, Database database) {
String sqlString;
if ((newValue == null) || "NULL".equalsIgnoreCase(newValue.toString())) {
sqlString = "NULL";
} else if ((newValue instanceof String) && !looksLikeFunctionCall(((String) newValue), database)) {
sqlString = DataTypeFactory.getInstance().fromObject(newValue, database).objectToSql(newValue, database);
} else if (newValue instanceof Date) {
// converting java.util.Date to java.sql.Date
Date date = (Date) newValue;
if (date.getClass().equals(java.util.Date.class)) {
date = new java.sql.Date(date.getTime());
}
sqlString = database.getDateLiteral(date);
} else if (newValue instanceof Boolean) {
if (((Boolean) newValue)) {
sqlString = DataTypeFactory.getInstance().getTrueBooleanValue(database);
} else {
sqlString = DataTypeFactory.getInstance().getFalseBooleanValue(database);
}
} else if (newValue instanceof DatabaseFunction) {
sqlString = database.generateDatabaseFunctionValue((DatabaseFunction) newValue);
} else {
sqlString = newValue.toString();
}
return sqlString;
}
}
|
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", updateStatement.getTableName());
validationErrors.checkRequiredField("columns", updateStatement.getNewColumnValues());
if ((updateStatement.getWhereParameters() != null) && !updateStatement.getWhereParameters().isEmpty() &&
(updateStatement.getWhereClause() == null)) {
validationErrors.addError("whereParams set but no whereClause");
}
return validationErrors;
| 738
| 122
| 860
|
<methods>public non-sealed void <init>() ,public boolean generateRollbackStatementsIsVolatile(liquibase.database.Database) ,public boolean generateStatementsIsVolatile(liquibase.database.Database) ,public int getPriority() ,public boolean looksLikeFunctionCall(java.lang.String, liquibase.database.Database) ,public boolean supports(liquibase.statement.core.UpdateStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.UpdateStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.UpdateStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/statement/BatchDmlExecutablePreparedStatement.java
|
BatchDmlExecutablePreparedStatement
|
generateSql
|
class BatchDmlExecutablePreparedStatement extends ExecutablePreparedStatementBase {
private final List<ExecutablePreparedStatementBase> collectedStatements;
private final Logger LOG = Scope.getCurrentScope().getLog(getClass());
public BatchDmlExecutablePreparedStatement(
Database database, String catalogName, String schemaName, String tableName,
List<LoadDataColumnConfig> columns, ChangeSet changeSet, ResourceAccessor resourceAccessor,
List<ExecutablePreparedStatementBase> statements) {
super(database, catalogName, schemaName, tableName, new ArrayList<ColumnConfig>(columns), changeSet,
resourceAccessor);
this.collectedStatements = new ArrayList<>(statements);
}
/**
* Returns the individual statements that are currently store in this batch.
* @return the List of the stored statements (may be empty if none are stored)
*/
public List<ExecutablePreparedStatementBase> getIndividualStatements() {
return new ArrayList<>(collectedStatements);
}
@Override
protected void attachParams(List<? extends ColumnConfig> ignored, PreparedStatement stmt)
throws SQLException, DatabaseException {
for (ExecutablePreparedStatementBase insertStatement : collectedStatements) {
super.attachParams(insertStatement.getColumns(), stmt);
stmt.addBatch();
}
}
@Override
protected String generateSql(List<ColumnConfig> cols) {<FILL_FUNCTION_BODY>}
@Override
protected void executePreparedStatement(PreparedStatement stmt) throws SQLException {
int[] updateCounts = stmt.executeBatch();
long sumUpdateCounts = 0;
for (int updateCount : updateCounts) {
sumUpdateCounts = updateCount;
}
LOG.info(String.format("Executing JDBC DML batch was successful. %d operations were executed, %d individual UPDATE events were confirmed by the database.",
updateCounts.length, sumUpdateCounts));
}
@Override
public boolean continueOnError() {
return false;
}
}
|
// By convention, all of the statements are the same except the bind values. So it is sufficient to simply
// return the first collected statement for generation.
return collectedStatements.get(0).generateSql(cols);
| 532
| 55
| 587
|
<methods>public void execute(liquibase.database.PreparedStatementFactory) throws liquibase.exception.DatabaseException,public java.lang.String getCatalogName() ,public liquibase.changelog.ChangeSet getChangeSet() ,public List<? extends liquibase.change.ColumnConfig> getColumns() ,public liquibase.resource.ResourceAccessor getResourceAccessor() ,public java.lang.String getSchemaName() ,public java.lang.String getTableName() ,public boolean skipOnUnsupported() <variables>private final non-sealed java.lang.String catalogName,private final non-sealed liquibase.changelog.ChangeSet changeSet,private final non-sealed Set<java.io.Closeable> closeables,private final non-sealed List<? extends liquibase.change.ColumnConfig> columns,protected static java.util.ResourceBundle coreBundle,protected liquibase.database.Database database,private static java.lang.reflect.Method executeWithFlagsMethod,private static java.sql.PreparedStatement lastPreparedStatement,private static java.lang.String lastPreparedStatementSql,private final non-sealed liquibase.resource.ResourceAccessor resourceAccessor,private final non-sealed java.lang.String schemaName,private final Map<java.lang.String,java.lang.Object> snapshotScratchPad,private final non-sealed java.lang.String tableName
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/statement/DatabaseFunction.java
|
DatabaseFunction
|
equals
|
class DatabaseFunction {
/**
* String value used for comparison. If a function matches this value then it should be replaces by the
* real current timestamp function.
*/
public static final String CURRENT_DATE_TIME_PLACE_HOLDER = "current_datetime";
private String schemaName;
private final String value;
public DatabaseFunction(String value) {
this.value = value;
}
public DatabaseFunction(String schemaName, String value) {
this.schemaName = schemaName;
this.value = value;
}
public String getValue() {
return value;
}
@Override
public String toString() {
return (getSchemaName() == null ? "" : getSchemaName() + ".") + getValue();
}
public String getSchemaName() {
return schemaName;
}
public void setSchemaName(String schemaName) {
this.schemaName = schemaName;
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return this.toString().hashCode();
}
}
|
if (obj instanceof DatabaseFunction) {
return this.toString().equals(obj.toString());
} else {
return super.equals(obj);
}
| 301
| 43
| 344
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/statement/InsertExecutablePreparedStatement.java
|
InsertExecutablePreparedStatement
|
generateSql
|
class InsertExecutablePreparedStatement extends ExecutablePreparedStatementBase {
public InsertExecutablePreparedStatement(
Database database, String catalogName, String schemaName, String tableName, List<? extends ColumnConfig> columns,
ChangeSet changeSet, ResourceAccessor resourceAccessor) {
super(database, catalogName, schemaName, tableName, columns, changeSet, resourceAccessor);
}
@Override
public boolean continueOnError() {
return false;
}
@Override
protected String generateSql(List<ColumnConfig> cols) {<FILL_FUNCTION_BODY>}
}
|
StringBuilder sql = new StringBuilder("INSERT INTO ");
StringBuilder params = new StringBuilder("VALUES(");
sql.append(database.escapeTableName(getCatalogName(), getSchemaName(), getTableName()));
sql.append("(");
for(ColumnConfig column : getColumns()) {
if(database.supportsAutoIncrement()
&& Boolean.TRUE.equals(column.isAutoIncrement())) {
continue;
}
sql.append(database.escapeColumnName(getCatalogName(), getSchemaName(), getTableName(), column.getName()));
sql.append(", ");
if (column.getValueObject() instanceof DatabaseFunction) {
params.append(column.getValueObject()).append(", ");
} else {
params.append("?, ");
cols.add(column);
}
}
sql.deleteCharAt(sql.lastIndexOf(" "));
sql.deleteCharAt(sql.lastIndexOf(","));
params.deleteCharAt(params.lastIndexOf(" "));
params.deleteCharAt(params.lastIndexOf(","));
params.append(")");
sql.append(") ");
sql.append(params);
return sql.toString();
| 157
| 305
| 462
|
<methods>public void execute(liquibase.database.PreparedStatementFactory) throws liquibase.exception.DatabaseException,public java.lang.String getCatalogName() ,public liquibase.changelog.ChangeSet getChangeSet() ,public List<? extends liquibase.change.ColumnConfig> getColumns() ,public liquibase.resource.ResourceAccessor getResourceAccessor() ,public java.lang.String getSchemaName() ,public java.lang.String getTableName() ,public boolean skipOnUnsupported() <variables>private final non-sealed java.lang.String catalogName,private final non-sealed liquibase.changelog.ChangeSet changeSet,private final non-sealed Set<java.io.Closeable> closeables,private final non-sealed List<? extends liquibase.change.ColumnConfig> columns,protected static java.util.ResourceBundle coreBundle,protected liquibase.database.Database database,private static java.lang.reflect.Method executeWithFlagsMethod,private static java.sql.PreparedStatement lastPreparedStatement,private static java.lang.String lastPreparedStatementSql,private final non-sealed liquibase.resource.ResourceAccessor resourceAccessor,private final non-sealed java.lang.String schemaName,private final Map<java.lang.String,java.lang.Object> snapshotScratchPad,private final non-sealed java.lang.String tableName
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/statement/StoredProcedureStatement.java
|
StoredProcedureStatement
|
getParameterType
|
class StoredProcedureStatement extends AbstractSqlStatement implements CallableSqlStatement {
private final String procedureName;
private final List<String> parameters = new ArrayList<>();
private final List<Integer> types = new ArrayList<>();
public StoredProcedureStatement(String procedureName) {
this.procedureName = procedureName;
}
public String getProcedureName() {
return procedureName;
}
public List<String> getParameters() {
return Collections.unmodifiableList(parameters);
}
public void addParameter(String param, int type) {
parameters.add(param);
types.add(type);
}
public int getParameterType(String param) {<FILL_FUNCTION_BODY>}
}
|
for (int i=0; i<parameters.size(); i++) {
if (parameters.get(i).equals(param)) {
return types.get(i);
}
}
return -1;
| 195
| 59
| 254
|
<methods>public non-sealed void <init>() ,public boolean continueOnError() ,public void setContinueOnError(boolean) ,public boolean skipOnUnsupported() <variables>private boolean continueOnError
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/statement/UpdateExecutablePreparedStatement.java
|
UpdateExecutablePreparedStatement
|
generateSql
|
class UpdateExecutablePreparedStatement extends ExecutablePreparedStatementBase {
private String whereClause;
private final List<String> whereColumnNames = new ArrayList<>();
private final List<Object> whereParameters = new ArrayList<>();
public UpdateExecutablePreparedStatement(Database database, String catalogName, String schemaName, String tableName, List<ColumnConfig> columns, ChangeSet changeSet, ResourceAccessor resourceAccessor) {
super(database, catalogName, schemaName, tableName, columns, changeSet, resourceAccessor);
}
@Override
public boolean continueOnError() {
return false;
}
@Override
protected String generateSql(List<ColumnConfig> cols) {<FILL_FUNCTION_BODY>}
public String getWhereClause() {
return whereClause;
}
public UpdateExecutablePreparedStatement setWhereClause(String whereClause) {
this.whereClause = whereClause;
return this;
}
public UpdateExecutablePreparedStatement addWhereParameter(Object value) {
this.whereParameters.add(value);
return this;
}
public UpdateExecutablePreparedStatement addWhereParameters(Object... value) {
this.whereParameters.addAll(Arrays.asList(value));
return this;
}
public UpdateExecutablePreparedStatement addWhereColumnName(String value) {
this.whereColumnNames.add(value);
return this;
}
public List<Object> getWhereParameters() {
return whereParameters;
}
public List<String> getWhereColumnNames() {
return whereColumnNames;
}
}
|
StringBuilder sql = new StringBuilder("UPDATE ").append(database.escapeTableName(getCatalogName(), getSchemaName(), getTableName()));
StringBuilder params = new StringBuilder(" SET ");
for(ColumnConfig column : getColumns()) {
params.append(database.escapeColumnName(getCatalogName(), getSchemaName(), getTableName(), column.getName()));
params.append(" = ");
if (column.getValueObject() instanceof DatabaseFunction) {
params.append(column.getValueObject()).append(", ");
} else {
params.append("?, ");
cols.add(column);
}
}
params.deleteCharAt(params.lastIndexOf(" "));
params.deleteCharAt(params.lastIndexOf(","));
sql.append(params);
if (getWhereClause() != null) {
sql.append(" WHERE ").append(replacePredicatePlaceholders(database, getWhereClause(), getWhereColumnNames(), getWhereParameters()));
}
return sql.toString();
| 428
| 262
| 690
|
<methods>public void execute(liquibase.database.PreparedStatementFactory) throws liquibase.exception.DatabaseException,public java.lang.String getCatalogName() ,public liquibase.changelog.ChangeSet getChangeSet() ,public List<? extends liquibase.change.ColumnConfig> getColumns() ,public liquibase.resource.ResourceAccessor getResourceAccessor() ,public java.lang.String getSchemaName() ,public java.lang.String getTableName() ,public boolean skipOnUnsupported() <variables>private final non-sealed java.lang.String catalogName,private final non-sealed liquibase.changelog.ChangeSet changeSet,private final non-sealed Set<java.io.Closeable> closeables,private final non-sealed List<? extends liquibase.change.ColumnConfig> columns,protected static java.util.ResourceBundle coreBundle,protected liquibase.database.Database database,private static java.lang.reflect.Method executeWithFlagsMethod,private static java.sql.PreparedStatement lastPreparedStatement,private static java.lang.String lastPreparedStatementSql,private final non-sealed liquibase.resource.ResourceAccessor resourceAccessor,private final non-sealed java.lang.String schemaName,private final Map<java.lang.String,java.lang.Object> snapshotScratchPad,private final non-sealed java.lang.String tableName
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/statement/core/AddColumnStatement.java
|
AddColumnStatement
|
isNullable
|
class AddColumnStatement extends AbstractSqlStatement {
private String catalogName;
private String schemaName;
private String tableName;
private String columnName;
private String columnType;
private Object defaultValue;
@Setter
private String defaultValueConstraintName;
private String remarks;
@Setter
private String addAfterColumn;
@Setter
private String addBeforeColumn;
@Setter
private Integer addAtPosition;
@Setter
private Boolean computed;
private final Set<ColumnConstraint> constraints = new HashSet<>();
private final List<AddColumnStatement> columns = new ArrayList<>();
public AddColumnStatement(String catalogName, String schemaName, String tableName, String columnName, String columnType, Object defaultValue, ColumnConstraint... constraints) {
this.catalogName = catalogName;
this.schemaName = schemaName;
this.tableName = tableName;
this.columnName = columnName;
this.columnType = columnType;
this.defaultValue = defaultValue;
if (constraints != null) {
this.constraints.addAll(Arrays.asList(constraints));
}
}
public AddColumnStatement(String catalogName, String schemaName, String tableName, String columnName, String columnType, Object defaultValue, String remarks,ColumnConstraint... constraints) {
this(catalogName,schemaName,tableName,columnName,columnType,defaultValue,constraints);
this.remarks = remarks;
}
public AddColumnStatement(List<AddColumnStatement> columns) {
this.columns.addAll(columns);
}
public AddColumnStatement(AddColumnStatement... columns) {
this(Arrays.asList(columns));
}
public boolean isMultiple() {
return !columns.isEmpty();
}
public boolean isAutoIncrement() {
for (ColumnConstraint constraint : getConstraints()) {
if (constraint instanceof AutoIncrementConstraint) {
return true;
}
}
return false;
}
public AutoIncrementConstraint getAutoIncrementConstraint() {
AutoIncrementConstraint autoIncrementConstraint = null;
for (ColumnConstraint constraint : getConstraints()) {
if (constraint instanceof AutoIncrementConstraint) {
autoIncrementConstraint = (AutoIncrementConstraint) constraint;
break;
}
}
return autoIncrementConstraint;
}
public boolean isPrimaryKey() {
for (ColumnConstraint constraint : getConstraints()) {
if (constraint instanceof PrimaryKeyConstraint) {
return true;
}
}
return false;
}
public boolean isNullable() {<FILL_FUNCTION_BODY>}
public boolean shouldValidateNullable() {
if (isPrimaryKey()) {
return false;
}
for (ColumnConstraint constraint : getConstraints()) {
if (constraint instanceof NotNullConstraint) {
if (!((NotNullConstraint) constraint).shouldValidateNullable()) {
return false;
}
}
}
return true;
}
public boolean shouldValidateUnique() {
for (ColumnConstraint constraint : getConstraints()) {
if (constraint instanceof UniqueConstraint) {
if (!((UniqueConstraint) constraint).shouldValidateUnique()) {
return false;
}
}
}
return true;
}
public boolean shouldValidatePrimaryKey() {
for (ColumnConstraint constraint : getConstraints()) {
if (constraint instanceof PrimaryKeyConstraint) {
if (!((PrimaryKeyConstraint) constraint).shouldValidatePrimaryKey()) {
return false;
}
}
}
return true;
}
public boolean isUnique() {
for (ColumnConstraint constraint : getConstraints()) {
if (constraint instanceof UniqueConstraint) {
return true;
}
}
return false;
}
public String getUniqueStatementName() {
for (ColumnConstraint constraint : getConstraints()) {
if (constraint instanceof UniqueConstraint) {
return ((UniqueConstraint) constraint).getConstraintName();
}
}
return null;
}
}
|
if (isPrimaryKey()) {
return false;
}
for (ColumnConstraint constraint : getConstraints()) {
if (constraint instanceof NotNullConstraint) {
return false;
}
}
return true;
| 1,046
| 60
| 1,106
|
<methods>public non-sealed void <init>() ,public boolean continueOnError() ,public void setContinueOnError(boolean) ,public boolean skipOnUnsupported() <variables>private boolean continueOnError
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/statement/core/CommentStatement.java
|
CommentStatement
|
toString
|
class CommentStatement extends AbstractSqlStatement {
private final String text;
private final int MAX_LENGTH = 80;
public CommentStatement(String text) {
this.text = text;
}
@Override
public int hashCode() {
return text.hashCode();
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof CommentStatement)) {
return false;
}
return this.toString().equals(obj.toString());
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
public String getText() {
return text;
}
}
|
if ((text != null) && (text.length() >= MAX_LENGTH)) {
return text.substring(0, MAX_LENGTH - 3) + "...";
}
return getText();
| 170
| 56
| 226
|
<methods>public non-sealed void <init>() ,public boolean continueOnError() ,public void setContinueOnError(boolean) ,public boolean skipOnUnsupported() <variables>private boolean continueOnError
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/statement/core/CreateIndexStatement.java
|
CreateIndexStatement
|
setClustered
|
class CreateIndexStatement extends AbstractSqlStatement implements CompoundStatement {
private final String tableCatalogName;
private final String tableSchemaName;
private final String indexName;
private final String tableName;
private final AddColumnConfig[] columns;
private String tablespace;
private final Boolean unique;
// Contain associations of index
// for example: foreignKey, primaryKey or uniqueConstraint
private String associatedWith;
private Boolean clustered;
public CreateIndexStatement(String indexName, String tableCatalogName, String tableSchemaName, String tableName, Boolean isUnique, String associatedWith, AddColumnConfig... columns) {
this.indexName = indexName;
this.tableCatalogName = tableCatalogName;
this.tableSchemaName = tableSchemaName;
this.tableName = tableName;
this.columns = columns;
this.unique = isUnique;
this.associatedWith = associatedWith;
}
public String getTableCatalogName() {
return tableCatalogName;
}
public String getTableSchemaName() {
return tableSchemaName;
}
public String getIndexName() {
return indexName;
}
public String getTableName() {
return tableName;
}
public AddColumnConfig[] getColumns() {
return columns;
}
public String getTablespace() {
return tablespace;
}
public CreateIndexStatement setTablespace(String tablespace) {
this.tablespace = tablespace;
return this;
}
public Boolean isUnique() {
return unique;
}
public String getAssociatedWith() {
return associatedWith;
}
public void setAssociatedWith(String associatedWith) {
this.associatedWith = associatedWith;
}
public Boolean isClustered() {
return clustered;
}
public CreateIndexStatement setClustered(Boolean clustered) {<FILL_FUNCTION_BODY>}
}
|
if (clustered == null) {
this.clustered = false;
} else {
this.clustered = clustered;
}
return this;
| 507
| 48
| 555
|
<methods>public non-sealed void <init>() ,public boolean continueOnError() ,public void setContinueOnError(boolean) ,public boolean skipOnUnsupported() <variables>private boolean continueOnError
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/statement/core/InsertOrUpdateStatement.java
|
InsertOrUpdateStatement
|
getAllowColumnUpdate
|
class InsertOrUpdateStatement extends InsertStatement {
private final String primaryKey;
private Boolean onlyUpdate = Boolean.FALSE;
private final Map<String, Boolean> allowUpdates = new HashMap<>();
public InsertOrUpdateStatement(String catalogName, String schemaName, String tableName, String primaryKey) {
super(catalogName, schemaName, tableName);
this.primaryKey = primaryKey ;
}
public InsertOrUpdateStatement(String catalogName, String schemaName, String tableName, String primaryKey, boolean onlyUpdate) {
this(catalogName, schemaName, tableName,primaryKey);
this.onlyUpdate = onlyUpdate;
}
public String getPrimaryKey() {
return primaryKey;
}
@DatabaseChangeProperty(description = "Whether records with no matching database record should be ignored")
public Boolean getOnlyUpdate() {
if ( onlyUpdate == null ) {
return false;
}
return onlyUpdate;
}
public void setOnlyUpdate(Boolean onlyUpdate) {
this.onlyUpdate = ((onlyUpdate == null) ? Boolean.FALSE : onlyUpdate);
}
public boolean getAllowColumnUpdate(String columnName) {<FILL_FUNCTION_BODY>}
public void setAllowColumnUpdate(String columnName, boolean allowUpdate) {
this.allowUpdates.put(columnName, allowUpdate);
}
}
|
final Boolean allow = this.allowUpdates.get(columnName);
if (allow == null) {
return true;
}
return allow;
| 346
| 42
| 388
|
<methods>public void <init>(java.lang.String, java.lang.String, java.lang.String) ,public liquibase.statement.core.InsertStatement addColumn(liquibase.change.ColumnConfig) ,public liquibase.statement.core.InsertStatement addColumnValue(java.lang.String, java.lang.Object) ,public java.lang.String getCatalogName() ,public java.lang.Object getColumnValue(java.lang.String) ,public Map<java.lang.String,java.lang.Object> getColumnValues() ,public java.lang.String getSchemaName() ,public java.lang.String getTableName() <variables>private final non-sealed java.lang.String catalogName,private final Map<java.lang.String,java.lang.Object> columnValues,private final non-sealed java.lang.String schemaName,private final non-sealed java.lang.String tableName
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/statement/core/RawParameterizedSqlStatement.java
|
RawParameterizedSqlStatement
|
toString
|
class RawParameterizedSqlStatement extends AbstractSqlStatement {
private final String sql;
private final List<Object> parameters = new ArrayList<>();
public RawParameterizedSqlStatement(String sql, Object... parameters) {
this.sql = sql;
if (parameters != null) {
this.parameters.addAll(Arrays.asList(parameters));
}
}
public String getSql() {
return sql;
}
public List<Object> getParameters() {
return parameters;
}
public RawParameterizedSqlStatement addParameter(Object parameter) {
this.parameters.add(parameter);
return this;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return sql + " with " + StringUtil.join(parameters, ",", new StringUtil.ToStringFormatter());
| 192
| 29
| 221
|
<methods>public non-sealed void <init>() ,public boolean continueOnError() ,public void setContinueOnError(boolean) ,public boolean skipOnUnsupported() <variables>private boolean continueOnError
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/AbstractDatabaseObject.java
|
AbstractDatabaseObject
|
compareTo
|
class AbstractDatabaseObject implements DatabaseObject {
private final Map<String, Object> attributes = new HashMap<>();
private static final String CURLY_BRACKET_REGEX = "(.*)!\\{(.*)\\}";
public static final Pattern CURLY_BRACKET_PATTERN = Pattern.compile(CURLY_BRACKET_REGEX);
private String snapshotId;
@Override
public String getObjectTypeName() {
return StringUtil.lowerCaseFirst(getClass().getSimpleName());
}
@Override
public String getSnapshotId() {
return snapshotId;
}
@Override
public void setSnapshotId(String snapshotId) {
if (this.snapshotId != null) {
throw new UnexpectedLiquibaseException("snapshotId already set");
}
this.snapshotId = snapshotId;
}
@Override
public boolean snapshotByDefault() {
return true;
}
@Override
public int compareTo(Object o) {<FILL_FUNCTION_BODY>}
@Override
public Set<String> getAttributes() {
return attributes.keySet();
}
@Override
@SuppressWarnings("unchecked")
public <T> T getAttribute(String attribute, Class<T> type) {
return (T) attributes.get(attribute);
}
@Override
@SuppressWarnings("unchecked")
public <T> T getAttribute(String attribute, T defaultValue) {
T value = (T) attributes.get(attribute);
if (value == null) {
return defaultValue;
}
return value;
}
@Override
public DatabaseObject setAttribute(String attribute, Object value) {
if (value == null) {
attributes.remove(attribute);
} else {
attributes.put(attribute, value);
}
return this;
}
@Override
public String getSerializedObjectName() {
return getObjectTypeName();
}
@Override
public String getSerializedObjectNamespace() {
return STANDARD_SNAPSHOT_NAMESPACE;
}
@Override
public String getSerializableFieldNamespace(String field) {
return getSerializedObjectNamespace();
}
@Override
public Set<String> getSerializableFields() {
TreeSet<String> fields = new TreeSet<>(attributes.keySet());
fields.add("snapshotId");
return fields;
}
@Override
public Object getSerializableFieldValue(String field) {
if ("snapshotId".equals(field)) {
return snapshotId;
}
if (!attributes.containsKey(field)) {
throw new UnexpectedLiquibaseException("Unknown field " + field);
}
Object value = attributes.get(field);
try {
if (value instanceof Schema) {
Schema clone = new Schema(((Schema) value).getCatalogName(), ((Schema) value).getName());
clone.setSnapshotId(((DatabaseObject) value).getSnapshotId());
return clone;
} else if (value instanceof DatabaseObject) {
DatabaseObject clone = (DatabaseObject) value.getClass().getConstructor().newInstance();
clone.setName(((DatabaseObject) value).getName());
clone.setSnapshotId(((DatabaseObject) value).getSnapshotId());
return clone;
}
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
return value;
}
@Override
public LiquibaseSerializable.SerializationType getSerializableFieldType(String field) {
return LiquibaseSerializable.SerializationType.NAMED_FIELD;
}
@Override
public void load(ParsedNode parsedNode, ResourceAccessor resourceAccessor) throws ParsedNodeException {
for (ParsedNode child : parsedNode.getChildren()) {
String name = child.getName();
if ("snapshotId".equals(name)) {
this.snapshotId = child.getValue(String.class);
continue;
}
Class propertyType = ObjectUtil.getPropertyType(this, name);
if ((propertyType != null) && Collection.class.isAssignableFrom(propertyType) && !(child.getValue()
instanceof Collection)) {
if (this.attributes.get(name) == null) {
this.setAttribute(name, new ArrayList<Column>());
}
this.getAttribute(name, List.class).add(child.getValue());
} else {
Object childValue = child.getValue();
if ((childValue instanceof String)) {
Matcher matcher = CURLY_BRACKET_PATTERN.matcher((String) childValue);
if (matcher.matches()) {
String stringValue = matcher.group(1);
try {
Class<?> aClass = Class.forName(matcher.group(2));
if (Date.class.isAssignableFrom(aClass)) {
Date date = new ISODateFormat().parse(stringValue);
childValue = aClass.getConstructor(long.class).newInstance(date.getTime());
} else if (Enum.class.isAssignableFrom(aClass)) {
childValue = Enum.valueOf((Class<? extends Enum>) aClass, stringValue);
} else {
childValue = aClass.getConstructor(String.class).newInstance(stringValue);
}
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
}
}
this.attributes.put(name, childValue);
}
}
}
@Override
public ParsedNode serialize() {
throw new RuntimeException("TODO");
}
@Override
public String toString() {
return getName();
}
/**
* Returns a boolean value indicating whether the object types should include the catalog name in their specification.
* This method checks the current value of the {@code INCLUDE_CATALOG_IN_SPECIFICATION} setting in the
* {@link GlobalConfiguration}.
*
* @return {@code true} if the object types should include the catalog name in their specification, otherwise {@code false}.
*/
public boolean shouldIncludeCatalogInSpecification() {
return GlobalConfiguration.INCLUDE_CATALOG_IN_SPECIFICATION.getCurrentValue();
}
}
|
AbstractDatabaseObject that = (AbstractDatabaseObject) o;
if ((this.getSchema() != null) && (that.getSchema() != null)) {
if (shouldIncludeCatalogInSpecification()) {
String thisCatalogName = this.getSchema().getCatalogName();
String thatCatalogName = that.getSchema().getCatalogName();
if (thisCatalogName != null && thatCatalogName != null) {
int compare = thisCatalogName.compareToIgnoreCase(thatCatalogName);
if (compare != 0) {
return compare;
}
} else if (thisCatalogName != null) {
return 1;
} else if (thatCatalogName != null) {
return -1;
} // if they are both null, it will continue with rest
}
// now compare schema name
int compare = StringUtil.trimToEmpty(this.getSchema().getName()).compareToIgnoreCase(StringUtil.trimToEmpty(that.getSchema().getName()));
if (compare != 0) {
return compare;
}
}
String thisName = this.getName();
String thatName = that.getName();
if (thisName != null && thatName != null) {
return thisName.compareTo(thatName);
} else if (thisName != null) {
return 1;
} else if (thatName != null) {
return -1;
}
return 0;
| 1,639
| 375
| 2,014
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/DatabaseObjectCollection.java
|
DatabaseObjectCollection
|
getSerializableFieldValue
|
class DatabaseObjectCollection implements LiquibaseSerializable {
private final Map<Class<? extends DatabaseObject>, Map<String, Set<DatabaseObject>>> cache = Collections.synchronizedMap(new LinkedHashMap<>());
private final Database database;
public DatabaseObjectCollection(Database database) {
this.database = database;
}
@Override
public String getSerializedObjectName() {
return "objects";
}
@Override
public String getSerializedObjectNamespace() {
return STANDARD_SNAPSHOT_NAMESPACE;
}
@Override
public String getSerializableFieldNamespace(String field) {
return getSerializedObjectNamespace();
}
@Override
public Set<String> getSerializableFields() {
SortedSet<String> types = new TreeSet<>();
for (Class type : cache.keySet()) {
types.add(type.getName());
}
return types;
}
@Override
public Object getSerializableFieldValue(String field) {<FILL_FUNCTION_BODY>}
@Override
public SerializationType getSerializableFieldType(String field) {
return SerializationType.NAMED_FIELD;
}
public void add(DatabaseObject databaseObject) {
if (databaseObject == null) {
return;
}
Map<String, Set<DatabaseObject>> collectionMap = cache.computeIfAbsent(databaseObject.getClass(), k -> new ConcurrentHashMap<>());
String[] hashes = DatabaseObjectComparatorFactory.getInstance().hash(databaseObject, null, database);
for (String hash : hashes) {
Set<DatabaseObject> collection = collectionMap.computeIfAbsent(hash, k -> new HashSet<>());
collection.add(databaseObject);
}
}
/**
* Returns the object described by the passed example if it is already included in this snapshot.
*/
public <DatabaseObjectType extends DatabaseObject> DatabaseObjectType get(DatabaseObjectType example, CompareControl.SchemaComparison[] schemaComparisons) {
Map<String, Set<DatabaseObject>> databaseObjectsByHash = cache.get(example.getClass());
if (databaseObjectsByHash == null) {
return null;
}
String[] hashes = DatabaseObjectComparatorFactory.getInstance().hash(example, null, database);
SortedSet<Set<DatabaseObject>> objectSets = new TreeSet<>((o1, o2) -> {
int sizeComparison = Integer.compare(o1.size(), o2.size());
if (sizeComparison == 0) {
return o1.toString().compareTo(o2.toString());
}
return sizeComparison;
});
for (String hash : hashes) {
Set<DatabaseObject> databaseObjects = databaseObjectsByHash.get(hash);
if (databaseObjects != null) {
objectSets.add(databaseObjects);
}
}
for (Set<DatabaseObject> databaseObjects : objectSets) {
for (DatabaseObject obj : databaseObjects) {
if (DatabaseObjectComparatorFactory.getInstance().isSameObject(obj, example, schemaComparisons, database)) {
//noinspection unchecked
return (DatabaseObjectType) obj;
}
}
}
return null;
}
/**
* Returns all objects of the given type that are already included in this snapshot.
*/
public <DatabaseObjectType extends DatabaseObject> Set<DatabaseObjectType> get(Class<DatabaseObjectType> type) {
Set<DatabaseObject> returnSet = new HashSet<>();
Map<String, Set<DatabaseObject>> allFound = cache.get(type);
if (allFound != null) {
for (Set<DatabaseObject> objects : allFound.values()) {
returnSet.addAll(objects);
}
}
return (Set<DatabaseObjectType>) Collections.unmodifiableSet(returnSet);
}
public boolean contains(DatabaseObject wantedObject, CompareControl.SchemaComparison[] schemaComparisons) {
return get(wantedObject, schemaComparisons) != null;
}
@Override
public void load(ParsedNode parsedNode, ResourceAccessor resourceAccessor) throws ParsedNodeException {
throw new RuntimeException("TODO");
}
@Override
public ParsedNode serialize() {
throw new RuntimeException("TODO");
}
public Map<Class<? extends DatabaseObject>, Set<? extends DatabaseObject>> toMap() {
Map<Class<? extends DatabaseObject>, Set<? extends DatabaseObject>> returnMap =
Collections.synchronizedMap(new LinkedHashMap<>());
for (Class<? extends DatabaseObject> type : this.cache.keySet()) {
returnMap.put(type, get(type));
}
return returnMap;
}
}
|
SortedSet<DatabaseObject> objects = new TreeSet<>(new DatabaseObjectCollectionComparator());
try {
Map<String, Set<DatabaseObject>> map = cache.get(Class.forName(field));
if (map == null) {
return null;
}
for (Set<DatabaseObject> set : map.values()) {
objects.addAll(set);
}
return objects;
} catch (ClassNotFoundException e) {
throw new UnexpectedLiquibaseException(e);
}
| 1,225
| 134
| 1,359
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/core/Catalog.java
|
Catalog
|
addDatabaseObject
|
class Catalog extends AbstractDatabaseObject {
public Catalog() {
setAttribute("objects", new ConcurrentHashMap<Class<? extends DatabaseObject>, Set<DatabaseObject>>());
}
public Catalog(String name) {
this();
setAttribute("name", name);
}
@Override
public String toString() {
String name = getName();
if (name == null) {
return "DEFAULT";
}
return name;
}
@Override
public DatabaseObject[] getContainingObjects() {
return null;
}
@Override
public Schema getSchema() {
return null;
}
@Override
public String getName() {
return getAttribute("name", String.class);
}
@Override
public Catalog setName(String name) {
setAttribute("name", name);
return this;
}
public boolean isDefault() {
return getAttribute("default", false) || (getName() == null);
}
public Catalog setDefault(Boolean isDefault) {
setAttribute("default", isDefault);
return this;
}
protected Map<Class<? extends DatabaseObject>, Set<DatabaseObject>> getObjects() {
return getAttribute("objects", Map.class);
}
public <DatabaseObjectType extends DatabaseObject> List<DatabaseObjectType> getDatabaseObjects(Class<DatabaseObjectType> type) {
Set<DatabaseObjectType> databaseObjects = (Set<DatabaseObjectType>) getObjects().get(type);
if (databaseObjects == null) {
return new ArrayList<>();
}
return new ArrayList<>(databaseObjects);
}
public void addDatabaseObject(DatabaseObject databaseObject) {<FILL_FUNCTION_BODY>}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if ((o == null) || (getClass() != o.getClass())) return false;
Catalog catalog = (Catalog) o;
return (getName() != null) ? getName().equalsIgnoreCase(catalog.getName()) : (catalog.getName() == null);
}
@Override
public int hashCode() {
return (getName() != null) ? getName().hashCode() : 0;
}
@Override
public Set<String> getSerializableFields() {
Set<String> fields = super.getSerializableFields();
fields.remove("objects");
return fields;
}
}
|
if (databaseObject == null) {
return;
}
Set<DatabaseObject> objects = this.getObjects().computeIfAbsent(databaseObject.getClass(), k -> new HashSet<>());
objects.add(databaseObject);
| 636
| 63
| 699
|
<methods>public non-sealed void <init>() ,public int compareTo(java.lang.Object) ,public T getAttribute(java.lang.String, Class<T>) ,public T getAttribute(java.lang.String, T) ,public Set<java.lang.String> getAttributes() ,public java.lang.String getObjectTypeName() ,public java.lang.String getSerializableFieldNamespace(java.lang.String) ,public liquibase.serializer.LiquibaseSerializable.SerializationType getSerializableFieldType(java.lang.String) ,public java.lang.Object getSerializableFieldValue(java.lang.String) ,public Set<java.lang.String> getSerializableFields() ,public java.lang.String getSerializedObjectName() ,public java.lang.String getSerializedObjectNamespace() ,public java.lang.String getSnapshotId() ,public void load(liquibase.parser.core.ParsedNode, liquibase.resource.ResourceAccessor) throws liquibase.parser.core.ParsedNodeException,public liquibase.parser.core.ParsedNode serialize() ,public liquibase.structure.DatabaseObject setAttribute(java.lang.String, java.lang.Object) ,public void setSnapshotId(java.lang.String) ,public boolean shouldIncludeCatalogInSpecification() ,public boolean snapshotByDefault() ,public java.lang.String toString() <variables>public static final java.util.regex.Pattern CURLY_BRACKET_PATTERN,private static final java.lang.String CURLY_BRACKET_REGEX,private final Map<java.lang.String,java.lang.Object> attributes,private java.lang.String snapshotId
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/core/Column.java
|
AutoIncrementInformation
|
isRealObject
|
class AutoIncrementInformation extends AbstractLiquibaseSerializable {
private BigInteger startWith;
private BigInteger incrementBy;
private Boolean defaultOnNull;
private String generationType;
public AutoIncrementInformation() {
this(1, 1);
}
public AutoIncrementInformation(Number startWith, Number incrementBy) {
this.startWith = (startWith == null) ? null : BigInteger.valueOf(startWith.longValue());
this.incrementBy = (incrementBy == null) ? null : BigInteger.valueOf(incrementBy.longValue());
}
public BigInteger getStartWith() {
return startWith;
}
public BigInteger getIncrementBy() {
return incrementBy;
}
public void setDefaultOnNull(Boolean defaultOnNull) {
this.defaultOnNull = defaultOnNull;
}
public Boolean getDefaultOnNull() {
return defaultOnNull;
}
public void setGenerationType(String generationType) {
this.generationType = generationType;
}
public String getGenerationType() {
return generationType;
}
@Override
public String toString() {
return String.format("GENERATED %s %sAUTO INCREMENT START WITH %d INCREMENT BY %d",
this.generationType, Boolean.TRUE.equals(this.defaultOnNull) ? "ON NULL " : "", startWith, incrementBy);
}
@Override
public String getSerializedObjectName() {
return "autoIncrementInformation";
}
@Override
public String getSerializedObjectNamespace() {
return STANDARD_CHANGELOG_NAMESPACE;
}
@Override
public void load(ParsedNode parsedNode, ResourceAccessor resourceAccessor) throws ParsedNodeException {
this.startWith = (BigInteger) convertEscaped(parsedNode.getChildValue(null, "startWith"));
this.incrementBy = (BigInteger) convertEscaped(parsedNode.getChildValue(null, "incrementBy"));
this.defaultOnNull = parsedNode.getChildValue(null, "defaultOnNull", Boolean.class);
this.generationType = parsedNode.getChildValue(null, "generationType", String.class);
}
}
@Override
public Set<String> getSerializableFields() {
final Set<String> fields = super.getSerializableFields();
//if this is a computed or indexed column, don't have the serializer try to traverse down to the relation since it may not be a "real" object with an objectId
if ((BooleanUtil.isTrue(getDescending()) || BooleanUtil.isTrue(getComputed())) && ! isRealObject()) {
fields.remove("relation");
}
fields.remove("forIndex");
return fields;
}
private boolean isRealObject() {<FILL_FUNCTION_BODY>
|
//
// Backwards compatibility if this flag is set then consider this object to not be "real"
//
if (Boolean.FALSE.equals( GlobalConfiguration.INCLUDE_RELATIONS_FOR_COMPUTED_COLUMNS.getCurrentValue())) {
return false;
}
Object obj = getAttribute("relation", Object.class);
if (obj instanceof DatabaseObject) {
DatabaseObject databaseObject = (DatabaseObject) obj;
return databaseObject.getSnapshotId() != null;
}
return false;
| 744
| 135
| 879
|
<methods>public non-sealed void <init>() ,public int compareTo(java.lang.Object) ,public T getAttribute(java.lang.String, Class<T>) ,public T getAttribute(java.lang.String, T) ,public Set<java.lang.String> getAttributes() ,public java.lang.String getObjectTypeName() ,public java.lang.String getSerializableFieldNamespace(java.lang.String) ,public liquibase.serializer.LiquibaseSerializable.SerializationType getSerializableFieldType(java.lang.String) ,public java.lang.Object getSerializableFieldValue(java.lang.String) ,public Set<java.lang.String> getSerializableFields() ,public java.lang.String getSerializedObjectName() ,public java.lang.String getSerializedObjectNamespace() ,public java.lang.String getSnapshotId() ,public void load(liquibase.parser.core.ParsedNode, liquibase.resource.ResourceAccessor) throws liquibase.parser.core.ParsedNodeException,public liquibase.parser.core.ParsedNode serialize() ,public liquibase.structure.DatabaseObject setAttribute(java.lang.String, java.lang.Object) ,public void setSnapshotId(java.lang.String) ,public boolean shouldIncludeCatalogInSpecification() ,public boolean snapshotByDefault() ,public java.lang.String toString() <variables>public static final java.util.regex.Pattern CURLY_BRACKET_PATTERN,private static final java.lang.String CURLY_BRACKET_REGEX,private final Map<java.lang.String,java.lang.Object> attributes,private java.lang.String snapshotId
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/core/Data.java
|
Data
|
getSchema
|
class Data extends AbstractDatabaseObject {
@Override
public boolean snapshotByDefault() {
return GlobalConfiguration.SHOULD_SNAPSHOT_DATA.getCurrentValue();
}
public Table getTable() {
return getAttribute("table", Table.class);
}
public Data setTable(Table table) {
setAttribute("table", table);
return this;
}
@Override
public DatabaseObject[] getContainingObjects() {
return new DatabaseObject[] {
getTable()
};
}
@Override
public String getName() {
Table table = getTable();
if (table == null) {
return null;
}
return table.getName();
}
@Override
public Data setName(String name) {
Table table = getTable();
if (table == null) {
setTable(new Table().setName(name));
} else {
table.setName(name);
}
return this;
}
@Override
public Schema getSchema() {<FILL_FUNCTION_BODY>}
}
|
Table table = getTable();
if (table == null) {
return null;
}
return table.getSchema();
| 286
| 36
| 322
|
<methods>public non-sealed void <init>() ,public int compareTo(java.lang.Object) ,public T getAttribute(java.lang.String, Class<T>) ,public T getAttribute(java.lang.String, T) ,public Set<java.lang.String> getAttributes() ,public java.lang.String getObjectTypeName() ,public java.lang.String getSerializableFieldNamespace(java.lang.String) ,public liquibase.serializer.LiquibaseSerializable.SerializationType getSerializableFieldType(java.lang.String) ,public java.lang.Object getSerializableFieldValue(java.lang.String) ,public Set<java.lang.String> getSerializableFields() ,public java.lang.String getSerializedObjectName() ,public java.lang.String getSerializedObjectNamespace() ,public java.lang.String getSnapshotId() ,public void load(liquibase.parser.core.ParsedNode, liquibase.resource.ResourceAccessor) throws liquibase.parser.core.ParsedNodeException,public liquibase.parser.core.ParsedNode serialize() ,public liquibase.structure.DatabaseObject setAttribute(java.lang.String, java.lang.Object) ,public void setSnapshotId(java.lang.String) ,public boolean shouldIncludeCatalogInSpecification() ,public boolean snapshotByDefault() ,public java.lang.String toString() <variables>public static final java.util.regex.Pattern CURLY_BRACKET_PATTERN,private static final java.lang.String CURLY_BRACKET_REGEX,private final Map<java.lang.String,java.lang.Object> attributes,private java.lang.String snapshotId
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/core/DataType.java
|
DataType
|
toString
|
class DataType extends AbstractLiquibaseSerializable {
private String typeName;
private Integer dataTypeId;
private Integer columnSize;
private ColumnSizeUnit columnSizeUnit;
private Integer decimalDigits;
private Integer radix;
private Integer characterOctetLength;
public DataType() {
}
public DataType(String typeName) {
this.typeName = typeName;
}
public String getTypeName() {
return typeName;
}
public void setTypeName(String typeName) {
this.typeName = typeName;
}
public Integer getDataTypeId() {
return dataTypeId;
}
public void setDataTypeId(Integer dataTypeId) {
this.dataTypeId = dataTypeId;
}
public Integer getColumnSize() {
return columnSize;
}
public void setColumnSize(Integer columnSize) {
this.columnSize = columnSize;
}
public ColumnSizeUnit getColumnSizeUnit() {
return columnSizeUnit;
}
public void setColumnSizeUnit(ColumnSizeUnit columnSizeUnit) {
this.columnSizeUnit = columnSizeUnit;
}
public Integer getDecimalDigits() {
return decimalDigits;
}
public void setDecimalDigits(Integer decimalDigits) {
this.decimalDigits = decimalDigits;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
public Integer getRadix() {
return radix;
}
public void setRadix(Integer radix) {
this.radix = radix;
}
public Integer getCharacterOctetLength() {
return characterOctetLength;
}
public void setCharacterOctetLength(Integer characterOctetLength) {
this.characterOctetLength = characterOctetLength;
}
@Override
public String getSerializedObjectName() {
return "dataType";
}
@Override
public String getSerializedObjectNamespace() {
return STANDARD_SNAPSHOT_NAMESPACE;
}
/**
* Specifies the unit of a column's size. Currently, the possible units are BYTE and CHAR.
*/
public enum ColumnSizeUnit {
BYTE,
CHAR,
}
}
|
String subtypeData = null;
String value = typeName;
if (value == null) {
return value;
}
if(value.contains("FOR BIT DATA")){
value = typeName.replaceAll("\\(.*","");
subtypeData = " FOR BIT DATA";
}else if (value.contains("FOR SBCS DATA")){
value = typeName.replaceAll("\\(.*","");
subtypeData = " FOR SBCS DATA";
}else if (value.contains("FOR MIXED DATA")){
value = typeName.replaceAll("\\(.*","");
subtypeData = " FOR MIXED DATA";
}
boolean unsigned = false;
if (value.toLowerCase().endsWith(" unsigned")) {
value = value.substring(0, value.length()-" unsigned".length());
unsigned = true;
}
if (columnSize == null) {
if (decimalDigits != null) {
value += "(*, " + decimalDigits + ")";
}
} else if (subtypeData != null) {
value += "(";
value += columnSize;
if (columnSizeUnit != null && (typeName.equalsIgnoreCase("VARCHAR")
|| typeName.equalsIgnoreCase("VARCHAR2")
|| typeName.equalsIgnoreCase("CHAR"))) {
value += " " + columnSizeUnit;
}
value +=")";
value +=subtypeData;
}else{
value += "(";
value += columnSize;
if (decimalDigits != null) {
value+= ", "+decimalDigits ;
}
//Failing on data types such as nvarchar if included
if ((columnSizeUnit != null) && ("VARCHAR".equalsIgnoreCase(typeName) || "VARCHAR2".equalsIgnoreCase
(typeName) || "CHAR".equalsIgnoreCase(typeName))
) {
value += " " + columnSizeUnit;
}
value +=")";
}
if (unsigned) {
value += " UNSIGNED";
}
return value;
| 608
| 546
| 1,154
|
<methods>public non-sealed void <init>() ,public java.lang.String getSerializableFieldNamespace(java.lang.String) ,public liquibase.serializer.LiquibaseSerializable.SerializationType getSerializableFieldType(java.lang.String) ,public java.lang.Object getSerializableFieldValue(java.lang.String) ,public Set<java.lang.String> getSerializableFields() ,public void load(liquibase.parser.core.ParsedNode, liquibase.resource.ResourceAccessor) throws liquibase.parser.core.ParsedNodeException,public liquibase.parser.core.ParsedNode serialize() throws liquibase.parser.core.ParsedNodeException<variables>private Set<java.lang.String> serializableFields
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/core/DatabaseObjectFactory.java
|
DatabaseObjectFactory
|
parseTypes
|
class DatabaseObjectFactory {
private static DatabaseObjectFactory instance;
private Set<Class<? extends DatabaseObject>> standardTypes;
public static synchronized DatabaseObjectFactory getInstance() {
if (instance == null) {
instance = new DatabaseObjectFactory();
}
return instance;
}
private DatabaseObjectFactory() {
}
public Set<Class<? extends DatabaseObject>> parseTypes(String typesString) {<FILL_FUNCTION_BODY>}
public Set<Class<? extends DatabaseObject>> getStandardTypes() {
if (standardTypes == null) {
Set<Class<? extends DatabaseObject>> set = new HashSet<>();
for (DatabaseObject databaseObject : Scope.getCurrentScope().getServiceLocator().findInstances(DatabaseObject.class)) {
if (!databaseObject.getClass().equals(LiquibaseColumn.class) && databaseObject.snapshotByDefault()) {
set.add(databaseObject.getClass());
}
}
standardTypes = set;
}
return standardTypes;
}
public void reset() {
this.standardTypes = null;
}
}
|
if (StringUtil.trimToNull(typesString) == null) {
return getStandardTypes();
} else {
Set<Class<? extends DatabaseObject>> returnSet = new HashSet<>();
Set<String> typesToInclude = new HashSet<>(Arrays.asList(typesString.toLowerCase().split("\\s*,\\s*")));
Set<String> typesNotFound = new HashSet<>(typesToInclude);
for (DatabaseObject object : Scope.getCurrentScope().getServiceLocator().findInstances(DatabaseObject.class)) {
Class<? extends DatabaseObject> clazz = object.getClass();
if (typesToInclude.contains(clazz.getSimpleName().toLowerCase())
|| typesToInclude.contains(clazz.getSimpleName().toLowerCase()+"s")
|| typesToInclude.contains(clazz.getSimpleName().toLowerCase()+"es") //like indexes
) {
returnSet.add(clazz);
typesNotFound.remove(clazz.getSimpleName().toLowerCase());
typesNotFound.remove(clazz.getSimpleName().toLowerCase()+"s");
typesNotFound.remove(clazz.getSimpleName().toLowerCase()+"es");
}
}
if (!typesNotFound.isEmpty()) {
throw new UnexpectedLiquibaseException("Unknown snapshot type(s) "+ StringUtil.join(typesNotFound, ", "));
}
return returnSet;
}
| 287
| 370
| 657
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/core/PrimaryKey.java
|
PrimaryKey
|
getColumnNamesAsList
|
class PrimaryKey extends AbstractDatabaseObject {
public PrimaryKey() {
setAttribute("columns", new ArrayList<>());
}
public PrimaryKey(String name, String tableCatalogName, String tableSchemaName, String tableName, Column... columns) {
this();
setName(name);
if (tableName != null) {
Table table = new Table(tableCatalogName, tableSchemaName, tableName);
if (columns != null) {
setAttribute("columns", Arrays.asList(columns));
for (Column column : getColumns()) {
column.setRelation(table);
}
}
setTable(table);
}
}
@Override
public DatabaseObject[] getContainingObjects() {
return new DatabaseObject[] {
getTable()
};
}
@Override
public String getName() {
return getAttribute("name", String.class);
}
@Override
public PrimaryKey setName(String name) {
this.setAttribute("name", name);
return this;
}
@Override
public Schema getSchema() {
if (getTable() == null) {
return null;
}
return getTable().getSchema();
}
public String getColumnNames() {
return StringUtil.join(getColumns(), ", ", obj -> ((Column) obj).toString(false));
}
/**
* Adds a new column to the column list of this PrimaryKey. The first column has the position 0.
* If you specify a position that is greater than the number of columns present, undefined
* columns (NULL expressions) will be added as padding. If a position that is already
* occupied by a column is specified, that column will be replaced.
*
* @param position the position where to insert or replace the column
* @param column the new column
* @return a reference to the updated PrimaryKey object.
*/
public PrimaryKey addColumn(int position, Column column) {
if (position >= getColumns().size()) {
for (int i = getColumns().size()-1; i < position; i++) {
this.getColumns().add(null);
}
}
this.getColumns().set(position, column);
return this;
}
/**
* Returns the Table object this PrimaryKey belongs to.
*
* @return the Table object, or null if not initialized yet.
*/
public Table getTable() {
return getAttribute("table", Table.class);
}
/**
* Sets the Table object this PrimaryKey belongs to.
*
* @param table the table object to set as the container for this PrimaryKey
* @return the updated object
*/
public PrimaryKey setTable(Table table) {
this.setAttribute("table", table);
return this;
}
@Override
public int compareTo(Object other) {
PrimaryKey o = (PrimaryKey) other;
int returnValue = this.getTable().compareTo(o.getTable());
if (returnValue == 0) {
returnValue = this.getColumnNames().compareTo(o.getColumnNames());
}
return returnValue;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if ((o == null) || (getClass() != o.getClass())) return false;
PrimaryKey that = (PrimaryKey) o;
return !((getColumnNames() != null) ? !getColumnNames().equals(that.getColumnNames()) : (that.getColumnNames
() != null)) && !((getTable() != null) ? !getTable().equals(that.getTable()) : (that.getTable() != null));
}
@Override
public int hashCode() {
return toString().hashCode();
}
@Override
public String toString() {
if (getTable() == null) {
return getName();
} else {
String tableName = getTable().getName();
if (getTable().getSchema() != null) {
tableName = getTable().getSchema().getName()+"."+tableName;
}
return getName() + " on " + tableName + "(" + getColumnNames() + ")";
}
}
public List<Column> getColumns() {
return getAttribute("columns", List.class);
}
public List<String> getColumnNamesAsList() {<FILL_FUNCTION_BODY>}
public boolean isCertainName() {
return getAttribute("certainName", Boolean.class);
}
public PrimaryKey setCertainName(boolean certainName) {
setAttribute("certainName", certainName);
return this;
}
public String getTablespace() {
return getAttribute("tablespace",String.class);
}
public PrimaryKey setTablespace(String tablespace) {
setAttribute("tablespace", tablespace);
return this;
}
public Index getBackingIndex() {
return getAttribute("backingIndex", Index.class);
}
public PrimaryKey setBackingIndex(Index backingIndex) {
setAttribute("backingIndex", backingIndex);
return this;
}
/**
* @param shouldValidate - if shouldValidate is set to FALSE then the constraint will be created
* with the 'ENABLE NOVALIDATE' mode. This means the constraint would be created, but that no
* check will be done to ensure old data has valid primary keys - only new data would be checked
* to see if it complies with the constraint logic. The default state for primary keys is to
* have 'ENABLE VALIDATE' set.
*/
public PrimaryKey setShouldValidate(boolean shouldValidate) {
this.setAttribute("validate", shouldValidate);
return this;
}
}
|
List<String> names = new ArrayList<>();
for (Column col : getColumns()) {
names.add(col.getName());
}
return names;
| 1,471
| 44
| 1,515
|
<methods>public non-sealed void <init>() ,public int compareTo(java.lang.Object) ,public T getAttribute(java.lang.String, Class<T>) ,public T getAttribute(java.lang.String, T) ,public Set<java.lang.String> getAttributes() ,public java.lang.String getObjectTypeName() ,public java.lang.String getSerializableFieldNamespace(java.lang.String) ,public liquibase.serializer.LiquibaseSerializable.SerializationType getSerializableFieldType(java.lang.String) ,public java.lang.Object getSerializableFieldValue(java.lang.String) ,public Set<java.lang.String> getSerializableFields() ,public java.lang.String getSerializedObjectName() ,public java.lang.String getSerializedObjectNamespace() ,public java.lang.String getSnapshotId() ,public void load(liquibase.parser.core.ParsedNode, liquibase.resource.ResourceAccessor) throws liquibase.parser.core.ParsedNodeException,public liquibase.parser.core.ParsedNode serialize() ,public liquibase.structure.DatabaseObject setAttribute(java.lang.String, java.lang.Object) ,public void setSnapshotId(java.lang.String) ,public boolean shouldIncludeCatalogInSpecification() ,public boolean snapshotByDefault() ,public java.lang.String toString() <variables>public static final java.util.regex.Pattern CURLY_BRACKET_PATTERN,private static final java.lang.String CURLY_BRACKET_REGEX,private final Map<java.lang.String,java.lang.Object> attributes,private java.lang.String snapshotId
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/core/Relation.java
|
Relation
|
compareTo
|
class Relation extends AbstractDatabaseObject {
private String name;
protected Relation() {
setAttribute("columns", new ArrayList<>());
setAttribute("uniqueConstraints", new ArrayList<UniqueConstraint>());
setAttribute("indexes", new ArrayList<Index>());
}
@Override
public String getName() {
return name;
}
@Override
public Relation setName(String name) {
setAttribute("name", name);
this.name = name;
return this;
}
public List<Index> getIndexes() {
return getAttribute("indexes", List.class);
}
public List<UniqueConstraint> getUniqueConstraints() {
return getAttribute("uniqueConstraints", List.class);
}
@Override
public DatabaseObject[] getContainingObjects() {
return new DatabaseObject[]{
getSchema()
};
}
public String getRemarks() {
return getAttribute("remarks", String.class);
}
public Relation setRemarks(String remarks) {
setAttribute("remarks", remarks);
return this;
}
public List<Column> getColumns() {
return getAttribute("columns", List.class);
}
public Relation addColumn(Column column) {
this.getColumns().add(column);
return this;
}
/**
* Returns the column object for the given columnName. If the column does not exist in this table,
* return null.
*/
public Column getColumn(String columnName) {
for (Column column : getColumns()) {
if (column.getName().equalsIgnoreCase(columnName)) {
return column;
}
}
return null;
}
/**
* @return Returns the schema.
*/
@Override
public Schema getSchema() {
return getAttribute("schema", Schema.class);
}
/**
* @param schema The schema to set.
*/
public Relation setSchema(Schema schema) {
setAttribute("schema", schema);
return this;
}
public Relation setSchema(String catalog, String schema) {
return setSchema(new Schema(catalog, schema));
}
@Override
public int compareTo(Object o) {<FILL_FUNCTION_BODY>}
}
|
Relation that = (Relation) o;
int returnValue = 0;
if ((this.getSchema() != null) && (that.getSchema() != null)) {
returnValue = this.getSchema().compareTo(that.getSchema());
}
if (returnValue == 0) {
returnValue = this.getName().compareToIgnoreCase(((Relation) o).getName());
}
return returnValue;
| 601
| 112
| 713
|
<methods>public non-sealed void <init>() ,public int compareTo(java.lang.Object) ,public T getAttribute(java.lang.String, Class<T>) ,public T getAttribute(java.lang.String, T) ,public Set<java.lang.String> getAttributes() ,public java.lang.String getObjectTypeName() ,public java.lang.String getSerializableFieldNamespace(java.lang.String) ,public liquibase.serializer.LiquibaseSerializable.SerializationType getSerializableFieldType(java.lang.String) ,public java.lang.Object getSerializableFieldValue(java.lang.String) ,public Set<java.lang.String> getSerializableFields() ,public java.lang.String getSerializedObjectName() ,public java.lang.String getSerializedObjectNamespace() ,public java.lang.String getSnapshotId() ,public void load(liquibase.parser.core.ParsedNode, liquibase.resource.ResourceAccessor) throws liquibase.parser.core.ParsedNodeException,public liquibase.parser.core.ParsedNode serialize() ,public liquibase.structure.DatabaseObject setAttribute(java.lang.String, java.lang.Object) ,public void setSnapshotId(java.lang.String) ,public boolean shouldIncludeCatalogInSpecification() ,public boolean snapshotByDefault() ,public java.lang.String toString() <variables>public static final java.util.regex.Pattern CURLY_BRACKET_PATTERN,private static final java.lang.String CURLY_BRACKET_REGEX,private final Map<java.lang.String,java.lang.Object> attributes,private java.lang.String snapshotId
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/core/Schema.java
|
Schema
|
getDatabaseObjects
|
class Schema extends AbstractDatabaseObject {
public Schema() {
setAttribute("objects", new ConcurrentHashMap<Class<? extends DatabaseObject>, Set<DatabaseObject>>());
}
public Schema(String catalog, String schemaName) {
this(new Catalog(catalog), schemaName);
}
public Schema(Catalog catalog, String schemaName) {
schemaName = StringUtil.trimToNull(schemaName);
setAttribute("name", schemaName);
setAttribute("catalog", catalog);
setAttribute("objects", new ConcurrentHashMap<Class<? extends DatabaseObject>, Set<DatabaseObject>>());
}
@Override
public DatabaseObject[] getContainingObjects() {
return null;
}
@Override
public String getName() {
return getAttribute("name", String.class);
}
@Override
public Schema setName(String name) {
setAttribute("name", name);
return this;
}
public boolean isDefault() {
return getAttribute("default", false) || (getName() == null);
}
public Schema setDefault(Boolean isDefault) {
setAttribute("default", isDefault);
return this;
}
@Override
public Schema getSchema() {
return this;
}
public Catalog getCatalog() {
return getAttribute("catalog", Catalog.class);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Schema schema = (Schema) o;
if (shouldIncludeCatalogInSpecification()) {
if (getCatalog() != null ? !getCatalog().equals(schema.getCatalog()) : schema.getCatalog() != null)
return false;
}
return getName() != null ? getName().equalsIgnoreCase(schema.getName()) : schema.getName() == null;
}
@Override
public int hashCode() {
int result = (shouldIncludeCatalogInSpecification() && getCatalog() != null) ? getCatalog().hashCode() : 0;
result = 31 * result + (getName() != null ? getName().hashCode() : 0);
return result;
}
public String getCatalogName() {
if (getCatalog() == null) {
return null;
}
return getCatalog().getName();
}
@Override
public String toString() {
String catalogName = getCatalogName();
String schemaName = getName();
if (schemaName == null) {
schemaName = "DEFAULT";
}
if ((catalogName == null) || catalogName.equals(schemaName)) {
return schemaName;
} else {
return catalogName +"."+ schemaName;
}
}
public CatalogAndSchema toCatalogAndSchema() {
String catalogName;
if ((getCatalog() != null) && getCatalog().isDefault()) {
catalogName = null;
} else {
catalogName = getCatalogName();
}
String schemaName;
if (isDefault()) {
schemaName = null;
} else {
schemaName = getName();
}
return new CatalogAndSchema(catalogName, schemaName);
}
protected Map<Class<? extends DatabaseObject>, Set<DatabaseObject>> getObjects() {
return getAttribute("objects", Map.class);
}
public <T extends DatabaseObject> List<T> getDatabaseObjects(Class<T> type) {<FILL_FUNCTION_BODY>}
public void addDatabaseObject(DatabaseObject databaseObject) {
if (databaseObject == null) {
return;
}
Set<DatabaseObject> objects = this.getObjects().computeIfAbsent(databaseObject.getClass(), k -> new HashSet<>());
objects.add(databaseObject);
}
@Override
public Set<String> getSerializableFields() {
Set<String> fields = super.getSerializableFields();
fields.remove("objects");
return fields;
}
}
|
Set<T> databaseObjects =
(Set<T>) getObjects().get(type);
if (databaseObjects == null) {
return new ArrayList<>();
}
return new ArrayList<>(databaseObjects);
| 1,071
| 57
| 1,128
|
<methods>public non-sealed void <init>() ,public int compareTo(java.lang.Object) ,public T getAttribute(java.lang.String, Class<T>) ,public T getAttribute(java.lang.String, T) ,public Set<java.lang.String> getAttributes() ,public java.lang.String getObjectTypeName() ,public java.lang.String getSerializableFieldNamespace(java.lang.String) ,public liquibase.serializer.LiquibaseSerializable.SerializationType getSerializableFieldType(java.lang.String) ,public java.lang.Object getSerializableFieldValue(java.lang.String) ,public Set<java.lang.String> getSerializableFields() ,public java.lang.String getSerializedObjectName() ,public java.lang.String getSerializedObjectNamespace() ,public java.lang.String getSnapshotId() ,public void load(liquibase.parser.core.ParsedNode, liquibase.resource.ResourceAccessor) throws liquibase.parser.core.ParsedNodeException,public liquibase.parser.core.ParsedNode serialize() ,public liquibase.structure.DatabaseObject setAttribute(java.lang.String, java.lang.Object) ,public void setSnapshotId(java.lang.String) ,public boolean shouldIncludeCatalogInSpecification() ,public boolean snapshotByDefault() ,public java.lang.String toString() <variables>public static final java.util.regex.Pattern CURLY_BRACKET_PATTERN,private static final java.lang.String CURLY_BRACKET_REGEX,private final Map<java.lang.String,java.lang.Object> attributes,private java.lang.String snapshotId
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/core/Sequence.java
|
Sequence
|
equals
|
class Sequence extends AbstractDatabaseObject {
public Sequence() {
}
public Sequence(String catalogName, String schemaName, String sequenceName) {
this.setSchema(new Schema(catalogName, schemaName));
this.setName(sequenceName);
}
@Override
public DatabaseObject[] getContainingObjects() {
return null;
}
@Override
public String getName() {
return getAttribute("name", String.class);
}
@Override
public Sequence setName(String name) {
this.setAttribute("name", name);
return this;
}
public BigInteger getStartValue() {
return getAttribute("startValue", BigInteger.class);
}
public Sequence setStartValue(BigInteger startValue) {
this.setAttribute("startValue", startValue);
return this;
}
public BigInteger getIncrementBy() {
return getAttribute("incrementBy", BigInteger.class);
}
public Sequence setIncrementBy(BigInteger incrementBy) {
this.setAttribute("incrementBy", incrementBy);
return this;
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return ((getName() != null) ? getName().toUpperCase().hashCode() : 0);
}
@Override
public String toString() {
return getName();
}
/**
* @return Returns the schema.
*/
@Override
public Schema getSchema () {
return getAttribute("schema", Schema.class);
}
/**
* @param schema The schema to set.
*/
public Sequence setSchema (Schema schema) {
this.setAttribute("schema", schema);
return this;
}
public Sequence setSchema(String catalog, String schema) {
return setSchema(new Schema(catalog, schema));
}
public BigInteger getMinValue() {
return getAttribute("minValue", BigInteger.class);
}
public Sequence setMinValue(BigInteger minValue) {
this.setAttribute("minValue", minValue);
return this;
}
public BigInteger getMaxValue() {
return getAttribute("maxValue", BigInteger.class);
}
public Sequence setMaxValue(BigInteger maxValue) {
this.setAttribute("maxValue", maxValue);
return this;
}
public Boolean getWillCycle() {
return getAttribute("willCycle", Boolean.class);
}
public Sequence setWillCycle(Boolean willCycle) {
this.setAttribute("willCycle", willCycle);
return this;
}
public Boolean getOrdered() {
return getAttribute("ordered", Boolean.class);
}
public Sequence setOrdered(Boolean isOrdered) {
this.setAttribute("ordered", isOrdered);
return this;
}
public BigInteger getLastReturnedValue() {
return getAttribute("lastReturnedValue", BigInteger.class);
}
public Sequence setLastReturnedValue(BigInteger lastReturnedValue) {
this.setAttribute("lastReturnedValue", lastReturnedValue);
return this;
}
public BigInteger getCacheSize() {
return getAttribute("cacheSize", BigInteger.class);
}
public Sequence setCacheSize(BigInteger cacheSize) {
this.setAttribute("cacheSize", cacheSize);
return this;
}
public String getDataType() {
return getAttribute("dataType", String.class);
}
public Sequence setDataType(String dataType) {
this.setAttribute("dataType", dataType);
return this;
}
}
|
if (this == o) return true;
if ((o == null) || (getClass() != o.getClass())) return false;
Sequence sequence = (Sequence) o;
if ((this.getSchema() != null) && (sequence.getSchema() != null)) {
boolean schemasEqual = this.getSchema().equals(sequence.getSchema());
if (!schemasEqual) {
return false;
}
}
return !((getName() != null) ? !getName().equalsIgnoreCase(sequence.getName()) : (sequence.getName() != null));
| 979
| 148
| 1,127
|
<methods>public non-sealed void <init>() ,public int compareTo(java.lang.Object) ,public T getAttribute(java.lang.String, Class<T>) ,public T getAttribute(java.lang.String, T) ,public Set<java.lang.String> getAttributes() ,public java.lang.String getObjectTypeName() ,public java.lang.String getSerializableFieldNamespace(java.lang.String) ,public liquibase.serializer.LiquibaseSerializable.SerializationType getSerializableFieldType(java.lang.String) ,public java.lang.Object getSerializableFieldValue(java.lang.String) ,public Set<java.lang.String> getSerializableFields() ,public java.lang.String getSerializedObjectName() ,public java.lang.String getSerializedObjectNamespace() ,public java.lang.String getSnapshotId() ,public void load(liquibase.parser.core.ParsedNode, liquibase.resource.ResourceAccessor) throws liquibase.parser.core.ParsedNodeException,public liquibase.parser.core.ParsedNode serialize() ,public liquibase.structure.DatabaseObject setAttribute(java.lang.String, java.lang.Object) ,public void setSnapshotId(java.lang.String) ,public boolean shouldIncludeCatalogInSpecification() ,public boolean snapshotByDefault() ,public java.lang.String toString() <variables>public static final java.util.regex.Pattern CURLY_BRACKET_PATTERN,private static final java.lang.String CURLY_BRACKET_REGEX,private final Map<java.lang.String,java.lang.Object> attributes,private java.lang.String snapshotId
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/core/StoredDatabaseLogic.java
|
StoredDatabaseLogic
|
equals
|
class StoredDatabaseLogic<T extends StoredDatabaseLogic> extends AbstractDatabaseObject {
@Override
public DatabaseObject[] getContainingObjects() {
return new DatabaseObject[]{
getSchema()
};
}
@Override
public boolean snapshotByDefault() {
return LicenseServiceUtils.isProLicenseValid();
}
@Override
public String getName() {
return getAttribute("name", String.class);
}
@Override
public T setName(String name) {
setAttribute("name", name);
return (T) this;
}
@Override
public Schema getSchema() {
return getAttribute("schema", Schema.class);
}
public T setSchema(Schema schema) {
setAttribute("schema", schema);
return (T) this;
}
public Boolean isValid() {
return getAttribute("valid", Boolean.class);
}
public T setValid(Boolean valid) {
setAttribute("valid", valid);
return (T) this;
}
public String getBody() {
return getAttribute("body", String.class);
}
public T setBody(String body) {
setAttribute("body", body);
return (T) this;
}
public DatabaseObjectCollectionComparator getDbObjectComparator() {
return null;
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return StringUtil.trimToEmpty(this.getName()).toLowerCase().hashCode();
}
}
|
if (this == obj) return true;
if ((obj == null) || (getClass() != obj.getClass())) return false;
StoredDatabaseLogic that = (StoredDatabaseLogic) obj;
if ((this.getSchema() != null) && (that.getSchema() != null)) {
boolean schemasEqual = this.getSchema().equals(that.getSchema());
if (!schemasEqual) {
return false;
}
}
return getName().equalsIgnoreCase(that.getName());
| 414
| 135
| 549
|
<methods>public non-sealed void <init>() ,public int compareTo(java.lang.Object) ,public T getAttribute(java.lang.String, Class<T>) ,public T getAttribute(java.lang.String, T) ,public Set<java.lang.String> getAttributes() ,public java.lang.String getObjectTypeName() ,public java.lang.String getSerializableFieldNamespace(java.lang.String) ,public liquibase.serializer.LiquibaseSerializable.SerializationType getSerializableFieldType(java.lang.String) ,public java.lang.Object getSerializableFieldValue(java.lang.String) ,public Set<java.lang.String> getSerializableFields() ,public java.lang.String getSerializedObjectName() ,public java.lang.String getSerializedObjectNamespace() ,public java.lang.String getSnapshotId() ,public void load(liquibase.parser.core.ParsedNode, liquibase.resource.ResourceAccessor) throws liquibase.parser.core.ParsedNodeException,public liquibase.parser.core.ParsedNode serialize() ,public liquibase.structure.DatabaseObject setAttribute(java.lang.String, java.lang.Object) ,public void setSnapshotId(java.lang.String) ,public boolean shouldIncludeCatalogInSpecification() ,public boolean snapshotByDefault() ,public java.lang.String toString() <variables>public static final java.util.regex.Pattern CURLY_BRACKET_PATTERN,private static final java.lang.String CURLY_BRACKET_REGEX,private final Map<java.lang.String,java.lang.Object> attributes,private java.lang.String snapshotId
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/core/Table.java
|
Table
|
equals
|
class Table extends Relation {
public Table() {
setAttribute("outgoingForeignKeys", new ArrayList<ForeignKey>());
setAttribute("indexes", new ArrayList<Index>());
setAttribute("uniqueConstraints", new ArrayList<UniqueConstraint>());
setAttribute("notNullConstraints", new ArrayList<UniqueConstraint>());
}
public Table(String catalogName, String schemaName, String tableName) {
this.setSchema(new Schema(catalogName, schemaName));
setName(tableName);
}
public PrimaryKey getPrimaryKey() {
return getAttribute("primaryKey", PrimaryKey.class);
}
public void setPrimaryKey(PrimaryKey primaryKey) {
this.setAttribute("primaryKey", primaryKey);
}
/**
* Returns the list of all outgoing FOREIGN KEYS from this table
*/
public List<ForeignKey> getOutgoingForeignKeys() {
List<ForeignKey> fkList = getAttribute("outgoingForeignKeys", List.class);
return ((fkList == null) ? new ArrayList<>(0) : fkList);
}
@Override
public List<Index> getIndexes() {
return getAttribute("indexes", List.class);
}
@Override
public List<UniqueConstraint> getUniqueConstraints() {
return getAttribute("uniqueConstraints", List.class);
}
public List<NotNullConstraint> getNotNullConstraints() {
return getAttribute("notNullConstraints", List.class);
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return StringUtil.trimToEmpty(getName()).toUpperCase().hashCode();
}
@Override
public String toString() {
return getName();
}
@Override
public Table setName(String name) {
return (Table) super.setName(name);
}
public String getTablespace() {
return getAttribute("tablespace",String.class);
}
public Table setTablespace(String tablespace) {
setAttribute("tablespace", tablespace);
return this;
}
public Boolean getDefaultTablespace() {
return getAttribute("default_tablespace", Boolean.class);
}
public Table setDefaultTablespace(Boolean tablespace) {
setAttribute("default_tablespace", tablespace);
return this;
}
public boolean isDefaultTablespace() {
Boolean b = getAttribute("default_tablespace",Boolean.class);
return BooleanUtil.isTrue(b);
}
}
|
if (this == o) return true;
if ((o == null) || (getClass() != o.getClass())) return false;
Table that = (Table) o;
if ((this.getSchema() != null) && (that.getSchema() != null)) {
boolean schemasTheSame = this.getSchema().equals(that.getSchema());
if (!schemasTheSame) {
return false;
}
}
return getName().equalsIgnoreCase(that.getName());
| 678
| 130
| 808
|
<methods>public liquibase.structure.core.Relation addColumn(liquibase.structure.core.Column) ,public int compareTo(java.lang.Object) ,public liquibase.structure.core.Column getColumn(java.lang.String) ,public List<liquibase.structure.core.Column> getColumns() ,public liquibase.structure.DatabaseObject[] getContainingObjects() ,public List<liquibase.structure.core.Index> getIndexes() ,public java.lang.String getName() ,public java.lang.String getRemarks() ,public liquibase.structure.core.Schema getSchema() ,public List<liquibase.structure.core.UniqueConstraint> getUniqueConstraints() ,public liquibase.structure.core.Relation setName(java.lang.String) ,public liquibase.structure.core.Relation setRemarks(java.lang.String) ,public liquibase.structure.core.Relation setSchema(liquibase.structure.core.Schema) ,public liquibase.structure.core.Relation setSchema(java.lang.String, java.lang.String) <variables>private java.lang.String name
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/structure/core/View.java
|
View
|
equals
|
class View extends Relation {
private boolean containsFullDefinition;
public View() {
}
public View(String catalogName, String schemaName, String tableName) {
this.setSchema(new Schema(catalogName, schemaName));
setName(tableName);
}
@Override
public Relation setSchema(Schema schema) {
return super.setSchema(schema); //To change body of overridden methods use File | Settings | File Templates.
}
public String getDefinition() {
return getAttribute("definition", String.class);
}
public void setDefinition(String definition) {
this.setAttribute("definition", definition);
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return getName().toUpperCase().hashCode();
}
@Override
public String toString() {
return this.getName();
}
@Override
public View setName(String name) {
return (View) super.setName(name);
}
public boolean getContainsFullDefinition() {
return this.containsFullDefinition;
}
public View setContainsFullDefinition(boolean fullDefinition) {
this.containsFullDefinition = fullDefinition;
return this;
}
}
|
if (this == o) return true;
if ((o == null) || (getClass() != o.getClass())) return false;
View that = (View) o;
if ((this.getSchema() != null) && (that.getSchema() != null)) {
boolean schemasEqual = this.getSchema().equals(that.getSchema());
if (!schemasEqual) {
return false;
}
}
return getName().equalsIgnoreCase(that.getName());
| 345
| 128
| 473
|
<methods>public liquibase.structure.core.Relation addColumn(liquibase.structure.core.Column) ,public int compareTo(java.lang.Object) ,public liquibase.structure.core.Column getColumn(java.lang.String) ,public List<liquibase.structure.core.Column> getColumns() ,public liquibase.structure.DatabaseObject[] getContainingObjects() ,public List<liquibase.structure.core.Index> getIndexes() ,public java.lang.String getName() ,public java.lang.String getRemarks() ,public liquibase.structure.core.Schema getSchema() ,public List<liquibase.structure.core.UniqueConstraint> getUniqueConstraints() ,public liquibase.structure.core.Relation setName(java.lang.String) ,public liquibase.structure.core.Relation setRemarks(java.lang.String) ,public liquibase.structure.core.Relation setSchema(liquibase.structure.core.Schema) ,public liquibase.structure.core.Relation setSchema(java.lang.String, java.lang.String) <variables>private java.lang.String name
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/ui/DefaultInputHandler.java
|
DefaultInputHandler
|
parseInput
|
class DefaultInputHandler<ReturnType> implements InputHandler<ReturnType> {
@Override
public ReturnType parseInput(String input, Class<ReturnType> returnType) throws IllegalArgumentException {<FILL_FUNCTION_BODY>}
protected IllegalArgumentException addPrefixToExceptionMessage(IllegalArgumentException ex, String input) {
if (ex.getCause() != null && ex.getCause().getMessage() != null) {
return new IllegalArgumentException(
String.format("Invalid value: '%s': %s", input, ex.getCause().getMessage()), ex);
}
if (ex.getMessage() != null) {
return new IllegalArgumentException(
String.format("Invalid value: '%s': %s", input, ex.getMessage()), ex);
}
return ex;
}
}
|
try {
return ObjectUtil.convert(input, returnType);
} catch (IllegalArgumentException e) {
throw addPrefixToExceptionMessage(e, input);
}
| 198
| 47
| 245
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/ui/LoggerUIService.java
|
LoggerUIService
|
setAllowPrompt
|
class LoggerUIService extends AbstractExtensibleObject implements UIService {
private Level standardLogLevel = Level.INFO;
private Level errorLogLevel = Level.SEVERE;
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
@Override
public void sendMessage(String message) {
Scope.getCurrentScope().getLog(getClass()).log(standardLogLevel, message, null);
}
@Override
public void sendErrorMessage(String message) {
sendErrorMessage(message, null);
}
@Override
public void sendErrorMessage(String message, Throwable exception) {
Scope.getCurrentScope().getLog(getClass()).log(errorLogLevel, message, exception);
}
@Override
public void setAllowPrompt(boolean allowPrompt) throws IllegalArgumentException {<FILL_FUNCTION_BODY>}
@Override
public boolean getAllowPrompt() {
return false;
}
/**
*
* This implementation simply returns the default value, since it cannot prompt the user.
*/
@Override
public <T> T prompt(String prompt, T valueIfNoEntry, InputHandler<T> inputHandler, Class<T> type) {
return valueIfNoEntry;
}
public Level getStandardLogLevel() {
return standardLogLevel;
}
public void setStandardLogLevel(Level standardLogLevel) {
this.standardLogLevel = standardLogLevel;
}
public Level getErrorLogLevel() {
return errorLogLevel;
}
public void setErrorLogLevel(Level errorLogLevel) {
this.errorLogLevel = errorLogLevel;
}
}
|
if (allowPrompt) {
throw new IllegalArgumentException("allowPrompt=true not allowed in LoggerUIService");
}
| 436
| 36
| 472
|
<methods>public void <init>() ,public void <init>(Map<java.lang.String,?>) ,public java.lang.Object clone() ,public java.lang.String describe() ,public boolean equals(java.lang.Object) ,public T get(java.lang.String, Class<T>) ,public T get(java.lang.String, T) ,public SortedSet<java.lang.String> getAttributes() ,public liquibase.ObjectMetaData getObjectMetaData() ,public List#RAW getValuePath(java.lang.String, Class#RAW) ,public boolean has(java.lang.String) ,public int hashCode() ,public liquibase.ExtensibleObject set(java.lang.String, java.lang.Object) ,public java.lang.String toString() <variables>private static final Map<Class#RAW,Map<java.lang.String,java.lang.reflect.Field>> attributeFieldCache,private final liquibase.util.SmartMap attributes
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/BomAwareInputStream.java
|
BomAwareInputStream
|
init
|
class BomAwareInputStream extends PushbackInputStream {
private static final byte _0xBF = (byte) 0xBF;
private static final byte _0x00 = (byte) 0x00;
private static final byte _0xBB = (byte) 0xBB;
private static final byte _0xFF = (byte) 0xFF;
private static final byte _0xFE = (byte) 0xFE;
private static final byte _0xEF = (byte) 0xEF;
private Charset detectedCharset;
public BomAwareInputStream(InputStream in) throws IOException {
super(in, 4);
init();
}
/**
* Returns detected charset name. Null if no BOM header was found.
* @return charset name - one of UTF-8, UTF-16BE, UTF-32LE, UTF-16LE, UTF-32BE or null if no BOM detected
*/
public Charset getDetectedCharset() {
return detectedCharset;
}
protected void init() throws IOException {<FILL_FUNCTION_BODY>}
}
|
byte bom[] = new byte[4];
int n, unread;
n = this.read(bom, 0, bom.length);
if ((bom[0] == _0xEF) && (bom[1] == _0xBB) && (bom[2] == _0xBF)) {
detectedCharset = StandardCharsets.UTF_8;
unread = n - 3;
} else if ((bom[0] == _0xFE) && (bom[1] == _0xFF)) {
detectedCharset = StandardCharsets.UTF_16BE;
unread = n - 2;
} else if ((bom[0] == _0xFF) && (bom[1] == _0xFE)) {
if ((n == 4) && (bom[2] == _0x00) && (bom[3] == _0x00)) {
detectedCharset = Charset.forName("UTF-32LE");
unread = n - 4;
} else {
detectedCharset = StandardCharsets.UTF_16LE;
unread = n - 2;
}
} else if ((bom[0] == _0x00) && (bom[1] == _0x00) && (bom[2] == _0xFE) && (bom[3] == _0xFF)) {
detectedCharset = Charset.forName("UTF-32BE");
unread = n - 4;
} else {
unread = n;
}
if (unread > 0) {
this.unread(bom, n - unread, unread);
} else if (unread < -1) {
this.unread(bom, 0, 0);
}
| 290
| 457
| 747
|
<methods>public void <init>(java.io.InputStream) ,public void <init>(java.io.InputStream, int) ,public int available() throws java.io.IOException,public synchronized void close() throws java.io.IOException,public synchronized void mark(int) ,public boolean markSupported() ,public int read() throws java.io.IOException,public int read(byte[], int, int) throws java.io.IOException,public synchronized void reset() throws java.io.IOException,public long skip(long) throws java.io.IOException,public void unread(int) throws java.io.IOException,public void unread(byte[]) throws java.io.IOException,public void unread(byte[], int, int) throws java.io.IOException<variables>protected byte[] buf,protected int pos
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/BooleanUtil.java
|
BooleanUtil
|
isTrue
|
class BooleanUtil {
private final static Set<String> trueValues = new HashSet<>(Arrays.asList("true", "t", "yes", "y", "1"));
private final static Set<String> falseValues = new HashSet<>(Arrays.asList("false", "f", "no", "n", "0"));
/**
* @param booleanStr not trimmed string
* @return true, if represents values "true", "t", "yes", "y", or integer >= 1, false otherwise
*/
public static boolean parseBoolean(String booleanStr) {
if (booleanStr == null) {
return false;
}
String value = booleanStr.trim().toLowerCase();
// Check is made to parse int as later as possible
return trueValues.contains(value) || (!falseValues.contains(value) && isTrue(value));
}
private static boolean isTrue(String str) {<FILL_FUNCTION_BODY>}
/**
* Checks if a {@link Boolean} value is {@code true}, handling <b>null</b> as {@code false}.
* - isTrue(null) = false
* - isTrue(false) = false
* - isTrue(true) = true
*/
public static boolean isTrue(Boolean value) {
return Boolean.TRUE.equals(value);
}
}
|
try {
return Integer.parseInt(str) > 0;
} catch (NumberFormatException ex) {
return false;
}
| 341
| 39
| 380
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/CollectionUtil.java
|
CollectionUtil
|
permutations
|
class CollectionUtil {
public static <T> Set<Set<T>> powerSet(Collection<T> originalSet) {
Set<Set<T>> sets = new HashSet<>();
if (originalSet.isEmpty()) {
sets.add(new HashSet<>());
return sets;
}
List<T> list = new ArrayList<>(originalSet);
T head = list.get(0);
Collection<T> rest = list.subList(1, list.size());
for (Set<T> set : powerSet(rest)) {
Set<T> newSet = new HashSet<>();
newSet.add(head);
newSet.addAll(set);
sets.add(newSet);
sets.add(set);
}
return sets;
}
public static <T> List<Map<String, T>> permutations(Map<String, List<T>> parameterValues) {<FILL_FUNCTION_BODY>}
private static <T> void permute(Map<String, T> basePermutation, List<String> remainingKeys, Map<String, List<T>> parameterValues, List<Map<String, T>> returnList) {
String thisKey = remainingKeys.get(0);
remainingKeys = remainingKeys.subList(1, remainingKeys.size());
for (T value : parameterValues.get(thisKey)) {
Map<String, T> permutation = new HashMap<>(basePermutation);
permutation.put(thisKey, value);
if (remainingKeys.isEmpty()) {
returnList.add(permutation);
} else {
permute(permutation, remainingKeys, parameterValues, returnList);
}
}
}
/**
* Returns passed currentValue if it is not null and creates a new ArrayList if it is null.
* <br><br>
* Example: values = createIfNull(values)
*/
public static <T> List<T> createIfNull(List<T> currentValue) {
if (currentValue == null) {
return new ArrayList<>();
} else {
return currentValue;
}
}
/**
* Returns a new empty array if the passed array is null.
*/
public static <T> T[] createIfNull(T[] arguments) {
if (arguments == null) {
return (T[]) new Object[0];
} else {
return arguments;
}
}
/**
* Returns a new empty set if the passed set is null.
*/
public static <T> Set<T> createIfNull(Set<T> currentValue) {
if (currentValue == null) {
return new HashSet<>();
} else {
return currentValue;
}
}
/**
* Returns a new empty map if the passed map is null.
*/
public static <T, E> Map<T, E> createIfNull(Map<T, E> currentValue) {
if (currentValue == null) {
return new HashMap<>();
} else {
return currentValue;
}
}
/**
* Converts a set of nested maps (like from yaml/json) into a flat map with dot-separated properties
*/
public static Map<String, Object> flatten(Map<String, Object> map) {
if (map == null) {
return null;
}
return flatten(null, map);
}
private static Map<String, Object> flatten(String prefix, Map<String, Object> map) {
Map<String, Object> outMap = new HashMap<>();
for (Map.Entry<String, Object> entry : map.entrySet()) {
String propertyName = entry.getKey();
if (prefix != null) {
propertyName = prefix + "." + propertyName;
}
if (entry.getValue() instanceof Map) {
outMap.putAll(flatten(propertyName, (Map<String, Object>) entry.getValue()));
} else {
outMap.put(propertyName, entry.getValue());
}
}
return outMap;
}
/**
* Find the actual key in a map, by searching the keys in the map and checking them ignoring case.
* @param key the key to search for, in any case
* @param map the map in which to search
* @return the properly cased key, if found, or null if not found
*/
public static String findKeyInMapIgnoreCase(String key, Map<String, Object> map) {
for (Map.Entry<String, Object> mapEntry : map.entrySet()) {
String actualKey = mapEntry.getKey();
if (actualKey.equalsIgnoreCase(key)) {
return actualKey;
}
}
return null;
}
}
|
List<Map<String, T>> list = new ArrayList<>();
if ((parameterValues == null) || parameterValues.isEmpty()) {
return list;
}
permute(new HashMap<>(), new ArrayList<>(parameterValues.keySet()), parameterValues, list);
return list;
| 1,213
| 77
| 1,290
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/DependencyUtil.java
|
DependencyGraph
|
add
|
class DependencyGraph<T> {
private final LinkedHashMap<T, GraphNode<T>> nodes = new LinkedHashMap<>();
private final NodeValueListener<T> listener;
private final List<GraphNode<T>> evaluatedNodes = new ArrayList<>();
private Integer recursiveSizeCheck;
public DependencyGraph(NodeValueListener<T> listener) {
this.listener = listener;
}
public void add(T evalFirstValue, T evalAfterValue) {<FILL_FUNCTION_BODY>}
private GraphNode<T> createNode(T value) {
GraphNode<T> node = new GraphNode<>();
node.value = value;
return node;
}
public void computeDependencies() {
List<GraphNode<T>> orphanNodes = getOrphanNodes();
List<GraphNode<T>> nextNodesToDisplay = new ArrayList<>();
if (orphanNodes != null) {
for (GraphNode<T> node : orphanNodes) {
listener.evaluating(node.value);
evaluatedNodes.add(node);
nextNodesToDisplay.addAll(node.getGoingOutNodes());
}
computeDependencies(nextNodesToDisplay);
}
}
private void computeDependencies(List<GraphNode<T>> nodes) {
List<GraphNode<T>> nextNodesToDisplay = null;
for (GraphNode<T> node : nodes) {
if (!isAlreadyEvaluated(node)) {
List<GraphNode<T>> comingInNodes = node.getComingInNodes();
if (areAlreadyEvaluated(comingInNodes)) {
listener.evaluating(node.value);
evaluatedNodes.add(node);
List<GraphNode<T>> goingOutNodes = node.getGoingOutNodes();
if (goingOutNodes != null) {
if (nextNodesToDisplay == null)
nextNodesToDisplay = new ArrayList<>();
// add these too, so they get a chance to be displayed
// as well
nextNodesToDisplay.addAll(goingOutNodes);
}
} else {
if (nextNodesToDisplay == null)
nextNodesToDisplay = new ArrayList<>();
// the checked node should be carried
nextNodesToDisplay.add(node);
}
}
}
if ((nextNodesToDisplay != null) && !nextNodesToDisplay.isEmpty()) {
int recursiveSizeDepth = recursiveSizeDepth(nextNodesToDisplay);
if (recursiveSizeDepth < 0 || (recursiveSizeCheck != null && recursiveSizeDepth >= recursiveSizeCheck)) {
//Recursion is not making progress, heading to a stack overflow exception.
//Probably some cycles in there somewhere, so pull out a node and re-try
GraphNode<T> nodeToRemove = null;
int nodeToRemoveLinks = Integer.MAX_VALUE;
for (GraphNode<T> node : nextNodesToDisplay) {
List<GraphNode<T>> links = node.getComingInNodes();
if ((links != null) && (links.size() < nodeToRemoveLinks)) {
nodeToRemove = node;
nodeToRemoveLinks = links.size();
}
}
if (nodeToRemove != null) {
Scope.getCurrentScope().getLog(getClass()).fine("Potential StackOverflowException. Pro-actively removing " +
nodeToRemove.value + " with " + nodeToRemoveLinks + " incoming nodes");
nextNodesToDisplay.remove(nodeToRemove);
}
}
if (recursiveSizeDepth >= 0) {
recursiveSizeCheck = recursiveSizeDepth;
}
computeDependencies(nextNodesToDisplay);
}
// here the recursive call ends
}
private int recursiveSizeDepth(List<GraphNode<T>> nodes) {
if (nodes == null) {
return 0;
}
int sum = 0;
for (GraphNode<T> node : nodes) {
int depth = recursiveSizeDepth(node, 0);
if (depth < 0) {
// safety counter was triggered. terminate
return -1;
}
sum += depth;
}
return sum;
}
private int recursiveSizeDepth(GraphNode<T> node, int safetyCounter) {
if (safetyCounter > 1000) {
return -1;
}
if (isAlreadyEvaluated(node)) {
return 0;
} else if (node.getGoingOutNodes() == null || node.getGoingOutNodes().isEmpty()) { // leaf node
return 1;
}
int sum = 0;
safetyCounter++;
for (GraphNode<T> n : node.getGoingOutNodes()) {
int depth = recursiveSizeDepth(n, safetyCounter);
if (depth < 0) {
return -1;
}
sum += depth;
}
return node.getGoingOutNodes().size() + sum;
}
private boolean isAlreadyEvaluated(GraphNode<T> node) {
return evaluatedNodes.contains(node);
}
private boolean areAlreadyEvaluated(List<GraphNode<T>> nodes) {
return evaluatedNodes.containsAll(nodes);
}
private List<GraphNode<T>> getOrphanNodes() {
List<GraphNode<T>> orphanNodes = null;
Set<T> keys = nodes.keySet();
for (T key : keys) {
GraphNode<T> node = nodes.get(key);
if (node.getComingInNodes() == null) {
if (orphanNodes == null)
orphanNodes = new ArrayList<>();
orphanNodes.add(node);
}
}
return orphanNodes;
}
}
|
GraphNode<T> firstNode = null;
GraphNode<T> afterNode = null;
if (nodes.containsKey(evalFirstValue)) {
firstNode = nodes.get(evalFirstValue);
} else {
firstNode = createNode(evalFirstValue);
nodes.put(evalFirstValue, firstNode);
}
if (nodes.containsKey(evalAfterValue)) {
afterNode = nodes.get(evalAfterValue);
} else {
afterNode = createNode(evalAfterValue);
nodes.put(evalAfterValue, afterNode);
}
firstNode.addGoingOutNode(afterNode);
afterNode.addComingInNode(firstNode);
| 1,470
| 175
| 1,645
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/ExceptionUtil.java
|
ExceptionUtil
|
findExceptionInCauseChain
|
class ExceptionUtil {
/**
* Find an exception in the stack of exception causes whose cause matches the desired one. Note that the exception
* whose cause matches the desired cause is returned, NOT the cause itself.
* @param exceptionToSearchIn the exception to search through
* @param desiredCause the cause that should be found in the stack of causes in the exception to search in
* @return the desired exception, if found, or null otherwise
*/
public static Throwable findExceptionInCauseChain(Throwable exceptionToSearchIn, Class<?> desiredCause) {<FILL_FUNCTION_BODY>}
}
|
if (exceptionToSearchIn == null || exceptionToSearchIn.getCause() == null) {
return null;
} else if (desiredCause.isAssignableFrom(exceptionToSearchIn.getCause().getClass())) {
return exceptionToSearchIn;
} else {
return findExceptionInCauseChain(exceptionToSearchIn.getCause(), desiredCause);
}
| 149
| 101
| 250
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/ExpressionMatcher.java
|
ExpressionMatcher
|
matches
|
class ExpressionMatcher {
/** find "(nested_expression)" in "left and (nested_expression) or right" expression */
private static final Pattern NESTED_EXPRESSION_PATTERN = Pattern.compile("\\([^()]+\\)");
private ExpressionMatcher() {
}
/**
* Test provided {@code expression} against list of {@code items}.
* Case insensitive.
*
* @param expression - expression that will be parsed and evaluated against provided list of items
* @param items - list of items
* @return {@code true} if provided list of items satisfy expression criteria. {@code false} otherwise.
*/
public static boolean matches(String expression, Collection<String> items) {<FILL_FUNCTION_BODY>}
}
|
final String requiredNotRegex = "^@\\s*(!|not )";
expression = StringUtil.trimToEmpty(expression);
if (expression.equals(":TRUE")) {
return true;
}
if (expression.equals(":FALSE")) {
return false;
}
while (expression.contains("(")) {
Matcher matcher = NESTED_EXPRESSION_PATTERN.matcher(expression);
if (!matcher.find()) {
throw new UnexpectedLiquibaseException("Cannot parse expression " + expression);
}
String left = expression.substring(0, matcher.start());
String right = expression.substring(matcher.end());
String nestedExpression = expression.substring(matcher.start() + 1, matcher.end() - 1); // +1/-1 -- exclude captured parenthesis
expression = left + " :" + String.valueOf(matches(nestedExpression, items)).toUpperCase() + " " + right;
}
expression = expression.replaceAll("\\s*,\\s*", " or ");
String[] orSplit = expression.split("\\s+or\\s+");
if (orSplit.length > 1) {
for (String split : orSplit) {
if (matches(split, items)) {
return true;
}
}
return false;
}
String[] andSplit = expression.split("\\s+and\\s+");
if (andSplit.length > 1) {
for (String split : andSplit) {
if (!matches(split, items)) {
return false;
}
}
return true;
}
boolean notExpression = false;
if (expression.startsWith("!")) {
notExpression = true;
expression = expression.substring(1).trim();
} else if (expression.toLowerCase().startsWith("not ")) {
notExpression = true;
expression = expression.substring(4).trim();
} else if (expression.matches(requiredNotRegex + ".+")) {
notExpression = true;
expression = expression.replaceFirst(requiredNotRegex, "").trim();
}
boolean requiredExpression = false;
if (expression.startsWith("@")) {
requiredExpression = true;
expression = expression.substring(1).trim();
}
if (!requiredExpression && items.isEmpty()) {
return true;
}
if (expression.trim().equals(":TRUE")) {
return !notExpression;
}
if (expression.trim().equals(":FALSE")) {
return notExpression;
}
for (String item : items) {
if (item.equalsIgnoreCase(expression)) {
return !notExpression;
}
}
return notExpression;
| 198
| 711
| 909
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/FileUtil.java
|
FileUtil
|
getFileNotFoundMessage
|
class FileUtil {
private FileUtil() {
throw new IllegalStateException("This utility class must not be instantiated. Sorry.");
}
public static String getContents(File file) throws IOException {
if (!file.exists()) {
return null;
}
try (
InputStream fileInputStream = Files.newInputStream(file.toPath())
) {
return StreamUtil.readStreamAsString(fileInputStream);
} catch (FileNotFoundException e) {
return null;
}
}
public static void write(String contents, File file) throws IOException {
write(contents, file, false);
}
public static void write(String contents, File file, boolean append) throws IOException {
if (file.getParentFile() != null) {
file.getParentFile().mkdirs();
}
try (
FileOutputStream output = new FileOutputStream(file, append)
){
StreamUtil.copy(new ByteArrayInputStream(contents.getBytes(GlobalConfiguration.OUTPUT_FILE_ENCODING.getCurrentValue())), output);
}
}
public static String getFileNotFoundMessage(String physicalChangeLogLocation) {<FILL_FUNCTION_BODY>}
public static boolean isAbsolute(String path) {
if (path == null) {
return false;
}
return new File(path).isAbsolute();
}
}
|
//
// Check for any prefix which is not file:
// Take this to indicate a full path
//
if (physicalChangeLogLocation.matches("^\\w\\w+:.*") && ! physicalChangeLogLocation.startsWith("file:")) {
return "ERROR: The file '" + physicalChangeLogLocation + "' was not found." + System.lineSeparator() +
"The file property cannot be configured with a fully qualified path, but must be a relative path on the property," + System.lineSeparator() +
"and any local or remote base of the path set on the search path.";
}
String message = "The file " + physicalChangeLogLocation + " was not found in the configured search path:" + System.lineSeparator();
StringBuilder builder = new StringBuilder(message);
for (String location : Scope.getCurrentScope().getResourceAccessor().describeLocations()) {
builder.append(" - ").append(location).append(System.lineSeparator());
}
builder.append("More locations can be added with the 'searchPath' parameter.");
return builder.toString();
| 357
| 271
| 628
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/FilenameUtil.java
|
FilenameUtil
|
getDirectory
|
class FilenameUtil {
/**
* Normalizes a path, removing double and single dot path steps as well as standardizing on "/" for a slash.
* <p>
*/
public static String normalize(String filename) {
if (filename == null) {
return null;
}
int size = filename.length();
if (size == 0) {
return filename;
}
filename = filename.replaceFirst("^//", "/");
try {
String returnPath = Paths.get(filename).normalize().toString();
returnPath = returnPath.replace('\\', '/');
returnPath = returnPath.replaceAll("/\\./", "/");
returnPath = returnPath.replaceAll("//", "/");
return returnPath;
} catch (InvalidPathException e) {
return null;
}
}
/**
* Concatenates a filename to a base path using normal command line style rules. This method uses the operating
* system rules to determine the path separator.
* <p>
* The returned path will be {@link #normalize(String)}'ed
*/
public static String concat(String basePath, String fullFilenameToAdd) {
if (basePath == null) {
return normalize(fullFilenameToAdd);
}
return normalize(Paths.get(basePath, fullFilenameToAdd).toString());
}
/**
* If the path is a file, return everything up to the file. If the path is a directory, return the directory.
* <p>
* The returned path will be {@link #normalize(String)}'ed
*/
public static String getDirectory(String filename) {<FILL_FUNCTION_BODY>}
/**
* Remove problematic characters from filename and replace them with '_'
* @see <a href="https://stackoverflow.com/questions/1976007/what-characters-are-forbidden-in-windows-and-linux-directory-names">
* What characters are forbidden in Windows and Linux directory names?</a>
* <p>
* ' ' '/' ':' '"' '\' '|' '*' '?' '<' '>'
*
* @param fileName Filename to remove characters from
* @return String Sanitized file name
*/
public static String sanitizeFileName(String fileName) {
if (fileName == null) {
return null;
}
fileName = fileName.replaceAll(" ", "_")
.replaceAll("/", "_")
.replaceAll(":", "_")
.replaceAll("\"", "_")
.replaceAll("\\|", "_")
.replaceAll("\\*", "_")
.replaceAll("\\?", "_")
.replaceAll("<", "_")
.replaceAll(">", "_")
.replaceAll("@", "_");
boolean done = false;
while (!done) {
String replacedString = fileName.replace('\\', '_');
done = (fileName.equals(replacedString));
if (!done) {
fileName = replacedString;
break;
}
}
return fileName;
}
}
|
if (filename == null) {
return null;
}
if (filename.endsWith("/") || filename.endsWith("\\")) {
return normalize(filename);
}
final Path path = Paths.get(filename);
final Path fileName = path.getFileName();
if (fileName.toString().contains(".")) {
//probably a file
final Path parent = path.getParent();
if (parent == null) {
return "";
}
return normalize(parent.toString());
} else {
//probably a directory
return normalize(filename);
}
| 810
| 157
| 967
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/ISODateFormat.java
|
ISODateFormat
|
format
|
class ISODateFormat {
private final SimpleDateFormat dateTimeFormat = new SimpleDateFormat(DATE_TIME_FORMAT_STRING);
private final SimpleDateFormat dateTimeFormatWithSpace = new SimpleDateFormat(DATE_TIME_FORMAT_STRING_WITH_SPACE);
private final SimpleDateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");
private final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
private static final String DATE_TIME_FORMAT_STRING = "yyyy-MM-dd'T'HH:mm:ss";
private static final String DATE_TIME_FORMAT_STRING_WITH_SPACE = "yyyy-MM-dd HH:mm:ss";
public String format(java.sql.Date date) {
return dateFormat.format(date);
}
public String format(java.sql.Time date) {
return timeFormat.format(date);
}
public String format(java.sql.Timestamp date) {
StringBuilder sb = new StringBuilder(dateTimeFormat.format(date));
int nanos = date.getNanos();
if (nanos != 0) {
String nanosString = String.format("%09d", nanos);
int lastNotNullIndex = 8;
for (; lastNotNullIndex > 0; lastNotNullIndex--) {
if (nanosString.charAt(lastNotNullIndex) != '0') {
break;
}
}
sb.append('.');
sb.append(nanosString, 0, lastNotNullIndex + 1);
}
return sb.toString();
}
public String format(Date date) {<FILL_FUNCTION_BODY>}
public Date parse(String dateAsString) throws ParseException {
if (dateAsString == null) {
return null;
}
int length = dateAsString.length();
switch (length) {
case 8:
return new java.sql.Time(timeFormat.parse(dateAsString).getTime());
case 10:
return new java.sql.Date(dateFormat.parse(dateAsString).getTime());
case 19:
if (dateAsString.contains(" ")) {
return new java.sql.Timestamp(dateTimeFormatWithSpace.parse(dateAsString).getTime());
} else {
return new java.sql.Timestamp(dateTimeFormat.parse(dateAsString).getTime());
}
default:
if (dateAsString.contains(":") && !dateAsString.contains("-")) {
if (dateAsString.contains(".")) {
//cannot handle milliseconds/nanoseconds in java.sql.Time, so throw exception so it's handled as a function
throw new ParseException(String.format("Unknown date format to parse: %s.", dateAsString), 0);
} else {
return new java.sql.Time(timeFormat.parse(dateAsString).getTime());
}
}
if ((length < 19) || (dateAsString.charAt(19) != '.')) {
throw new ParseException(String.format("Unknown date format to parse: %s.", dateAsString), 0);
}
long time = 0;
if (dateAsString.contains(" ")) {
time = dateTimeFormatWithSpace.parse(dateAsString.substring(0, 19)).getTime();
} else {
time = dateTimeFormat.parse(dateAsString.substring(0,19)).getTime();
}
ZonedDateTime zonedDateTime;
int nanos;
try {
OffsetDateTime odt = OffsetDateTime.parse(dateAsString);
zonedDateTime = odt.toZonedDateTime();
nanos = zonedDateTime.getNano();
}
catch (DateTimeParseException dtpe) {
if (dateAsString.contains(" ")) {
dateAsString = dateAsString.replaceAll(" ", "T");
}
nanos = Integer.parseInt(dateAsString.substring(20));
for (; length < 29; length++) {
nanos *= 10;
}
}
/*
*/
java.sql.Timestamp timestamp = new java.sql.Timestamp(time);
timestamp.setNanos(nanos);
return timestamp;
}
}
}
|
if (date == null) {
return null;
}
if (date instanceof java.sql.Date) {
return format(((java.sql.Date) date));
} else if (date instanceof Time) {
return format(((java.sql.Time) date));
} else if (date instanceof java.sql.Timestamp) {
return format(((java.sql.Timestamp) date));
} else if (date instanceof java.util.Date) {
return format(new java.sql.Timestamp(date.getTime()));
} else {
throw new RuntimeException("Unknown type: "+date.getClass().getName());
}
| 1,091
| 160
| 1,251
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/JdbcUtil.java
|
JdbcUtil
|
closeStatement
|
class JdbcUtil {
/**
* Constant that indicates an unknown (or unspecified) SQL type.
*
* @see java.sql.Types
*/
public static final int TYPE_UNKNOWN = Integer.MIN_VALUE;
/**
* Close the given JDBC Statement and ignore any thrown exception.
* This is useful for typical finally blocks in manual JDBC code.
*
* @param stmt the JDBC Statement to close (may be <code>null</code>)
*/
public static void closeStatement(Statement stmt) {<FILL_FUNCTION_BODY>}
/**
* Close the given JDBC ResultSet and ignore any thrown exception.
* This is useful for typical finally blocks in manual JDBC code.
*
* @param rs the JDBC ResultSet to close (may be <code>null</code>)
*/
public static void closeResultSet(ResultSet rs) {
if (rs != null) {
try {
rs.close();
} catch (Throwable ex) {
// We don't trust the JDBC driver: It might throw RuntimeException or Error.
// logger.debug("Unexpected exception on closing JDBC ResultSet", ex);
}
}
}
public static void close(ResultSet rs, Statement stmt) {
closeResultSet(rs);
closeStatement(stmt);
}
/**
* Retrieve a JDBC column value from a ResultSet, using the most appropriate
* value type. The returned value should be a detached value object, not having
* any ties to the active ResultSet: in particular, it should not be a Blob or
* Clob object but rather a byte array respectively String representation.
* <p>Uses the <code>getObject(index)</code> method, but includes additional "hacks"
* to get around Oracle 10g returning a non-standard object for its TIMESTAMP
* datatype and a <code>java.sql.Date</code> for DATE columns leaving out the
* time portion: These columns will explicitly be extracted as standard
* <code>java.sql.Timestamp</code> object.
*
* @param rs is the ResultSet holding the data
* @param index is the column index
* @return the value object
* @throws SQLException if thrown by the JDBC API
* @see java.sql.Blob
* @see java.sql.Clob
* @see java.sql.Timestamp
*/
public static Object getResultSetValue(ResultSet rs, int index) throws SQLException {
Object obj = null;
try {
obj = rs.getObject(index);
} catch (SQLException e) {
if ("The conversion from char to SMALLINT is unsupported.".equals(e.getMessage())) {
//issue with sqlserver jdbc 3.0 http://social.msdn.microsoft.com/Forums/sqlserver/en-US/2c908b45-6f75-484a-a891-5e8206f8844f/conversion-error-in-the-jdbc-30-driver-when-accessing-metadata
obj = rs.getString(index);
} else {
throw e;
}
}
if (obj instanceof Blob) {
obj = rs.getBytes(index);
} else if (obj instanceof Clob) {
obj = rs.getString(index);
} else if ((obj != null) && obj.getClass().getName().startsWith("oracle.sql.TIMESTAMP")) {
obj = rs.getTimestamp(index);
} else if ((obj != null) && obj.getClass().getName().startsWith("oracle.sql.DATE")) {
String metaDataClassName = rs.getMetaData().getColumnClassName(index);
if ("java.sql.Timestamp".equals(metaDataClassName) ||
"oracle.sql.TIMESTAMP".equals(metaDataClassName)) {
obj = rs.getTimestamp(index);
} else {
obj = rs.getDate(index);
}
} else if ((obj instanceof Date)) {
if ("java.sql.Timestamp".equals(rs.getMetaData().getColumnClassName(index))) {
obj = rs.getTimestamp(index);
}
} else if (obj instanceof SQLXML) {
obj = rs.getSQLXML(index).getString();
}
return obj;
}
/**
* Check whether the given SQL type is numeric.
*
* @param sqlType the SQL type to be checked
* @return whether the type is numeric
*/
public static boolean isNumeric(int sqlType) {
return (Types.BIT == sqlType) || (Types.BIGINT == sqlType) || (Types.DECIMAL == sqlType) || (Types.DOUBLE ==
sqlType) || (Types.FLOAT == sqlType) || (Types.INTEGER == sqlType) || (Types.NUMERIC == sqlType) ||
(Types.REAL == sqlType) || (Types.SMALLINT == sqlType) || (Types.TINYINT == sqlType);
}
/**
* Return a single result object from the given Collection.
* <p>Throws an exception if 0 or more than 1 element found.
* @param results the result Collection (can be <code>null</code>)
* @return the single result object
*/
public static Object requiredSingleResult(Collection results) throws DatabaseException {
int size = ((results != null) ? results.size() : 0);
if (size == 0) {
throw new DatabaseException("Empty result set, expected one row");
}
if (results.size() > 1) {
throw new DatabaseException("Result set larger than one row");
}
return results.iterator().next();
}
/**
* Checks whether a result set has a column matching the specified column name.
* The column name is first changed to match the database format.
* E.g. an unquoted columnName in h2 will be converted to uppercase so the column name that is
* being checked for is really the uppercase version of the column name,
*
* @param rs result set to check
* @param columnNameToCheck column name to check
* @return The value if found, null if not found
*/
public static String getValueForColumn(ResultSet rs, String columnNameToCheck, Database database) throws SQLException {
ResultSetMetaData metadata = rs.getMetaData();
int numberOfColumns = metadata.getColumnCount();
String correctedColumnName = database.correctObjectName(columnNameToCheck, Column.class);
// get the column names; column indexes start from 1
for (int i = 1; i < (numberOfColumns + 1); i++) {
String columnName = metadata.getColumnLabel(i);
// Get the name of the column's table name
if (correctedColumnName.equalsIgnoreCase(columnName)) {
return rs.getString(columnName);
}
}
return null;
}
}
|
if (stmt != null) {
try {
stmt.close();
} catch (Throwable ex) {
// We don't trust the JDBC driver: It might throw RuntimeException or Error.
// logger.debug("Unexpected exception on closing JDBC Statement", ex);
}
}
| 1,807
| 83
| 1,890
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/LiquibaseUtil.java
|
LiquibaseUtil
|
getBuildInfo
|
class LiquibaseUtil {
private static Properties liquibaseBuildProperties;
/**
* Return the configured build.version. Will always be "DEV" for non-release builds.
*/
public static String getBuildVersion() {
return getBuildInfo("build.version");
}
/**
* Return the build version for release builds and a more descriptive string for snapshot builds.
*/
public static String getBuildVersionInfo() {
String version = getBuildInfo("build.version");
if (version.equals("DEV")) {
final String buildCommit = getBuildInfo("build.commit");
if (buildCommit.equals("unknown")) {
version = "[local build]";
} else {
version = "[Core: " + getBuildInfo("build.repository.owner") + "/" + getBuildInfo("build.repository.name") + "/" + getBuildInfo("build.branch") + "/" + getBuildInfo("build.number") + "/" + buildCommit.substring(0, 6) + "/" + getBuildInfo("build.timestamp");
if (!getBuildInfo("build.pro.number").equals("UNKNOWN")) {
version += ", Pro: " + getBuildInfo("build.pro.branch") + "/" + getBuildInfo("build.pro.number") + "/" + getBuildInfo("build.pro.commit").substring(0, 6) + "/" + getBuildInfo("build.pro.timestamp");
}
version += "]";
}
}
return version;
}
public static String getBuildTime() {
return getBuildInfo("build.timestamp");
}
public static String getBuildNumber() {
return getBuildInfo("build.number");
}
// will extract the information from liquibase.build.properties, which should be a properties file in
// the jar file.
private static String getBuildInfo(String propertyId) {<FILL_FUNCTION_BODY>}
}
|
if (liquibaseBuildProperties == null) {
Boolean osgiPlatform = Scope.getCurrentScope().get(Scope.Attr.osgiPlatform, Boolean.class);
if (Boolean.TRUE.equals(osgiPlatform)) {
Bundle bundle = FrameworkUtil.getBundle(LiquibaseUtil.class);
URL propURL = bundle.getEntry("liquibase.build.properties");
if (propURL == null) {
Scope.getCurrentScope().getLog(LiquibaseUtil.class).severe("Cannot read liquibase.build.properties");
} else {
try (InputStream buildProperties = propURL.openStream()) {
liquibaseBuildProperties = new Properties();
if (buildProperties != null) {
liquibaseBuildProperties.load(buildProperties);
}
} catch (IOException e) {
Scope.getCurrentScope().getLog(LiquibaseUtil.class).severe("Cannot read liquibase.build.properties", e);
}
}
} else {
try {
liquibaseBuildProperties = new Properties();
final Enumeration<URL> propertiesUrls = Scope.getCurrentScope().getClassLoader().getResources("liquibase.build.properties");
while (propertiesUrls.hasMoreElements()) {
final URL url = propertiesUrls.nextElement();
try (InputStream buildProperties = url.openStream()) {
if (buildProperties != null) {
liquibaseBuildProperties.load(buildProperties);
}
}
}
} catch (IOException e) {
Scope.getCurrentScope().getLog(LiquibaseUtil.class).severe("Cannot read liquibase.build.properties", e);
}
}
}
String value = null;
if(liquibaseBuildProperties != null) {
value = liquibaseBuildProperties.getProperty(propertyId);
}
if (value == null) {
value = "UNKNOWN";
}
return value;
| 493
| 504
| 997
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/LoggingExecutorTextUtil.java
|
LoggingExecutorTextUtil
|
outputHeader
|
class LoggingExecutorTextUtil {
private LoggingExecutorTextUtil() {}
public static void outputHeader(String message, Database database, String changeLogFile) throws DatabaseException {<FILL_FUNCTION_BODY>}
}
|
Executor executor = Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("logging", database);
executor.comment("*********************************************************************");
executor.comment(message);
executor.comment("*********************************************************************");
executor.comment("Change Log: " + changeLogFile);
executor.comment("Ran at: " +
DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT).format(new Date())
);
DatabaseConnection connection = database.getConnection();
if (connection != null) {
executor.comment("Against: " + connection.getConnectionUserName() + "@" + connection.getURL());
}
executor.comment("Liquibase version: " + LiquibaseUtil.getBuildVersionInfo());
executor.comment("*********************************************************************" +
StreamUtil.getLineSeparator()
);
if ((database instanceof MSSQLDatabase) && (database.getDefaultCatalogName() != null)) {
executor.execute(new RawSqlStatement("USE " +
database.escapeObjectName(database.getDefaultCatalogName(), Catalog.class) + ";")
);
}
| 57
| 297
| 354
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/MD5Util.java
|
MD5Util
|
encodeHex
|
class MD5Util {
/**
* Used to build output as Hex
*/
private static final char[] DIGITS_LOWER = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
};
public static String computeMD5(String input) {
if (input == null) {
return null;
}
MessageDigest digest;
try {
digest = MessageDigest.getInstance("MD5");
digest.update(input.getBytes(GlobalConfiguration.OUTPUT_FILE_ENCODING.getCurrentValue()));
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
byte[] digestBytes = digest.digest();
String returnString = new String(encodeHex(digestBytes));
String inputToLog = input;
if (inputToLog.length() > 500) {
inputToLog = inputToLog.substring(0, 500)+"... [truncated in log]";
}
Scope.getCurrentScope().getLog(MD5Util.class).fine("Computed checksum for "+inputToLog+" as "+returnString);
return returnString;
}
public static String computeMD5(InputStream stream) {
if (stream == null) {
return null;
}
MessageDigest digest;
try {
digest = MessageDigest.getInstance("MD5");
DigestInputStream digestStream = new DigestInputStream(stream, digest);
byte[] buf = new byte[20480];
while (digestStream.read(buf) != -1) {
//digest is updating
}
} catch (Exception e) {
throw new RuntimeException(e);
}
byte[] digestBytes = digest.digest();
String returnString = new String(encodeHex(digestBytes));
Scope.getCurrentScope().getLog(MD5Util.class).fine("Computed checksum for inputStream as "+returnString);
return returnString;
}
/**
* Converts an array of bytes into an array of characters representing the hexadecimal values of each byte in order.
* The returned array will be double the length of the passed array, as it takes two characters to represent any
* given byte.
*
* @param data
* a byte[] to convert to Hex characters
* @return A char[] containing hexadecimal characters
*/
private static char[] encodeHex(byte[] data) {<FILL_FUNCTION_BODY>}
}
|
int l = data.length;
char[] out = new char[l << 1];
// two characters form the hex value.
for (int i = 0, j = 0; i < l; i++) {
out[j++] = DIGITS_LOWER[(0xF0 & data[i]) >>> 4];
out[j++] = DIGITS_LOWER[0x0F & data[i]];
}
return out;
| 686
| 124
| 810
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/NetUtil.java
|
NetUtil
|
getLocalHostName
|
class NetUtil {
private static InetAddress localHost;
private static String hostName;
private static final String UNKNOWN_HOST_NAME = "unknown";
private NetUtil() {}
/**
* Smarter way to get localhost than InetAddress.getLocalHost.
* @see <a href="https://bugs.java.com/bugdatabase/view_bug.do?bug_id=4665037">view bug</a>
*/
private static InetAddress getLocalHost() throws UnknownHostException, SocketException {
if (localHost == null) {
InetAddress foundHost = InetAddress.getLocalHost();
if (foundHost == null || foundHost.isLoopbackAddress() || foundHost.isLinkLocalAddress()) {
//try to find something other than localhost
Enumeration<NetworkInterface> e = NetworkInterface.getNetworkInterfaces();
while (e.hasMoreElements()) {
NetworkInterface i = e.nextElement();
if (i.isUp() && !i.isPointToPoint()) {
Enumeration<InetAddress> ie = i.getInetAddresses();
while (ie.hasMoreElements()) {
InetAddress lch = ie.nextElement();
if (!lch.isLoopbackAddress() && !lch.isLinkLocalAddress()) {
localHost = lch;
return localHost;
}
}
}
}
}
localHost = foundHost;
}
return localHost;
}
/**
* @return Machine's IP address
*/
public static String getLocalHostAddress() {
try {
InetAddress localHost = getLocalHost();
if(localHost != null) {
return localHost.getHostAddress();
}
else {
return UNKNOWN_HOST_NAME;
}
} catch (Exception e) {
Scope.getCurrentScope().getLog(NetUtil.class).fine("Error getting hostname", e);
return UNKNOWN_HOST_NAME;
}
}
/**
* @return Machine's host name. This method can be better to call than getting it off {@link #getLocalHost()} because sometimes the external address returned by that function does not have a useful hostname attached to it.
* This function will make sure a good value is returned.
*/
public static String getLocalHostName() {<FILL_FUNCTION_BODY>}
}
|
if (hostName == null ) {
try {
InetAddress localHost = getLocalHost();
if(localHost != null) {
hostName = localHost.getHostName();
if (hostName.equals(localHost.getHostAddress())) {
//sometimes the external IP interface doesn't have a hostname associated with it but localhost always does
InetAddress lHost = InetAddress.getLocalHost();
if (lHost != null) {
hostName = lHost.getHostName();
}
}
}
else {
hostName = UNKNOWN_HOST_NAME;
}
} catch (Exception e) {
Scope.getCurrentScope().getLog(NetUtil.class).fine("Error getting hostname", e);
if (hostName == null) {
hostName = UNKNOWN_HOST_NAME;
}
}
}
return hostName;
| 630
| 237
| 867
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/NumberUtil.java
|
NumberUtil
|
parseNumber
|
class NumberUtil {
/**
* Convert the given number into an instance of the given target class.
*
* @deprecated use {@link ObjectUtil#convert(Object, Class)}
*/
public static Number convertNumberToTargetClass(Number number, Class targetClass) throws IllegalArgumentException {
return (Number) ObjectUtil.convert(number, targetClass);
}
/**
* Parse the given text into a number instance of the given target class,
* using the corresponding default <code>decode</code> methods. Trims the
* input <code>String</code> before attempting to parse the number. Supports
* numbers in hex format (with leading 0x) and in octal format (with leading 0).
*
* @param text the text to convert
* @param targetClass the target class to parse into
* @return the parsed number
* @throws IllegalArgumentException if the target class is not supported
* (i.e. not a standard Number subclass as included in the JDK)
* @see java.lang.Byte#decode
* @see java.lang.Short#decode
* @see java.lang.Integer#decode
* @see java.lang.Long#decode
* @see java.lang.Float#valueOf
* @see java.lang.Double#valueOf
* @see java.math.BigDecimal#BigDecimal(String)
*/
public static Number parseNumber(String text, Class targetClass) {<FILL_FUNCTION_BODY>}
}
|
String trimmed = text.trim();
if (targetClass.equals(Byte.class)) {
return Byte.decode(trimmed);
} else if (targetClass.equals(Short.class)) {
return Short.decode(trimmed);
} else if (targetClass.equals(Integer.class)) {
return Integer.decode(trimmed);
} else if (targetClass.equals(Long.class)) {
return Long.decode(trimmed);
} else if (targetClass.equals(BigInteger.class)) {
return new BigInteger(trimmed);
} else if (targetClass.equals(Float.class)) {
return Float.valueOf(trimmed);
} else if (targetClass.equals(Double.class)) {
return Double.valueOf(trimmed);
} else if (targetClass.equals(BigDecimal.class) || targetClass.equals(Number.class)) {
return new BigDecimal(trimmed);
} else {
throw new IllegalArgumentException(
"Cannot convert String [" + text + "] to target class [" + targetClass.getName() + "]");
}
| 374
| 278
| 652
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/OsgiUtil.java
|
OsgiUtil
|
isClassAllowed
|
class OsgiUtil {
private OsgiUtil() {
}
/**
* Tries to load a class under OSGI environment. It will attempt to load the class
* from all Liquibase bundles registered via
* {@link Activator Activator}.
*
* @param <T> the type of the class to load
* @param className the name of the class to load
* @return the loaded class
* @throws ClassNotFoundException if the class could not be found
*/
public static <T> Class<T> loadClass(String className) throws ClassNotFoundException {
List<LiquibaseBundle> liquibaseBundles = Activator.getLiquibaseBundles();
for (LiquibaseBundle lb : liquibaseBundles) {
try {
Class<T> clazz = (Class<T>) lb.getBundle().loadClass(className);
if (!isClassAllowed(lb, clazz)) {
throw new ClassNotFoundException("Class is not allowed to load, class:" + className + " bundles:"
+ liquibaseBundles.stream().map(i -> i.getBundle().getSymbolicName())
.collect(Collectors.joining(",")));
}
return clazz;
} catch (ClassNotFoundException ex) {
// nothing to do
}
}
throw new ClassNotFoundException("Cannot find class:" + className + " bundles:"
+ liquibaseBundles.stream().map(i -> i.getBundle().getSymbolicName())
.collect(Collectors.joining(",")));
}
/**
* Checks whether a given class is allowed according to the configuration of the provided {@link LiquibaseBundle}.
*
* @param liquibaseBundle the {@link LiquibaseBundle} instance containing the configuration for the allowed packages
* @param clazz the class to check
* @return {@code true} if the class is allowed, {@code false} otherwise
* @throws ClassNotFoundException if the class is not found
*/
private static boolean isClassAllowed(LiquibaseBundle liquibaseBundle, Class clazz) {<FILL_FUNCTION_BODY>}
}
|
if (liquibaseBundle.allowedAllPackages()) {
return true;
}
for (String allowedPackage : liquibaseBundle.getAllowedPackages()) {
Package pkg = clazz.getPackage();
if (pkg != null) {
String pkgName = pkg.getName();
if (allowedPackage.equals(pkgName) || allowedPackage.startsWith(pkgName + ".")) {
return true;
}
}
}
return false;
| 549
| 127
| 676
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/SmartMap.java
|
SmartMap
|
get
|
class SmartMap implements Map<String, Object> {
private final SortedMap<String, Object> values = new TreeMap<>();
@Override
public int size() {
return values.size();
}
@Override
public boolean isEmpty() {
return values.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return values.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return values.containsValue(value);
}
@Override
public Object get(Object key) {
return values.get(key);
}
/**
* Return the value for the given key converted to the passed type. If the value associated with the key is null, null is returned.
* If the stored value is different than the passed type, a conversion is attempted using {@link ObjectUtil#convert(Object, Class)}.
* Any conversion is done only on the return value. The stored value is unchanged.
*/
public <T> T get(String key, Class<T> type) {
return ObjectUtil.convert(values.get(key), type);
}
/**
* Return the value for the given key converted to the type of the default value.
* If the value is null, defaultValue is returned.
* Conversion is done using {@link #get(String, Class)}
*/
public <T> T get(String key, T defaultValue) {<FILL_FUNCTION_BODY>}
/**
* Like normal {@link Map#put(Object, Object)} operation, but if null is passed as "value" it removes the key/value from the map.
*/
@Override
public Object put(String key, Object value) {
if (value == null) {
return values.remove(key);
} else {
return values.put(key, value);
}
}
/**
* Works like {@link #put(String, Object)} but returns this SmartMap rather than the old value.
*/
public SmartMap set(String key, Object value) {
put(key, value);
return this;
}
@Override
public Object remove(Object key) {
return values.remove(key);
}
@Override
public void putAll(Map<? extends String, ?> m) {
values.putAll(m);
}
@Override
public void clear() {
values.clear();
}
@Override
public boolean equals(Object o) {
return values.equals(o);
}
@Override
public int hashCode() {
return values.hashCode();
}
@Override
public Set<String> keySet() {
return values.keySet();
}
@Override
public Collection<Object> values() {
return values.values();
}
@Override
public Set<Entry<String, Object>> entrySet() {
return values.entrySet();
}
}
|
Class type;
if (defaultValue == null) {
type = Object.class;
} else {
type = defaultValue.getClass();
}
Object value = get(key, type);
if (value == null) {
return defaultValue;
}
return (T) value;
| 755
| 82
| 837
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/SnakeYamlUtil.java
|
SnakeYamlUtil
|
safelyCallNewSnakeYamlMethod
|
class SnakeYamlUtil {
private static boolean showErrorMessage = true;
private SnakeYamlUtil() {
}
/**
* Safely set the code point limit when configuring a new SnakeYaml instance.
*/
public static void setCodePointLimitSafely(LoaderOptions loaderOptions, int codePointLimit) {
safelyCallNewSnakeYamlMethod(() -> loaderOptions.setCodePointLimit(codePointLimit));
}
/**
* Safely set configuration to process comments when configuring a new SnakeYaml instance. This method
* had the return type changed.
*/
public static void setProcessCommentsSafely(LoaderOptions loaderOptions, boolean enable) {
safelyCallNewSnakeYamlMethod(() -> loaderOptions.setProcessComments(enable));
}
/**
* Safely set the default tag inspector when configuring a new SnakeYaml instance.
*/
public static void setDefaultTagInspector(LoaderOptions loaderOptions) { // pro uses this method
safelyCallNewSnakeYamlMethod(() -> loaderOptions.setTagInspector(tag -> true));
}
/**
* Helper method to make sure that we display the error message only once.
*/
private static void safelyCallNewSnakeYamlMethod(Runnable code) {<FILL_FUNCTION_BODY>}
}
|
try {
code.run();
} catch (NoSuchMethodError | BootstrapMethodError e) {
if (showErrorMessage) {
showErrorMessage = false;
Scope.getCurrentScope().getLog(SnakeYamlUtil.class).warning(
"Failed to perform a method call for SnakeYaml because the version of SnakeYaml being used is too old. " +
"Consider upgrading to a SnakeYaml version equal to or newer than 1.32, by downloading and " +
"installing a newer version of Liquibase (which includes a newer version of SnakeYaml). " +
"Loading particularly large JSON and YAML documents (like snapshots) in Liquibase may fail if SnakeYaml is not upgraded.");
Scope.getCurrentScope().getLog(SnakeYamlUtil.class).fine("Missing Snakeyaml feature: ", e);
}
}
| 341
| 226
| 567
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/SqlParser.java
|
SqlParser
|
parse
|
class SqlParser {
/**
* @deprecated load the {@link LiquibaseSqlParser} using the {@link SqlParserFactory} directly.
*/
@Deprecated
public static StringClauses parse(String sqlBlock) {
SqlParserFactory sqlParserFactory = Scope.getCurrentScope().getSingleton(SqlParserFactory.class);
LiquibaseSqlParser sqlParser = sqlParserFactory.getSqlParser();
return sqlParser.parse(sqlBlock);
}
/**
* @deprecated load the {@link LiquibaseSqlParser} using the {@link SqlParserFactory} directly.
*/
@Deprecated
public static StringClauses parse(String sqlBlock, boolean preserveWhitespace, boolean preserveComments) {<FILL_FUNCTION_BODY>}
}
|
SqlParserFactory sqlParserFactory = Scope.getCurrentScope().getSingleton(SqlParserFactory.class);
LiquibaseSqlParser sqlParser = sqlParserFactory.getSqlParser();
return sqlParser.parse(sqlBlock, preserveWhitespace, preserveComments);
| 193
| 68
| 261
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/StandardSqlParser.java
|
StandardSqlParser
|
parse
|
class StandardSqlParser implements LiquibaseSqlParser {
@Override
public StringClauses parse(String sqlBlock) {
return parse(sqlBlock, false, false);
}
@Override
public StringClauses parse(String sqlBlock, boolean preserveWhitespace, boolean preserveComments) {
return parse(sqlBlock, preserveWhitespace, preserveComments, null);
}
@Override
public StringClauses parse(String sqlBlock, boolean preserveWhitespace, boolean preserveComments, ChangeSet changeSet) {<FILL_FUNCTION_BODY>}
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
}
|
StringClauses clauses = new StringClauses(preserveWhitespace?"":" ");
SimpleSqlGrammarTokenManager tokenManager = new SimpleSqlGrammarTokenManager(new SimpleCharStream(new StringReader(sqlBlock)));
SimpleSqlGrammar t = new SimpleSqlGrammar(tokenManager);
try {
Token token = t.getNextToken();
while (!"".equals(token.toString())) {
if (token.kind == SimpleSqlGrammarConstants.WHITESPACE) {
if (preserveWhitespace) {
clauses.append(new StringClauses.Whitespace(token.image));
}
} else if ((token.kind == SimpleSqlGrammarConstants.LINE_COMMENT) || (token.kind ==
SimpleSqlGrammarConstants.MULTI_LINE_COMMENT)) {
if (preserveComments) {
String comment = token.image;
if (!preserveWhitespace && (token.kind == SimpleSqlGrammarConstants.LINE_COMMENT)) {
if (!comment.endsWith("\n")) {
comment = comment + "\n";
}
}
clauses.append(new StringClauses.Comment(comment));
}
} else {
clauses.append(token.image);
}
token = t.getNextToken();
}
} catch (Throwable e) {
if (changeSet != null) {
throw new UnexpectedLiquibaseException(changeSet.toString(), e);
} else {
throw new UnexpectedLiquibaseException(e);
}
}
return clauses;
| 171
| 403
| 574
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/StreamUtil.java
|
StreamUtil
|
readStreamWithReader
|
class StreamUtil {
public static String getLineSeparator() {
return GlobalConfiguration.OUTPUT_LINE_SEPARATOR.getCurrentValue();
}
public static void copy(InputStream inputStream, OutputStream outputStream) throws IOException {
byte[] bytes = new byte[1024];
int r = inputStream.read(bytes);
while (r > 0) {
outputStream.write(bytes, 0, r);
r = inputStream.read(bytes);
}
}
public static byte[] readStream(InputStream stream) throws IOException {
try (ByteArrayOutputStream buffer = new ByteArrayOutputStream()) {
copy(stream, buffer);
buffer.flush();
return buffer.toByteArray();
}
}
/**
* Calls {@link #readStreamAsString(InputStream, String)} with {@link GlobalConfiguration#FILE_ENCODING} as the encoding
*/
public static String readStreamAsString(InputStream stream) throws IOException {
return readStreamAsString(stream, null);
}
/**
* Returns the given stream as a string using the given encoding.
* If encoding is null, use {@link GlobalConfiguration#FILE_ENCODING}
*/
public static String readStreamAsString(InputStream stream, String encoding) throws IOException {
StringBuilder result = new StringBuilder();
try (Reader reader = readStreamWithReader(stream, encoding)) {
char[] buffer = new char[2048];
int read;
while ((read = reader.read(buffer)) > -1) {
result.append(buffer, 0, read);
}
return result.toString();
}
}
public static Reader readStreamWithReader(InputStream stream, String encoding) throws IOException {<FILL_FUNCTION_BODY>}
/**
* @deprecated use {@link ResourceAccessor#openStream(String, String)}
*/
public static InputStream openStream(String path, Boolean relativeToChangelogFile, ChangeSet changeSet, ResourceAccessor resourceAccessor) throws IOException {
if (relativeToChangelogFile != null && relativeToChangelogFile) {
path = resourceAccessor.get(changeSet.getChangeLog().getPhysicalFilePath()).resolveSibling(path).getPath();
}
return resourceAccessor.getExisting(path).openInputStream();
}
}
|
BomAwareInputStream encodingAwareStream = new BomAwareInputStream(stream);
Charset detectedEncoding = encodingAwareStream.getDetectedCharset();
if (encoding == null) {
if (detectedEncoding != null) {
encoding = detectedEncoding.name();
}
} else {
String canonicalEncodingName = Charset.forName(encoding).name();
if (detectedEncoding != null && canonicalEncodingName.startsWith("UTF") && !canonicalEncodingName.equals(detectedEncoding.name())) {
throw new IllegalArgumentException("Expected encoding was '"
+ encoding + "' but a BOM was detected for '"
+ detectedEncoding + "'");
}
}
return new InputStreamReader(encodingAwareStream, ObjectUtil.defaultIfNull(encoding == null ? null : Charset.forName(encoding), GlobalConfiguration.FILE_ENCODING.getCurrentValue()));
| 586
| 224
| 810
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/SystemUtil.java
|
SystemUtil
|
getJavaMajorVersion
|
class SystemUtil {
public static boolean isWindows() {
return StringUtil.trimToEmpty(System.getProperties().getProperty("os.name")).toLowerCase().startsWith("windows");
}
/**
* Returns java.version system property
*/
public static String getJavaVersion() {
return System.getProperty("java.version");
}
/**
* Returns the "major" version of java, including returning "8" for java "1.8"
*/
public static int getJavaMajorVersion() {<FILL_FUNCTION_BODY>}
public static boolean isAtLeastJava11() {
return getJavaMajorVersion() >= 11;
}
}
|
final String version = getJavaVersion();
String[] splitVersion = version.split("\\.", 2);
int majorVersion = Integer.parseInt(splitVersion[0]);
if (majorVersion == 1) {
splitVersion = splitVersion[1].split("\\.", 2);
return Integer.parseInt(splitVersion[0]);
}
return majorVersion;
| 181
| 94
| 275
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/UrlUtil.java
|
UrlUtil
|
handleSqlServerDbUrlParameters
|
class UrlUtil {
/**
* Move the specified keys up in the connection url for better readability and remove additional parameters. As far as I can tell this is sql server specific right now.
*
* @param keys the important keys to keep at the start of the connection url
* @param url the url to modify
* @return a new connection url with the connection parameters matching the keys provided moved forward, sorted alphabetically and with all other parameters REMOVED.
*/
public static String handleSqlServerDbUrlParameters(List<String> keys, String url) {<FILL_FUNCTION_BODY>}
}
|
if (url != null && url.contains(";")) {
List<String> moveForward = new ArrayList<>();
String[] parts = url.split(";");
String mainPart = parts[0];
for (String part : parts) {
if (keys.stream().anyMatch(key -> part.toLowerCase().startsWith(key.toLowerCase() + "="))) {
moveForward.add(part);
}
}
Collections.sort(moveForward);
String forward = String.join(";", moveForward);
return String.format("%s;%s", mainPart, forward);
}
return url;
| 150
| 168
| 318
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/ValueHandlerUtil.java
|
ValueHandlerUtil
|
getIntegerWithConstraints
|
class ValueHandlerUtil {
/**
* Get an integer entry, with constraints.
* @param input the user supplied input
* @param errorMessage the error message that should be returned if none of the valid values match. This message
* should end with the string "one of the allowed values: ", because the allowed values will
* be appended to this error message before it is used.
* @param validValues the permissible values for the input
*/
public static Integer getIntegerWithConstraints(Object input, String errorMessage, List<Integer> validValues) {<FILL_FUNCTION_BODY>}
}
|
if (input == null) {
return null;
}
Integer convertedInput = Integer.valueOf(String.valueOf(input));
boolean anyMatch = validValues.contains(convertedInput);
if (!anyMatch) {
throw new IllegalArgumentException(errorMessage + StringUtil.join(validValues.stream().sorted().map(String::valueOf).collect(Collectors.toList()), ", "));
}
return convertedInput;
| 150
| 113
| 263
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/XMLUtil.java
|
XMLUtil
|
getTextContent
|
class XMLUtil {
/**
* Extracts the text from the given element.
* {@link Node#getTextContent()} returns the text from ALL children, this returns the text only for this element.
*/
public static String getTextContent(Node element) {<FILL_FUNCTION_BODY>}
}
|
StringBuilder text = new StringBuilder();
NodeList childNodes = element.getChildNodes();
for (int i = 0; i < childNodes.getLength(); i++) {
Node child = childNodes.item(i);
if (child instanceof Text) {
text.append(child.getNodeValue());
}
}
return text.toString();
| 78
| 94
| 172
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/csv/CSVReader.java
|
CSVReader
|
readNext
|
class CSVReader implements AutoCloseable {
private final com.opencsv.CSVReader delegate;
public static final char DEFAULT_SEPARATOR = ',';
public static final char DEFAULT_QUOTE_CHARACTER = '"';
public CSVReader(Reader reader) {
this(reader, DEFAULT_SEPARATOR, DEFAULT_QUOTE_CHARACTER);
}
public CSVReader(Reader reader, char separator, char quotchar) {
delegate = new CSVReaderBuilder(reader).withCSVParser(
new RFC4180ParserBuilder().withSeparator(separator).withQuoteChar(quotchar).build()
).build();
}
@Override
public void close() throws Exception {
delegate.close();
}
public String[] readNext() throws IOException {<FILL_FUNCTION_BODY>}
}
|
try {
return delegate.readNext();
} catch (CsvValidationException e) {
throw new IOException(e.getMessage(), e);
}
| 221
| 42
| 263
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/util/xml/DefaultXmlWriter.java
|
DefaultXmlWriter
|
write
|
class DefaultXmlWriter implements XmlWriter {
@Override
public void write(Document doc, OutputStream outputStream) throws IOException {<FILL_FUNCTION_BODY>}
}
|
try {
TransformerFactory factory = TransformerFactory.newInstance();
try {
factory.setAttribute("indent-number", 4);
} catch (Exception e) {
//guess we can't set it, that's ok
}
Transformer transformer = factory.newTransformer();
transformer.setOutputProperty(OutputKeys.METHOD, "xml");
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.ENCODING, GlobalConfiguration.OUTPUT_FILE_ENCODING.getCurrentValue());
//need to nest outputStreamWriter to get around JDK 5 bug. See http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6296446
OutputStreamWriter writer = new OutputStreamWriter(outputStream, GlobalConfiguration.OUTPUT_FILE_ENCODING.getCurrentValue());
transformer.transform(new DOMSource(doc), new StreamResult(writer));
writer.flush();
writer.close();
} catch (TransformerException e) {
throw new IOException(e.getMessage());
}
| 46
| 282
| 328
|
<no_super_class>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/annotation/util/AnnoUtil.java
|
AnnoUtil
|
getAnnotation
|
class AnnoUtil {
private static Map<String, Annotation> annoCacheMap = new ConcurrentHashMap<>();
public static <A extends Annotation> A getAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType) {<FILL_FUNCTION_BODY>}
private static <A extends Annotation> Object getDefaultValue(Class<A> annotationType, String property) {
try {
return annotationType.getMethod(property).getDefaultValue();
}
catch (Exception e) {
return null;
}
}
}
|
String cacheKey = StrUtil.format("{}-{}", annotatedElement, annotationType.getSimpleName());
if (annoCacheMap.containsKey(cacheKey)){
return (A)annoCacheMap.get(cacheKey);
}
A annotation = AnnotationUtil.getAnnotation(annotatedElement, annotationType);
if (ObjectUtil.isNull(annotation)) {
return null;
}
Map<String, String> aliasMap = new HashMap<>();
Map<String, Object> defaultValueMap = new HashMap<>();
Arrays.stream(ReflectUtil.getMethods(annotationType)).forEach(method -> {
LFAliasFor aliasFor = AnnotationUtil.getAnnotation(method, LFAliasFor.class);
if (ObjectUtil.isNotNull(aliasFor)) {
aliasMap.put(method.getName(), aliasFor.value());
defaultValueMap.put(method.getName(), getDefaultValue(annotationType, method.getName()));
}
});
aliasMap.forEach((key, value1) -> {
Object value = ReflectUtil.invoke(annotation, key);
Object defaultValue = defaultValueMap.get(key);
if (ObjectUtil.notEqual(value, defaultValue)) {
AnnotationUtil.setValue(annotation, value1, value);
}
});
annoCacheMap.put(cacheKey, annotation);
return annotation;
| 141
| 364
| 505
|
<no_super_class>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/LiteFlowNodeBuilder.java
|
LiteFlowNodeBuilder
|
checkBuild
|
class LiteFlowNodeBuilder {
private final LFLog LOG = LFLoggerManager.getLogger(this.getClass());
private final Node node;
public static LiteFlowNodeBuilder createNode() {
return new LiteFlowNodeBuilder();
}
public static LiteFlowNodeBuilder createCommonNode() {
return new LiteFlowNodeBuilder(NodeTypeEnum.COMMON);
}
public static LiteFlowNodeBuilder createSwitchNode() {
return new LiteFlowNodeBuilder(NodeTypeEnum.SWITCH);
}
public static LiteFlowNodeBuilder createBooleanNode() {
return new LiteFlowNodeBuilder(NodeTypeEnum.BOOLEAN);
}
public static LiteFlowNodeBuilder createForNode() {
return new LiteFlowNodeBuilder(NodeTypeEnum.FOR);
}
public static LiteFlowNodeBuilder createIteratorNode() {
return new LiteFlowNodeBuilder(NodeTypeEnum.ITERATOR);
}
public static LiteFlowNodeBuilder createScriptNode() {
return new LiteFlowNodeBuilder(NodeTypeEnum.SCRIPT);
}
public static LiteFlowNodeBuilder createScriptSwitchNode() {
return new LiteFlowNodeBuilder(NodeTypeEnum.SWITCH_SCRIPT);
}
public static LiteFlowNodeBuilder createScriptBooleanNode() {
return new LiteFlowNodeBuilder(NodeTypeEnum.BOOLEAN_SCRIPT);
}
public static LiteFlowNodeBuilder createScriptForNode() {
return new LiteFlowNodeBuilder(NodeTypeEnum.FOR_SCRIPT);
}
public LiteFlowNodeBuilder() {
this.node = new Node();
}
public LiteFlowNodeBuilder(NodeTypeEnum type) {
this.node = new Node();
this.node.setType(type);
}
public LiteFlowNodeBuilder setId(String nodeId) {
if (StrUtil.isBlank(nodeId)) {
return this;
}
this.node.setId(nodeId.trim());
return this;
}
public LiteFlowNodeBuilder setName(String name) {
if (StrUtil.isBlank(name)) {
return this;
}
this.node.setName(name.trim());
return this;
}
public LiteFlowNodeBuilder setClazz(String clazz) {
if (StrUtil.isBlank(clazz)) {
return this;
}
this.node.setClazz(clazz.trim());
return this;
}
public LiteFlowNodeBuilder setClazz(Class<?> clazz) {
assert clazz != null;
setClazz(clazz.getName());
return this;
}
public LiteFlowNodeBuilder setType(NodeTypeEnum type) {
this.node.setType(type);
return this;
}
public LiteFlowNodeBuilder setScript(String script) {
this.node.setScript(script);
return this;
}
public LiteFlowNodeBuilder setFile(String filePath) {
if (StrUtil.isBlank(filePath)) {
return this;
}
try {
List<String> scriptList = PathContentParserHolder.loadContextAware()
.parseContent(ListUtil.toList(filePath));
String script = CollUtil.getFirst(scriptList);
setScript(script);
// 添加脚本文件监听
List<String> fileAbsolutePath = PathContentParserHolder.loadContextAware()
.getFileAbsolutePath(ListUtil.toList(filePath));
MonitorFile.getInstance().addMonitorFilePaths(fileAbsolutePath);
}
catch (Exception e) {
String errMsg = StrUtil.format("An exception occurred while building the node[{}],{}", this.node.getId(),
e.getMessage());
throw new NodeBuildException(errMsg);
}
return this;
}
public LiteFlowNodeBuilder setLanguage(String language) {
if (StrUtil.isNotBlank(language)){
this.node.setLanguage(language);
}
return this;
}
public void build() {
checkBuild();
try {
// 用于处理脚本 node
if (this.node.getType().isScript()) {
FlowBus.addScriptNode(this.node.getId(), this.node.getName(), this.node.getType(),
this.node.getScript(), this.node.getLanguage());
}
// 用于处理普通 node
else {
FlowBus.addNode(this.node.getId(), this.node.getName(), this.node.getType(), this.node.getClazz());
}
}
catch (Exception e) {
String errMsg = StrUtil.format("An exception occurred while building the node[{}],{}", this.node.getId(),
e.getMessage());
LOG.error(errMsg, e);
throw new NodeBuildException(errMsg);
}
}
/**
* build 前简单校验
*/
private void checkBuild() {<FILL_FUNCTION_BODY>}
}
|
List<String> errorList = new ArrayList<>();
if (StrUtil.isBlank(this.node.getId())) {
errorList.add("id is blank");
}
if (Objects.isNull(this.node.getType())) {
errorList.add("type is null");
}
if (CollUtil.isNotEmpty(errorList)) {
throw new NodeBuildException(CollUtil.join(errorList, ",", "[", "]"));
}
| 1,270
| 124
| 1,394
|
<no_super_class>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/AndOperator.java
|
AndOperator
|
build
|
class AndOperator extends BaseOperator<AndOrCondition> {
@Override
public AndOrCondition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeGteTwo(objects);
AndOrCondition andOrCondition = new AndOrCondition();
andOrCondition.setBooleanConditionType(BooleanConditionTypeEnum.AND);
for (Object object : objects){
OperatorHelper.checkObjMustBeBooleanTypeItem(object);
Executable item = OperatorHelper.convert(object, Executable.class);
andOrCondition.addItem(item);
}
return andOrCondition;
| 46
| 119
| 165
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.condition.AndOrCondition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.condition.AndOrCondition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/AnyOperator.java
|
AnyOperator
|
build
|
class AnyOperator extends BaseOperator<WhenCondition> {
@Override
public WhenCondition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeEqTwo(objects);
WhenCondition whenCondition = OperatorHelper.convert(objects[0], WhenCondition.class);
Boolean any = OperatorHelper.convert(objects[1], Boolean.class);
whenCondition.setParallelStrategy(any ? ParallelStrategyEnum.ANY : ParallelStrategyEnum.ALL);
return whenCondition;
| 44
| 96
| 140
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.condition.WhenCondition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.condition.WhenCondition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/BreakOperator.java
|
BreakOperator
|
build
|
class BreakOperator extends BaseOperator<LoopCondition> {
@Override
public LoopCondition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeEqTwo(objects);
// DO关键字有可能用在FOR后面，也有可能用于WHILE后面，所以这里要进行判断是不是这两种类型的超类LoopCondition
String errorMsg = "The caller must be ForCondition or WhileCondition item";
LoopCondition condition = OperatorHelper.convert(objects[0], LoopCondition.class, errorMsg);
// 获得需要执行的可执行表达式
OperatorHelper.checkObjMustBeBooleanTypeItem(objects[1]);
Executable breakItem = OperatorHelper.convert(objects[1], Executable.class);
condition.setBreakItem(breakItem);
return condition;
| 45
| 167
| 212
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.condition.LoopCondition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.condition.LoopCondition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/CatchOperator.java
|
CatchOperator
|
build
|
class CatchOperator extends BaseOperator<CatchCondition> {
@Override
public CatchCondition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeEq(objects, 1);
OperatorHelper.checkObjMustBeCommonTypeItem(objects[0]);
Executable catchItem = OperatorHelper.convert(objects[0], Executable.class);
CatchCondition catchCondition = new CatchCondition();
//如果是单个Node的话，要包装成THEN的CONDITION模式，否则CATCH不到异常
if (catchItem instanceof Node){
ThenCondition thenCondition = new ThenCondition();
thenCondition.addExecutable(catchItem);
catchCondition.setCatchItem(thenCondition);
}else{
catchCondition.setCatchItem(catchItem);
}
return catchCondition;
| 47
| 179
| 226
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.condition.CatchCondition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.condition.CatchCondition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/DataOperator.java
|
DataOperator
|
build
|
class DataOperator extends BaseOperator<Node> {
@Override
public Node build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeEqTwo(objects);
Node node = OperatorHelper.convert(objects[0], Node.class);
String cmpData = OperatorHelper.convert(objects[1], String.class);
node.setCmpData(cmpData);
return node;
| 42
| 81
| 123
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.Node build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.Node executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/DefaultOperator.java
|
DefaultOperator
|
build
|
class DefaultOperator extends BaseOperator<SwitchCondition> {
@Override
public SwitchCondition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeEqTwo(objects);
String errorMsg = "The caller must be SwitchCondition item";
SwitchCondition switchCondition = OperatorHelper.convert(objects[0], SwitchCondition.class, errorMsg);
OperatorHelper.checkObjMustBeCommonTypeItem(objects[1]);
Executable target = OperatorHelper.convert(objects[1], Executable.class);
switchCondition.setDefaultExecutor(target);
return switchCondition;
| 44
| 122
| 166
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.condition.SwitchCondition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.condition.SwitchCondition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/DoOperator.java
|
DoOperator
|
build
|
class DoOperator extends BaseOperator<Condition> {
@Override
public Condition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeEqTwo(objects);
if (objects[0] instanceof CatchCondition) {
String errorMsg = "The caller must be CatchCondition item";
CatchCondition condition = OperatorHelper.convert(objects[0], CatchCondition.class, errorMsg);
// 获得需要执行的可执行表达式
OperatorHelper.checkObjMustBeCommonTypeItem(objects[1]);
Executable doExecutableItem = OperatorHelper.convert(objects[1], Executable.class);
condition.setDoItem(doExecutableItem);
return condition;
}
else if (objects[0] instanceof LoopCondition) {
String errorMsg = "The caller must be LoopCondition item";
// DO关键字有可能用在FOR后面，也有可能用于WHILE后面，所以这里要进行判断是不是这两种类型的超类LoopCondition
LoopCondition condition = OperatorHelper.convert(objects[0], LoopCondition.class, errorMsg);
// 获得需要执行的可执行表达式
OperatorHelper.checkObjMustBeCommonTypeItem(objects[1]);
Executable doExecutableItem = OperatorHelper.convert(objects[1], Executable.class);
condition.setDoExecutor(doExecutableItem);
return condition;
}
else {
String errorMsg = "The caller must be LoopCondition or CatchCondition item";
throw new QLException(errorMsg);
}
| 42
| 361
| 403
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.Condition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.Condition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/ElifOperator.java
|
ElifOperator
|
build
|
class ElifOperator extends BaseOperator<IfCondition> {
@Override
public IfCondition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeEqThree(objects);
// 解析caller
String errorMsg = "The caller must be IfCondition item";
IfCondition ifCondition = OperatorHelper.convert(objects[0], IfCondition.class, errorMsg);
// 解析第一个参数
OperatorHelper.checkObjMustBeBooleanTypeItem(objects[1]);
Executable ifItem = OperatorHelper.convert(objects[1], Executable.class);
// 解析第二个参数
OperatorHelper.checkObjMustBeCommonTypeItem(objects[2]);
Executable trueCaseExecutableItem = OperatorHelper.convert(objects[2], Executable.class);
// 构建一个内部的IfCondition
IfCondition ifConditionItem = new IfCondition();
ifConditionItem.setIfItem(ifItem);
ifConditionItem.setTrueCaseExecutableItem(trueCaseExecutableItem);
// 因为可能会有多个ELIF，所以每一次拿到的caller总是最开始大的if，需要遍历到没有falseCaseExecutable的地方。
// 塞进去是一个新的IfCondition
IfCondition loopIfCondition = ifCondition;
while (true) {
if (loopIfCondition.getFalseCaseExecutableItem() == null) {
loopIfCondition.setFalseCaseExecutableItem(ifConditionItem);
break;
}
else {
loopIfCondition = (IfCondition) loopIfCondition.getFalseCaseExecutableItem();
}
}
return ifCondition;
| 45
| 377
| 422
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.condition.IfCondition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.condition.IfCondition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/ElseOperator.java
|
ElseOperator
|
build
|
class ElseOperator extends BaseOperator<IfCondition> {
@Override
public IfCondition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
// 参数只能是1个，但这里为什么是2个呢？第一个是caller，第二个才是参数
OperatorHelper.checkObjectSizeEqTwo(objects);
String errorMsg = "The caller must be IfCondition item";
IfCondition ifCondition = OperatorHelper.convert(objects[0], IfCondition.class, errorMsg);
OperatorHelper.checkObjMustBeCommonTypeItem(objects[1]);
Executable elseExecutableItem = OperatorHelper.convert(objects[1], Executable.class);
// 因为当中可能会有多个ELIF，所以并不知道这个ELSE前面有没有ELIF，
// 每一次拿到的caller总是最开始大的if，需要遍历到没有falseCaseExecutable的地方。
// 塞进去是一个elseExecutableItem
IfCondition loopIfCondition = ifCondition;
while (true) {
if (loopIfCondition.getFalseCaseExecutableItem() == null) {
loopIfCondition.setFalseCaseExecutableItem(elseExecutableItem);
break;
}
else {
loopIfCondition = (IfCondition) loopIfCondition.getFalseCaseExecutableItem();
}
}
return ifCondition;
| 45
| 297
| 342
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.condition.IfCondition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.condition.IfCondition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/FinallyOperator.java
|
FinallyOperator
|
build
|
class FinallyOperator extends BaseOperator<FinallyCondition> {
@Override
public FinallyCondition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeGtZero(objects);
FinallyCondition finallyCondition = new FinallyCondition();
for (Object obj : objects) {
OperatorHelper.checkObjMustBeCommonTypeItem(obj);
Executable item = OperatorHelper.convert(obj, Executable.class);
finallyCondition.addExecutable(item);
}
return finallyCondition;
| 44
| 99
| 143
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.condition.FinallyCondition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.condition.FinallyCondition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/ForOperator.java
|
ForOperator
|
build
|
class ForOperator extends BaseOperator<ForCondition> {
@Override
public ForCondition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeEq(objects, 1);
Node node;
if (objects[0] instanceof Node) {
OperatorHelper.checkObjMustBeForTypeItem(objects[0]);
node = OperatorHelper.convert(objects[0], Node.class);
}
else if (objects[0] instanceof Integer) {
Integer forCount = OperatorHelper.convert(objects[0], Integer.class);
node = new Node();
NodeForComponent nodeForComponent = new NodeForComponent() {
@Override
public int processFor() {
return forCount;
}
};
nodeForComponent.setSelf(nodeForComponent);
nodeForComponent.setNodeId(StrUtil.format("LOOP_{}", forCount));
node.setInstance(nodeForComponent);
}
else {
throw new QLException("The parameter must be Node item");
}
ForCondition forCondition = new ForCondition();
forCondition.setForNode(node);
return forCondition;
| 44
| 266
| 310
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.condition.ForCondition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.condition.ForCondition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/IdOperator.java
|
IdOperator
|
build
|
class IdOperator extends BaseOperator<Condition> {
@Override
public Condition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeEqTwo(objects);
String errorMsg = "The caller must be Condition item";
Condition condition = OperatorHelper.convert(objects[0], Condition.class, errorMsg);
String id = OperatorHelper.convert(objects[1], String.class);
condition.setId(id);
return condition;
| 42
| 93
| 135
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.Condition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.Condition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/IfOperator.java
|
IfOperator
|
build
|
class IfOperator extends BaseOperator<IfCondition> {
@Override
public IfCondition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeEq(objects, 2, 3);
// 解析第一个参数
OperatorHelper.checkObjMustBeBooleanTypeItem(objects[0]);
Executable ifItem = OperatorHelper.convert(objects[0], Executable.class);
// 解析第二个参数
OperatorHelper.checkObjMustBeCommonTypeItem(objects[1]);
Executable trueCaseExecutableItem = OperatorHelper.convert(objects[1], Executable.class);
// 解析第三个参数，如果有的话
Executable falseCaseExecutableItem = null;
if (objects.length == 3) {
OperatorHelper.checkObjMustBeCommonTypeItem(objects[2]);
falseCaseExecutableItem = OperatorHelper.convert(objects[2], Executable.class);
}
IfCondition ifCondition = new IfCondition();
ifCondition.setIfItem(ifItem);
ifCondition.setTrueCaseExecutableItem(trueCaseExecutableItem);
ifCondition.setFalseCaseExecutableItem(falseCaseExecutableItem);
return ifCondition;
| 44
| 277
| 321
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.condition.IfCondition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.condition.IfCondition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/IgnoreErrorOperator.java
|
IgnoreErrorOperator
|
build
|
class IgnoreErrorOperator extends BaseOperator<WhenCondition> {
@Override
public WhenCondition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeEqTwo(objects);
String errorMsg = "The caller must be WhenCondition item";
WhenCondition condition = OperatorHelper.convert(objects[0], WhenCondition.class, errorMsg);
Boolean ignoreError = OperatorHelper.convert(objects[1], Boolean.class);
condition.setIgnoreError(ignoreError);
return condition;
| 46
| 99
| 145
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.condition.WhenCondition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.condition.WhenCondition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
dromara_liteflow
|
liteflow/liteflow-core/src/main/java/com/yomahub/liteflow/builder/el/operator/IteratorOperator.java
|
IteratorOperator
|
build
|
class IteratorOperator extends BaseOperator<IteratorCondition> {
@Override
public IteratorCondition build(Object[] objects) throws Exception {<FILL_FUNCTION_BODY>}
}
|
OperatorHelper.checkObjectSizeEq(objects, 1);
OperatorHelper.checkObjMustBeIteratorTypeItem(objects[0]);
Node node = OperatorHelper.convert(objects[0], Node.class);
IteratorCondition iteratorCondition = new IteratorCondition();
iteratorCondition.setIteratorNode(node);
return iteratorCondition;
| 46
| 94
| 140
|
<methods>public non-sealed void <init>() ,public abstract com.yomahub.liteflow.flow.element.condition.IteratorCondition build(java.lang.Object[]) throws java.lang.Exception,public com.yomahub.liteflow.flow.element.condition.IteratorCondition executeInner(java.lang.Object[]) throws java.lang.Exception<variables>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.