_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q165600 | StringUtil.pad | validation | public static String pad(String value, int length) {
value = StringUtil.trimToEmpty(value);
if (value.length() >= length) {
return value;
}
return value + StringUtil.repeat(" ", length - value.length());
} | java | {
"resource": ""
} |
q165601 | StringUtil.leftPad | validation | public static String leftPad(String value, int length) {
value = StringUtil.trimToEmpty(value);
if (value.length() >= length) {
return value;
}
return StringUtil.repeat(" ", length - value.length()) + value;
} | java | {
"resource": ""
} |
q165602 | StringUtil.randomIdentifer | validation | public static String randomIdentifer(int len) {
final String AB = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
StringBuilder sb = new StringBuilder( len );
for (int i = 0; i < len; i++)
sb.append( AB.charAt( rnd.nextInt(AB.length()) ) );
return sb.toString();
} | java | {
"resource": ""
} |
q165603 | StringUtil.stripSqlCommentsAndWhitespacesFromTheEnd | validation | public static String stripSqlCommentsAndWhitespacesFromTheEnd(String sqlString) {
if (isEmpty(sqlString)) {
return sqlString;
}
StringBuilder str = new StringBuilder(sqlString);
boolean strModified = true;
while (strModified) {
strModified = false;
// first check for last block comment
// since line comments could be inside block comments, we want to
// remove them first.
String lastBlockComment = getLastBlockComment(str.toString());
if (isNotEmpty(lastBlockComment)) {
str.setLength(str.length() - lastBlockComment.length());
// we just modified the end of the string,
// do another loop to check for next block or line comments
strModified = true;
}
// now check for the line comments
String lastLineComment = getLastLineComment(str.toString());
if (isNotEmpty(lastLineComment)) {
str.setLength(str.length() - lastLineComment.length());
// we just modified the end of the string,
// do another loop to check for next block or line comments
strModified = true;
}
}
return trimRight(str.toString());
} | java | {
"resource": ""
} |
q165604 | StringUtil.concatConsistentCase | validation | public static String concatConsistentCase(String baseString, String addition) {
boolean hasLowerCase = hasLowerCase(baseString);
boolean hasUpperCase = hasUpperCase(baseString);
if ((hasLowerCase && hasUpperCase) || (!hasLowerCase && !hasUpperCase)) { //mixed case || no letters
return baseString + addition;
} else if (hasLowerCase) {
return baseString + addition.toLowerCase();
} else {
return baseString + addition.toUpperCase();
}
} | java | {
"resource": ""
} |
q165605 | JdbcSnapshotGenerator.getDatabaseCatalogNames | validation | protected String[] getDatabaseCatalogNames(Database database) throws SQLException, DatabaseException {
List<String> returnList = new ArrayList<>();
ResultSet catalogs = null;
try {
if (((AbstractJdbcDatabase) database).jdbcCallsCatalogsSchemas()) {
catalogs = ((JdbcConnection) database.getConnection()).getMetaData().getSchemas();
} else {
catalogs = ((JdbcConnection) database.getConnection()).getMetaData().getCatalogs();
}
while (catalogs.next()) {
if (((AbstractJdbcDatabase) database).jdbcCallsCatalogsSchemas()) {
returnList.add(catalogs.getString("TABLE_SCHEM"));
} else {
returnList.add(catalogs.getString("TABLE_CAT"));
}
}
} finally {
if (catalogs != null) {
try {
catalogs.close();
} catch (SQLException ignore) {
}
}
}
return returnList.toArray(new String[returnList.size()]);
} | java | {
"resource": ""
} |
q165606 | StringClauses.append | validation | public StringClauses append(String key, String clause) {
Validate.notNull(StringUtil.trimToNull(key), "key must be a non-null, non-empty value");
key = StringUtil.trimToEmpty(key).toLowerCase();
clause = StringUtil.trimToEmpty(clause);
if (clauses.containsKey(key)) {
throw new IllegalArgumentException("Cannot add clause with key '" + key + "' because it is already defined");
}
clauses.put(key, clause.trim());
return this;
} | java | {
"resource": ""
} |
q165607 | StringClauses.append | validation | public StringClauses append(String key, StringClauses subclauses) {
Validate.notNull(StringUtil.trimToNull(key), "key must be a non-null, non-empty value");
key = StringUtil.trimToEmpty(key).toLowerCase();
if (clauses.containsKey(key)) {
throw new IllegalArgumentException("Cannot add clause with key '" + key + "' because it is already defined");
}
clauses.put(key, subclauses);
return this;
} | java | {
"resource": ""
} |
q165608 | StringClauses.prepend | validation | public StringClauses prepend(String key, String clause) {
return prependImpl(key, StringUtil.trimToEmpty(clause));
} | java | {
"resource": ""
} |
q165609 | StringClauses.insertBefore | validation | public StringClauses insertBefore(String existingKey, String newKey, String newValue) throws IllegalArgumentException {
return insertBeforeImpl(existingKey, newKey, newValue);
} | java | {
"resource": ""
} |
q165610 | StringClauses.insertAfter | validation | public StringClauses insertAfter(String existingKey, String newKey, String newValue) {
return insertAfterImpl(existingKey, newKey, newValue);
} | java | {
"resource": ""
} |
q165611 | StringClauses.get | validation | public String get(String exitingKey) {
exitingKey = StringUtil.trimToEmpty(exitingKey).toLowerCase();
Object clauses = getImpl(exitingKey);
if (clauses == null) {
return null;
}
return clauses.toString();
} | java | {
"resource": ""
} |
q165612 | StringClauses.getSubclause | validation | public StringClauses getSubclause(String exitingKey) {
exitingKey = StringUtil.trimToEmpty(exitingKey).toLowerCase();
Object clauses = getImpl(exitingKey);
if (clauses == null) {
return null;
}
if (clauses instanceof String) {
return new StringClauses().append((String) clauses);
}
return (StringClauses) clauses;
} | java | {
"resource": ""
} |
q165613 | DiffToChangeLog.print | validation | public void print(PrintStream out, ChangeLogSerializer changeLogSerializer) throws ParserConfigurationException, IOException, DatabaseException {
List<ChangeSet> changeSets = generateChangeSets();
changeLogSerializer.write(changeSets, out);
out.flush();
} | java | {
"resource": ""
} |
q165614 | DatabaseFactory.getImplementedDatabases | validation | public List<Database> getImplementedDatabases() {
List<Database> returnList = new ArrayList<>();
for (SortedSet<Database> set : implementedDatabases.values()) {
returnList.add(set.iterator().next());
}
return returnList;
} | java | {
"resource": ""
} |
q165615 | DatabaseFactory.getInternalDatabases | validation | public List<Database> getInternalDatabases() {
List<Database> returnList = new ArrayList<>();
for (SortedSet<Database> set : internalDatabases.values()) {
returnList.add(set.iterator().next());
}
return returnList;
} | java | {
"resource": ""
} |
q165616 | LiquibaseDataType.validate | validation | public boolean validate(Database database) {
int maxParameters = this.getMaxParameters(database);
int minParameters = this.getMinParameters(database);
if (parameters.size() > maxParameters) {
throw new UnexpectedLiquibaseException("Type "+getClass()+" doesn't support "+ maxParameters+" parameters");
}
if (parameters.size() < minParameters) {
throw new UnexpectedLiquibaseException("Type "+getClass()+" requires "+ minParameters+" parameters");
}
return true;
} | java | {
"resource": ""
} |
q165617 | LiquibaseDataType.toDatabaseDataType | validation | public DatabaseDataType toDatabaseDataType(Database database) {
if (database instanceof MSSQLDatabase) {
String name = database.escapeDataTypeName(getName());
int dataTypeMaxParameters = database.getDataTypeMaxParameters(getName());
Object[] parameters = getParameters();
if (dataTypeMaxParameters < parameters.length) {
parameters = Arrays.copyOfRange(parameters, 0, dataTypeMaxParameters);
}
return new DatabaseDataType(name, parameters);
}
DatabaseDataType type = new DatabaseDataType(name.toUpperCase(Locale.US), getParameters());
type.addAdditionalInformation(additionalInformation);
return type;
} | java | {
"resource": ""
} |
q165618 | LiquibaseDataType.objectToSql | validation | public String objectToSql(Object value, Database database) {
if ((value == null) || "null".equals(value.toString().toLowerCase(Locale.US))) {
return null;
} else if (value instanceof DatabaseFunction) {
return functionToSql((DatabaseFunction) value, database);
} else if (value instanceof Number) {
return numberToSql((Number) value, database);
}
return otherToSql(value, database);
} | java | {
"resource": ""
} |
q165619 | LiquibaseDataType.isCurrentDateTimeFunction | validation | protected boolean isCurrentDateTimeFunction(String string, Database database) {
return string.toLowerCase(Locale.US).startsWith("current_timestamp")
|| string.toLowerCase(Locale.US).startsWith(DatabaseFunction.CURRENT_DATE_TIME_PLACE_HOLDER)
|| database.getCurrentDateTimeFunction().toLowerCase(Locale.US).equals(string.toLowerCase(Locale.US));
} | java | {
"resource": ""
} |
q165620 | DB2Database.supportsBooleanDataType | validation | public boolean supportsBooleanDataType() {
if (getConnection() == null)
return false; /// assume not;
try {
final Integer fixPack = getDb2FixPack();
if (fixPack == null)
throw new DatabaseException("Error getting fix pack number");
return getDatabaseMajorVersion() > 11
|| getDatabaseMajorVersion() == 11 && getDatabaseMinorVersion() >= 1 && fixPack.intValue() >= 1;
} catch (final DatabaseException e) {
return false; // assume not
}
} | java | {
"resource": ""
} |
q165621 | H2Database.getConcatSql | validation | private String getConcatSql(List<String> values) {
if (values.size() == 1) {
return values.get(0);
} else {
return START_CONCAT + values.get(0) + SEP_CONCAT + getConcatSql(values.subList(1, values.size())) + END_CONCAT;
}
} | java | {
"resource": ""
} |
q165622 | SqlGeneratorFactory.generateStatementsVolatile | validation | public boolean generateStatementsVolatile(SqlStatement statement, Database database) {
for (SqlGenerator generator : getGenerators(statement, database)) {
if (generator.generateStatementsIsVolatile(database)) {
return true;
}
}
return false;
} | java | {
"resource": ""
} |
q165623 | MavenUtils.addArtifact | validation | private static void addArtifact(Set<URI> urls,
Artifact artifact,
Log log,
boolean verbose)
throws MalformedURLException {
File f = artifact.getFile();
if (f == null) {
log.warn("Artifact with no actual file, '" + artifact.getGroupId()
+ ":" + artifact.getArtifactId() + "'");
} else {
addFile(urls, f, log, verbose);
}
// if (f != null) {
// URL fileURL = f.toURI().toURL();
// if (verbose) {
// log.info(" artifact: " + fileURL);
// }
// urls.add(fileURL);
// } else {
// log.warning("Artifact with no actual file, '" + artifact.getGroupId()
// + ":" + artifact.getArtifactId() + "'");
// }
} | java | {
"resource": ""
} |
q165624 | MavenUtils.getDeclaredField | validation | public static Field getDeclaredField(Class clazz, String fieldName)
throws NoSuchFieldException {
Field f = getField(clazz, fieldName);
if (f == null) {
// Try the parent class
Class parent = clazz.getSuperclass();
if (parent != null) {
return getDeclaredField(parent, fieldName);
} else {
throw new NoSuchFieldException("The field '" + fieldName + "' could not be "
+ "found in the class of any of its parent "
+ "classes.");
}
} else {
return f;
}
} | java | {
"resource": ""
} |
q165625 | CommandLineResourceAccessor.getAlternatePaths | validation | protected List<String> getAlternatePaths(String path) {
List<String> alternatePaths = new ArrayList<>();
if (path.startsWith("/")) { //People are often confused about leading slashes in resource paths...
alternatePaths.add(path.substring(1));
}
return alternatePaths;
} | java | {
"resource": ""
} |
q165626 | ContextExpression.matches | validation | public boolean matches(Contexts runtimeContexts) {
if ((runtimeContexts == null) || runtimeContexts.isEmpty()) {
return true;
}
if (this.contexts.isEmpty()) {
return true;
}
for (String expression : this.contexts) {
if (matches(expression, runtimeContexts)) {
return true;
}
}
return false;
} | java | {
"resource": ""
} |
q165627 | BaseLiquibaseTask.createResourceAccessor | validation | private ResourceAccessor createResourceAccessor(ClassLoader classLoader) {
List<ResourceAccessor> resourceAccessors = new ArrayList<ResourceAccessor>();
resourceAccessors.add(new FileSystemResourceAccessor(Paths.get(".").toAbsolutePath().getRoot().toFile()));
resourceAccessors.add(new ClassLoaderResourceAccessor(classLoader));
String changeLogDirectory = getChangeLogDirectory();
if (changeLogDirectory != null) {
changeLogDirectory = changeLogDirectory.trim().replace('\\', '/'); //convert to standard / if using absolute path on windows
resourceAccessors.add(new FileSystemResourceAccessor(new File(changeLogDirectory)));
}
return new CompositeResourceAccessor(resourceAccessors.toArray(new ResourceAccessor[0]));
} | java | {
"resource": ""
} |
q165628 | BaseLiquibaseTask.closeDatabase | validation | protected void closeDatabase(Database database) {
try {
if(database != null) {
database.close();
}
} catch (DatabaseException e) {
log("Error closing the database connection.", e, Project.MSG_WARN);
}
} | java | {
"resource": ""
} |
q165629 | CSVParser.appendNextCharacterAndAdvanceLoop | validation | private int appendNextCharacterAndAdvanceLoop(String line, StringBuilder sb, int i) {
sb.append(line.charAt(i + 1));
i++;
return i;
} | java | {
"resource": ""
} |
q165630 | CSVParser.isNextCharacterEscapedQuote | validation | private boolean isNextCharacterEscapedQuote(String nextLine, boolean inQuotes, int i) {
return inQuotes // we are in quotes, therefore there can be escaped quotes in here.
&& (nextLine.length() > (i + 1)) // there is indeed another character to check.
&& isCharacterQuoteCharacter(nextLine.charAt(i + 1));
} | java | {
"resource": ""
} |
q165631 | CSVParser.isNextCharacterEscapable | validation | protected boolean isNextCharacterEscapable(String nextLine, boolean inQuotes, int i) {
return inQuotes // we are in quotes, therefore there can be escaped quotes in here.
&& (nextLine.length() > (i + 1)) // there is indeed another character to check.
&& isCharacterEscapable(nextLine.charAt(i + 1));
} | java | {
"resource": ""
} |
q165632 | ParsedNode.getChildren | validation | public List<ParsedNode> getChildren(String namespace, String nodename) {
List<ParsedNode> returnList = new ArrayList<>();
for (ParsedNode node : children) {
if (nodeMatches(node, namespace, nodename)) {
returnList.add(node);
}
}
return Collections.unmodifiableList(returnList);
} | java | {
"resource": ""
} |
q165633 | ParsedNode.setValue | validation | public ParsedNode setValue(Object value) throws ParsedNodeException {
if (value instanceof ParsedNode) {
this.addChild((ParsedNode) value);
} else if (value instanceof Collection) {
List newValue = new ArrayList();
for (Object obj : ((Collection) value)) {
if (obj instanceof Map) {
addChildren((Map) obj);
} else if (obj instanceof ParsedNode) {
addChild(((ParsedNode) obj));
} else {
newValue.add(obj);
}
}
if (newValue.isEmpty()) {
//do nothing
} else if (newValue.size() == 1) {
this.value = newValue.get(0);
} else {
this.value = newValue;
}
} else if (value instanceof Map) {
addChildren(((Map) value));
} else {
this.value = value;
}
return this;
} | java | {
"resource": ""
} |
q165634 | ParsedNode.getValue | validation | public <T> T getValue(Class<T> type) throws ParsedNodeException {
return convertObject(value, type);
} | java | {
"resource": ""
} |
q165635 | ParsedNode.getChild | validation | public ParsedNode getChild(String namespace, String name) throws ParsedNodeException {
ParsedNode returnNode = null;
for (ParsedNode node : children) {
if (nodeMatches(node, namespace, name)) {
if (returnNode != null) {
throw new ParsedNodeException("Multiple nodes match "+namespace+"/"+name);
}
returnNode = node;
}
}
return returnNode;
} | java | {
"resource": ""
} |
q165636 | ParsedNode.getChildValue | validation | public <T> T getChildValue(String namespace, String nodename, Class<T> type) throws ParsedNodeException {
Object rawValue = getChildValue(namespace, nodename);
if (rawValue == null) {
return null;
}
return convertObject(rawValue, type);
} | java | {
"resource": ""
} |
q165637 | ParsedNode.getChildValue | validation | public Object getChildValue(String namespace, String nodename) throws ParsedNodeException {
ParsedNode child = getChild(namespace, nodename);
if (child == null) {
return null;
}
return child.getValue();
} | java | {
"resource": ""
} |
q165638 | InputStreamList.close | validation | @Override
public void close() throws IOException {
for (InputStream stream : this) {
try {
stream.close();
} catch (IOException e) {
Scope.getCurrentScope().getLog(getClass()).severe("Error closing stream. Logging error and continuing", e);
}
}
} | java | {
"resource": ""
} |
q165639 | DatabaseDataType.isAutoIncrement | validation | public boolean isAutoIncrement() {
return "serial".equals(type.toLowerCase(Locale.US)) || "bigserial".equals(type.toLowerCase(Locale.US)) || "smallserial"
.equals(type.toLowerCase(Locale.US));
} | java | {
"resource": ""
} |
q165640 | FileSystemResourceAccessor.isCompressedFile | validation | protected boolean isCompressedFile(Path path) {
return path != null && (path.toString().startsWith("jar:") || path.toString().toLowerCase().endsWith(".jar") || path.toString().toLowerCase().endsWith(".zip"));
} | java | {
"resource": ""
} |
q165641 | Relation.getColumn | validation | public Column getColumn(String columnName) {
for (Column column : getColumns()) {
if (column.getName().equalsIgnoreCase(columnName)) {
return column;
}
}
return null;
} | java | {
"resource": ""
} |
q165642 | Scope.getSingleton | validation | public <T extends SingletonObject> T getSingleton(Class<T> type) {
if (getParent() != null) {
return getParent().getSingleton(type);
}
String key = type.getName();
T singleton = get(key, type);
if (singleton == null) {
try {
try {
Constructor<T> constructor = type.getDeclaredConstructor(Scope.class);
constructor.setAccessible(true);
singleton = constructor.newInstance(this);
} catch (NoSuchMethodException e) { //try without scope
Constructor<T> constructor = type.getDeclaredConstructor();
constructor.setAccessible(true);
singleton = constructor.newInstance();
}
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
values.put(key, singleton);
}
return singleton;
} | java | {
"resource": ""
} |
q165643 | StandardChangeLogHistoryService.tag | validation | @Override
public void tag(final String tagString) throws DatabaseException {
Database database = getDatabase();
Executor executor = ExecutorService.getInstance().getExecutor(database);
int totalRows = ExecutorService.getInstance().getExecutor(database).queryForInt(new
SelectFromDatabaseChangeLogStatement(new ColumnConfig().setName("COUNT(*)", true)));
if (totalRows == 0) {
ChangeSet emptyChangeSet = new ChangeSet(String.valueOf(new Date().getTime()), "liquibase",
false,false, "liquibase-internal", null, null,
getDatabase().getObjectQuotingStrategy(), null);
this.setExecType(emptyChangeSet, ChangeSet.ExecType.EXECUTED);
}
executor.execute(new TagDatabaseStatement(tagString));
getDatabase().commit();
if (this.ranChangeSetList != null) {
ranChangeSetList.get(ranChangeSetList.size() - 1).setTag(tagString);
}
} | java | {
"resource": ""
} |
q165644 | PreconditionFactory.create | validation | public Precondition create(String tagName) {
Class<?> aClass = preconditions.get(tagName);
if (aClass == null) {
return null;
}
try {
return (Precondition) aClass.getConstructor().newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
} | java | {
"resource": ""
} |
q165645 | NowAndTodayUtil.isNowOrTodayFormat | validation | public static boolean isNowOrTodayFormat(String value) {
boolean ret = false;
if (value != null) {
String lowerValue = value.toLowerCase();
if (lowerValue.length() >= NOW_LENGTH && lowerValue.startsWith(NOW)) {
ret = true;
} else if (lowerValue.length() >= TODAY_LENGTH && lowerValue.startsWith(TODAY)) {
ret = true;
}
}
return ret;
} | java | {
"resource": ""
} |
q165646 | ChangeLogParameters.getValue | validation | public Object getValue(String key, DatabaseChangeLog changeLog) {
ChangeLogParameter parameter = findParameter(key, changeLog);
return (parameter != null) ? parameter.getValue() : null;
} | java | {
"resource": ""
} |
q165647 | UniqueConstraintSnapshotGenerator.setValidateOptionIfAvailable | validation | private void setValidateOptionIfAvailable(Database database, UniqueConstraint uniqueConstraint, Map<String, ?> columnsMetadata) {
if (!(database instanceof OracleDatabase)) {
return;
}
final Object constraintValidate = columnsMetadata.get("CONSTRAINT_VALIDATE");
final String VALIDATE = "VALIDATED";
if (constraintValidate!=null && !constraintValidate.toString().trim().isEmpty()) {
uniqueConstraint.setShouldValidate(VALIDATE.equals(cleanNameFromDatabase(constraintValidate.toString().trim(), database)));
}
} | java | {
"resource": ""
} |
q165648 | UniqueConstraintSnapshotGenerator.getUniqueConstraintsSqlInformix | validation | private String getUniqueConstraintsSqlInformix(InformixDatabase database, Schema schema, String name) {
StringBuffer sqlBuf = new StringBuffer();
sqlBuf.append("SELECT * FROM (\n");
// Yes, I am serious about this. It appears there are neither CTE/WITH clauses nor PIVOT/UNPIVOT operators
// in Informix SQL.
for (int i=1; i<=16; i++) {
if (i>1)
sqlBuf.append("UNION ALL\n");
sqlBuf.append(
String.format(" SELECT\n" +
" CONS.owner,\n" +
" CONS.constrname AS constraint_name,\n" +
" COL.colname AS column_name,\n" +
" CONS.constrtype,\n" +
" %d AS column_index\n" +
" FROM informix.sysconstraints CONS\n" +
" JOIN informix.sysindexes IDX ON CONS.idxname = IDX.idxname\n" +
" JOIN informix.syscolumns COL ON COL.tabid = CONS.tabid AND COL.colno = IDX.part%d\n",
i, i
)
);
}
// Finish the subquery and filter on the U(NIQUE) constraint type
sqlBuf.append(
" ) SUBQ\n" +
"WHERE constrtype='U' \n");
String catalogName = database.correctObjectName(schema.getCatalogName(), Catalog.class);
String constraintName = database.correctObjectName(name, UniqueConstraint.class);
// If possible, filter for catalog name and/or constraint name
if (catalogName != null) {
sqlBuf.append("AND owner='" + catalogName + "'\n");
}
if (constraintName != null) {
sqlBuf.append("AND constraint_name='" + constraintName + "'");
}
// For correct processing, it is important that we get all columns in order.
sqlBuf.append("ORDER BY owner, constraint_name, column_index");
// Return the query
return sqlBuf.toString();
} | java | {
"resource": ""
} |
q165649 | ChangeMetaData.getSetParameters | validation | public Map<String, ChangeParameterMetaData> getSetParameters(Change change) {
Map<String, ChangeParameterMetaData> returnMap = new HashMap<>();
for (Map.Entry<String, ChangeParameterMetaData> entry : getParameters().entrySet()) {
if (entry.getValue().getCurrentValue(change) != null) {
returnMap.put(entry.getKey(), entry.getValue());
}
}
return Collections.unmodifiableMap(returnMap);
} | java | {
"resource": ""
} |
q165650 | ChangeMetaData.getRequiredParameters | validation | public Map<String, ChangeParameterMetaData> getRequiredParameters(Database database) {
Map<String, ChangeParameterMetaData> returnMap = new HashMap<>();
for (ChangeParameterMetaData metaData : parameters.values()) {
if (metaData.isRequiredFor(database)) {
returnMap.put(metaData.getParameterName(), metaData);
}
}
return returnMap;
} | java | {
"resource": ""
} |
q165651 | InsertOrUpdateGeneratorInformix.convertToString | validation | private String convertToString(Object newValue, Database database) {
String sqlString;
if (newValue == null || newValue.toString().equals("") || newValue.toString().equalsIgnoreCase("NULL")) {
sqlString = "NULL::INTEGER";
} else if (newValue instanceof String && !looksLikeFunctionCall(((String) newValue), database)) {
sqlString = "'" + database.escapeStringForDatabase(newValue.toString()) + "'";
} else if (newValue instanceof Date) {
sqlString = database.getDateLiteral(((Date) newValue));
} else if (newValue instanceof Boolean) {
if (((Boolean) newValue)) {
sqlString = DataTypeFactory.getInstance().getTrueBooleanValue(database);
} else {
sqlString = DataTypeFactory.getInstance().getFalseBooleanValue(database);
}
} else {
sqlString = newValue.toString();
}
return sqlString;
} | java | {
"resource": ""
} |
q165652 | AbstractChange.getSerializableFields | validation | @Override
public Set<String> getSerializableFields() {
return Scope.getCurrentScope().getSingleton(ChangeFactory.class).getChangeMetaData(this).getParameters().keySet();
} | java | {
"resource": ""
} |
q165653 | FilenameUtils.doGetFullPath | validation | private static String doGetFullPath(String filename, boolean includeSeparator) {
if (filename == null) {
return null;
}
int prefix = getPrefixLength(filename);
if (prefix < 0) {
return null;
}
if (prefix >= filename.length()) {
if (includeSeparator) {
return getPrefix(filename); // add end slash if necessary
} else {
return filename;
}
}
int index = indexOfLastSeparator(filename);
if (index < 0) {
return filename.substring(0, prefix);
}
int end = index + (includeSeparator ? 1 : 0);
return filename.substring(0, end);
} | java | {
"resource": ""
} |
q165654 | HeaderColumnNameMappingStrategy.createIndexLookup | validation | protected void createIndexLookup(String[] values) {
if (indexLookup.isEmpty()) {
for (int i = 0; i < values.length; i++) {
indexLookup.put(values[i], i);
}
}
} | java | {
"resource": ""
} |
q165655 | HeaderColumnNameMappingStrategy.getColumnIndex | validation | @Override
public Integer getColumnIndex(String name) {
if (null == header) {
throw new IllegalStateException("The header row hasn't been read yet.");
}
createIndexLookup(header);
return indexLookup.get(name);
} | java | {
"resource": ""
} |
q165656 | HeaderColumnNameMappingStrategy.findDescriptor | validation | @Override
public PropertyDescriptor findDescriptor(int col) throws IntrospectionException {
String columnName = getColumnName(col);
return (StringUtil.trimToNull(columnName) != null) ? findDescriptor(columnName) : null;
} | java | {
"resource": ""
} |
q165657 | HeaderColumnNameMappingStrategy.findField | validation | @Override
public BeanField findField(int col) {
String columnName = getColumnName(col);
return (StringUtil.trimToNull(columnName) != null) ? findField(columnName) : null;
} | java | {
"resource": ""
} |
q165658 | HeaderColumnNameMappingStrategy.getColumnName | validation | public String getColumnName(int col) {
return ((null != header) && (col < header.length)) ? header[col] : null;
} | java | {
"resource": ""
} |
q165659 | HeaderColumnNameMappingStrategy.findDescriptor | validation | protected PropertyDescriptor findDescriptor(String name) throws IntrospectionException {
if (null == descriptorMap) {
descriptorMap = loadDescriptorMap(); //lazy load descriptors
}
return descriptorMap.get(name.toUpperCase().trim());
} | java | {
"resource": ""
} |
q165660 | HeaderColumnNameMappingStrategy.findField | validation | protected BeanField findField(String name) {
if (null == fieldMap) {
fieldMap = loadFieldMap(); //lazy load fields
}
return fieldMap.get(name.toUpperCase().trim());
} | java | {
"resource": ""
} |
q165661 | HeaderColumnNameMappingStrategy.matches | validation | protected boolean matches(String name, PropertyDescriptor desc) {
return desc.getName().equals(name.trim());
} | java | {
"resource": ""
} |
q165662 | HeaderColumnNameMappingStrategy.loadDescriptorMap | validation | protected Map<String, PropertyDescriptor> loadDescriptorMap() throws IntrospectionException {
Map<String, PropertyDescriptor> map = new HashMap<>();
PropertyDescriptor[] descriptors;
descriptors = loadDescriptors(getType());
for (PropertyDescriptor descriptor : descriptors) {
map.put(descriptor.getName().toUpperCase().trim(), descriptor);
}
return map;
} | java | {
"resource": ""
} |
q165663 | ColumnPositionMappingStrategy.getColumnName | validation | @Override
public String getColumnName(int col) {
return (col < columnMapping.length) ? columnMapping[col] : null;
} | java | {
"resource": ""
} |
q165664 | ColumnPositionMappingStrategy.setColumnMapping | validation | public void setColumnMapping(String... columnMapping) {
this.columnMapping = (columnMapping != null) ? columnMapping.clone() : new String[]{};
resetIndexMap();
createIndexLookup(this.columnMapping);
} | java | {
"resource": ""
} |
q165665 | CharType.getSize | validation | protected int getSize() {
if (getParameters().length == 0) {
return -1;
}
if (getParameters()[0] instanceof String) {
return Integer.parseInt((String) getParameters()[0]);
}
if (getParameters()[0] instanceof Number) {
return ((Number) getParameters()[0]).intValue();
}
return -1;
} | java | {
"resource": ""
} |
q165666 | HsqlDatabase.supportsDefaultValueComputed | validation | public static boolean supportsDefaultValueComputed(String columnType, String defaultValue) {
HashSet<String> possibleComputedValues = SUPPORTED_DEFAULT_VALUE_COMPUTED_MAP.get(columnType);
return (possibleComputedValues != null) && possibleComputedValues.contains(defaultValue.toLowerCase());
} | java | {
"resource": ""
} |
q165667 | StatusVisitor.getChangeSetsToRun | validation | public List<ChangeSetStatus> getChangeSetsToRun() {
ArrayList<ChangeSetStatus> returnList = new ArrayList<>();
for (ChangeSetStatus status : changeSetStatuses.values()) {
if (status.getWillRun()) {
returnList.add(status);
}
}
return returnList;
} | java | {
"resource": ""
} |
q165668 | PostgresDatabase.escapeObjectName | validation | @Override
public String escapeObjectName(String objectName, Class<? extends DatabaseObject> objectType) {
if ((quotingStrategy == ObjectQuotingStrategy.LEGACY) && hasMixedCase(objectName)) {
return "\"" + objectName + "\"";
} else if (objectType != null && LiquibaseColumn.class.isAssignableFrom(objectType)) {
return (objectName != null && !objectName.isEmpty()) ? objectName.trim() : objectName;
}
return super.escapeObjectName(objectName, objectType);
} | java | {
"resource": ""
} |
q165669 | ColumnConfig.setValueNumeric | validation | public ColumnConfig setValueNumeric(String valueNumeric) {
if ((valueNumeric == null) || "null".equalsIgnoreCase(valueNumeric)) {
this.valueNumeric = null;
} else {
String saved = valueNumeric;
if (valueNumeric.startsWith("(")) {
valueNumeric = valueNumeric.replaceFirst("^\\(", "");
valueNumeric = valueNumeric.replaceFirst("\\)$", "");
}
try {
this.valueNumeric = ValueNumeric.of(Locale.US, valueNumeric);
} catch (ParseException e) {
this.valueComputed = new DatabaseFunction(saved);
}
}
return this;
} | java | {
"resource": ""
} |
q165670 | ColumnConfig.setValueBoolean | validation | public ColumnConfig setValueBoolean(String valueBoolean) {
valueBoolean = StringUtil.trimToNull(valueBoolean);
if ((valueBoolean == null) || "null".equalsIgnoreCase(valueBoolean)) {
this.valueBoolean = null;
} else {
if ("true".equalsIgnoreCase(valueBoolean) || "1".equals(valueBoolean)) {
this.valueBoolean = true;
} else if ("false".equalsIgnoreCase(valueBoolean) || "0".equals(valueBoolean)) {
this.valueBoolean = false;
} else {
this.valueComputed = new DatabaseFunction(valueBoolean);
}
}
return this;
} | java | {
"resource": ""
} |
q165671 | ColumnConfig.setDefaultValueBoolean | validation | public ColumnConfig setDefaultValueBoolean(String defaultValueBoolean) {
defaultValueBoolean = StringUtil.trimToNull(defaultValueBoolean);
if ((defaultValueBoolean == null) || "null".equalsIgnoreCase(defaultValueBoolean)) {
this.defaultValueBoolean = null;
} else {
if ("true".equalsIgnoreCase(defaultValueBoolean) || "1".equals(defaultValueBoolean)) {
this.defaultValueBoolean = true;
} else if ("false".equalsIgnoreCase(defaultValueBoolean) || "0".equals(defaultValueBoolean)) {
this.defaultValueBoolean = false;
} else {
this.defaultValueComputed = new DatabaseFunction(defaultValueBoolean);
}
}
return this;
} | java | {
"resource": ""
} |
q165672 | ChangeFactory.unregister | validation | public void unregister(String name) {
for (Change change : new ArrayList<>(findAllInstances())) {
if (getChangeMetaData(change).getName().equals(name)) {
this.removeInstance(change);
}
}
} | java | {
"resource": ""
} |
q165673 | ChangeFactory.getDefinedChanges | validation | public SortedSet<String> getDefinedChanges() {
SortedSet<String> names = new TreeSet<>();
for (Change change : findAllInstances()) {
names.add(getChangeMetaData(change).getName());
}
return Collections.unmodifiableSortedSet(names);
} | java | {
"resource": ""
} |
q165674 | ChangeFactory.create | validation | public Change create(String name) {
Change plugin = getPlugin(name);
if (plugin == null) {
return null;
}
try {
return plugin.getClass().getConstructor().newInstance();
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
} | java | {
"resource": ""
} |
q165675 | SwingUIFacade.promptForNonLocalDatabase | validation | @Override
public boolean promptForNonLocalDatabase(Database database) throws DatabaseException {
return JOptionPane.showConfirmDialog(null, "You are running a database migration against a non-local database." + StreamUtil.getLineSeparator() +
"Database URL is: " + database.getConnection().getURL() + StreamUtil.getLineSeparator() +
"Username is: " + database.getConnection().getConnectionUserName() + StreamUtil.getLineSeparator() + StreamUtil.getLineSeparator() +
"Are you sure you want to do this?",
"Confirm", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE) == JOptionPane.NO_OPTION;
} | java | {
"resource": ""
} |
q165676 | AbstractJdbcDatabase.getConnectionSchemaName | validation | protected String getConnectionSchemaName() {
if (connection == null) {
return null;
}
if (connection instanceof OfflineConnection) {
return ((OfflineConnection) connection).getSchema();
}
try {
SqlStatement currentSchemaStatement = getConnectionSchemaNameCallStatement();
return ExecutorService.getInstance().getExecutor(this).
queryForObject(currentSchemaStatement, String.class);
} catch (Exception e) {
Scope.getCurrentScope().getLog(getClass()).info(LogType.LOG, "Error getting default schema", e);
}
return null;
} | java | {
"resource": ""
} |
q165677 | AbstractJdbcDatabase.isSafeToRunUpdate | validation | @Override
public boolean isSafeToRunUpdate() throws DatabaseException {
DatabaseConnection connection = getConnection();
if (connection == null) {
return true;
}
String url = connection.getURL();
if (url == null) {
return false;
}
return (url.contains("localhost")) || (url.contains("127.0.0.1"));
} | java | {
"resource": ""
} |
q165678 | AbstractJdbcDatabase.filterRollbackVisitors | validation | protected List<SqlVisitor> filterRollbackVisitors(final List<SqlVisitor> visitors) {
final List<SqlVisitor> rollbackVisitors = new ArrayList<>();
if (visitors != null) {
for (SqlVisitor visitor : visitors) {
if (visitor.isApplyToRollback()) {
rollbackVisitors.add(visitor);
}
}
}
return rollbackVisitors;
} | java | {
"resource": ""
} |
q165679 | AbstractJdbcDatabase.getMaxFractionalDigitsForTimestamp | validation | @Override
public int getMaxFractionalDigitsForTimestamp() {
if (getConnection() == null) {
// if no connection is there we cannot do anything...
Scope.getCurrentScope().getLog(getClass()).warning(
LogType.LOG, "No database connection available - specified"
+ " DATETIME/TIMESTAMP precision will be tried");
return DEFAULT_MAX_TIMESTAMP_FRACTIONAL_DIGITS;
}
return DEFAULT_MAX_TIMESTAMP_FRACTIONAL_DIGITS;
} | java | {
"resource": ""
} |
q165680 | XMLChangeLogSerializer.checkString | validation | protected String checkString(String text) throws UnexpectedLiquibaseException {
if (null == text || text.isEmpty()) {
return text;
}
final int len = text.length();
char current;
int codePoint;
for (int i = 0; i < len; i++) {
current = text.charAt(i);
if (Character.isHighSurrogate(current) && i + 1 < len && Character.isLowSurrogate(text.charAt(i + 1))) {
codePoint = text.codePointAt(i++);
} else {
codePoint = current;
}
if ((codePoint == '\n')
|| (codePoint == '\r')
|| (codePoint == '\t')
|| (codePoint == 0xB)
|| (codePoint == 0xC)
|| ((codePoint >= 0x20) && (codePoint <= 0x7E))
|| ((codePoint >= 0xA0) && (codePoint <= 0xD7FF))
|| ((codePoint >= 0xE000) && (codePoint <= 0xFFFD))
|| ((codePoint >= 0x10000) && (codePoint <= 0x10FFFF))
) {
//ok
} else {
throw new UnexpectedLiquibaseException(INVALID_STRING_ENCODING_MESSAGE);
}
}
return text;
} | java | {
"resource": ""
} |
q165681 | XMLChangeLogSerializer.createNode | validation | public Element createNode(String nodeNamespace, String nodeName, String nodeContent) {
Element element = currentChangeLogFileDOM.createElementNS(nodeNamespace, nodeName);
element.setTextContent(nodeContent);
return element;
} | java | {
"resource": ""
} |
q165682 | Validate.notNull | validation | public static void notNull(Object object, String failMessage) throws UnexpectedLiquibaseException {
if (object == null) {
fail(failMessage);
}
} | java | {
"resource": ""
} |
q165683 | SybaseDatabase.isSybaseProductName | validation | boolean isSybaseProductName(String dbProductName) {
return
PRODUCT_NAME.equals(dbProductName)
|| "Sybase SQL Server".equals(dbProductName)
|| "sql server".equals(dbProductName)
|| "ASE".equals(dbProductName);
} | java | {
"resource": ""
} |
q165684 | SqlVisitorFactory.create | validation | public SqlVisitor create(String tagName) {
Class<?> aClass = tagToClassMap.get(tagName);
if (aClass == null) {
return null;
}
try {
return (SqlVisitor) aClass.getConstructor().newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
} | java | {
"resource": ""
} |
q165685 | NetUtil.getLocalHostAddress | validation | public static String getLocalHostAddress() throws UnknownHostException, SocketException {
try {
return getLocalHost().getHostAddress();
} catch (Exception e) {
Scope.getCurrentScope().getLog(NetUtil.class).fine(LogType.LOG, "Error getting hostname", e);
return "unknown";
}
} | java | {
"resource": ""
} |
q165686 | NetUtil.getLocalHostName | validation | public static String getLocalHostName() throws UnknownHostException, SocketException {
try {
return getLocalHost().getHostName();
} catch (Exception e) {
Scope.getCurrentScope().getLog(NetUtil.class).fine(LogType.LOG, "Error getting hostname", e);
return "unknown";
}
} | java | {
"resource": ""
} |
q165687 | CreateProcedureGenerator.surroundWithSchemaSets | validation | public static void surroundWithSchemaSets(List<Sql> sql, String schemaName, Database database) {
if ((StringUtil.trimToNull(schemaName) != null) && !LiquibaseConfiguration.getInstance().getProperty(ChangeLogParserCofiguration.class, ChangeLogParserCofiguration.USE_PROCEDURE_SCHEMA).getValue(Boolean.class)) {
String defaultSchema = database.getDefaultSchemaName();
if (database instanceof OracleDatabase) {
sql.add(0, new UnparsedSql("ALTER SESSION SET CURRENT_SCHEMA=" + database.escapeObjectName(schemaName, Schema.class)));
sql.add(new UnparsedSql("ALTER SESSION SET CURRENT_SCHEMA=" + database.escapeObjectName(defaultSchema, Schema.class)));
} else if (database instanceof AbstractDb2Database) {
sql.add(0, new UnparsedSql("SET CURRENT SCHEMA " + schemaName));
sql.add(new UnparsedSql("SET CURRENT SCHEMA " + defaultSchema));
}
}
} | java | {
"resource": ""
} |
q165688 | CreateProcedureGenerator.addSchemaToText | validation | public static String addSchemaToText(String procedureText, String schemaName, String keywordBeforeName, Database database) {
if (schemaName == null) {
return procedureText;
}
if ((StringUtil.trimToNull(schemaName) != null) && LiquibaseConfiguration.getInstance().getProperty(ChangeLogParserCofiguration.class, ChangeLogParserCofiguration.USE_PROCEDURE_SCHEMA).getValue(Boolean.class)) {
StringClauses parsedSql = SqlParser.parse(procedureText, true, true);
StringClauses.ClauseIterator clauseIterator = parsedSql.getClauseIterator();
Object next = "START";
while ((next != null) && !next.toString().equalsIgnoreCase(keywordBeforeName) && clauseIterator.hasNext()) {
if (!"PACKAGE".equalsIgnoreCase(keywordBeforeName) && "PACKAGE".equalsIgnoreCase((String) next)) {
return procedureText;
}
next = clauseIterator.nextNonWhitespace();
}
if ((next != null) && clauseIterator.hasNext()) {
Object procNameClause = clauseIterator.nextNonWhitespace();
if (procNameClause instanceof String) {
String[] nameParts = ((String) procNameClause).split("\\.");
String finalName;
if (nameParts.length == 1) {
finalName = database.escapeObjectName(schemaName, Schema.class) + "." + nameParts[0];
} else if (nameParts.length == 2) {
finalName = database.escapeObjectName(schemaName, Schema.class) + "." + nameParts[1];
} else if (nameParts.length == 3) {
finalName = nameParts[0] + "." + database.escapeObjectName(schemaName, Schema.class) + "." + nameParts[2];
} else {
finalName = (String) procNameClause; //just go with what was there
}
clauseIterator.replace(finalName);
}
procedureText = parsedSql.toString();
}
}
return procedureText;
} | java | {
"resource": ""
} |
q165689 | MD5Util.encodeHex | validation | private static char[] encodeHex(byte[] data) {
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;
} | java | {
"resource": ""
} |
q165690 | SchemaSnapshotGenerator.getDatabaseSchemaNames | validation | protected String[] getDatabaseSchemaNames(Database database) throws SQLException, DatabaseException {
List<String> returnList = new ArrayList<>();
ResultSet schemas = null;
try {
schemas = ((JdbcConnection) database.getConnection()).getMetaData().getSchemas();
while (schemas.next()) {
returnList.add(JdbcUtils.getValueForColumn(schemas, "TABLE_SCHEM", database));
}
} finally {
if (schemas != null) {
schemas.close();
}
}
return returnList.toArray(new String[returnList.size()]);
} | java | {
"resource": ""
} |
q165691 | CSVReader.readNext | validation | public String[] readNext() throws IOException {
String[] result = null;
do {
String nextLine = getNextLine();
if (!hasNext) {
return validateResult(result);
}
String[] r = parser.parseLineMulti(nextLine);
if (r.length > 0) {
if (result == null) {
result = r;
} else {
result = combineResultsFromMultipleReads(result, r);
}
}
} while (parser.isPending());
return validateResult(result);
} | java | {
"resource": ""
} |
q165692 | CSVReader.getNextLine | validation | protected String getNextLine() throws IOException {
if (isClosed()) {
hasNext = false;
return null;
}
if (!this.linesSkiped) {
for (int i = 0; i < skipLines; i++) {
lineReader.readLine();
linesRead++;
}
this.linesSkiped = true;
}
String nextLine = lineReader.readLine();
if (nextLine == null) {
hasNext = false;
} else {
linesRead++;
}
return hasNext ? nextLine : null;
} | java | {
"resource": ""
} |
q165693 | CSVReader.isClosed | validation | private boolean isClosed() {
if (!verifyReader) {
return false;
}
try {
br.mark(READ_AHEAD_LIMIT);
int nextByte = br.read();
br.reset(); // resets stream position, possible because its buffered
return nextByte == -1; // read() returns -1 at end of stream
} catch (IOException e) {
return true;
}
} | java | {
"resource": ""
} |
q165694 | DynamicConfiguration.startPolling | validation | public synchronized void startPolling(PolledConfigurationSource source, AbstractPollingScheduler scheduler) {
this.scheduler = scheduler;
this.source = source;
init(source, scheduler);
scheduler.startPolling(source, this);
} | java | {
"resource": ""
} |
q165695 | ZooKeeperConfigurationSource.start | validation | public void start() throws Exception {
// create the watcher for future configuration updatess
pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
public void childEvent(CuratorFramework aClient, PathChildrenCacheEvent event)
throws Exception {
Type eventType = event.getType();
ChildData data = event.getData();
String path = null;
if (data != null) {
path = data.getPath();
// scrub configRootPath out of the key name
String key = removeRootPath(path);
byte[] value = data.getData();
String stringValue = new String(value, charset);
logger.debug("received update to pathName [{}], eventType [{}]", path, eventType);
logger.debug("key [{}], and value [{}]", key, stringValue);
// fire event to all listeners
Map<String, Object> added = null;
Map<String, Object> changed = null;
Map<String, Object> deleted = null;
if (eventType == Type.CHILD_ADDED) {
added = new HashMap<String, Object>(1);
added.put(key, stringValue);
} else if (eventType == Type.CHILD_UPDATED) {
changed = new HashMap<String, Object>(1);
changed.put(key, stringValue);
} else if (eventType == Type.CHILD_REMOVED) {
deleted = new HashMap<String, Object>(1);
deleted.put(key, stringValue);
}
WatchedUpdateResult result = WatchedUpdateResult.createIncremental(added,
changed, deleted);
fireEvent(result);
}
}
});
// passing true to trigger an initial rebuild upon starting. (blocking call)
pathChildrenCache.start(true);
} | java | {
"resource": ""
} |
q165696 | WebApplicationProperties.setAppConfFolder | validation | public static void setAppConfFolder(File appConfFolderFromConfig, String baseConfigFileName) {
WebApplicationProperties.appConfFolder = appConfFolderFromConfig;
WebApplicationProperties.baseConfigFileName = baseConfigFileName;
} | java | {
"resource": ""
} |
q165697 | DynamicPropertyFactory.getIntProperty | validation | public DynamicIntProperty getIntProperty(String propName, int defaultValue, final Runnable propertyChangeCallback) {
checkAndWarn(propName);
DynamicIntProperty property = new DynamicIntProperty(propName, defaultValue);
addCallback(propertyChangeCallback, property);
return property;
} | java | {
"resource": ""
} |
q165698 | DynamicPropertyFactory.getLongProperty | validation | public DynamicLongProperty getLongProperty(String propName, long defaultValue, final Runnable propertyChangeCallback) {
checkAndWarn(propName);
DynamicLongProperty property = new DynamicLongProperty(propName, defaultValue);
addCallback(propertyChangeCallback, property);
return property;
} | java | {
"resource": ""
} |
q165699 | DynamicPropertyFactory.getBooleanProperty | validation | public DynamicBooleanProperty getBooleanProperty(String propName, boolean defaultValue, final Runnable propertyChangeCallback) {
checkAndWarn(propName);
DynamicBooleanProperty property = new DynamicBooleanProperty(propName, defaultValue);
addCallback(propertyChangeCallback, property);
return property;
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.