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/sdk/resource/MockResourceAccessor.java
|
MockResourceAccessor
|
search
|
class MockResourceAccessor extends AbstractResourceAccessor {
private final SortedMap<String, String> contentByFileName;
public MockResourceAccessor() {
this(new HashMap<>());
}
public MockResourceAccessor(Map<String, String> contentByFileName) {
this.contentByFileName = new TreeMap<>(contentByFileName);
}
@Override
public void close() throws Exception {
}
@Override
public List<Resource> getAll(String path) throws IOException {
path = path.replace("\\", "/");
String content = contentByFileName.get(path);
List<Resource> returnSet = new ArrayList<>();
if (content != null) {
returnSet.add(new MockResource(path, content));
}
if (returnSet.isEmpty()) {
return null;
}
return returnSet;
}
@Override
public List<Resource> search(String path, boolean recursive) throws IOException {<FILL_FUNCTION_BODY>}
@Override
public List<String> describeLocations() {
return Collections.singletonList("MockResouceAccessor.java");
}
public void setContent(String fileName, String content) {
this.contentByFileName.put(fileName, content);
}
}
|
path = path.replace("\\", "/");
List<Resource> returnList = new ArrayList<>();
for (String file : contentByFileName.keySet()) {
if (file.startsWith(path)) {
if (!recursive && file.split("/").length > 2) {
continue;
}
returnList.add(new MockResource(file, contentByFileName.get(file)));
}
}
return returnList;
| 335
| 114
| 449
|
<methods>public non-sealed void <init>() <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sdk/supplier/resource/ResourceSupplier.java
|
SimpleResourceAccessor
|
getAll
|
class SimpleResourceAccessor extends AbstractResourceAccessor{
@Override
public void close() throws Exception {
}
@Override
public List<Resource> getAll(String path) throws IOException {<FILL_FUNCTION_BODY>}
@Override
public List<Resource> search(String path, SearchOptions searchOptions) throws IOException {
return null;
}
@Override
public List<Resource> search(String path, boolean recursive) throws IOException {
return null;
}
@Override
public List<String> describeLocations() {
return Collections.singletonList("Logic in ResourceSupplier.java");
}
}
|
Resource resource;
if (path.toLowerCase().endsWith("csv")) {
resource = new MockResource(path, USERS_CSV);
} else if (path.toLowerCase().endsWith("my-logic.sql")) {
resource = new MockResource(path, (String) Scope.getCurrentScope().getSingleton(ChangeFactory.class).getChangeMetaData(
new CreateProcedureChange()).getParameters().get("procedureBody").getExampleValue(
new HsqlDatabase()));
} else if (path.toLowerCase().endsWith("sql")) {
resource = new MockResource(path, EXAMPLE_SQL_COMMAND);
} else {
throw new RuntimeException("Unknown resource type: "+ path);
}
return Collections.singletonList(resource);
| 170
| 197
| 367
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/serializer/ChangeLogSerializerFactory.java
|
ChangeLogSerializerFactory
|
getSerializer
|
class ChangeLogSerializerFactory {
private static ChangeLogSerializerFactory instance;
private final Map<String, List<ChangeLogSerializer>> serializers = new ConcurrentHashMap<>();
public static synchronized void reset() {
instance = new ChangeLogSerializerFactory();
}
public static synchronized ChangeLogSerializerFactory getInstance() {
if (instance == null) {
instance = new ChangeLogSerializerFactory();
}
return instance;
}
private ChangeLogSerializerFactory() {
try {
for (ChangeLogSerializer serializer : Scope.getCurrentScope().getServiceLocator().findInstances(ChangeLogSerializer.class)) {
register(serializer);
}
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
}
public List<ChangeLogSerializer> getSerializers(String fileNameOrExtension) {
fileNameOrExtension = fileNameOrExtension.replaceAll(".*\\.", ""); //just need the extension
List<ChangeLogSerializer> changeLogSerializers = serializers.get(fileNameOrExtension);
if (changeLogSerializers == null) {
return Collections.emptyList();
}
return changeLogSerializers;
}
public ChangeLogSerializer getSerializer(String fileNameOrExtension) {<FILL_FUNCTION_BODY>}
public void register(ChangeLogSerializer changeLogSerializer) {
for (String extension : changeLogSerializer.getValidFileExtensions()) {
List<ChangeLogSerializer> changeLogSerializers = serializers.computeIfAbsent(extension, k -> new ArrayList<>());
changeLogSerializers.add(changeLogSerializer);
changeLogSerializers.sort(PrioritizedService.COMPARATOR);
}
}
public void unregister(ChangeLogSerializer changeLogSerializer) {
for (Iterator<Map.Entry<String, List<ChangeLogSerializer>>> entryIterator = serializers.entrySet().iterator(); entryIterator.hasNext();) {
Map.Entry<String, List<ChangeLogSerializer>> entry = entryIterator.next();
List<ChangeLogSerializer> changeLogSerializers = entry.getValue();
changeLogSerializers.removeIf(value -> value.equals(changeLogSerializer));
if (changeLogSerializers.isEmpty()) {
entryIterator.remove();
}
}
}
}
|
List<ChangeLogSerializer> changeLogSerializers = getSerializers(fileNameOrExtension);
if (changeLogSerializers.isEmpty()) {
throw new RuntimeException("No serializers associated with the filename or extension '" + fileNameOrExtension + "'");
}
return changeLogSerializers.get(0);
| 574
| 77
| 651
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/serializer/ReflectionSerializer.java
|
ReflectionSerializer
|
getValue
|
class ReflectionSerializer {
private static final ReflectionSerializer instance = new ReflectionSerializer();
public static ReflectionSerializer getInstance() {
return instance;
}
private final Map<Class, Map<String, Field>> reflectionCache = new ConcurrentHashMap<>();
private ReflectionSerializer() {
}
public Set<String> getFields(Object object) {
if (!reflectionCache.containsKey(object.getClass())) {
Map<String, Field> fields = new HashMap<>();
Set<Field> allFields = new HashSet<>();
Class<?> classToExtractFieldsFrom = object.getClass();
while (!classToExtractFieldsFrom.equals(Object.class)) {
allFields.addAll(Arrays.asList(classToExtractFieldsFrom.getDeclaredFields()));
classToExtractFieldsFrom = classToExtractFieldsFrom.getSuperclass();
}
for (Field field : allFields) {
if ("serialVersionUID".equals(field.getName()) || "serializableFields".equals(field.getName())) {
continue;
}
if (field.isSynthetic() || "$VRc".equals(field.getName())) { //from emma
continue;
}
fields.put(field.getName(), field);
field.setAccessible(true);
}
reflectionCache.put(object.getClass(), fields);
}
return reflectionCache.get(object.getClass()).keySet();
}
private Field findField(Object object, String field) {
Field foundField = null;
Class<?> classToCheck = object.getClass();
while ((foundField == null) && !classToCheck.equals(Object.class)) {
try {
foundField = classToCheck.getDeclaredField(field);
} catch (NoSuchFieldException e) {
classToCheck = classToCheck.getSuperclass();
}
}
if (foundField == null) {
throw new UnexpectedLiquibaseException("No field " + field + " on " + object.getClass());
}
return foundField;
}
public Object getValue(Object object, String field) {<FILL_FUNCTION_BODY>}
public void setValue(Object object, String field, Object value) {
try {
Field foundField = findField(object, field);
foundField.setAccessible(true);
foundField.set(object, value);
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
}
public Class getDataTypeClass(Object object, String field) {
try {
Field foundField = findField(object, field);
Type dataType = foundField.getGenericType();
if (dataType instanceof Class) {
return (Class) dataType;
}
if (dataType instanceof ParameterizedType) {
return (Class) ((ParameterizedType) dataType).getRawType();
}
return Object.class;
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
}
public Type[] getDataTypeClassParameters(Object object, String field) {
try {
Field foundField = findField(object, field);
Type dataType = foundField.getGenericType();
if (dataType instanceof ParameterizedType) {
return ((ParameterizedType) dataType).getActualTypeArguments();
}
return new Type[0];
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
}
}
|
if (!reflectionCache.containsKey(object.getClass())) {
getFields(object); //fills cache
}
Map<String, Field> fieldsByName = reflectionCache.get(object.getClass());
Field foundField = fieldsByName.get(field);
try {
if (foundField == null) {
foundField = findField(object, field);
foundField.setAccessible(true);
fieldsByName.put(field, foundField);
}
return foundField.get(object);
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
| 912
| 164
| 1,076
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/serializer/SnapshotSerializerFactory.java
|
SnapshotSerializerFactory
|
getSerializer
|
class SnapshotSerializerFactory {
private static SnapshotSerializerFactory instance;
private final Map<String, List<SnapshotSerializer>> serializers = new ConcurrentHashMap<>();
public static synchronized void reset() {
instance = new SnapshotSerializerFactory();
}
public static synchronized SnapshotSerializerFactory getInstance() {
if (instance == null) {
instance = new SnapshotSerializerFactory();
}
return instance;
}
private SnapshotSerializerFactory() {
try {
for (SnapshotSerializer serializer : Scope.getCurrentScope().getServiceLocator().findInstances(SnapshotSerializer.class)) {
register(serializer);
}
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
}
public Map<String, List<SnapshotSerializer>> getSerializers() {
return serializers;
}
public List<SnapshotSerializer> getSerializers(String fileNameOrExtension) {
fileNameOrExtension = fileNameOrExtension.replaceAll(".*\\.", ""); //just need the extension
List<SnapshotSerializer> snapshotSerializers = serializers.get(fileNameOrExtension);
if (snapshotSerializers == null) {
return Collections.emptyList();
}
return snapshotSerializers;
}
public SnapshotSerializer getSerializer(String fileNameOrExtension) {<FILL_FUNCTION_BODY>}
public void register(SnapshotSerializer snapshotSerializer) {
for (String extension : snapshotSerializer.getValidFileExtensions()) {
List<SnapshotSerializer> snapshotSerializers = serializers.computeIfAbsent(extension, k -> new ArrayList<>());
snapshotSerializers.add(snapshotSerializer);
snapshotSerializers.sort(PrioritizedService.COMPARATOR);
}
}
public void unregister(SnapshotSerializer snapshotSerializer) {
for (Iterator<Map.Entry<String, List<SnapshotSerializer>>> entryIterator = serializers.entrySet().iterator(); entryIterator.hasNext();) {
Map.Entry<String, List<SnapshotSerializer>> entry = entryIterator.next();
List<SnapshotSerializer> snapshotSerializers = entry.getValue();
snapshotSerializers.removeIf(value -> value.equals(snapshotSerializer));
if (snapshotSerializers.isEmpty()) {
entryIterator.remove();
}
}
}
}
|
List<SnapshotSerializer> snapshotSerializers = getSerializers(fileNameOrExtension);
if (snapshotSerializers.isEmpty()) {
throw new RuntimeException("No serializers associated with the filename or extension '" + fileNameOrExtension + "'");
}
return snapshotSerializers.get(0);
| 580
| 74
| 654
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/serializer/core/formattedsql/FormattedSqlChangeLogSerializer.java
|
FormattedSqlChangeLogSerializer
|
getTargetDatabase
|
class FormattedSqlChangeLogSerializer implements ChangeLogSerializer {
private static final String SQL_FILE_NAME_REGEX = ".*\\.(\\w+)\\.sql";
private static final Pattern SQL_FILE_NAME_PATTERN = Pattern.compile(SQL_FILE_NAME_REGEX);
@Override
public String[] getValidFileExtensions() {
return new String[] {
"sql"
};
}
@Override
public String serialize(LiquibaseSerializable object, boolean pretty) {
if (object instanceof ChangeSet) {
//
// If there is a Database object in the current scope, then use it for serialization
//
ChangeSet changeSet = (ChangeSet) object;
Database database = Scope.getCurrentScope().get(DiffToChangeLog.DIFF_SNAPSHOT_DATABASE, Database.class);
if (database == null) {
database = getTargetDatabase(changeSet);
}
StringBuilder builder = new StringBuilder();
createChangeSetInfo(changeSet, builder);
for (Change change : changeSet.getChanges()) {
Sql[] sqls = SqlGeneratorFactory.getInstance().generateSql(change.generateStatements(database), database);
if (sqls != null) {
for (Sql sql : sqls) {
builder.append(sql.toSql().endsWith(sql.getEndDelimiter()) ? sql.toSql() : sql.toSql() + sql.getEndDelimiter()).append("\n");
}
}
}
return builder.toString();
} else {
throw new UnexpectedLiquibaseException("Cannot serialize object type: "+object.getClass().getName());
}
}
/**
*
* Create the changeSet header information and add it to the StringBuilder
*
* @param changeSet The ChangeSet we are emitting
* @param builder The current StringBuilder we will add to
*
*/
public void createChangeSetInfo(ChangeSet changeSet, StringBuilder builder) {
String author = (changeSet.getAuthor()).replaceAll("\\s+", "_");
author = author.replace("_(generated)", "");
builder.append("-- changeset ").append(author).append(":").append(changeSet.getId());
Labels labels = changeSet.getLabels();
if (labels != null && ! labels.isEmpty()) {
String outputLabels = labels.toString();
builder.append(" labels: \"");
builder.append(outputLabels);
builder.append("\"");
}
ContextExpression contexts = changeSet.getContextFilter();
if (contexts != null && ! contexts.isEmpty()) {
String outputContexts = contexts.toString();
builder.append(" contextFilter: \"");
builder.append(outputContexts);
builder.append("\"");
}
builder.append("\n");
}
protected Database getTargetDatabase(ChangeSet changeSet) {<FILL_FUNCTION_BODY>}
@Override
public <T extends ChangeLogChild> void write(List<T> children, OutputStream out) throws IOException {
StringBuilder builder = new StringBuilder();
builder.append("-- liquibase formatted sql\n\n");
for (T child : children) {
builder.append(serialize(child, true));
builder.append("\n");
}
out.write(builder.toString().getBytes(GlobalConfiguration.OUTPUT_FILE_ENCODING.getCurrentValue()));
}
@Override
public void append(ChangeSet changeSet, File changeLogFile) throws IOException {
}
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
}
|
String filePath = changeSet.getFilePath();
if (filePath == null) {
throw new UnexpectedLiquibaseException("You must specify the changelog file name as filename.DB_TYPE.sql. Example: changelog.mysql.sql");
}
Matcher matcher = SQL_FILE_NAME_PATTERN.matcher(filePath);
if (!matcher.matches()) {
throw new UnexpectedLiquibaseException("Serializing changelog as sql requires a file name in the format *.databaseType.sql. Example: changelog.h2.sql. Passed: "+filePath);
}
String shortName = matcher.replaceFirst("$1");
Database database = DatabaseFactory.getInstance().getDatabase(shortName);
if (database == null) {
List<Database> databases = DatabaseFactory.getInstance().getImplementedDatabases();
StringBuilder availableDbs = new StringBuilder();
availableDbs.append("Available database short names for serialization:\n");
for (Database db : databases) {
availableDbs.append(" ").append(db.getShortName()).append("\n");
}
throw new UnexpectedLiquibaseException("Serializing changelog as sql requires a file name in the format *.databaseType.sql. Example: changelog.h2.sql. Unknown database type: "+shortName +"\n" + availableDbs);
}
return database;
| 936
| 360
| 1,296
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/serializer/core/json/JsonChangeLogSerializer.java
|
JsonChangeLogSerializer
|
write
|
class JsonChangeLogSerializer extends YamlChangeLogSerializer {
@Override
public <T extends ChangeLogChild> void write(List<T> children, OutputStream out) throws IOException {<FILL_FUNCTION_BODY>}
@Override
public String[] getValidFileExtensions() {
return new String[]{
"json"
};
}
}
|
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out, GlobalConfiguration.OUTPUT_FILE_ENCODING.getCurrentValue()));
writer.write("{ \"databaseChangeLog\": [\n");
int i = 0;
for (T child : children) {
String serialized = serialize(child, true);
if (++i < children.size()) {
serialized = serialized.replaceFirst("}\\s*$", "},\n");
}
writer.write(StringUtil.indent(serialized, 2));
writer.write("\n");
}
writer.write("]}");
writer.flush();
| 93
| 162
| 255
|
<methods>public non-sealed void <init>() ,public void append(liquibase.changelog.ChangeSet, java.io.File) throws java.io.IOException,public int getPriority() ,public void write(List<T>, java.io.OutputStream) throws java.io.IOException<variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/serializer/core/string/StringChangeLogSerializer.java
|
StringChangeLogSerializer
|
serializeObject
|
class StringChangeLogSerializer implements ChangeLogSerializer {
private static final int INDENT_LENGTH = 4;
private final FieldFilter fieldFilter;
public StringChangeLogSerializer() {
this(new FieldFilter());
}
public StringChangeLogSerializer(FieldFilter fieldFilter) {
this.fieldFilter = fieldFilter;
}
@Override
public String[] getValidFileExtensions() {
return new String[]{"txt"};
}
@Override
public String serialize(LiquibaseSerializable object, boolean pretty) {
return object.getSerializedObjectName() + ":" + serializeObject(object, 1);
}
private String serializeObject(LiquibaseSerializable objectToSerialize, int indent) {<FILL_FUNCTION_BODY>}
private String indent(int indent) {
return StringUtil.repeat(" ", INDENT_LENGTH * indent);
}
private String serializeObject(Object[] collection, int indent) {
if (collection.length == 0) {
return "[]";
}
StringBuilder returnString = new StringBuilder("[\n");
for (Object object : collection) {
if (object instanceof LiquibaseSerializable) {
returnString.append(indent(indent)).append(serializeObject((LiquibaseSerializable) object, indent + 1)).append(",\n");
} else {
returnString.append(indent(indent)).append(object.toString()).append(",\n");
}
}
returnString = new StringBuilder(returnString.toString().replaceFirst(",$", ""));
returnString.append(indent(indent - 1)).append("]");
return returnString.toString();
}
private String serializeObject(Collection collection, int indent) {
if (collection.isEmpty()) {
return "[]";
}
StringBuilder returnString = new StringBuilder("[\n");
for (Object object : collection) {
if (object instanceof LiquibaseSerializable) {
returnString.append(indent(indent)).append(serializeObject((LiquibaseSerializable) object, indent + 1)).append(",\n");
} else {
returnString.append(indent(indent)).append(object.toString()).append(",\n");
}
}
returnString = new StringBuilder(returnString.toString().replaceFirst(",$", ""));
returnString.append(indent(indent - 1)).append("]");
return returnString.toString();
}
private String serializeObject(Map collection, int indent) {
if (collection.isEmpty()) {
return "[]";
}
StringBuilder returnString = new StringBuilder("{\n");
for (Object key : new TreeSet(collection.keySet())) {
returnString
.append(indent(indent))
.append(key.toString())
.append("=\"")
.append(collection.get(key))
.append("\",\n");
}
return String.format("%s%s}",
returnString.toString().replaceFirst(",$", ""),
indent(indent - 1)
);
}
@Override
public <T extends ChangeLogChild> void write(List<T> children, OutputStream out) throws IOException {
}
@Override
public void append(ChangeSet changeSet, File changeLogFile) throws IOException {
}
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
public static class FieldFilter {
public boolean include(Object obj, String field, Object value) {
return true;
}
}
}
|
try {
StringBuilder buffer = new StringBuilder();
buffer.append("[");
SortedSet<String> values = new TreeSet<>();
for (String field : objectToSerialize.getSerializableFields()) {
Object value = objectToSerialize.getSerializableFieldValue(field);
if (value == null) {
continue;
}
if (!fieldFilter.include(objectToSerialize, field, value)) {
continue;
}
if (value instanceof LiquibaseSerializable) {
values.add(indent(indent) + serializeObject((LiquibaseSerializable) value, indent + 1));
} else {
if (value instanceof Map) {
values.add(indent(indent) + field + "=" + serializeObject((Map) value, indent + 1));
} else if (value instanceof Collection) {
values.add(indent(indent) + field + "=" + serializeObject((Collection) value, indent + 1));
} else if (value instanceof Object[]) {
values.add(indent(indent) + field + "=" + serializeObject((Object[]) value, indent + 1));
} else {
String valueString = value.toString();
if ((value instanceof Double) || (value instanceof Float)) { //java 6 adds additional zeros to the end of doubles and floats
if (valueString.contains(".")) {
valueString = valueString.replaceFirst("(\\.[0-9]+)0+$","$1");
valueString = valueString.replaceFirst("\\.0+$", "");
}
}
values.add(indent(indent) + field + "=\"" + valueString + "\"");
}
}
}
if (!values.isEmpty()) {
buffer.append("\n");
buffer.append(StringUtil.join(values, "\n"));
buffer.append("\n");
}
buffer.append(indent(indent - 1)).append("]");
return buffer.toString().replace("\r\n", "\n").replace("\r", "\n"); //standardize all newline chars
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
| 928
| 555
| 1,483
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/serializer/core/string/StringSnapshotSerializer.java
|
StringSnapshotSerializer
|
serializeObject
|
class StringSnapshotSerializer implements SnapshotSerializer {
private static final int INDENT_LENGTH = 4;
@Override
public String[] getValidFileExtensions() {
return new String[]{"checksum"};
}
@Override
public String serialize(LiquibaseSerializable object, boolean pretty) {
return object.getSerializedObjectName() + ":" + serializeObject(object, 1);
}
private String serializeObject(Object object, int indent) {
return object instanceof LiquibaseSerializable
? serializeObject((LiquibaseSerializable) object, indent)
: object.toString();
}
private String serializeObject(LiquibaseSerializable objectToSerialize, int indent) {<FILL_FUNCTION_BODY>}
private String indent(int indent) {
return StringUtil.repeat(" ", INDENT_LENGTH * indent);
}
private String serializeObject(Object[] collection, int indent) {
if (collection.length == 0) {
return "[]";
}
StringBuilder returnString = new StringBuilder("[\n");
for (Object object : collection) {
returnString
.append(indent(indent))
.append(serializeObject(object, indent + 1))
.append(",\n");
}
String result = returnString.toString().replaceFirst(",$", "");
return result + indent(indent - 1) + "]";
}
private String serializeObject(Collection collection, int indent) {
if (collection.isEmpty()) {
return "[]";
}
StringBuilder returnString = new StringBuilder("[\n");
for (Object object : collection) {
returnString.append(indent(indent));
returnString.append(serializeObject(object, indent + 1));
returnString.append(",\n");
}
String result = returnString.toString().replaceFirst(",$", "");
return result + indent(indent - 1) + "]";
}
private String serializeObject(Map collection, int indent) {
if (collection.isEmpty()) {
return "[]";
}
StringBuilder returnString = new StringBuilder("{\n");
TreeSet sortedCollection = new TreeSet((o1, o2) -> {
if (o1 instanceof Comparable) {
return ((Comparable) o1).compareTo(o2);
} else if (o1 instanceof Class) {
return ((Class<?>) o1).getName().compareTo(((Class<?>) o2).getName());
} else {
throw new ClassCastException(o1.getClass().getName()+" cannot be cast to java.lang.Comparable or java.lang.Class");
}
});
sortedCollection.addAll(collection.keySet());
for (Object key : sortedCollection) {
returnString
.append(indent(indent))
.append(key.toString())
.append("=\"")
.append(collection.get(key))
.append("\",\n");
}
String result = returnString.toString().replaceFirst(",$", "");
return result + indent(indent - 1) + "}";
}
@Override
public void write(DatabaseSnapshot snapshot, OutputStream out) throws IOException {
out.write(serialize(snapshot, true).getBytes(GlobalConfiguration.OUTPUT_FILE_ENCODING.getCurrentValue()));
}
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
}
|
try {
StringBuilder buffer = new StringBuilder();
buffer.append("[");
SortedSet<String> values = new TreeSet<>();
for (String field : objectToSerialize.getSerializableFields()) {
Object value = objectToSerialize.getSerializableFieldValue(field);
if (value instanceof LiquibaseSerializable) {
values.add(indent(indent) + serializeObject((LiquibaseSerializable) value, indent + 1));
} else {
if (value != null) {
if (value instanceof Map) {
values.add(indent(indent) + field + "=" + serializeObject((Map) value, indent + 1));
} else if (value instanceof Collection) {
values.add(indent(indent) + field + "=" + serializeObject((Collection) value, indent + 1));
} else if (value instanceof Object[]) {
values.add(indent(indent) + field + "=" + serializeObject((Object[]) value, indent + 1));
} else {
String valueString = value.toString();
if ((value instanceof Double) || (value instanceof Float)) { //java 6 adds additional zeros to the end of doubles and floats
if (valueString.contains(".")) {
valueString = valueString.replaceFirst("0*$","");
}
}
values.add(indent(indent) + field + "=\"" + valueString + "\"");
}
}
}
}
if (!values.isEmpty()) {
buffer.append("\n");
buffer.append(StringUtil.join(values, "\n"));
buffer.append("\n");
}
buffer.append(indent(indent - 1)).append("]");
return buffer.toString().replace("\r\n", "\n").replace("\r", "\n"); //standardize all newline chars
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
| 912
| 499
| 1,411
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/serializer/core/string/StringSnapshotSerializerReadable.java
|
StringSnapshotSerializerReadable
|
outputObjects
|
class StringSnapshotSerializerReadable implements SnapshotSerializer {
private static final int INDENT_LENGTH = 4;
@Override
public String[] getValidFileExtensions() {
return new String[]{"txt"};
}
@Override
public String serialize(LiquibaseSerializable object, boolean pretty) {
try {
StringBuilder buffer = new StringBuilder();
DatabaseSnapshot snapshot = ((DatabaseSnapshot) object);
Database database = snapshot.getDatabase();
buffer.append("Database snapshot for ").append(database.getConnection().getURL()).append("\n");
addDivider(buffer);
buffer.append("Database type: ").append(database.getDatabaseProductName()).append("\n");
buffer.append("Database version: ").append(database.getDatabaseProductVersion()).append("\n");
buffer.append("Database user: ").append(database.getConnection().getConnectionUserName()).append("\n");
SnapshotControl snapshotControl = snapshot.getSnapshotControl();
List<Class> includedTypes = sort(snapshotControl.getTypesToInclude());
buffer.append("Included types:\n" ).append(StringUtil.indent(StringUtil.join(includedTypes, "\n", (StringUtil.StringUtilFormatter<Class>) Class::getName))).append("\n");
List<Schema> schemas = sort(snapshot.get(Schema.class), Comparator.comparing(Schema::toString));
for (Schema schema : schemas) {
if (database.supports(Schema.class)) {
buffer.append("\nCatalog & Schema: ").append(schema.getCatalogName()).append(" / ").append(schema.getName()).append("\n");
} else {
buffer.append("\nCatalog: ").append(schema.getCatalogName()).append("\n");
}
StringBuilder catalogBuffer = new StringBuilder();
for (Class type : includedTypes) {
if (type.equals(Schema.class) || type.equals(Catalog.class) || type.equals(Column.class)) {
continue;
}
List<DatabaseObject> objects = new ArrayList<DatabaseObject>(snapshot.get(type));
ListIterator<DatabaseObject> iterator = objects.listIterator();
while (iterator.hasNext()) {
DatabaseObject next = iterator.next();
if (next instanceof DatabaseLevelObject) {
continue;
}
Schema objectSchema = next.getSchema();
if (objectSchema == null) {
if (!(next instanceof CatalogLevelObject) || !((CatalogLevelObject) next).getCatalog().equals(schema.getCatalog())) {
iterator.remove();
}
} else if (!objectSchema.equals(schema)) {
iterator.remove();
}
}
outputObjects(objects, type, catalogBuffer);
}
buffer.append(StringUtil.indent(catalogBuffer.toString(), INDENT_LENGTH));
}
return buffer.toString().replace("\r\n", "\n").replace("\r", "\n"); //standardize all newline chars
} catch (Exception e) {
throw new UnexpectedLiquibaseException(e);
}
}
protected void outputObjects(List objects, Class type, StringBuilder catalogBuffer) {<FILL_FUNCTION_BODY>}
private String serialize(final DatabaseObject databaseObject, final DatabaseObject parentObject) {
StringBuilder buffer = new StringBuilder();
final List<String> attributes = sort(databaseObject.getAttributes());
for (String attribute : attributes) {
if ("name".equals(attribute)) {
continue;
}
if ("schema".equals(attribute)) {
continue;
}
if ("catalog".equals(attribute)) {
continue;
}
Object value = databaseObject.getAttribute(attribute, Object.class);
if (value instanceof Schema) {
continue;
}
if (value instanceof DatabaseObject) {
if (
(parentObject != null)
&& ((DatabaseObject) value).getSnapshotId() != null
&& ((DatabaseObject) value).getSnapshotId().equals(parentObject.getSnapshotId())
) {
continue;
}
boolean expandContainedObjects = shouldExpandNestedObject(value, databaseObject);
if (expandContainedObjects) {
value = ((DatabaseObject) value).getName()+"\n"+ StringUtil.indent(serialize((DatabaseObject) value, databaseObject), INDENT_LENGTH);
} else {
value = databaseObject.getSerializableFieldValue(attribute);
}
} else if (value instanceof Collection) {
if (((Collection<?>) value).isEmpty()) {
value = null;
} else {
if (((Collection) value).iterator().next() instanceof DatabaseObject) {
value = StringUtil.join(new TreeSet<>((Collection<DatabaseObject>) value), "\n", obj -> {
if (obj instanceof DatabaseObject) {
if (shouldExpandNestedObject(obj, databaseObject)) {
return ((DatabaseObject) obj).getName()+"\n"+ StringUtil.indent(serialize(((DatabaseObject) obj), databaseObject), INDENT_LENGTH);
} else {
return ((DatabaseObject) obj).getName();
}
} else {
return obj.toString();
}
});
value = "\n"+ StringUtil.indent((String) value, INDENT_LENGTH);
} else {
value = databaseObject.getSerializableFieldValue(attribute);
}
}
} else {
value = databaseObject.getSerializableFieldValue(attribute);
}
if (value != null) {
buffer.append(attribute).append(": ").append(value).append("\n");
}
}
return buffer.toString().replaceFirst("\n$", "");
}
protected boolean shouldExpandNestedObject(Object nestedValue, DatabaseObject container) {
return (container instanceof Table) || (container instanceof View);
}
protected void addDivider(StringBuilder buffer) {
buffer.append("-----------------------------------------------------------------\n");
}
private List sort(Collection objects) {
return sort(objects, (Comparator) (o1, o2) -> {
if (o1 instanceof Comparable) {
return ((Comparable) o1).compareTo(o2);
} else if (o1 instanceof Class) {
return ((Class<?>) o1).getName().compareTo(((Class<?>) o2).getName());
} else {
throw new ClassCastException(o1.getClass().getName()+" cannot be cast to java.lang.Comparable or java.lang.Class");
}
});
}
private <T> List<T> sort(Collection objects, Comparator<T> comparator) {
List returnList = new ArrayList(objects);
returnList.sort(comparator);
return returnList;
}
@Override
public void write(DatabaseSnapshot snapshot, OutputStream out) throws IOException {
out.write(serialize(snapshot, true).getBytes(GlobalConfiguration.OUTPUT_FILE_ENCODING.getCurrentValue()));
}
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
}
|
List<? extends DatabaseObject> databaseObjects = sort(objects);
if (!databaseObjects.isEmpty()) {
catalogBuffer.append(type.getName()).append(":\n");
StringBuilder typeBuffer = new StringBuilder();
for (DatabaseObject databaseObject : databaseObjects) {
typeBuffer.append(databaseObject.getName()).append("\n");
typeBuffer.append(StringUtil.indent(serialize(databaseObject, null), INDENT_LENGTH)).append("\n");
}
catalogBuffer.append(StringUtil.indent(typeBuffer.toString(), INDENT_LENGTH)).append("\n");
}
| 1,822
| 152
| 1,974
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/serializer/core/yaml/YamlChangeLogSerializer.java
|
ChangeSetComparator
|
compare
|
class ChangeSetComparator implements Comparator<String> {
private static final Map<String, Integer> order = new HashMap<>();
static {
order.put("id", 1);
order.put("author", 2);
order.put("changes", Integer.MAX_VALUE);
}
@Override
public int compare(String o1, String o2) {<FILL_FUNCTION_BODY>}
}
|
Integer o1Order = order.get(o1);
if (o1Order == null) {
o1Order = 10;
}
Integer o2Order = order.get(o2);
if (o2Order == null) {
o2Order = 10;
}
int orderCompare = o1Order.compareTo(o2Order);
if (orderCompare == 0) {
return o1.compareTo(o2);
}
return orderCompare;
| 112
| 128
| 240
|
<methods>public void <init>() ,public java.lang.String[] getValidFileExtensions() ,public static java.lang.String removeClassTypeMarksFromSerializedJson(java.lang.String) ,public java.lang.String serialize(liquibase.serializer.LiquibaseSerializable, boolean) <variables>protected Yaml yaml
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/serializer/core/yaml/YamlSnapshotSerializer.java
|
YamlSnapshotSerializer
|
toMap
|
class YamlSnapshotSerializer extends YamlSerializer implements SnapshotSerializer {
private boolean alreadySerializingObject;
@Override
public void write(DatabaseSnapshot snapshot, OutputStream out) throws IOException {
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out, GlobalConfiguration.OUTPUT_FILE_ENCODING.getCurrentValue()));
writer.write(serialize(snapshot, true));
}
@Override
protected Object toMap(final LiquibaseSerializable object) {<FILL_FUNCTION_BODY>}
@Override
protected LiquibaseRepresenter getLiquibaseRepresenter(DumperOptions options) {
return new SnapshotLiquibaseRepresenter(options);
}
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
public static class SnapshotLiquibaseRepresenter extends LiquibaseRepresenter {
public SnapshotLiquibaseRepresenter(DumperOptions options) {
super(options);
}
@Override
protected void init() {
multiRepresenters.put(DatabaseFunction.class, new TypeStoringAsStringRepresenter());
multiRepresenters.put(SequenceNextValueFunction.class, new TypeStoringAsStringRepresenter());
multiRepresenters.put(SequenceCurrentValueFunction.class, new TypeStoringAsStringRepresenter());
multiRepresenters.put(java.util.Date.class, new TypeStoringAsStringRepresenter());
multiRepresenters.put(java.sql.Date.class, new TypeStoringAsStringRepresenter());
multiRepresenters.put(Integer.class, new TypeStoringAsStringRepresenter());
multiRepresenters.put(BigInteger.class, new TypeStoringAsStringRepresenter());
multiRepresenters.put(Number.class, new TypeStoringAsStringRepresenter());
multiRepresenters.put(Enum.class, new TypeStoringAsStringRepresenter());
}
private class TypeStoringAsStringRepresenter implements Represent {
@Override
public Node representData(Object data) {
String value;
if (data instanceof Date) {
value = new ISODateFormat().format((Date) data);
} else if (data instanceof Enum) {
value = ((Enum<?>) data).name();
} else {
value = data.toString();
}
return representScalar(Tag.STR, value + "!{" + data.getClass().getName() + "}");
}
}
}
}
|
if (object instanceof DatabaseObject) {
if (object instanceof Column && ((Column) object).isForIndex()) {
//not really a "real" column that has a snapshot to reference, just serialize the ColumnObject
return super.toMap(object);
} else if (alreadySerializingObject) {
String snapshotId = ((DatabaseObject) object).getSnapshotId();
if (snapshotId == null) {
String name = ((DatabaseObject) object).getName();
Object table = ((DatabaseObject) object).getAttribute("table", Object.class);
if (table == null) {
table = ((DatabaseObject) object).getAttribute("relation", Object.class);
}
if (table != null) {
name = table + "." + name;
}
if (((DatabaseObject) object).getSchema() != null) {
name = ((DatabaseObject) object).getSchema().toString() + "." + name;
}
throw new UnexpectedLiquibaseException("Found a null snapshotId for " + StringUtil.lowerCaseFirst(object.getClass().getSimpleName()) + " " + name);
}
return ((DatabaseObject) object).getClass().getName() + "#" + snapshotId;
} else {
alreadySerializingObject = true;
Object map = super.toMap(object);
alreadySerializingObject = false;
return map;
}
}
if (object instanceof DatabaseObjectCollection) {
SortedMap<String, Object> returnMap = new TreeMap<>();
for (Map.Entry<Class<? extends DatabaseObject>, Set<? extends DatabaseObject>> entry : ((DatabaseObjectCollection) object).toMap().entrySet()) {
ArrayList value = new ArrayList(entry.getValue());
value.sort(new DatabaseObjectCollectionComparator());
returnMap.put(entry.getKey().getName(), value);
}
return returnMap;
}
return super.toMap(object);
| 645
| 480
| 1,125
|
<methods>public void <init>() ,public java.lang.String[] getValidFileExtensions() ,public static java.lang.String removeClassTypeMarksFromSerializedJson(java.lang.String) ,public java.lang.String serialize(liquibase.serializer.LiquibaseSerializable, boolean) <variables>protected Yaml yaml
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/servicelocator/StandardServiceLocator.java
|
StandardServiceLocator
|
findInstances
|
class StandardServiceLocator implements ServiceLocator {
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
@Override
public <T> List<T> findInstances(Class<T> interfaceType) throws ServiceNotFoundException {<FILL_FUNCTION_BODY>}
/**
* Exception handler for when a service cannot be loaded. Created as an inner class so logs can be suppressed if desired.
*/
static class ServiceLoadExceptionHandler {
void handleException(Throwable e) {
Logger log = Scope.getCurrentScope().getLog(getClass());
log.info("Cannot load service", e);
}
}
}
|
List<T> allInstances = new ArrayList<>();
final Logger log = Scope.getCurrentScope().getLog(getClass());
final Iterator<T> services = ServiceLoader.load(interfaceType, Scope.getCurrentScope().getClassLoader(true)).iterator();
while (services.hasNext()) {
try {
final T service = services.next();
log.fine("Loaded "+interfaceType.getName()+" instance "+service.getClass().getName());
allInstances.add(service);
} catch (Throwable e) {
new ServiceLoadExceptionHandler().handleException(e);
log.fine(e.getMessage(), e);
}
}
return Collections.unmodifiableList(allInstances);
| 173
| 192
| 365
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/CachedRow.java
|
CachedRow
|
getInt
|
class CachedRow {
private final Map row;
public CachedRow(Map row) {
this.row = row;
}
public Object get(String columnName) {
return row.get(columnName);
}
public void set(String columnName, Object value) {
row.put(columnName, value);
}
public boolean containsColumn(String columnName) {
return row.containsKey(columnName);
}
public String getString(String columnName) {
return (String) row.get(columnName);
}
public Integer getInt(String columnName) {<FILL_FUNCTION_BODY>}
public Short getShort(String columnName) {
Object o = row.get(columnName);
if (o instanceof Number) {
return ((Number) o).shortValue();
} else if (o instanceof String) {
return Short.valueOf((String) o);
}
return (Short) o;
}
public Boolean getBoolean(String columnName) {
Object o = row.get(columnName);
if (o instanceof Number) {
return ((Number) o).longValue() != 0;
}
if (o instanceof String) {
String s = (String)o;
// Firebird JDBC driver quirk:
// Returns "T" instead of "true" (Boolean.valueOf tests case-insensitively for "true")
if ("T".equalsIgnoreCase(s))
s = "TRUE";
return Boolean.valueOf(s);
}
return (Boolean) o;
}
/**
* Converts a 'YES'/'NO' value to a boolean value.
*
* @param columnName the name of the column whose value should be converted
* @return {@code true} if the column value is 'YES', {@code false} otherwise; or {@code null} if the column value is {@code null}
*/
public Boolean yesNoToBoolean(String columnName) {
Object o = row.get(columnName);
if (o instanceof String && "YES".equalsIgnoreCase((String)o)) {
return Boolean.TRUE;
}
return getBoolean(columnName);
}
}
|
Object o = row.get(columnName);
if (o instanceof Number) {
return ((Number) o).intValue();
} else if (o instanceof String) {
return Integer.valueOf((String) o);
} else if (o instanceof byte[]) {
//
// Added this condition after finding that Clustrix (MariadDB/MySQL)
// returns the size value as a byte[] that contains the ASCII values
// of the numbers
//
return Integer.valueOf(new String((byte[]) o));
}
return (Integer) o;
| 566
| 147
| 713
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/ResultSetCache.java
|
ResultSetExtractor
|
getColumnValue
|
class ResultSetExtractor {
private final Database database;
public ResultSetExtractor(Database database) {
this.database = database;
}
public abstract boolean bulkContainsSchema(String schemaKey);
public String getSchemaKey(CachedRow row) {
throw new UnexpectedLiquibaseException("Not Implemented");
}
protected boolean shouldBulkSelect(String schemaKey, ResultSetCache resultSetCache) {
return resultSetCache.getTimesSingleQueried(schemaKey) >= 3;
}
protected List<CachedRow> executeAndExtract(String sql, Database database) throws DatabaseException, SQLException {
return executeAndExtract(database, false, sql);
}
protected List<CachedRow> executeAndExtract(Database database, String sql, Object...parameters) throws DatabaseException, SQLException {
return executeAndExtract(database, false, sql, parameters);
}
protected List<CachedRow> executeAndExtract(Database database, boolean informixTrimHint, String sql, Object...parameters)
throws DatabaseException, SQLException {
if (sql == null) {
return new ArrayList<>();
}
PreparedStatement statement = null;
ResultSet resultSet = null;
try {
JdbcConnection connection = (JdbcConnection) database.getConnection();
statement = connection.prepareStatement(sql);
for (int i = 0; i < parameters.length; ++i) {
statement.setObject(i + 1, parameters[i]);
}
resultSet = statement.executeQuery();
resultSet.setFetchSize(database.getFetchSize());
return extract(resultSet, informixTrimHint);
} finally {
JdbcUtil.close(resultSet, statement);
}
}
public boolean equals(Object expectedValue, Object foundValue) {
return equals(expectedValue, foundValue, true);
}
public boolean equals(Object expectedValue, Object foundValue, boolean equalIfEitherNull) {
if ((expectedValue == null) && (foundValue == null)) {
return true;
}
if ((expectedValue == null) || (foundValue == null)) {
return equalIfEitherNull;
}
return expectedValue.equals(foundValue);
}
public abstract RowData rowKeyParameters(CachedRow row);
public abstract RowData wantedKeyParameters();
public abstract List<CachedRow> fastFetch() throws SQLException, DatabaseException;
public abstract List<CachedRow> bulkFetch() throws SQLException, DatabaseException;
protected List<CachedRow> extract(ResultSet resultSet) throws SQLException {
return extract(resultSet, false);
}
protected List<CachedRow> extract(ResultSet resultSet, final boolean informixIndexTrimHint)
throws SQLException {
resultSet.setFetchSize(database.getFetchSize());
List<CachedRow> returnList = new ArrayList<>();
try {
List<Map> result = (List<Map>) new RowMapperResultSetExtractor(new ColumnMapRowMapper(database.isCaseSensitive()) {
@Override
protected Object getColumnValue(ResultSet rs, int index) throws SQLException {<FILL_FUNCTION_BODY>}
}).extractData(resultSet);
for (Map row : result) {
returnList.add(new CachedRow(row));
}
} finally {
JdbcUtil.closeResultSet(resultSet);
}
return returnList;
}
}
|
Object value = super.getColumnValue(rs, index);
if ((value instanceof String)) {
// Don't trim for informix database,
// We need to discern the space in front of an index name,
// to know if it was auto-generated or not
if (informixIndexTrimHint == false) {
value = ((String) value).trim(); // Trim the value normally
} else {
boolean startsWithSpace = (database instanceof InformixDatabase) && ((String) value).matches("^ .*$");
// Set the flag if the value started with a space
value = ((String) value).trim(); // Trim the value normally
if (startsWithSpace == true) {
value = " " + value; // Put the space back at the beginning if the flag was set
}
}
}
return value;
| 886
| 214
| 1,100
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/SnapshotControl.java
|
SnapshotControl
|
getSerializableFieldType
|
class SnapshotControl implements LiquibaseSerializable {
private Set<Class<? extends DatabaseObject>> types;
private ObjectChangeFilter objectChangeFilter;
private SnapshotListener snapshotListener;
private boolean warnIfObjectNotFound = true;
/**
* Create a SnapshotControl for a given database and mark the database's standard types for inclusion.
* @param database the DBMS for which snapshots should be generated
*/
public SnapshotControl(Database database) {
setTypes(DatabaseObjectFactory.getInstance().getStandardTypes(), database);
}
/**
* Create a Snapshot control for a given database, but explicitly set the object types to be included in snapshots.
* @param database the DBMS for which snapshots should be generated
* @param types the list of object types to be included in the snapshot
*/
@SafeVarargs
public SnapshotControl(Database database, Class<? extends DatabaseObject>... types) {
this(database, true, types);
}
@SafeVarargs
public SnapshotControl(Database database, boolean expandTypesIfNeeded, Class<? extends DatabaseObject>... types) {
if ((types == null) || (types.length == 0)) {
setTypes(DatabaseObjectFactory.getInstance().getStandardTypes(), database);
} else {
if (expandTypesIfNeeded) {
setTypes(new HashSet<>(Arrays.asList(types)), database);
} else {
this.types = new HashSet<>(Arrays.asList(types));
}
}
}
/**
* Create a Snapshot control for a given database, but explicitly set the object types to be included in snapshots.
* @param database the DBMS for which snapshots should be generated
* @param types the list of object types to be included in the snapshot, separated by commas
*/
public SnapshotControl(Database database, String types) {
setTypes(DatabaseObjectFactory.getInstance().parseTypes(types), database);
}
public SnapshotControl(Database database, ObjectChangeFilter objectChangeFilter, Class<? extends
DatabaseObject>... types) {
this(database, true, types);
this.objectChangeFilter = objectChangeFilter;
}
public SnapshotListener getSnapshotListener() {
return snapshotListener;
}
public void setSnapshotListener(SnapshotListener snapshotListener) {
this.snapshotListener = snapshotListener;
}
@Override
public String getSerializedObjectName() {
return "snapshotControl";
}
@Override
public Set<String> getSerializableFields() {
return new HashSet<>(Collections.singletonList("includedType"));
}
@Override
public Object getSerializableFieldValue(String field) {
if ("includedType".equals(field)) {
SortedSet<String> typesNames = new TreeSet<>();
for (Class type : this.getTypesToInclude()) {
typesNames.add(type.getName());
}
return typesNames;
} else {
throw new UnexpectedLiquibaseException("Unknown field "+field);
}
}
@Override
public SerializationType getSerializableFieldType(String field) {<FILL_FUNCTION_BODY>}
@Override
public String getSerializedObjectNamespace() {
return STANDARD_SNAPSHOT_NAMESPACE;
}
@Override
public String getSerializableFieldNamespace(String field) {
return getSerializedObjectNamespace();
}
private void setTypes(Set<Class<? extends DatabaseObject>> types, Database database) {
this.types = new HashSet<>();
Stream<Class<? extends DatabaseObject>> objectStream = types.stream();
if (database != null) {
// Firebird does not support catalogs, but we need to include them in the snapshot for it as it has a catalog name
// Something incorrectly implemented in the FirebirdDatabase class that we work around here
objectStream = objectStream.filter(t -> (database.supports(t) || (database instanceof FirebirdDatabase && t.equals(Catalog.class))));
}
objectStream.forEach(type -> addType(type, database));
}
/**
* Adds a new DatabaseObject type to the list of object types to be included in snapshots.
* @param type The type to be added
* @param database The database to check for any dependent types that need to be included as well
* @return true if the type was added to the list, false if it was already present.
*/
public boolean addType(Class<? extends DatabaseObject> type, Database database) {
boolean added = this.types.add(type);
if (added) {
for (Class<? extends DatabaseObject> container : SnapshotGeneratorFactory.getInstance().getContainerTypes(type, database)) {
addType(container, database);
}
}
return added;
}
/**
* Return the types to be included in snapshots
* @return the set of currently registered types
*/
public Set<Class<? extends DatabaseObject>> getTypesToInclude() {
return types;
}
/**
* Queries the currently registered list of types to be included and returns true if the given type is in that list
* @param type the DatabaseObject type to be checked
* @return true if that type is registered for inclusion, false if not
*/
public boolean shouldInclude(Class<? extends DatabaseObject> type) {
return types.contains(type);
}
@Override
public void load(ParsedNode parsedNode, ResourceAccessor resourceAccessor) throws ParsedNodeException {
throw new RuntimeException("TODO");
}
@Override
public ParsedNode serialize() {
throw new RuntimeException("TODO");
}
/**
* Returns if the code should log a LogLevel.WARNING message if the object to be snapshotted could not be found.
* @return true if WARNINGs should be emitted (default), false if not.
*/
public boolean isWarnIfObjectNotFound() {
return warnIfObjectNotFound;
}
/**
* Configures the code to log a LogLevel.WARNING message if the object to be snapshotted could not be found.
* @param warnIfObjectNotFound true if a warning should emitted (default value), false if not.
*/
public SnapshotControl setWarnIfObjectNotFound(boolean warnIfObjectNotFound) {
this.warnIfObjectNotFound = warnIfObjectNotFound;
return this;
}
public <T extends DatabaseObject> boolean shouldInclude(T example) {
if (objectChangeFilter != null) {
return objectChangeFilter.include(example);
}
return shouldInclude(example.getClass());
}
}
|
if ("includedType".equals(field)) {
return SerializationType.NESTED_OBJECT;
} else {
throw new UnexpectedLiquibaseException("Unknown field "+field);
}
| 1,693
| 57
| 1,750
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/SnapshotGeneratorChain.java
|
SnapshotGeneratorChain
|
snapshot
|
class SnapshotGeneratorChain {
private Iterator<SnapshotGenerator> snapshotGenerators;
private final Set<Class<? extends SnapshotGenerator>> replacedGenerators = new HashSet<>();
private final SnapshotIdService snapshotIdService;
public SnapshotGeneratorChain(SortedSet<SnapshotGenerator> snapshotGenerators) {
snapshotIdService = SnapshotIdService.getInstance();
if (snapshotGenerators != null) {
this.snapshotGenerators = snapshotGenerators.iterator();
for (SnapshotGenerator generator : snapshotGenerators) {
Class<? extends SnapshotGenerator>[] replaces = generator.replaces();
if ((replaces != null) && (replaces.length > 0)) {
replacedGenerators.addAll(Arrays.asList(replaces));
}
}
}
}
/**
* This calls all the non-replaced {@link SnapshotGenerator} in the chain, by comparison order
* Only the first generator in the chain is allowed to create a new instance of T
* Subsequent generators must modify the instance or call the chain if the provided object is not handled,
* otherwise a {@link DatabaseException} is thrown
*
* @return snapshot object
* @throws DatabaseException if any of the subsequent generators return an instance different from the first generator's
* invocation result
* @see SnapshotGenerator#replaces() to skip generators that do not comply to the above requireemnts
*/
public <T extends DatabaseObject> T snapshot(T example, DatabaseSnapshot snapshot)
throws DatabaseException, InvalidExampleException {<FILL_FUNCTION_BODY>}
public SnapshotGenerator getNextValidGenerator() {
if (snapshotGenerators == null) {
return null;
}
if (!snapshotGenerators.hasNext()) {
return null;
}
SnapshotGenerator next = snapshotGenerators.next();
for (Class<? extends SnapshotGenerator> removedGenerator : replacedGenerators) {
if (removedGenerator.equals(next.getClass())) {
return getNextValidGenerator();
}
}
return next;
}
}
|
if (example == null) {
return null;
}
if (snapshot.getDatabase().isSystemObject(example)) {
return null;
}
if (!snapshot.getSnapshotControl().shouldInclude(example.getClass())) {
return null;
}
SnapshotGenerator next = getNextValidGenerator();
if (next == null) {
return null;
}
T obj = next.snapshot(example, snapshot, this);
if ((obj != null) && (obj.getSnapshotId() == null)) {
obj.setSnapshotId(snapshotIdService.generateId());
}
return obj;
| 523
| 169
| 692
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/SnapshotGeneratorComparator.java
|
SnapshotGeneratorComparator
|
compare
|
class SnapshotGeneratorComparator implements Comparator<SnapshotGenerator> {
private final Class<? extends DatabaseObject> objectType;
private final Database database;
public SnapshotGeneratorComparator(Class<? extends DatabaseObject> objectType, Database database) {
this.objectType = objectType;
this.database = database;
}
@Override
public int compare(SnapshotGenerator o1, SnapshotGenerator o2) {<FILL_FUNCTION_BODY>}
}
|
int result = -1 * Integer.compare(o1.getPriority(objectType, database), o2.getPriority(objectType, database));
if (result == 0) {
return o1.getClass().getName().compareTo(o2.getClass().getName());
}
return result;
| 122
| 76
| 198
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/jvm/CatalogSnapshotGenerator.java
|
CatalogSnapshotGenerator
|
snapshotObject
|
class CatalogSnapshotGenerator extends JdbcSnapshotGenerator {
public CatalogSnapshotGenerator() {
super(Catalog.class);
}
@Override
protected DatabaseObject snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {<FILL_FUNCTION_BODY>}
protected boolean isDefaultCatalog(Catalog match, Database database) {
if (CatalogAndSchema.CatalogAndSchemaCase.ORIGINAL_CASE.equals(database.getSchemaAndCatalogCase())) {
return (match.getName() == null || match.getName().equals(database.getDefaultCatalogName()));
}
return ((match.getName() == null) || match.getName().equalsIgnoreCase(database.getDefaultCatalogName()));
}
@Override
protected void addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {
//nothing to add to
}
}
|
if (!(example instanceof Catalog)) {
throw new UnexpectedLiquibaseException("Unexpected example type: " + example.getClass().getName());
}
Database database = snapshot.getDatabase();
Catalog match = null;
String catalogName = example.getName();
if ((catalogName == null) && database.supports(Catalog.class)) {
catalogName = database.getDefaultCatalogName();
}
example = new Catalog(catalogName);
try {
for (String potentialCatalogName : getDatabaseCatalogNames(database)) {
Catalog catalog = new Catalog(potentialCatalogName);
if (DatabaseObjectComparatorFactory.getInstance().isSameObject(catalog, example, snapshot.getSchemaComparisons(), database)) {
if (match == null) {
match = catalog;
} else {
throw new InvalidExampleException("Found multiple catalogs matching " + example.getName());
}
}
}
} catch (SQLException e) {
throw new DatabaseException(e);
}
if ((match != null) && isDefaultCatalog(match, database)) {
match.setDefault(true);
}
return match;
| 229
| 305
| 534
|
<methods>public void addStatusListener(liquibase.diff.DiffStatusListener) ,public Class<? extends liquibase.structure.DatabaseObject>[] addsTo() ,public int getPriority(Class<? extends liquibase.structure.DatabaseObject>, liquibase.database.Database) ,public Class<? extends liquibase.snapshot.SnapshotGenerator>[] replaces() ,public liquibase.structure.DatabaseObject snapshot(liquibase.structure.DatabaseObject, liquibase.snapshot.DatabaseSnapshot, liquibase.snapshot.SnapshotGeneratorChain) throws liquibase.exception.DatabaseException, liquibase.snapshot.InvalidExampleException<variables>private Class<? extends liquibase.structure.DatabaseObject>[] addsTo,private final non-sealed Class<? extends liquibase.structure.DatabaseObject> defaultFor,private final Set<liquibase.diff.DiffStatusListener> statusListeners
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/jvm/ColumnSnapshotGeneratorH2.java
|
ColumnSnapshotGeneratorH2
|
getPriority
|
class ColumnSnapshotGeneratorH2 extends ColumnSnapshotGenerator {
@Override
public int getPriority(Class<? extends DatabaseObject> objectType, Database database) {<FILL_FUNCTION_BODY>}
@Override
public Class<? extends SnapshotGenerator>[] replaces() {
return new Class[]{ColumnSnapshotGenerator.class};
}
@Override
protected Object readDefaultValue(CachedRow columnMetadataResultSet, Column columnInfo, Database database) {
Object defaultValue = super.readDefaultValue(columnMetadataResultSet, columnInfo, database);
if ((defaultValue instanceof DatabaseFunction) && ((DatabaseFunction) defaultValue)
.getValue().startsWith("NEXT VALUE FOR ")) {
columnInfo.setAutoIncrementInformation(new Column.AutoIncrementInformation());
return null;
}
return defaultValue;
}
}
|
if (!(database instanceof H2Database)) {
return PRIORITY_NONE;
}
int priority = super.getPriority(objectType, database);
if (priority == 0) {
return priority;
}
return priority + 5;
| 213
| 70
| 283
|
<methods>public void <init>() <variables>protected static final java.lang.String COLUMN_DEF_COL,private static final java.lang.String GENERATED_ALWAYS_AS,private static final java.lang.String IS_GENERATED_COLUMN,private static final java.lang.String LIQUIBASE_COMPLETE,private static final java.lang.String MYSQL_DEFAULT_GENERATED,private static final java.util.regex.Pattern POSTGRES_NUMBER_VALUE_PATTERN,private static final java.lang.String POSTGRES_NUMBER_VALUE_REGEX,private static final java.util.regex.Pattern POSTGRES_STRING_VALUE_PATTERN,private static final java.lang.String POSTGRES_STRING_VALUE_REGEX,private static final java.lang.String YES_VALUE,private final liquibase.snapshot.jvm.ColumnAutoIncrementService columnAutoIncrementService
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/jvm/ColumnSnapshotGeneratorInformix.java
|
ColumnSnapshotGeneratorInformix
|
readDataType
|
class ColumnSnapshotGeneratorInformix extends ColumnSnapshotGenerator {
private static final Map<Integer, String> qualifiers = new HashMap<>();
static {
qualifiers.put(0, "YEAR");
qualifiers.put(2, "MONTH");
qualifiers.put(4, "DAY");
qualifiers.put(6, "HOUR");
qualifiers.put(8, "MINUTE");
qualifiers.put(10, "SECOND");
qualifiers.put(11, "FRACTION(1)");
qualifiers.put(12, "FRACTION(2)");
qualifiers.put(13, "FRACTION(3)");
qualifiers.put(14, "FRACTION(4)");
qualifiers.put(15, "FRACTION(5)");
}
@Override
public int getPriority(Class<? extends DatabaseObject> objectType, Database database) {
if (database instanceof InformixDatabase)
return PRIORITY_DATABASE;
else
return PRIORITY_NONE; // Other DB? Let the generic handler do it.
}
@Override
public Class<? extends SnapshotGenerator>[] replaces() {
return new Class[]{ColumnSnapshotGenerator.class};
}
@Override
protected DataType readDataType(CachedRow columnMetadataResultSet, Column column, Database database) throws DatabaseException {<FILL_FUNCTION_BODY>}
}
|
// For an explanation of the information encoded in the column length, please see
// https://www.ibm.com/support/knowledgecenter/SSGU8G_11.50.0/com.ibm.sqlr.doc/ids_sqr_027.htm
String typeName = columnMetadataResultSet.getString("TYPE_NAME").toUpperCase();
if ("DATETIME".equals(typeName) || "INTERVAL".equals(typeName)) {
int colLength = columnMetadataResultSet.getInt("COLUMN_SIZE");
int firstQualifierType = (colLength % 256) / 16;
int lastQualifierType = (colLength % 256) % 16;
String type = "DATETIME".equals(typeName) ? "DATETIME" : "INTERVAL";
String firstQualifier = qualifiers.get(firstQualifierType);
String lastQualifier = qualifiers.get(lastQualifierType);
if (firstQualifier == null) {
throw new liquibase.exception.DatabaseException(
String.format(
"Encountered unknown firstQualifier code (%d) for column '%s', basic date type '%s', " +
"while trying to decipher information encoded in the column length (%d)",
firstQualifierType, column.toString(), typeName, colLength)
);
}
if (lastQualifier == null) {
throw new liquibase.exception.DatabaseException(
String.format(
"Encountered unknown lastQualifier code (%d) for column '%s', basic date type '%s', " +
"while trying to decipher information encoded in the column length (%d)",
firstQualifierType, column.toString(), typeName, colLength)
);
}
DataType dataTypeMetaData = new DataType(type + " " + firstQualifier + " TO " + lastQualifier);
dataTypeMetaData.setColumnSizeUnit(DataType.ColumnSizeUnit.BYTE);
return dataTypeMetaData;
} else {
return super.readDataType(columnMetadataResultSet, column, database);
}
| 372
| 547
| 919
|
<methods>public void <init>() <variables>protected static final java.lang.String COLUMN_DEF_COL,private static final java.lang.String GENERATED_ALWAYS_AS,private static final java.lang.String IS_GENERATED_COLUMN,private static final java.lang.String LIQUIBASE_COMPLETE,private static final java.lang.String MYSQL_DEFAULT_GENERATED,private static final java.util.regex.Pattern POSTGRES_NUMBER_VALUE_PATTERN,private static final java.lang.String POSTGRES_NUMBER_VALUE_REGEX,private static final java.util.regex.Pattern POSTGRES_STRING_VALUE_PATTERN,private static final java.lang.String POSTGRES_STRING_VALUE_REGEX,private static final java.lang.String YES_VALUE,private final liquibase.snapshot.jvm.ColumnAutoIncrementService columnAutoIncrementService
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/jvm/ColumnSnapshotGeneratorOracle.java
|
ColumnSnapshotGeneratorOracle
|
readDataType
|
class ColumnSnapshotGeneratorOracle extends ColumnSnapshotGenerator {
@Override
public int getPriority(Class<? extends DatabaseObject> objectType, Database database) {
if (database instanceof OracleDatabase)
return PRIORITY_DATABASE;
else
return PRIORITY_NONE; // Other DB? Let the generic handler do it.
}
@Override
public Class<? extends SnapshotGenerator>[] replaces() {
return new Class[]{ColumnSnapshotGenerator.class};
}
@Override
protected DataType readDataType(CachedRow columnMetadataResultSet, Column column, Database database) {<FILL_FUNCTION_BODY>}
}
|
String dataType = columnMetadataResultSet.getString("DATA_TYPE_NAME");
dataType = dataType.replace("VARCHAR2", "VARCHAR");
dataType = dataType.replace("NVARCHAR2", "NVARCHAR");
DataType type = new DataType(dataType);
type.setDataTypeId(columnMetadataResultSet.getInt("DATA_TYPE"));
if ("NUMBER".equalsIgnoreCase(dataType)) {
type.setColumnSize(columnMetadataResultSet.getInt("DATA_PRECISION"));
type.setDecimalDigits(columnMetadataResultSet.getInt("DATA_SCALE"));
} else {
type.setColumnSize(columnMetadataResultSet.getInt("DATA_LENGTH"));
if ("NCLOB".equalsIgnoreCase(dataType) || "BLOB".equalsIgnoreCase(dataType) || "CLOB".equalsIgnoreCase
(dataType)) {
type.setColumnSize(null);
} else if ("NVARCHAR".equalsIgnoreCase(dataType) || "NCHAR".equalsIgnoreCase(dataType)) {
type.setColumnSize(columnMetadataResultSet.getInt("CHAR_LENGTH"));
type.setColumnSizeUnit(DataType.ColumnSizeUnit.CHAR);
} else {
String charUsed = columnMetadataResultSet.getString("CHAR_USED");
DataType.ColumnSizeUnit unit = null;
if ("C".equals(charUsed)) {
unit = DataType.ColumnSizeUnit.CHAR;
type.setColumnSize(columnMetadataResultSet.getInt("CHAR_LENGTH"));
} else if ("B".equals(charUsed)) {
unit = DataType.ColumnSizeUnit.BYTE;
}
type.setColumnSizeUnit(unit);
}
}
return type;
| 168
| 442
| 610
|
<methods>public void <init>() <variables>protected static final java.lang.String COLUMN_DEF_COL,private static final java.lang.String GENERATED_ALWAYS_AS,private static final java.lang.String IS_GENERATED_COLUMN,private static final java.lang.String LIQUIBASE_COMPLETE,private static final java.lang.String MYSQL_DEFAULT_GENERATED,private static final java.util.regex.Pattern POSTGRES_NUMBER_VALUE_PATTERN,private static final java.lang.String POSTGRES_NUMBER_VALUE_REGEX,private static final java.util.regex.Pattern POSTGRES_STRING_VALUE_PATTERN,private static final java.lang.String POSTGRES_STRING_VALUE_REGEX,private static final java.lang.String YES_VALUE,private final liquibase.snapshot.jvm.ColumnAutoIncrementService columnAutoIncrementService
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/jvm/DataSnapshotGenerator.java
|
DataSnapshotGenerator
|
addTo
|
class DataSnapshotGenerator extends JdbcSnapshotGenerator {
public DataSnapshotGenerator() {
super(Data.class, new Class[]{Table.class});
}
@Override
protected DatabaseObject snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {
return example;
}
@Override
protected void addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {<FILL_FUNCTION_BODY>}
}
|
if (!snapshot.getSnapshotControl().shouldInclude(Data.class) || !snapshot.getDatabase().supports(Table.class)) {
return;
}
if (foundObject instanceof Table) {
Table table = (Table) foundObject;
try {
Data exampleData = new Data().setTable(table);
table.setAttribute("data", exampleData);
} catch (Exception e) {
throw new DatabaseException(e);
}
}
| 118
| 121
| 239
|
<methods>public void addStatusListener(liquibase.diff.DiffStatusListener) ,public Class<? extends liquibase.structure.DatabaseObject>[] addsTo() ,public int getPriority(Class<? extends liquibase.structure.DatabaseObject>, liquibase.database.Database) ,public Class<? extends liquibase.snapshot.SnapshotGenerator>[] replaces() ,public liquibase.structure.DatabaseObject snapshot(liquibase.structure.DatabaseObject, liquibase.snapshot.DatabaseSnapshot, liquibase.snapshot.SnapshotGeneratorChain) throws liquibase.exception.DatabaseException, liquibase.snapshot.InvalidExampleException<variables>private Class<? extends liquibase.structure.DatabaseObject>[] addsTo,private final non-sealed Class<? extends liquibase.structure.DatabaseObject> defaultFor,private final Set<liquibase.diff.DiffStatusListener> statusListeners
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/jvm/JdbcSnapshotGenerator.java
|
JdbcSnapshotGenerator
|
getDatabaseCatalogNames
|
class JdbcSnapshotGenerator implements SnapshotGenerator {
private final Set<DiffStatusListener> statusListeners = new HashSet<>();
private final Class<? extends DatabaseObject> defaultFor;
private Class<? extends DatabaseObject>[] addsTo;
protected JdbcSnapshotGenerator(Class<? extends DatabaseObject> defaultFor) {
this.defaultFor = defaultFor;
}
protected JdbcSnapshotGenerator(Class<? extends DatabaseObject> defaultFor, Class<? extends DatabaseObject>[] addsTo) {
this.defaultFor = defaultFor;
this.addsTo = addsTo;
}
@Override
public int getPriority(Class<? extends DatabaseObject> objectType, Database database) {
if (database instanceof AbstractJdbcDatabase) {
if ((defaultFor != null) && defaultFor.isAssignableFrom(objectType)) {
return PRIORITY_DEFAULT;
}
if (addsTo() != null) {
for (Class<? extends DatabaseObject> type : addsTo()) {
if (type.isAssignableFrom(objectType)) {
return PRIORITY_ADDITIONAL;
}
}
}
}
return PRIORITY_NONE;
}
@Override
public Class<? extends DatabaseObject>[] addsTo() {
return addsTo;
}
@Override
public DatabaseObject snapshot(DatabaseObject example, DatabaseSnapshot snapshot, SnapshotGeneratorChain chain) throws DatabaseException, InvalidExampleException {
if ((defaultFor != null) && defaultFor.isAssignableFrom(example.getClass())) {
return snapshotObject(example, snapshot);
}
DatabaseObject chainResponse = chain.snapshot(example, snapshot);
if (chainResponse == null) {
return null;
}
if (shouldAddTo(example.getClass(), snapshot)) {
if (addsTo() != null) {
for (Class<? extends DatabaseObject> addType : addsTo()) {
if (addType.isAssignableFrom(example.getClass())) {
if (chainResponse != null) {
addTo(chainResponse, snapshot);
}
}
}
}
}
return chainResponse;
}
protected boolean shouldAddTo(Class<? extends DatabaseObject> databaseObjectType, DatabaseSnapshot snapshot) {
return (defaultFor != null) && snapshot.getSnapshotControl().shouldInclude(defaultFor);
}
@Override
public Class<? extends SnapshotGenerator>[] replaces() {
return null;
}
protected abstract DatabaseObject snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException;
protected abstract void addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException;
public void addStatusListener(DiffStatusListener listener) {
statusListeners.add(listener);
}
protected void updateListeners(String message) {
Scope.getCurrentScope().getLog(getClass()).fine(message);
for (DiffStatusListener listener : this.statusListeners) {
listener.statusUpdate(message);
}
}
protected String cleanNameFromDatabase(String objectName, Database database) {
if (objectName == null) {
return null;
}
if (!(database instanceof InformixDatabase)) {
objectName = objectName.trim();
}
if (database instanceof PostgresDatabase) {
return objectName.replaceAll("\"", "");
}
return objectName;
}
/**
* Fetches an array of Strings with the catalog names in the database.
* @param database The database from which to get the schema names
* @return An array of catalog name Strings (May be an empty array)
* @throws SQLException propagated java.sql.SQLException
* @throws DatabaseException if a different problem occurs during the DBMS-specific code
*/
protected String[] getDatabaseCatalogNames(Database database) throws SQLException, DatabaseException {<FILL_FUNCTION_BODY>}
}
|
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();
}
if (catalogs == null) {
String message = "Unable to retrieve the list of catalog names from the database metadata";
Scope.getCurrentScope().getLog(getClass()).warning(message);
} else {
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) {
}
}
}
if (returnList.isEmpty()) {
returnList.add(database.getDefaultCatalogName());
}
return returnList.toArray(new String[0]);
| 1,012
| 344
| 1,356
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/jvm/PrimaryKeySnapshotGenerator.java
|
PrimaryKeySnapshotGenerator
|
addTo
|
class PrimaryKeySnapshotGenerator extends JdbcSnapshotGenerator {
public PrimaryKeySnapshotGenerator() {
super(PrimaryKey.class, new Class[]{Table.class});
}
@Override
protected DatabaseObject snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot) throws
DatabaseException, InvalidExampleException {
Database database = snapshot.getDatabase();
Schema schema = example.getSchema();
String searchTableName = null;
if (((PrimaryKey) example).getTable() != null) {
searchTableName = ((PrimaryKey) example).getTable().getName();
searchTableName = database.correctObjectName(searchTableName, Table.class);
}
List<CachedRow> rs;
try {
JdbcDatabaseSnapshot.CachingDatabaseMetaData metaData = ((JdbcDatabaseSnapshot) snapshot)
.getMetaDataFromCache();
rs = metaData.getPrimaryKeys(((AbstractJdbcDatabase) database).getJdbcCatalogName(schema), (
(AbstractJdbcDatabase) database).getJdbcSchemaName(schema), searchTableName);
PrimaryKey returnKey = null;
for (CachedRow row : rs) {
if ((example.getName() != null) && !example.getName().equalsIgnoreCase(row.getString("PK_NAME"))) {
continue;
}
String columnName = cleanNameFromDatabase(row.getString("COLUMN_NAME"), database);
short position = row.getShort("KEY_SEQ");
if (returnKey == null) {
returnKey = new PrimaryKey();
CatalogAndSchema tableSchema = ((AbstractJdbcDatabase) database).getSchemaFromJdbcInfo(
row.getString("TABLE_CAT"), row.getString("TABLE_SCHEM")
);
returnKey.setTable((Table) new Table().setName(row.getString("TABLE_NAME"))
.setSchema(new Schema(tableSchema.getCatalogName(), tableSchema.getSchemaName())));
returnKey.setName(row.getString("PK_NAME"));
}
String ascOrDesc = row.getString("ASC_OR_DESC");
Boolean descending = null;
if("D".equals(ascOrDesc)) {
descending = Boolean.TRUE;
} else {
if ("A".equals(ascOrDesc)) {
descending = Boolean.FALSE;
}
}
boolean computed = descending != null && descending;
returnKey.addColumn(position - 1, new Column(columnName)
.setDescending(descending)
.setComputed(computed)
.setRelation(((PrimaryKey) example).getTable())
);
setValidateOptionIfAvailable(database, returnKey, row);
}
if (returnKey != null) {
Index exampleIndex = new Index().setRelation(returnKey.getTable());
exampleIndex.setColumns(returnKey.getColumns());
returnKey.setBackingIndex(exampleIndex);
}
return returnKey;
} catch (SQLException e) {
throw new DatabaseException(e);
}
}
/**
* Method to map 'validate' option for PK.
*
* @param database - DB where PK will be created
* @param primaryKey - PK object to persist validate option
* @param cachedRow - it's a cache-map to get metadata about PK
*/
private void setValidateOptionIfAvailable(Database database, PrimaryKey primaryKey, CachedRow cachedRow) {
if (!(database instanceof OracleDatabase)) {
return;
}
final String constraintValidate = cachedRow.getString("VALIDATED");
final String VALIDATE = "VALIDATED";
if (constraintValidate!=null && !constraintValidate.isEmpty()) {
primaryKey.setShouldValidate(VALIDATE.equals(cleanNameFromDatabase(constraintValidate.trim(), database)));
}
}
@Override
protected void addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot) throws DatabaseException {<FILL_FUNCTION_BODY>}
}
|
if (!snapshot.getSnapshotControl().shouldInclude(PrimaryKey.class) || !snapshot.getDatabase().supports(PrimaryKey.class)) {
return;
}
if (foundObject instanceof Table) {
Table table = (Table) foundObject;
Database database = snapshot.getDatabase();
Schema schema = table.getSchema();
List<CachedRow> rs;
try {
JdbcDatabaseSnapshot.CachingDatabaseMetaData metaData = ((JdbcDatabaseSnapshot) snapshot)
.getMetaDataFromCache();
rs = metaData.getPrimaryKeys(((AbstractJdbcDatabase) database).getJdbcCatalogName(schema), (
(AbstractJdbcDatabase) database).getJdbcSchemaName(schema), table.getName());
if (!rs.isEmpty()) {
PrimaryKey primaryKey = new PrimaryKey().setName(rs.get(0).getString("PK_NAME"));
primaryKey.setTable((Table) foundObject);
if (!database.isSystemObject(primaryKey)) {
table.setPrimaryKey(primaryKey.setTable(table));
}
}
} catch (SQLException e) {
throw new DatabaseException(e);
}
}
| 995
| 300
| 1,295
|
<methods>public void addStatusListener(liquibase.diff.DiffStatusListener) ,public Class<? extends liquibase.structure.DatabaseObject>[] addsTo() ,public int getPriority(Class<? extends liquibase.structure.DatabaseObject>, liquibase.database.Database) ,public Class<? extends liquibase.snapshot.SnapshotGenerator>[] replaces() ,public liquibase.structure.DatabaseObject snapshot(liquibase.structure.DatabaseObject, liquibase.snapshot.DatabaseSnapshot, liquibase.snapshot.SnapshotGeneratorChain) throws liquibase.exception.DatabaseException, liquibase.snapshot.InvalidExampleException<variables>private Class<? extends liquibase.structure.DatabaseObject>[] addsTo,private final non-sealed Class<? extends liquibase.structure.DatabaseObject> defaultFor,private final Set<liquibase.diff.DiffStatusListener> statusListeners
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/jvm/SchemaSnapshotGenerator.java
|
SchemaSnapshotGenerator
|
snapshotObject
|
class SchemaSnapshotGenerator extends JdbcSnapshotGenerator {
public SchemaSnapshotGenerator() {
super(Schema.class);
}
@Override
protected DatabaseObject snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {<FILL_FUNCTION_BODY>}
protected CatalogAndSchema toCatalogAndSchema(String tableSchema, Database database) {
return ((AbstractJdbcDatabase) database).getSchemaFromJdbcInfo(null, tableSchema);
}
@Override
protected void addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {
//no other types
}
/**
* Fetches an array of Strings with the schema names in the database.
* @param database The database from which to get the schema names
* @return An array of schema name Strings (May be an empty array)
* @throws SQLException propagated java.sql.SQLException
* @throws DatabaseException if a different problem occurs during the DBMS-specific code
*/
protected String[] getDatabaseSchemaNames(Database database) throws SQLException, DatabaseException {
List<String> returnList = new ArrayList<>();
try (ResultSet schemas = ((JdbcConnection) database.getConnection()).getMetaData().getSchemas()) {
while (schemas.next()) {
returnList.add(JdbcUtil.getValueForColumn(schemas, "TABLE_SCHEM", database));
}
}
return returnList.toArray(new String[0]);
}
}
|
Database database = snapshot.getDatabase();
Schema match = null;
String catalogName = ((Schema) example).getCatalogName();
String schemaName = example.getName();
if (database.supports(Schema.class)) {
if (catalogName == null) {
catalogName = database.getDefaultCatalogName();
}
if (schemaName == null) {
schemaName = database.getDefaultSchemaName();
}
} else {
if (database.supports(Catalog.class)) {
if ((catalogName == null) && (schemaName != null)) {
catalogName = schemaName;
schemaName = null;
}
} else {
catalogName = null;
schemaName = null;
}
}
example = new Schema(catalogName, schemaName);
// use LEGACY quoting since we're dealing with system objects
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
if (database.supports(Schema.class)) {
for (String tableSchema : getDatabaseSchemaNames(database)) {
CatalogAndSchema schemaFromJdbcInfo = toCatalogAndSchema(tableSchema, database);
Catalog catalog = new Catalog(schemaFromJdbcInfo.getCatalogName());
Schema schema = new Schema(catalog, tableSchema);
if (DatabaseObjectComparatorFactory.getInstance().isSameObject(schema, example, snapshot.getSchemaComparisons(), database)) {
if (match == null) {
match = schema;
} else {
throw new InvalidExampleException("Found multiple catalog/schemas matching " + ((Schema) example).getCatalogName() + "." + example.getName());
}
}
}
} else { // Database does NOT support schemas
// If the database supports catalogs, but does not support schema names, then we treat the schema
// name as equal to the catalog name.
if (((Schema) example).getCatalog().isDefault()) {
match = new Schema(((Schema) example).getCatalog(), catalogName);
} else {
/* Before we confirm the schema/catalog existence, we must first check if the catalog exists. */
Catalog catalog = ((Schema) example).getCatalog();
String[] dbCatalogNames = getDatabaseCatalogNames(database);
for (String candidateCatalogName : dbCatalogNames) {
if (catalog.equals(new Catalog(candidateCatalogName))) {
match = new Schema(catalog, catalogName);
}
}
}
}
} catch (SQLException e) {
throw new DatabaseException(e);
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
if ((match != null) && ((match.getName() == null) || match.getName().equalsIgnoreCase(database
.getDefaultSchemaName()))) {
match.setDefault(true);
}
return match;
| 382
| 764
| 1,146
|
<methods>public void addStatusListener(liquibase.diff.DiffStatusListener) ,public Class<? extends liquibase.structure.DatabaseObject>[] addsTo() ,public int getPriority(Class<? extends liquibase.structure.DatabaseObject>, liquibase.database.Database) ,public Class<? extends liquibase.snapshot.SnapshotGenerator>[] replaces() ,public liquibase.structure.DatabaseObject snapshot(liquibase.structure.DatabaseObject, liquibase.snapshot.DatabaseSnapshot, liquibase.snapshot.SnapshotGeneratorChain) throws liquibase.exception.DatabaseException, liquibase.snapshot.InvalidExampleException<variables>private Class<? extends liquibase.structure.DatabaseObject>[] addsTo,private final non-sealed Class<? extends liquibase.structure.DatabaseObject> defaultFor,private final Set<liquibase.diff.DiffStatusListener> statusListeners
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/jvm/TableSnapshotGenerator.java
|
TableSnapshotGenerator
|
snapshotObject
|
class TableSnapshotGenerator extends JdbcSnapshotGenerator {
public TableSnapshotGenerator() {
super(Table.class, new Class[] { Schema.class});
}
@Override
protected DatabaseObject snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot) throws DatabaseException {<FILL_FUNCTION_BODY>}
@Override
protected void addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {
if (!snapshot.getSnapshotControl().shouldInclude(Table.class) || !snapshot.getDatabase().supports(Table.class)) {
return;
}
if (foundObject instanceof Schema) {
Database database = snapshot.getDatabase();
Schema schema = (Schema) foundObject;
List<CachedRow> tableMetaDataRs = null;
try {
tableMetaDataRs = ((JdbcDatabaseSnapshot) snapshot).getMetaDataFromCache().getTables(((AbstractJdbcDatabase) database).getJdbcCatalogName(schema), ((AbstractJdbcDatabase) database).getJdbcSchemaName(schema), null);
for (CachedRow row : tableMetaDataRs) {
String tableName = row.getString("TABLE_NAME");
Table tableExample = (Table) new Table().setName(cleanNameFromDatabase(tableName, database)).setSchema(schema);
schema.addDatabaseObject(tableExample);
}
} catch (SQLException e) {
throw new DatabaseException(e);
}
}
}
protected Table readTable(CachedRow tableMetadataResultSet, Database database) throws SQLException, DatabaseException {
String rawTableName = tableMetadataResultSet.getString("TABLE_NAME");
String rawSchemaName = StringUtil.trimToNull(tableMetadataResultSet.getString("TABLE_SCHEM"));
String rawCatalogName = StringUtil.trimToNull(tableMetadataResultSet.getString("TABLE_CAT"));
String remarks = StringUtil.trimToNull(tableMetadataResultSet.getString("REMARKS"));
String tablespace = StringUtil.trimToNull(tableMetadataResultSet.getString("TABLESPACE_NAME"));
String defaultTablespaceString = StringUtil.trimToNull(tableMetadataResultSet.getString("DEFAULT_TABLESPACE"));
if (remarks != null) {
remarks = remarks.replace("''", "'"); //come back escaped sometimes
}
Table table = new Table().setName(cleanNameFromDatabase(rawTableName, database));
table.setRemarks(remarks);
table.setTablespace(tablespace);
table.setDefaultTablespace(BooleanUtil.isTrue(Boolean.parseBoolean(defaultTablespaceString)));
CatalogAndSchema schemaFromJdbcInfo = ((AbstractJdbcDatabase) database).getSchemaFromJdbcInfo(rawCatalogName, rawSchemaName);
table.setSchema(new Schema(schemaFromJdbcInfo.getCatalogName(), schemaFromJdbcInfo.getSchemaName()));
if ("Y".equals(tableMetadataResultSet.getString("TEMPORARY"))) {
table.setAttribute("temporary", "GLOBAL");
String duration = tableMetadataResultSet.getString("DURATION");
if ("SYS$TRANSACTION".equals(duration)) {
table.setAttribute("duration", "ON COMMIT DELETE ROWS");
} else if ("SYS$SESSION".equals(duration)) {
table.setAttribute("duration", "ON COMMIT PRESERVE ROWS");
}
}
return table;
}
}
|
Database database = snapshot.getDatabase();
String objectName = example.getName();
Schema schema = example.getSchema();
List<CachedRow> rs = null;
try {
JdbcDatabaseSnapshot.CachingDatabaseMetaData metaData = ((JdbcDatabaseSnapshot) snapshot).getMetaDataFromCache();
rs = metaData.getTables(((AbstractJdbcDatabase) database).getJdbcCatalogName(schema), ((AbstractJdbcDatabase) database).getJdbcSchemaName(schema), objectName);
Table table;
if (!rs.isEmpty()) {
table = readTable(rs.get(0), database);
} else {
return null;
}
return table;
} catch (SQLException e) {
throw new DatabaseException(e);
}
| 864
| 200
| 1,064
|
<methods>public void addStatusListener(liquibase.diff.DiffStatusListener) ,public Class<? extends liquibase.structure.DatabaseObject>[] addsTo() ,public int getPriority(Class<? extends liquibase.structure.DatabaseObject>, liquibase.database.Database) ,public Class<? extends liquibase.snapshot.SnapshotGenerator>[] replaces() ,public liquibase.structure.DatabaseObject snapshot(liquibase.structure.DatabaseObject, liquibase.snapshot.DatabaseSnapshot, liquibase.snapshot.SnapshotGeneratorChain) throws liquibase.exception.DatabaseException, liquibase.snapshot.InvalidExampleException<variables>private Class<? extends liquibase.structure.DatabaseObject>[] addsTo,private final non-sealed Class<? extends liquibase.structure.DatabaseObject> defaultFor,private final Set<liquibase.diff.DiffStatusListener> statusListeners
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/snapshot/jvm/ViewSnapshotGenerator.java
|
ViewSnapshotGenerator
|
snapshotObject
|
class ViewSnapshotGenerator extends JdbcSnapshotGenerator {
public ViewSnapshotGenerator() {
super(View.class, new Class[] { Schema.class });
}
@Override
protected DatabaseObject snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot) throws DatabaseException {<FILL_FUNCTION_BODY>}
@Override
protected void addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {
Database database = snapshot.getDatabase();
if (!snapshot.getSnapshotControl().shouldInclude(View.class) || !database.supports(View.class)) {
return;
}
if (!(foundObject instanceof Schema)) {
return;
}
Schema schema = (Schema) foundObject;
List<CachedRow> viewsMetadataRs;
try {
viewsMetadataRs = ((JdbcDatabaseSnapshot) snapshot).getMetaDataFromCache().getViews(((AbstractJdbcDatabase) database).getJdbcCatalogName(schema), ((AbstractJdbcDatabase) database).getJdbcSchemaName(schema), null);
for (CachedRow row : viewsMetadataRs) {
CatalogAndSchema catalogAndSchema = ((AbstractJdbcDatabase) database).getSchemaFromJdbcInfo(row.getString("TABLE_CAT"), row.getString("TABLE_SCHEM"));
View view = new View();
view.setName(row.getString("TABLE_NAME"));
view.setSchema(new Schema(catalogAndSchema.getCatalogName(), catalogAndSchema.getSchemaName()));
view.setRemarks(row.getString("REMARKS"));
String definition = StringUtil.standardizeLineEndings(row.getString("OBJECT_BODY"));
view.setDefinition(definition);
if(database instanceof OracleDatabase) {
view.setAttribute("editioning", "Y".equals(row.getString("EDITIONING_VIEW")));
}
schema.addDatabaseObject(view);
}
} catch (SQLException e) {
throw new DatabaseException(e);
}
}
}
|
if (((View) example).getDefinition() != null) {
return example;
}
Database database = snapshot.getDatabase();
Schema schema = example.getSchema();
List<CachedRow> viewsMetadataRs;
try {
viewsMetadataRs = ((JdbcDatabaseSnapshot) snapshot).getMetaDataFromCache().getViews(((AbstractJdbcDatabase) database).getJdbcCatalogName(schema), ((AbstractJdbcDatabase) database).getJdbcSchemaName(schema), example.getName());
if (!viewsMetadataRs.isEmpty()) {
CachedRow row = viewsMetadataRs.get(0);
String rawViewName = row.getString("TABLE_NAME");
String rawSchemaName = StringUtil.trimToNull(row.getString("TABLE_SCHEM"));
String rawCatalogName = StringUtil.trimToNull(row.getString("TABLE_CAT"));
String remarks = row.getString("REMARKS");
if (remarks != null) {
remarks = remarks.replace("''", "'"); //come back escaped sometimes
}
View view = new View().setName(cleanNameFromDatabase(rawViewName, database));
view.setRemarks(remarks);
CatalogAndSchema schemaFromJdbcInfo = ((AbstractJdbcDatabase) database).getSchemaFromJdbcInfo(rawCatalogName, rawSchemaName);
view.setSchema(new Schema(schemaFromJdbcInfo.getCatalogName(), schemaFromJdbcInfo.getSchemaName()));
ObjectQuotingStrategy originalQuotingStrategy = database.getObjectQuotingStrategy();
try {
database.setObjectQuotingStrategy(ObjectQuotingStrategy.QUOTE_ALL_OBJECTS);
String definition = database.getViewDefinition(schemaFromJdbcInfo, view.getName());
if (definition != null && definition.startsWith("FULL_DEFINITION: ")) {
definition = definition.replaceFirst("^FULL_DEFINITION: ", "");
view.setContainsFullDefinition(true);
}
// remove strange zero-termination seen on some Oracle view definitions
int length = definition != null ? definition.length() : 0;
if (length > 0 && definition.charAt(length-1) == 0) {
definition = definition.substring(0, length-1);
}
if (database instanceof InformixDatabase && definition != null) {
// Cleanup
definition = definition.trim();
definition = definition.replaceAll("\\s*,\\s*", ", ");
definition = definition.replaceAll("\\s*;", "");
// Strip the schema definition because it can optionally be included in the tag attribute
definition = definition.replaceAll("(?i)\""+view.getSchema().getName()+"\"\\.", "");
}
definition = StringUtil.trimToNull(definition);
if (definition == null) {
definition = "[CANNOT READ VIEW DEFINITION]";
String warningMessage = null;
if (database instanceof MariaDBDatabase) {
warningMessage =
"\nThe current MariaDB user does not have permissions to access view definitions needed for this Liquibase command.\n" +
"Please search the changelog for '[CANNOT READ VIEW DEFINITION]' to locate inaccessible objects. " +
"Learn more about altering permissions with suggested MariaDB GRANTs at https://docs.liquibase.com/workflows/liquibase-pro/mariadbgrants.html\n";
} else if (database instanceof MySQLDatabase) {
warningMessage =
"\nThe current MySQL user does not have permissions to access view definitions needed for this Liquibase command.\n" +
"Please search the changelog for '[CANNOT READ VIEW DEFINITION]' to locate inaccessible objects. This is\n" +
"potentially due to a known MySQL bug https://bugs.mysql.com/bug.php?id=22763. Learn more about altering\n" +
"permissions with suggested MySQL GRANTs at https://docs.liquibase.com/workflows/liquibase-pro/mysqlgrants.html\n";
}
if (warningMessage != null) {
Scope.getCurrentScope().getUI().sendMessage("WARNING: " + warningMessage);
Scope.getCurrentScope().getLog(getClass()).warning(warningMessage);
}
}
view.setDefinition(definition);
} catch (DatabaseException e) {
throw new DatabaseException("Error getting " + database.getConnection().getURL() + " view with " + new GetViewDefinitionStatement(view.getSchema().getCatalogName(), view.getSchema().getName(), rawViewName), e);
} finally {
database.setObjectQuotingStrategy(originalQuotingStrategy);
}
return view;
} else {
return null;
}
} catch (SQLException e) {
throw new DatabaseException(e);
}
| 505
| 1,224
| 1,729
|
<methods>public void addStatusListener(liquibase.diff.DiffStatusListener) ,public Class<? extends liquibase.structure.DatabaseObject>[] addsTo() ,public int getPriority(Class<? extends liquibase.structure.DatabaseObject>, liquibase.database.Database) ,public Class<? extends liquibase.snapshot.SnapshotGenerator>[] replaces() ,public liquibase.structure.DatabaseObject snapshot(liquibase.structure.DatabaseObject, liquibase.snapshot.DatabaseSnapshot, liquibase.snapshot.SnapshotGeneratorChain) throws liquibase.exception.DatabaseException, liquibase.snapshot.InvalidExampleException<variables>private Class<? extends liquibase.structure.DatabaseObject>[] addsTo,private final non-sealed Class<? extends liquibase.structure.DatabaseObject> defaultFor,private final Set<liquibase.diff.DiffStatusListener> statusListeners
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sql/visitor/AbstractSqlVisitor.java
|
AbstractSqlVisitor
|
load
|
class AbstractSqlVisitor implements SqlVisitor {
private Set<String> applicableDbms;
private boolean applyToRollback;
private ContextExpression contextFilter;
private Labels labels;
@Override
public Set<String> getApplicableDbms() {
return applicableDbms;
}
@Override
public void setApplicableDbms(Set<String> applicableDbms) {
this.applicableDbms = applicableDbms;
}
@Override
public boolean isApplyToRollback() {
return applyToRollback;
}
@Override
public void setApplyToRollback(boolean applyToRollback) {
this.applyToRollback = applyToRollback;
}
/**
* @deprecated use {@link #getContextFilter()}
*/
@Deprecated
public ContextExpression getContexts() {
return contextFilter;
}
/**
* @deprecated use {@link #setContextFilter(ContextExpression)}
*/
@Deprecated
public void setContexts(ContextExpression contexts) {
this.contextFilter = contexts;
}
@Override
public ContextExpression getContextFilter() {
return contextFilter;
}
@Override
public void setContextFilter(ContextExpression contextFilter) {
this.contextFilter = contextFilter;
}
@Override
public Labels getLabels() {
return labels;
}
@Override
public void setLabels(Labels labels) {
this.labels = labels;
}
@Override
public CheckSum generateCheckSum() {
ChecksumVersion version = Scope.getCurrentScope().getChecksumVersion();
return CheckSum.compute(new StringChangeLogSerializer(new StringChangeLogSerializer.FieldFilter(){
@Override
public boolean include(Object obj, String field, Object value) {
if(Arrays.stream(getExcludedFieldFilters(version)).anyMatch(filter -> filter.equals(field))) {
return false;
}
return super.include(obj, field, value);
}
}).serialize(this, false));
}
public String[] getExcludedFieldFilters(ChecksumVersion version) {
if (version.lowerOrEqualThan(ChecksumVersion.V8)) {
return new String[0];
}
return new String[]{
"applicableDbms",
"contextFilter",
"labels"
};
}
@Override
public Set<String> getSerializableFields() {
return ReflectionSerializer.getInstance().getFields(this);
}
@Override
public Object getSerializableFieldValue(String field) {
return ReflectionSerializer.getInstance().getValue(this, field);
}
@Override
public String getSerializedObjectName() {
return getName();
}
@Override
public SerializationType getSerializableFieldType(String field) {
return SerializationType.NAMED_FIELD;
}
@Override
public String getSerializedObjectNamespace() {
return GENERIC_CHANGELOG_EXTENSION_NAMESPACE;
}
@Override
public String getSerializableFieldNamespace(String field) {
return getSerializedObjectNamespace();
}
@Override
public void load(ParsedNode parsedNode, ResourceAccessor resourceAccessor) throws ParsedNodeException {<FILL_FUNCTION_BODY>}
@Override
public ParsedNode serialize() {
throw new RuntimeException("TODO");
}
}
|
for (ParsedNode childNode : parsedNode.getChildren()) {
try {
if ("dbms".equals(childNode.getName())) {
this.setApplicableDbms(new HashSet<>(StringUtil.splitAndTrim((String) childNode.getValue(), ",")));
} else if ("applyToRollback".equals(childNode.getName())) {
Boolean value = childNode.getValue(Boolean.class);
if (value != null) {
setApplyToRollback(value);
}
} else if ("contextFilter".equals(childNode.getName()) || "context".equals(childNode.getName()) || "contexts".equals(childNode.getName())) {
setContextFilter(new ContextExpression((String) childNode.getValue()));
} else if (ObjectUtil.hasWriteProperty(this, childNode.getName())) {
Object value = childNode.getValue();
if (value != null) {
value = value.toString();
}
ObjectUtil.setProperty(this, childNode.getName(), (String) value);
}
} catch (Exception e) {
throw new ParsedNodeException("Error setting property", e);
}
}
| 911
| 297
| 1,208
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sql/visitor/AppendSqlIfNotPresentVisitor.java
|
AppendSqlIfNotPresentVisitor
|
modifySql
|
class AppendSqlIfNotPresentVisitor extends AppendSqlVisitor {
@Override
public String modifySql(String sql, Database database) {<FILL_FUNCTION_BODY>}
}
|
String returnValue = sql;
String appendValue = getValue();
if (! returnValue.endsWith(appendValue)) {
returnValue += appendValue;
}
return returnValue;
| 50
| 51
| 101
|
<methods>public non-sealed void <init>() ,public java.lang.String getName() ,public java.lang.String getSerializedObjectNamespace() ,public java.lang.String modifySql(java.lang.String, liquibase.database.Database) <variables>private java.lang.String value
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sql/visitor/SqlVisitorFactory.java
|
SqlVisitorFactory
|
create
|
class SqlVisitorFactory {
@SuppressWarnings("unchecked")
private final Map<String, Class> tagToClassMap;
private static final SqlVisitorFactory instance = new SqlVisitorFactory();
@SuppressWarnings("unchecked")
private SqlVisitorFactory() {
tagToClassMap = new HashMap<>();
Class[] visitors = new Class[]{
PrependSqlVisitor.class,
AppendSqlVisitor.class,
RegExpReplaceSqlVisitor.class,
ReplaceSqlVisitor.class,
};
try {
for (Class<SqlVisitor> visitorClass : visitors) {
SqlVisitor visitor = visitorClass.getConstructor().newInstance();
tagToClassMap.put(visitor.getName(), visitorClass);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static SqlVisitorFactory getInstance() {
return instance;
}
/**
* Create a new Change subclass based on the given tag name.
*/
public SqlVisitor create(String tagName) {<FILL_FUNCTION_BODY>}
}
|
Class<?> aClass = tagToClassMap.get(tagName);
if (aClass == null) {
return null;
}
try {
return (SqlVisitor) aClass.getConstructor().newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
| 292
| 82
| 374
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/SqlGeneratorChain.java
|
SqlGeneratorChain
|
generateSql
|
class SqlGeneratorChain<T extends SqlStatement> {
private Iterator<SqlGenerator<T>> sqlGenerators;
public SqlGeneratorChain(SortedSet<SqlGenerator<T>> sqlGenerators) {
if (sqlGenerators != null) {
this.sqlGenerators = sqlGenerators.iterator();
}
}
public Sql[] generateSql(T statement, Database database) {<FILL_FUNCTION_BODY>}
public Warnings warn(T statement, Database database) {
if ((sqlGenerators == null) || !sqlGenerators.hasNext()) {
return new Warnings();
}
return sqlGenerators.next().warn(statement, database, this);
}
public ValidationErrors validate(T statement, Database database) {
if ((sqlGenerators == null) || !sqlGenerators.hasNext()) {
return new ValidationErrors();
}
return sqlGenerators.next().validate(statement, database, this);
}
}
|
if (sqlGenerators == null) {
return null;
}
if (!sqlGenerators.hasNext()) {
return EMPTY_SQL;
}
return sqlGenerators.next().generateSql(statement, database, this);
| 247
| 66
| 313
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AbstractSqlGenerator.java
|
AbstractSqlGenerator
|
looksLikeFunctionCall
|
class AbstractSqlGenerator<T extends SqlStatement> implements SqlGenerator<T> {
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
@Override
public boolean generateStatementsIsVolatile(Database database) {
return false;
}
@Override
public boolean generateRollbackStatementsIsVolatile(Database database) {
return false;
}
@Override
public boolean supports(T statement, Database database) {
return true;
}
@Override
public Warnings warn(T statementType, Database database, SqlGeneratorChain<T> sqlGeneratorChain) {
return sqlGeneratorChain.warn(statementType, database);
}
/**
* Tries to find out if a given value (part a database-specific SQL statement) is just a simple literal
* (e.g. 'Jones', 149.99 or false) or if it is a call to a function within the database (e.g.
* TO_DATE('28.12.2017', 'dd.mm.yyyy') in Oracle DB).
* This method is often used to determine if we need to quote literals which are Strings, e.g. if we determine
* "Dr. Jones" to be a literal, then we generate
* <pre><code>{@code INSERT INTO customers(last_name) VALUES('Dr. Jones')}</code></pre>
* but if the value is a function call, we may not quote it, e.g. for "TO_DATE('28.12.2017', 'dd.mm.yyyy')", we
* need to generate (note the absence of the apostrophes!):
* <pre><code>{@code INSERT INTO bookings(booking_date) VALUES (TO_DATE('28.12.2017', 'dd.mm.yyyy'))}</code></pre>
* @param value The string to test
* @param database the database object to test against
* @return true if value looks like a function call, false if it looks like a literal.
*/
public boolean looksLikeFunctionCall(String value, Database database) {<FILL_FUNCTION_BODY>}
}
|
// TODO: SYSIBM looks DB2-specific, we should move that out of AbstractSqlGenerator into a DB2-specific class.
return value.startsWith("\"SYSIBM\"") || value.startsWith("to_date(") ||
value.equalsIgnoreCase(database.getCurrentDateTimeFunction());
| 552
| 77
| 629
|
<no_super_class>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddAutoIncrementGenerator.java
|
AddAutoIncrementGenerator
|
generateSql
|
class AddAutoIncrementGenerator extends AbstractSqlGenerator<AddAutoIncrementStatement> {
@Override
public int getPriority() {
return PRIORITY_DEFAULT;
}
@Override
public boolean supports(AddAutoIncrementStatement statement, Database database) {
return (database.supportsAutoIncrement()
&& !(database instanceof Db2zDatabase)
&& !(database instanceof DerbyDatabase)
&& !(database instanceof MSSQLDatabase)
&& !(database instanceof HsqlDatabase)
&& !(database instanceof H2Database)
&& !(database instanceof OracleDatabase));
}
@Override
public ValidationErrors validate(
AddAutoIncrementStatement statement,
Database database,
SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("columnName", statement.getColumnName());
validationErrors.checkRequiredField("tableName", statement.getTableName());
validationErrors.checkRequiredField("columnDataType", statement.getColumnDataType());
return validationErrors;
}
@Override
public Sql[] generateSql(
AddAutoIncrementStatement statement,
Database database,
SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Column getAffectedColumn(AddAutoIncrementStatement statement) {
return new Column()
.setRelation(new Table().setName(statement.getTableName()).setSchema(
new Schema(statement.getCatalogName(), statement.getSchemaName())))
.setName(statement.getColumnName());
}
}
|
String sql;
if (database instanceof SybaseASADatabase) {
sql = "ALTER TABLE " +
database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(),
statement.getTableName()) +
" ALTER " +
database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement
.getTableName(), statement.getColumnName()) +
" SET " +
database.getAutoIncrementClause(statement.getStartWith(), statement.getIncrementBy(), null, null);
} else {
sql = "ALTER TABLE " +
database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement
.getTableName()) +
" MODIFY " +
database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement
.getTableName(), statement.getColumnName()) +
" " +
DataTypeFactory.getInstance().fromDescription(statement.getColumnDataType() +
"{autoIncrement:true}", database).toDatabaseDataType(database) +
" " +
database.getAutoIncrementClause(statement.getStartWith(), statement.getIncrementBy(), statement.getGenerationType(), statement.getDefaultOnNull());
}
return new Sql[]{
new UnparsedSql(sql, getAffectedColumn(statement))
};
| 407
| 350
| 757
|
<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.AddAutoIncrementStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.AddAutoIncrementStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddAutoIncrementGeneratorDB2.java
|
AddAutoIncrementGeneratorDB2
|
validate
|
class AddAutoIncrementGeneratorDB2 extends AddAutoIncrementGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddAutoIncrementStatement statement, Database database) {
return database instanceof AbstractDb2Database;
}
@Override
public ValidationErrors validate(
AddAutoIncrementStatement statement,
Database database,
SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(
AddAutoIncrementStatement statement,
Database database,
SqlGeneratorChain sqlGeneratorChain) {
return new Sql[]{
new UnparsedSql(
"ALTER TABLE "
+ database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
+ " ALTER COLUMN "
+ database.escapeColumnName(
statement.getCatalogName(),
statement.getSchemaName(),
statement.getTableName(),
statement.getColumnName())
+ " SET "
+ database.getAutoIncrementClause(
statement.getStartWith(), statement.getIncrementBy(), statement.getGenerationType(), statement.getDefaultOnNull()),
getAffectedColumn(statement))
};
}
}
|
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("columnName", statement.getColumnName());
validationErrors.checkRequiredField("tableName", statement.getTableName());
return validationErrors;
| 337
| 60
| 397
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public int getPriority() ,public boolean supports(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddAutoIncrementGeneratorHsqlH2.java
|
AddAutoIncrementGeneratorHsqlH2
|
generateSql
|
class AddAutoIncrementGeneratorHsqlH2 extends AddAutoIncrementGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddAutoIncrementStatement statement, Database database) {
return (database instanceof HsqlDatabase) || (database instanceof H2Database);
}
@Override
public Sql[] generateSql(
AddAutoIncrementStatement statement,
Database database,
SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
return new Sql[]{
new UnparsedSql(
"ALTER TABLE "
+ database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
+ " ALTER COLUMN "
+ database.escapeColumnName(
statement.getCatalogName(),
statement.getSchemaName(),
statement.getTableName(),
statement.getColumnName())
+ " "
+ DataTypeFactory.getInstance().fromDescription(statement.getColumnDataType(), database)
+ " "
+ database.getAutoIncrementClause(
statement.getStartWith(), statement.getIncrementBy(), statement.getGenerationType(), statement.getDefaultOnNull()),
getAffectedColumn(statement))
};
| 144
| 190
| 334
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public int getPriority() ,public boolean supports(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddAutoIncrementGeneratorInformix.java
|
AddAutoIncrementGeneratorInformix
|
validate
|
class AddAutoIncrementGeneratorInformix extends AddAutoIncrementGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddAutoIncrementStatement statement, Database database) {
return database instanceof InformixDatabase;
}
@Override
public ValidationErrors validate(
AddAutoIncrementStatement addAutoIncrementStatement,
Database database,
SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(
AddAutoIncrementStatement statement,
Database database,
SqlGeneratorChain sqlGeneratorChain) {
return new Sql[]{
new UnparsedSql(
"ALTER TABLE "
+ database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
+ " MODIFY "
+ database.escapeColumnName(
statement.getCatalogName(),
statement.getSchemaName(),
statement.getTableName(),
statement.getColumnName())
+ " "
+ DataTypeFactory.getInstance().fromDescription(statement.getColumnDataType() + "{autoIncrement:true}", database).toDatabaseDataType(database),
getAffectedColumn(statement))
};
}
}
|
ValidationErrors validationErrors = super.validate(
addAutoIncrementStatement, database, sqlGeneratorChain);
validationErrors.checkRequiredField(
"columnDataType", addAutoIncrementStatement.getColumnDataType());
return validationErrors;
| 335
| 66
| 401
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public int getPriority() ,public boolean supports(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddAutoIncrementGeneratorMySQL.java
|
AddAutoIncrementGeneratorMySQL
|
generateSql
|
class AddAutoIncrementGeneratorMySQL extends AddAutoIncrementGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddAutoIncrementStatement statement, Database database) {
return database instanceof MySQLDatabase;
}
@Override
public Sql[] generateSql(final AddAutoIncrementStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public ValidationErrors validate(AddAutoIncrementStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = super.validate(statement, database, sqlGeneratorChain);
validationErrors.checkDisallowedField("incrementBy", statement.getIncrementBy(), database, MySQLDatabase.class);
return validationErrors;
}
private Sql[] concat(Sql[] origSql, UnparsedSql unparsedSql) {
Sql[] changedSql = new Sql[origSql.length+1];
System.arraycopy(origSql, 0, changedSql, 0, origSql.length);
changedSql[origSql.length] = unparsedSql;
return changedSql;
}
private DatabaseObject getAffectedTable(AddAutoIncrementStatement statement) {
return new Table().setName(statement.getTableName()).setSchema(new Schema(statement.getCatalogName(), statement.getSchemaName()));
}
}
|
Sql[] sql = super.generateSql(statement, database, sqlGeneratorChain);
if(statement.getStartWith() != null){
MySQLDatabase mysqlDatabase = (MySQLDatabase)database;
String alterTableSql = "ALTER TABLE "
+ mysqlDatabase.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
+ " "
+ mysqlDatabase.getTableOptionAutoIncrementStartWithClause(statement.getStartWith());
sql = concat(sql, new UnparsedSql(alterTableSql, getAffectedTable(statement)));
}
return sql;
| 367
| 158
| 525
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public int getPriority() ,public boolean supports(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddAutoIncrementGeneratorSQLite.java
|
AddAutoIncrementGeneratorSQLite
|
generateStatementsIsVolatile
|
class AddAutoIncrementGeneratorSQLite extends AddAutoIncrementGenerator {
@Override
public ValidationErrors validate(AddAutoIncrementStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return super.validate(statement, database, sqlGeneratorChain);
}
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddAutoIncrementStatement statement, Database database) {
return database instanceof SQLiteDatabase;
}
@Override
public boolean generateStatementsIsVolatile(Database database) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(final AddAutoIncrementStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
// Workaround implemented by replacing a table with a new one (duplicate)
// with auto increment set true on the specified column
// https://sqlite.org/autoinc.html
// For Auto increment to work, the column has to be either primary or have rowid specified on insert statements
// Since adding rowid on inserts is out of scope here, we will try to use primary key for the column
Sql[] generatedSqls;
SQLiteDatabase.AlterTableVisitor alterTableVisitor = new SQLiteDatabase.AlterTableVisitor() {
@Override
public ColumnConfig[] getColumnsToAdd() {
return new ColumnConfig[0];
}
@Override
public boolean copyThisColumn(ColumnConfig column) {
return true;
}
@Override
public boolean createThisColumn(ColumnConfig column) {
// update the column to set autoincrement while copying
setPrimaryKeyAndAutoIncrement(column, statement);
return true;
}
@Override
public boolean createThisIndex(Index index) {
return true;
}
};
generatedSqls = SQLiteDatabase.getAlterTableSqls(database, alterTableVisitor, statement.getCatalogName(),
statement.getSchemaName(), statement.getTableName());
return generatedSqls;
}
private void setPrimaryKeyAndAutoIncrement(ColumnConfig column, AddAutoIncrementStatement statement) {
if (column.getName().equals(statement.getColumnName())) {
column.setAutoIncrement(true);
ConstraintsConfig constraints = column.getConstraints();
if (constraints == null) {
constraints = new ConstraintsConfig();
column.setConstraints(constraints);
}
constraints.setPrimaryKey(true);
}
}
}
|
// need metadata for copying the table
return true;
| 645
| 17
| 662
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public int getPriority() ,public boolean supports(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddAutoIncrementStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddColumnGeneratorDefaultClauseBeforeNotNull.java
|
AddColumnGeneratorDefaultClauseBeforeNotNull
|
getDefaultClauseBeforeNotNull
|
class AddColumnGeneratorDefaultClauseBeforeNotNull extends AddColumnGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddColumnStatement statement, Database database) {
return (database instanceof OracleDatabase) || (database instanceof HsqlDatabase) || (database instanceof
H2Database) || (database instanceof DerbyDatabase) || (database instanceof AbstractDb2Database) || (database
instanceof FirebirdDatabase) || (database instanceof SybaseDatabase) || (database instanceof
SybaseASADatabase) || (database instanceof InformixDatabase);
}
@Override
public ValidationErrors validate(AddColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = super.validate(statement, database, sqlGeneratorChain);
if (statement.isMultiple()) {
for (AddColumnStatement column : statement.getColumns()) {
validateSingleColumn(column, database, validationErrors);
}
} else {
validateSingleColumn(statement, database, validationErrors);
}
return validationErrors;
}
private void validateSingleColumn(AddColumnStatement statement,
Database database, ValidationErrors validationErrors) {
if ((database instanceof DerbyDatabase) && statement.isAutoIncrement()) {
validationErrors.addError("Cannot add an identity column to derby");
}
}
@Override
protected String generateSingleColumnSQL(AddColumnStatement statement,
Database database) {
String alterTable = " ADD " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " " + DataTypeFactory.getInstance().fromDescription(statement.getColumnType() + (statement.isAutoIncrement() ? "{autoIncrement:true}" : ""), database).toDatabaseDataType(database);
alterTable += getDefaultClauseBeforeNotNull(statement, database);
if (primaryKeyBeforeNotNull(database)) {
if (statement.isPrimaryKey()) {
alterTable += " PRIMARY KEY";
}
}
if (statement.isAutoIncrement()) {
AutoIncrementConstraint autoIncrementConstraint = statement.getAutoIncrementConstraint();
alterTable += " " + database.getAutoIncrementClause(autoIncrementConstraint.getStartWith(), autoIncrementConstraint.getIncrementBy(), autoIncrementConstraint.getGenerationType(), autoIncrementConstraint.getDefaultOnNull());
}
if (!statement.isNullable()) {
alterTable += " NOT NULL";
} else if ((database instanceof SybaseDatabase) || (database instanceof SybaseASADatabase)) {
alterTable += " NULL";
}
if (!primaryKeyBeforeNotNull(database)) {
if (statement.isPrimaryKey()) {
alterTable += " PRIMARY KEY";
}
}
if (!StringUtil.isEmpty(statement.getAddBeforeColumn())) {
alterTable += " BEFORE " + database.escapeColumnName(statement.getSchemaName(), statement.getSchemaName(), statement.getTableName(), statement.getAddBeforeColumn()) + " ";
}
if (!StringUtil.isEmpty(statement.getAddAfterColumn())) {
alterTable += " AFTER " + database.escapeColumnName(statement.getSchemaName(), statement.getSchemaName(), statement.getTableName(), statement.getAddAfterColumn());
}
return alterTable;
}
private String getDefaultClauseBeforeNotNull(AddColumnStatement statement, Database database) {<FILL_FUNCTION_BODY>}
private boolean primaryKeyBeforeNotNull(Database database) {
return !((database instanceof HsqlDatabase) || (database instanceof H2Database));
}
}
|
String clause = "";
Object defaultValue = statement.getDefaultValue();
if (defaultValue != null) {
clause += " DEFAULT " + DataTypeFactory.getInstance().fromObject(defaultValue, database).objectToSql(defaultValue, database);
}
return clause;
| 917
| 71
| 988
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddColumnStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddColumnStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>public static final java.util.regex.Pattern REFERENCE_PATTERN,private static final java.lang.String REFERENCE_REGEX
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddColumnGeneratorSQLite.java
|
AddColumnGeneratorSQLite
|
generateSql
|
class AddColumnGeneratorSQLite extends AddColumnGenerator {
@Override
public ValidationErrors validate(AddColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = super.validate(statement, database, sqlGeneratorChain);
validationErrors.checkRequiredField("tableName", statement);
validationErrors.checkRequiredField("columnName", statement);
return validationErrors;
}
@Override
public boolean generateStatementsIsVolatile(Database database) {
// need metadata for copying the table
return true;
}
@Override
public boolean supports(AddColumnStatement statement, Database database) {
return database instanceof SQLiteDatabase;
}
@Override
public Sql[] generateSql(final AddColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
}
|
// Workaround implemented by replacing a table with a new one (duplicate)
// with a new column added
final List<AddColumnStatement> columns = new ArrayList<>(statement.getColumns());
if (columns.size() == 0) {
columns.add(statement);
}
Set<String> newColumnNames = columns.stream().map(AddColumnStatement::getColumnName).collect(Collectors.toSet());
Sql[] generatedSqls;
SQLiteDatabase.AlterTableVisitor alterTableVisitor = new SQLiteDatabase.AlterTableVisitor() {
@Override
public ColumnConfig[] getColumnsToAdd() {
ColumnConfig[] columnConfigs = new ColumnConfig[columns.size()];
int i = 0;
for (AddColumnStatement column : columns) {
ColumnConfig newColumn = new ColumnConfig();
newColumn.setName(column.getColumnName());
newColumn.setType(column.getColumnType());
newColumn.setAutoIncrement(column.isAutoIncrement());
ConstraintsConfig constraintsConfig = new ConstraintsConfig();
if (column.isPrimaryKey()) {
constraintsConfig.setPrimaryKey(true);
}
if (column.isNullable()) {
constraintsConfig.setNullable(true);
}
if (column.isUnique()) {
constraintsConfig.setUnique(true);
}
newColumn.setConstraints(constraintsConfig);
for (ColumnConstraint constraint : column.getConstraints()) {
if (constraint instanceof ForeignKeyConstraint) {
final ForeignKeyConstraint fkConstraint = (ForeignKeyConstraint) constraint;
constraintsConfig.setReferencedTableCatalogName(fkConstraint.getReferencedTableCatalogName());
constraintsConfig.setReferencedTableSchemaName(fkConstraint.getReferencedTableSchemaName());
constraintsConfig.setReferencedTableName(fkConstraint.getReferencedTableName());
constraintsConfig.setReferencedColumnNames(fkConstraint.getReferencedColumnNames());
constraintsConfig.setReferences(fkConstraint.getReferences());
constraintsConfig.setForeignKeyName(fkConstraint.getForeignKeyName());
if (fkConstraint.isDeleteCascade()) {
constraintsConfig.setDeleteCascade(true);
}
}
}
columnConfigs[i++] = newColumn;
}
return columnConfigs;
}
@Override
public boolean copyThisColumn(ColumnConfig column) {
return !newColumnNames.contains(column.getName());
}
@Override
public boolean createThisColumn(ColumnConfig column) {
return true;
}
@Override
public boolean createThisIndex(Index index) {
return true;
}
};
final String catalogName = columns.get(0).getCatalogName();
final String schemaName = columns.get(0).getSchemaName();
final String tableName = columns.get(0).getTableName();
generatedSqls = SQLiteDatabase.getAlterTableSqls(database, alterTableVisitor, catalogName,
schemaName, tableName);
return generatedSqls;
| 239
| 795
| 1,034
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddColumnStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddColumnStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>public static final java.util.regex.Pattern REFERENCE_PATTERN,private static final java.lang.String REFERENCE_REGEX
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddDefaultValueGenerator.java
|
AddDefaultValueGenerator
|
validate
|
class AddDefaultValueGenerator extends AbstractSqlGenerator<AddDefaultValueStatement> {
@Override
public ValidationErrors validate(AddDefaultValueStatement addDefaultValueStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public Warnings warn(AddDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
Warnings warnings = super.warn(statement, database, sqlGeneratorChain);
if (database instanceof MySQLDatabase) {
((MySQLDatabase) database).warnAboutAlterColumn("addDefaultValue", warnings);
}
return warnings;
}
@Override
public Sql[] generateSql(AddDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
Object defaultValue = statement.getDefaultValue();
return new Sql[] {
new UnparsedSql("ALTER TABLE "
+ database.escapeTableName(
statement.getCatalogName(),
statement.getSchemaName(),
statement.getTableName() )
+ " ALTER COLUMN "
+ database.escapeColumnName(
statement.getCatalogName(),
statement.getSchemaName(),
statement.getTableName(),
statement.getColumnName()
) + " SET DEFAULT "
+ DataTypeFactory.getInstance()
.fromObject(defaultValue, database)
.objectToSql(defaultValue, database),
getAffectedColumn(statement) )
};
}
protected Column getAffectedColumn(AddDefaultValueStatement statement) {
return new Column()
.setRelation(new Table().setName(statement.getTableName()).setSchema(new Schema(statement.getCatalogName(), statement.getSchemaName())))
.setName(statement.getColumnName());
}
}
|
Object defaultValue = addDefaultValueStatement.getDefaultValue();
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("defaultValue", defaultValue, true);
validationErrors.checkRequiredField("columnName", addDefaultValueStatement.getColumnName());
validationErrors.checkRequiredField("tableName", addDefaultValueStatement.getTableName());
if (!database.supports(Sequence.class) && (defaultValue instanceof SequenceNextValueFunction)) {
validationErrors.addError("Database "+database.getShortName()+" does not support sequences");
}
if (database instanceof HsqlDatabase) {
if (defaultValue instanceof SequenceNextValueFunction) {
validationErrors.addError("Database " + database.getShortName() + " does not support adding sequence-based default values");
} else if ((defaultValue instanceof DatabaseFunction) && !HsqlDatabase.supportsDefaultValueComputed
(addDefaultValueStatement.getColumnDataType(), defaultValue.toString())) {
validationErrors.addError("Database " + database.getShortName() + " does not support adding function-based default values");
}
}
String columnDataType = addDefaultValueStatement.getColumnDataType();
if (columnDataType != null) {
LiquibaseDataType dataType = DataTypeFactory.getInstance().fromDescription(columnDataType, database);
boolean typeMismatch = false;
if (dataType instanceof BooleanType) {
if (!(defaultValue instanceof Boolean) && !(defaultValue instanceof DatabaseFunction)) {
typeMismatch = true;
}
} else if (dataType instanceof CharType) {
if (!(defaultValue instanceof String) && !(defaultValue instanceof DatabaseFunction)) {
typeMismatch = true;
}
}
if (typeMismatch) {
validationErrors.addError("Default value of "+defaultValue+" does not match defined type of "+columnDataType);
}
}
return validationErrors;
| 441
| 485
| 926
|
<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.AddDefaultValueStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.AddDefaultValueStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddDefaultValueGeneratorDerby.java
|
AddDefaultValueGeneratorDerby
|
generateSql
|
class AddDefaultValueGeneratorDerby extends AddDefaultValueGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddDefaultValueStatement statement, Database database) {
return database instanceof DerbyDatabase;
}
@Override
public Sql[] generateSql(AddDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
Object defaultValue = statement.getDefaultValue();
return new Sql[]{
new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " ALTER COLUMN " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " WITH DEFAULT " + DataTypeFactory.getInstance().fromObject(defaultValue, database).objectToSql(defaultValue, database),
getAffectedColumn(statement))
};
| 118
| 141
| 259
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddDefaultValueGeneratorInformix.java
|
AddDefaultValueGeneratorInformix
|
generateSql
|
class AddDefaultValueGeneratorInformix extends AddDefaultValueGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddDefaultValueStatement statement, Database database) {
return database instanceof InformixDatabase;
}
@Override
public ValidationErrors validate(AddDefaultValueStatement addDefaultValueStatement, Database database,
SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = super.validate(addDefaultValueStatement, database, sqlGeneratorChain);
if (addDefaultValueStatement.getColumnDataType() == null) {
validationErrors.checkRequiredField("columnDataType", addDefaultValueStatement.getColumnDataType());
}
return validationErrors;
}
@Override
public Sql[] generateSql(AddDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
Object defaultValue = statement.getDefaultValue();
String sql = String.format("ALTER TABLE %s MODIFY (%s %s DEFAULT %s)",
database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()),
database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()),
DataTypeFactory.getInstance().fromDescription(statement.getColumnDataType(), database).toDatabaseDataType(database),
DataTypeFactory.getInstance().fromObject(defaultValue, database).objectToSql(defaultValue, database)
);
UnparsedSql unparsedSql = new UnparsedSql(sql, getAffectedColumn(statement));
return new Sql[]{unparsedSql};
| 230
| 195
| 425
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddDefaultValueGeneratorMSSQL.java
|
AddDefaultValueGeneratorMSSQL
|
generateSql
|
class AddDefaultValueGeneratorMSSQL extends AddDefaultValueGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddDefaultValueStatement statement, Database database) {
return database instanceof MSSQLDatabase;
}
@Override
public Sql[] generateSql(AddDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
Object defaultValue = statement.getDefaultValue();
String constraintName = statement.getDefaultValueConstraintName();
if (constraintName == null) {
constraintName = ((MSSQLDatabase) database).generateDefaultConstraintName(statement.getTableName(), statement.getColumnName());
}
return new Sql[] {
new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " ADD CONSTRAINT " + database.escapeObjectName(constraintName, Column.class) + " DEFAULT " + DataTypeFactory.getInstance().fromObject(defaultValue, database).objectToSql(defaultValue, database) + " FOR " + database.escapeObjectName(statement.getColumnName(), Column.class),
getAffectedColumn(statement))
};
| 120
| 199
| 319
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddDefaultValueGeneratorMySQL.java
|
AddDefaultValueGeneratorMySQL
|
generateSql
|
class AddDefaultValueGeneratorMySQL extends AddDefaultValueGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddDefaultValueStatement statement, Database database) {
return database instanceof MySQLDatabase;
}
@Override
public ValidationErrors validate(AddDefaultValueStatement addDefaultValueStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors errors = super.validate(addDefaultValueStatement, database, sqlGeneratorChain);
try {
int majorVersion = database.getDatabaseMajorVersion();
int minorVersion = database.getDatabaseMinorVersion();
if (addDefaultValueStatement.getDefaultValue() instanceof DatabaseFunction
&& (majorVersion < 5 || (majorVersion == 5 && minorVersion < 7))) {
errors.addError("This version of mysql does not support non-literal default values");
}
}
catch (DatabaseException e){
Scope.getCurrentScope().getLog(getClass()).fine("Can't get default value");
}
return errors;
}
@Override
public Sql[] generateSql(AddDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
Object defaultValue = statement.getDefaultValue();
String finalDefaultValue;
if (defaultValue instanceof DatabaseFunction) {
try {
if (database.getDatabaseMajorVersion() == 5 && database.getDatabaseMinorVersion() >= 7) {
finalDefaultValue = defaultValue.toString();
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) + " DEFAULT " + finalDefaultValue,
getAffectedColumn(statement))
};
}
}
catch (DatabaseException e) {
Scope.getCurrentScope().getLog(getClass()).fine("Can't get database version");
}
finalDefaultValue = "("+defaultValue+")";
if (finalDefaultValue.startsWith("((")) {
finalDefaultValue = defaultValue.toString();
}
} else {
finalDefaultValue = DataTypeFactory.getInstance().fromObject(defaultValue, database).objectToSql(defaultValue, database);
}
return new Sql[]{
new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " ALTER " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " SET DEFAULT " + finalDefaultValue,
getAffectedColumn(statement))
};
| 312
| 439
| 751
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddDefaultValueGeneratorOracle.java
|
AddDefaultValueGeneratorOracle
|
generateSql
|
class AddDefaultValueGeneratorOracle extends AddDefaultValueGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddDefaultValueStatement statement, Database database) {
return database instanceof OracleDatabase;
}
@Override
public Sql[] generateSql(AddDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
Object defaultValue = statement.getDefaultValue();
return new Sql[]{
new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " MODIFY " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " DEFAULT " + DataTypeFactory.getInstance().fromObject(defaultValue, database).objectToSql(defaultValue, database),
getAffectedColumn(statement))
};
| 117
| 138
| 255
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddDefaultValueGeneratorPostgres.java
|
AddDefaultValueGeneratorPostgres
|
generateSql
|
class AddDefaultValueGeneratorPostgres extends AddDefaultValueGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddDefaultValueStatement statement, Database database) {
return database instanceof PostgresDatabase;
}
@Override
public Sql[] generateSql(final AddDefaultValueStatement statement, final Database database,
final SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Sequence getAffectedSequence(SequenceNextValueFunction sequenceFunction) {
return new Sequence().setName(sequenceFunction.getValue());
}
}
|
if (!(statement.getDefaultValue() instanceof SequenceNextValueFunction)) {
return super.generateSql(statement, database, sqlGeneratorChain);
}
List<Sql> commands = new ArrayList<>(Arrays.asList(super.generateSql(statement, database, sqlGeneratorChain)));
// for postgres, we need to also set the sequence to be owned by this table for true serial like functionality.
// this will allow a drop table cascade to remove the sequence as well.
SequenceNextValueFunction sequenceFunction = (SequenceNextValueFunction) statement.getDefaultValue();
String sequenceName = sequenceFunction.getValue();
String sequenceSchemaName = sequenceFunction.getSchemaName();
String sequence = database.escapeObjectName(null, sequenceSchemaName, sequenceName, Sequence.class);
Sql alterSequenceOwner = new UnparsedSql("ALTER SEQUENCE " + sequence + " OWNED BY " +
database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + "."
+ database.escapeObjectName(statement.getColumnName(), Column.class),
getAffectedColumn(statement),
getAffectedSequence(sequenceFunction));
commands.add(alterSequenceOwner);
return commands.toArray(EMPTY_SQL);
| 162
| 315
| 477
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddDefaultValueGeneratorSQLite.java
|
AddDefaultValueGeneratorSQLite
|
createThisColumn
|
class AddDefaultValueGeneratorSQLite extends AddDefaultValueGenerator {
@Override
public ValidationErrors validate(AddDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return super.validate(statement, database, sqlGeneratorChain);
}
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddDefaultValueStatement statement, Database database) {
return database instanceof SQLiteDatabase;
}
@Override
public boolean generateStatementsIsVolatile(Database database) {
// need metadata for copying the table
return true;
}
@Override
public Sql[] generateSql(final AddDefaultValueStatement statement, final Database database, SqlGeneratorChain sqlGeneratorChain) {
// Workaround implemented by replacing a table with a new one (duplicate)
// with default value set on the specified column
final SQLiteDatabase.AlterTableVisitor alterTableVisitor = new SQLiteDatabase.AlterTableVisitor() {
@Override
public ColumnConfig[] getColumnsToAdd() {
return new ColumnConfig[0];
}
@Override
public boolean copyThisColumn(ColumnConfig column) {
return true;
}
@Override
public boolean createThisColumn(ColumnConfig column) {<FILL_FUNCTION_BODY>}
@Override
public boolean createThisIndex(Index index) {
return true;
}
};
return SQLiteDatabase.getAlterTableSqls(database, alterTableVisitor, statement.getCatalogName(),
statement.getSchemaName(), statement.getTableName());
}
}
|
// update the column to set Default value while copying
if (column.getName().equals(statement.getColumnName())) {
if (statement.getDefaultValueConstraintName() != null) {
column.setDefaultValueConstraintName(statement.getDefaultValueConstraintName());
}
// could be of string, numeric, boolean and date
Object defaultValue = statement.getDefaultValue();
LiquibaseDataType dataType = DataTypeFactory.getInstance().fromDescription(statement.getColumnDataType(), database);
if (dataType instanceof BooleanType) {
// validation is done before hand so the defaultValue is instance of dataType
if (defaultValue instanceof Boolean) {
column.setDefaultValueBoolean((Boolean) defaultValue);
} else {
column.setDefaultValueBoolean(defaultValue.toString());
}
} else if (dataType instanceof CharType) {
column.setDefaultValue(defaultValue.toString());
} else if (dataType instanceof DateType) {
if (defaultValue instanceof Date) {
column.setDefaultValueDate((Date) defaultValue);
} else {
column.setDefaultValueDate(defaultValue.toString());
}
} else {
// fallback??
column.setDefaultValue(defaultValue.toString());
}
}
return true;
| 412
| 323
| 735
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddDefaultValueGeneratorSybase.java
|
AddDefaultValueGeneratorSybase
|
generateSql
|
class AddDefaultValueGeneratorSybase extends AddDefaultValueGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddDefaultValueStatement statement, Database database) {
return database instanceof SybaseDatabase;
}
@Override
public Sql[] generateSql(AddDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
Object defaultValue = statement.getDefaultValue();
return new Sql[]{
new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " REPLACE " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " DEFAULT " + DataTypeFactory.getInstance().fromObject(defaultValue, database).objectToSql(defaultValue, database),
getAffectedColumn(statement))
};
| 119
| 137
| 256
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddDefaultValueGeneratorSybaseASA.java
|
AddDefaultValueGeneratorSybaseASA
|
generateSql
|
class AddDefaultValueGeneratorSybaseASA extends AddDefaultValueGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddDefaultValueStatement statement, Database database) {
return database instanceof SybaseASADatabase;
}
@Override
public Sql[] generateSql(AddDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
Object defaultValue = statement.getDefaultValue();
return new Sql[]{
new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " MODIFY " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " DEFAULT " + DataTypeFactory.getInstance().fromObject(defaultValue, database).objectToSql(defaultValue, database),
getAffectedColumn(statement))
};
| 124
| 138
| 262
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddForeignKeyConstraintGenerator.java
|
AddForeignKeyConstraintGenerator
|
validate
|
class AddForeignKeyConstraintGenerator extends AbstractSqlGenerator<AddForeignKeyConstraintStatement> {
@Override
@SuppressWarnings({"SimplifiableIfStatement"})
public boolean supports(AddForeignKeyConstraintStatement statement, Database database) {
return (!(database instanceof SQLiteDatabase));
}
@Override
public ValidationErrors validate(AddForeignKeyConstraintStatement addForeignKeyConstraintStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(AddForeignKeyConstraintStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
StringBuilder sb = new StringBuilder();
sb.append("ALTER TABLE ")
.append(database.escapeTableName(statement.getBaseTableCatalogName(), statement.getBaseTableSchemaName(), statement.getBaseTableName()))
.append(" ADD CONSTRAINT ");
if (!(database instanceof InformixDatabase)) {
sb.append(database.escapeConstraintName(statement.getConstraintName()));
}
sb.append(" FOREIGN KEY (")
.append(database.escapeColumnNameList(statement.getBaseColumnNames()))
.append(") REFERENCES ")
.append(database.escapeTableName(statement.getReferencedTableCatalogName(), statement.getReferencedTableSchemaName(), statement.getReferencedTableName()))
.append(" (")
.append(database.escapeColumnNameList(statement.getReferencedColumnNames()))
.append(")");
if (statement.getOnUpdate() != null) {
if (database instanceof OracleDatabase) {
//don't use
} else if ((database instanceof MSSQLDatabase) && "RESTRICT".equalsIgnoreCase(statement.getOnUpdate())) {
//don't use
} else if (database instanceof InformixDatabase) {
//TODO don't know if correct
} else if ((database instanceof FirebirdDatabase) && "RESTRICT".equalsIgnoreCase(statement.getOnUpdate())) {
//don't use
} else if (database instanceof SybaseDatabase) {
//don't use
} else if ((database instanceof SybaseASADatabase) && "NO ACTION".equalsIgnoreCase(statement.getOnUpdate())) {
//SQL Anywhere cannot do "nothing", so we let SQL Anywhere choose its implicit default (i. e. RESTRICT)
} else {
sb.append(" ON UPDATE ").append(statement.getOnUpdate());
}
}
if (statement.getOnDelete() != null) {
if ((database instanceof OracleDatabase) && ("RESTRICT".equalsIgnoreCase(statement.getOnDelete()) || ("NO " +
"ACTION").equalsIgnoreCase(statement.getOnDelete()))) {
//don't use
} else if ((database instanceof MSSQLDatabase) && "RESTRICT".equalsIgnoreCase(statement.getOnDelete())) {
//don't use
} else if ((database instanceof InformixDatabase) && !("CASCADE".equalsIgnoreCase(statement.getOnDelete()))) {
//TODO Informix can handle ON DELETE CASCADE only, but I don't know if this is really correct
// see "REFERENCES Clause" in manual
} else if ((database instanceof FirebirdDatabase) && "RESTRICT".equalsIgnoreCase(statement.getOnDelete())) {
//don't use
} else if (database instanceof SybaseDatabase) {
//don't use
} else if ((database instanceof SybaseASADatabase) && "NO ACTION".equalsIgnoreCase(statement.getOnDelete())) {
//SQL Anywhere cannot do "nothing", so we let SQL Anywhere choose its implicit default (i. e. RESTRICT)
} else {
sb.append(" ON DELETE ").append(statement.getOnDelete());
}
}
if (statement.isDeferrable() || statement.isInitiallyDeferred()) {
if (statement.isDeferrable() && !(database instanceof SybaseASADatabase)) {
sb.append(" DEFERRABLE");
}
if (statement.isInitiallyDeferred()) {
if (database instanceof SybaseASADatabase) {
sb.append(" CHECK ON COMMIT");
} else {
sb.append(" INITIALLY DEFERRED");
}
}
}
if (database instanceof OracleDatabase) {
sb.append(!statement.shouldValidate() ? " ENABLE NOVALIDATE " : "");
}
// since Postgres 9.1
// https://www.postgresql.org/docs/9.1/sql-altertable.html
if (database instanceof PostgresDatabase) {
sb.append(!statement.shouldValidate() ? " NOT VALID " : "");
}
if (database instanceof InformixDatabase) {
sb.append(" CONSTRAINT ");
sb.append(database.escapeConstraintName(statement.getConstraintName()));
}
return new Sql[]{
new UnparsedSql(sb.toString(), getAffectedForeignKey(statement))
};
}
protected ForeignKey getAffectedForeignKey(AddForeignKeyConstraintStatement statement) {
return new ForeignKey().setName(statement.getConstraintName()).setForeignKeyColumns(Column.listFromNames(statement.getBaseColumnNames())).setForeignKeyTable((Table) new Table().setName(statement.getBaseTableName()).setSchema(statement.getBaseTableCatalogName(), statement.getBaseTableSchemaName()));
}
}
|
ValidationErrors validationErrors = new ValidationErrors();
if ((addForeignKeyConstraintStatement.isInitiallyDeferred() || addForeignKeyConstraintStatement.isDeferrable())
&& !database.supportsInitiallyDeferrableColumns()
) {
if(database.failOnDefferable()) {
validationErrors.checkDisallowedField("initiallyDeferred", addForeignKeyConstraintStatement.isInitiallyDeferred(), database);
validationErrors.checkDisallowedField("deferrable", addForeignKeyConstraintStatement.isDeferrable(), database);
}else{
// reset this as its not supported
addForeignKeyConstraintStatement.setDeferrable(false);
addForeignKeyConstraintStatement.setInitiallyDeferred(false);
}
}
validationErrors.checkRequiredField("baseColumnNames", addForeignKeyConstraintStatement.getBaseColumnNames());
validationErrors.checkRequiredField("baseTableNames", addForeignKeyConstraintStatement.getBaseTableName());
validationErrors.checkRequiredField("referencedColumnNames", addForeignKeyConstraintStatement.getReferencedColumnNames());
validationErrors.checkRequiredField("referencedTableName", addForeignKeyConstraintStatement.getReferencedTableName());
validationErrors.checkRequiredField("constraintName", addForeignKeyConstraintStatement.getConstraintName());
validationErrors.checkDisallowedField("onDelete", addForeignKeyConstraintStatement.getOnDelete(), database, SybaseDatabase.class);
if (database instanceof SybaseASADatabase) {
validationErrors.addWarning("SQL Anywhere will apply RESTRICT instead of NO ACTION.");
}
return validationErrors;
| 1,369
| 404
| 1,773
|
<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.AddForeignKeyConstraintStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddForeignKeyConstraintStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.AddForeignKeyConstraintStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddPrimaryKeyGenerator.java
|
AddPrimaryKeyGenerator
|
generateSql
|
class AddPrimaryKeyGenerator extends AbstractSqlGenerator<AddPrimaryKeyStatement> {
@Override
public boolean supports(AddPrimaryKeyStatement statement, Database database) {
return (!(database instanceof SQLiteDatabase));
}
@Override
public ValidationErrors validate(AddPrimaryKeyStatement addPrimaryKeyStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("columnNames", addPrimaryKeyStatement.getColumnNames());
validationErrors.checkRequiredField("tableName", addPrimaryKeyStatement.getTableName());
if (addPrimaryKeyStatement.isClustered() != null) {
if (database instanceof PostgresDatabase) {
if (addPrimaryKeyStatement.isClustered() && addPrimaryKeyStatement.getConstraintName() == null) {
validationErrors.addError("Postgresql requires constraintName on addPrimaryKey when clustered=true");
}
} else if (database instanceof MSSQLDatabase || database instanceof MockDatabase) {
//clustered is fine
} else if (addPrimaryKeyStatement.isClustered()) {
validationErrors.addError("Cannot specify clustered=true on "+database.getShortName());
}
}
if (!((database instanceof OracleDatabase) || (database instanceof AbstractDb2Database) || (database instanceof PostgresDatabase))) {
validationErrors.checkDisallowedField("forIndexName", addPrimaryKeyStatement.getForIndexName(), database);
}
return validationErrors;
}
@Override
public Sql[] generateSql(AddPrimaryKeyStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected PrimaryKey getAffectedPrimaryKey(AddPrimaryKeyStatement statement) {
return new PrimaryKey().setTable((Table) new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName()));
}
}
|
String sql;
if ((statement.getConstraintName() == null) || (database instanceof MySQLDatabase) || (database instanceof
SybaseASADatabase)) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " ADD PRIMARY KEY (" + database.escapeColumnNameList(statement.getColumnNames()) + ")";
} else {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " ADD CONSTRAINT " + database.escapeConstraintName(statement.getConstraintName())+" PRIMARY KEY";
if ((database instanceof MSSQLDatabase) && (statement.isClustered() != null)) {
if (statement.isClustered()) {
sql += " CLUSTERED";
} else {
sql += " NONCLUSTERED";
}
}
sql += " (" + database.escapeColumnNameList(statement.getColumnNames()) + ")";
}
if ((StringUtil.trimToNull(statement.getTablespace()) != null) && database.supportsTablespaces()) {
if (database instanceof MSSQLDatabase) {
sql += " ON "+statement.getTablespace();
} else if ((database instanceof AbstractDb2Database) || (database instanceof SybaseASADatabase)) {
//not supported
} else {
sql += " USING INDEX TABLESPACE "+statement.getTablespace();
}
}
if ((database instanceof OracleDatabase) && (statement.getForIndexName() != null)) {
sql += " USING INDEX "+database.escapeObjectName(statement.getForIndexCatalogName(), statement.getForIndexSchemaName(), statement.getForIndexName(), Index.class);
}
if (database instanceof OracleDatabase) {
sql += !statement.shouldValidate() ? " ENABLE NOVALIDATE " : "";
}
if ((database instanceof PostgresDatabase) && (statement.isClustered() != null) && statement.isClustered() &&
(statement.getConstraintName() != null)) {
return new Sql[] {
new UnparsedSql(sql, getAffectedPrimaryKey(statement)),
new UnparsedSql("CLUSTER "+database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())+" USING "+database.escapeObjectName(statement.getConstraintName(), PrimaryKey.class))
};
} else {
return new Sql[] {
new UnparsedSql(sql, getAffectedPrimaryKey(statement))
};
}
| 474
| 659
| 1,133
|
<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.AddPrimaryKeyStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddPrimaryKeyStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.AddPrimaryKeyStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddPrimaryKeyGeneratorInformix.java
|
AddPrimaryKeyGeneratorInformix
|
generateSql
|
class AddPrimaryKeyGeneratorInformix extends AddPrimaryKeyGenerator {
@Override
public int getPriority() {
return SqlGenerator.PRIORITY_DATABASE;
}
@Override
public boolean supports(AddPrimaryKeyStatement statement, Database database) {
return (database instanceof InformixDatabase);
}
@Override
public Sql[] generateSql(AddPrimaryKeyStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
StringBuilder sql = new StringBuilder();
sql.append("ALTER TABLE ");
sql.append(database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()));
sql.append(" ADD CONSTRAINT PRIMARY KEY (");
sql.append(database.escapeColumnNameList(statement.getColumnNames()));
sql.append(")");
// Using auto-generated names of the form <constraint_type><tabid>_<constraintid> can cause collisions
// See here: http://www-01.ibm.com/support/docview.wss?uid=swg21156047
String constraintName = statement.getConstraintName();
if ((constraintName != null) && !constraintName.matches("[urcn][0-9]+_[0-9]+")) {
sql.append(" CONSTRAINT ");
sql.append(database.escapeConstraintName(constraintName));
}
return new Sql[] {
new UnparsedSql(sql.toString(), getAffectedPrimaryKey(statement))
};
| 125
| 268
| 393
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddPrimaryKeyStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public boolean supports(liquibase.statement.core.AddPrimaryKeyStatement, liquibase.database.Database) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddPrimaryKeyStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddUniqueConstraintGenerator.java
|
AddUniqueConstraintGenerator
|
generateSql
|
class AddUniqueConstraintGenerator extends AbstractSqlGenerator<AddUniqueConstraintStatement> {
@Override
public boolean supports(AddUniqueConstraintStatement statement, Database database) {
return !(database instanceof SQLiteDatabase)
&& !(database instanceof SybaseDatabase)
&& !(database instanceof SybaseASADatabase)
&& !(database instanceof InformixDatabase)
;
}
@Override
public ValidationErrors validate(AddUniqueConstraintStatement addUniqueConstraintStatement, Database database, SqlGeneratorChain<AddUniqueConstraintStatement> sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("columnNames", addUniqueConstraintStatement.getColumnNames());
validationErrors.checkRequiredField("tableName", addUniqueConstraintStatement.getTableName());
if (!((database instanceof OracleDatabase) || (database instanceof PostgresDatabase))) {
validationErrors.checkDisallowedField("forIndexName", addUniqueConstraintStatement.getForIndexName(), database);
}
if (!(database instanceof MSSQLDatabase) && addUniqueConstraintStatement.isClustered()) {
validationErrors.checkDisallowedField("clustered", addUniqueConstraintStatement.isClustered(), database);
}
return validationErrors;
}
@Override
public Sql[] generateSql(AddUniqueConstraintStatement statement, Database database, SqlGeneratorChain<AddUniqueConstraintStatement> sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected UniqueConstraint getAffectedUniqueConstraint(AddUniqueConstraintStatement statement) {
UniqueConstraint uniqueConstraint = new UniqueConstraint()
.setName(statement.getConstraintName())
.setRelation(new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName()));
int i = 0;
for (Column column : Column.listFromNames(statement.getColumnNames())) {
uniqueConstraint.addColumn(i++, column);
}
return uniqueConstraint;
}
}
|
String sql;
if (statement.getConstraintName() == null) {
sql = String.format("ALTER TABLE %s ADD UNIQUE" + (statement.isClustered() ? " CLUSTERED " : " ") + "(%s)"
, database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
, database.escapeColumnNameList(statement.getColumnNames())
);
} else {
sql = String.format("ALTER TABLE %s ADD CONSTRAINT %s UNIQUE" + (statement.isClustered() ? " CLUSTERED " : " ") + "(%s)"
, database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
, database.escapeConstraintName(statement.getConstraintName())
, database.escapeColumnNameList(statement.getColumnNames())
);
}
if ((database instanceof OracleDatabase) || (database instanceof PostgresDatabase)) {
if (statement.isDeferrable()) {
sql += " DEFERRABLE";
}
if (statement.isInitiallyDeferred()) {
sql += " INITIALLY DEFERRED";
}
}
if ((database instanceof OracleDatabase) && statement.isDisabled()) {
sql += " DISABLE";
}
boolean isInUsingIndexClause = false;
if (statement.getForIndexName() != null && !(database instanceof H2Database)) {
sql += " USING INDEX ";
sql += database.escapeObjectName(statement.getForIndexCatalogName(), statement.getForIndexSchemaName(),
statement.getForIndexName(), Index.class);
isInUsingIndexClause = true;
}
if ((StringUtil.trimToNull(statement.getTablespace()) != null) && database.supportsTablespaces()) {
if (database instanceof MSSQLDatabase) {
sql += " ON " + statement.getTablespace();
} else if ((database instanceof AbstractDb2Database) || (database instanceof SybaseASADatabase) || (database
instanceof InformixDatabase)) {
//not supported
} else if (database instanceof OracleDatabase) {
/*
* In Oracle, you can use only exactly one of these clauses:
* 1. USING INDEX (identifier)
* 2. USING INDEX (index attributes) <-- Note that NO identifier is allowed in this form!
* 3. USING INDEX (CREATE INDEX (identifier) TABLESPACE (tablespace) (further attributes...) )
* However, if an index name _is_ present, we can assume that CreateIndexGenerator picked it up before
* this generator is called, so we really only need the second form at this point.
*/
if (statement.getForIndexName() == null)
sql += " USING INDEX TABLESPACE " + statement.getTablespace();
} else {
if (!isInUsingIndexClause)
sql += " USING INDEX";
sql += " TABLESPACE " + statement.getTablespace();
}
}
if (database instanceof OracleDatabase) {
sql += !statement.shouldValidate() ? " ENABLE NOVALIDATE " : "";
}
return new Sql[]{
new UnparsedSql(sql, getAffectedUniqueConstraint(statement))
};
| 495
| 828
| 1,323
|
<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.AddUniqueConstraintStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AddUniqueConstraintStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.AddUniqueConstraintStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddUniqueConstraintGeneratorInformix.java
|
AddUniqueConstraintGeneratorInformix
|
generateSql
|
class AddUniqueConstraintGeneratorInformix extends AddUniqueConstraintGenerator {
@Override
public int getPriority() {
return SqlGenerator.PRIORITY_DATABASE;
}
@Override
public boolean supports(AddUniqueConstraintStatement statement, Database database) {
return (database instanceof InformixDatabase);
}
@Override
public Sql[] generateSql(AddUniqueConstraintStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
final String sqlNoConstraintNameTemplate = "ALTER TABLE %s ADD CONSTRAINT UNIQUE (%s)";
final String sqlTemplate = "ALTER TABLE %s ADD CONSTRAINT UNIQUE (%s) CONSTRAINT %s";
// Using an auto-generated name (a name beginning with space) when creating a new unique constraint is impossible
String constraintName = statement.getConstraintName();
if ((constraintName == null) || constraintName.startsWith(" ")) { // Names beginning with a space can't be created in informix using SQL
return new Sql[] {
new UnparsedSql(String.format(sqlNoConstraintNameTemplate
, database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
, database.escapeColumnNameList(statement.getColumnNames())
), getAffectedUniqueConstraint(statement))
};
} else {
return new Sql[] {
new UnparsedSql(String.format(sqlTemplate
, database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
, database.escapeColumnNameList(statement.getColumnNames())
, database.escapeConstraintName(statement.getConstraintName())
), getAffectedUniqueConstraint(statement))
};
}
| 129
| 322
| 451
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddUniqueConstraintStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.AddUniqueConstraintStatement>) ,public boolean supports(liquibase.statement.core.AddUniqueConstraintStatement, liquibase.database.Database) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddUniqueConstraintStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.AddUniqueConstraintStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AddUniqueConstraintGeneratorTDS.java
|
AddUniqueConstraintGeneratorTDS
|
generateSql
|
class AddUniqueConstraintGeneratorTDS extends AddUniqueConstraintGenerator {
public AddUniqueConstraintGeneratorTDS() {
}
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(AddUniqueConstraintStatement statement, Database database) {
return (database instanceof SybaseDatabase)
|| (database instanceof SybaseASADatabase)
;
}
@Override
public Sql[] generateSql(AddUniqueConstraintStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
final String sqlTemplate = "ALTER TABLE %s ADD CONSTRAINT %s UNIQUE (%s)";
final String sqlNoConstraintNameTemplate = "ALTER TABLE %s ADD UNIQUE (%s)";
if (statement.getConstraintName() == null) {
return new Sql[] {
new UnparsedSql(String.format(sqlNoConstraintNameTemplate
, database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
, database.escapeColumnNameList(statement.getColumnNames())
), getAffectedUniqueConstraint(statement))
};
} else {
return new Sql[] {
new UnparsedSql(String.format(sqlTemplate
, database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
, database.escapeConstraintName(statement.getConstraintName())
, database.escapeColumnNameList(statement.getColumnNames())
), getAffectedUniqueConstraint(statement))
};
}
| 160
| 257
| 417
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.AddUniqueConstraintStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.AddUniqueConstraintStatement>) ,public boolean supports(liquibase.statement.core.AddUniqueConstraintStatement, liquibase.database.Database) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.AddUniqueConstraintStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.AddUniqueConstraintStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/AlterSequenceGenerator.java
|
AlterSequenceGenerator
|
generateSql
|
class AlterSequenceGenerator extends AbstractSqlGenerator<AlterSequenceStatement> {
@Override
public boolean supports(AlterSequenceStatement statement, Database database) {
return database.supports(Sequence.class);
}
@Override
public ValidationErrors validate(AlterSequenceStatement alterSequenceStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkDisallowedField("incrementBy", alterSequenceStatement.getIncrementBy(), database, HsqlDatabase.class, H2Database.class);
if (isH2WithMinMaxSupport(database)) {
validationErrors.checkDisallowedField("maxValue", alterSequenceStatement.getMaxValue(), database, HsqlDatabase.class);
} else {
validationErrors.checkDisallowedField("maxValue", alterSequenceStatement.getMaxValue(), database, H2Database.class, HsqlDatabase.class);
validationErrors.checkDisallowedField("minValue", alterSequenceStatement.getMinValue(), database, H2Database.class);
}
validationErrors.checkDisallowedField("ordered", alterSequenceStatement.getOrdered(), database, HsqlDatabase.class, DB2Database.class, MSSQLDatabase.class);
validationErrors.checkDisallowedField("dataType", alterSequenceStatement.getDataType(), database, DB2Database.class, HsqlDatabase.class, OracleDatabase.class, MySQLDatabase.class, MSSQLDatabase.class);
validationErrors.checkRequiredField("sequenceName", alterSequenceStatement.getSequenceName());
return validationErrors;
}
@Override
public Sql[] generateSql(AlterSequenceStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Sequence getAffectedSequence(AlterSequenceStatement statement) {
return new Sequence().setName(statement.getSequenceName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
private boolean isH2WithMinMaxSupport(Database database) {
return H2Database.class.isAssignableFrom(database.getClass())
&& ((H2Database) database).supportsMinMaxForSequences();
}
}
|
StringBuilder buffer = new StringBuilder();
buffer.append("ALTER SEQUENCE ");
buffer.append(database.escapeSequenceName(statement.getCatalogName(), statement.getSchemaName(), statement.getSequenceName()));
if (statement.getDataType() != null) {
buffer.append(" AS ").append(statement.getDataType());
}
if (statement.getIncrementBy() != null) {
buffer.append(" INCREMENT BY ").append(statement.getIncrementBy());
}
if (statement.getMinValue() != null) {
if (database instanceof FirebirdDatabase || database instanceof HsqlDatabase) {
buffer.append(" RESTART WITH ").append(statement.getMinValue());
} else {
buffer.append(" MINVALUE ").append(statement.getMinValue());
}
}
if (statement.getMaxValue() != null) {
buffer.append(" MAXVALUE ").append(statement.getMaxValue());
}
if (statement.getOrdered() != null) {
if (statement.getOrdered()) {
buffer.append(" ORDER ");
} else {
buffer.append(" NOORDER ");
}
}
if ((statement.getCacheSize() != null) && (database instanceof OracleDatabase || database instanceof PostgresDatabase || database instanceof MariaDBDatabase)) {
if (statement.getCacheSize().equals(BigInteger.ZERO)) {
buffer.append(" NOCACHE ");
} else {
buffer.append(" CACHE ").append(statement.getCacheSize());
}
}
if ((statement.getCycle() != null) &&
(database instanceof OracleDatabase || database instanceof PostgresDatabase
|| database instanceof MariaDBDatabase || database instanceof MSSQLDatabase)) {
if (statement.getCycle()) {
buffer.append(" CYCLE ");
} else {
if(database instanceof OracleDatabase || database instanceof MariaDBDatabase) {
buffer.append(" NOCYCLE ");
} else if(database instanceof PostgresDatabase || database instanceof MSSQLDatabase) {
buffer.append(" NO CYCLE ");
}
}
}
return new Sql[] {
new UnparsedSql(buffer.toString(), getAffectedSequence(statement))
};
| 537
| 576
| 1,113
|
<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.AlterSequenceStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.AlterSequenceStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.AlterSequenceStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/ClearDatabaseChangeLogTableGenerator.java
|
ClearDatabaseChangeLogTableGenerator
|
generateSql
|
class ClearDatabaseChangeLogTableGenerator extends AbstractSqlGenerator<ClearDatabaseChangeLogTableStatement> {
@Override
public ValidationErrors validate(ClearDatabaseChangeLogTableStatement clearDatabaseChangeLogTableStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return new ValidationErrors();
}
@Override
public Sql[] generateSql(ClearDatabaseChangeLogTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Relation getAffectedTable(Database database, String schemaName) {
return new Table().setName(database.getDatabaseChangeLogTableName()).setSchema(database.getLiquibaseCatalogName(), schemaName);
}
}
|
String schemaName;
if (StringUtil.isNotEmpty(statement.getSchemaName())) {
schemaName = statement.getSchemaName();
} else {
schemaName = database.getLiquibaseSchemaName();
}
// use LEGACY quoting since we're dealing with system objects
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
return new Sql[] {
new UnparsedSql("DELETE FROM " + database.escapeTableName(database.getLiquibaseCatalogName(), schemaName, database.getDatabaseChangeLogTableName()),
getAffectedTable(database, schemaName)) };
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
| 173
| 204
| 377
|
<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.ClearDatabaseChangeLogTableStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.ClearDatabaseChangeLogTableStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.ClearDatabaseChangeLogTableStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/CommentGenerator.java
|
CommentGenerator
|
validate
|
class CommentGenerator extends AbstractSqlGenerator<CommentStatement> {
@Override
public Sql[] generateSql(CommentStatement comment, Database database, SqlGeneratorChain sqlGeneratorChain) {
return new Sql[] {
new SingleLineComment(comment.getText(), database.getLineComment())
};
}
@Override
public ValidationErrors validate(CommentStatement comment,
Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("text", comment.getText());
return validationErrors;
| 117
| 37
| 154
|
<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.CommentStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.CommentStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.CommentStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/CopyRowsGenerator.java
|
CopyRowsGenerator
|
validate
|
class CopyRowsGenerator extends AbstractSqlGenerator<CopyRowsStatement> {
@Override
public boolean supports(CopyRowsStatement statement, Database database) {
return (database instanceof SQLiteDatabase);
}
@Override
public ValidationErrors validate(CopyRowsStatement copyRowsStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(CopyRowsStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
StringBuilder sql = new StringBuilder();
if (statement.getCopyColumns().isEmpty()) {
return new Sql[]{};
}
if (database instanceof SQLiteDatabase) {
sql.append("INSERT INTO ").append(database.escapeTableName(null, null, statement.getTargetTable())).append(" (");
for (int i = 0; i < statement.getCopyColumns().size(); i++) {
ColumnConfig column = statement.getCopyColumns().get(i);
if (i > 0) {
sql.append(",");
}
sql.append(database.escapeColumnName(null, null, statement.getTargetTable(), column.getName()));
}
sql.append(") SELECT ");
for (int i = 0; i < statement.getCopyColumns().size(); i++) {
ColumnConfig column = statement.getCopyColumns().get(i);
if (i > 0) {
sql.append(",");
}
sql.append(database.escapeColumnName(null, null, statement.getSourceTable(), column.getName()));
}
sql.append(" FROM ").append(database.escapeTableName(null, null, statement.getSourceTable()));
}
return new Sql[]{
new UnparsedSql(sql.toString(), getAffectedTable(statement))
};
}
protected Relation getAffectedTable(CopyRowsStatement statement) {
return new Table().setName(statement.getTargetTable()).setSchema(null, null);
}
}
|
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("targetTable", copyRowsStatement.getTargetTable());
validationErrors.checkRequiredField("sourceTable", copyRowsStatement.getSourceTable());
validationErrors.checkRequiredField("copyColumns", copyRowsStatement.getCopyColumns());
return validationErrors;
| 496
| 82
| 578
|
<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.CopyRowsStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.CopyRowsStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.CopyRowsStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/CreateDatabaseChangeLogLockTableGenerator.java
|
CreateDatabaseChangeLogLockTableGenerator
|
getCharTypeName
|
class CreateDatabaseChangeLogLockTableGenerator extends AbstractSqlGenerator<CreateDatabaseChangeLogLockTableStatement> {
@Override
public ValidationErrors validate(CreateDatabaseChangeLogLockTableStatement createDatabaseChangeLogLockTableStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return new ValidationErrors();
}
@Override
public Sql[] generateSql(CreateDatabaseChangeLogLockTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
String charTypeName = getCharTypeName(database);
String dateTimeTypeString = getDateTimeTypeString(database);
CreateTableStatement createTableStatement = new CreateTableStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogLockTableName())
.setTablespace(database.getLiquibaseTablespaceName())
.addPrimaryKeyColumn("ID", DataTypeFactory.getInstance().fromDescription("int", database), null, null, null, new NotNullConstraint())
.addColumn("LOCKED", DataTypeFactory.getInstance().fromDescription("boolean", database), null, null, new NotNullConstraint())
.addColumn("LOCKGRANTED", DataTypeFactory.getInstance().fromDescription(dateTimeTypeString, database))
.addColumn("LOCKEDBY", DataTypeFactory.getInstance().fromDescription(charTypeName + "(255)", database));
// use LEGACY quoting since we're dealing with system objects
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
return SqlGeneratorFactory.getInstance().generateSql(createTableStatement, database);
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
}
protected String getCharTypeName(Database database) {<FILL_FUNCTION_BODY>}
protected String getDateTimeTypeString(Database database) {
if (database instanceof MSSQLDatabase) {
return "datetime2(3)";
}
return "datetime";
}
}
|
if ((database instanceof MSSQLDatabase) && ((MSSQLDatabase) database).sendsStringParametersAsUnicode()) {
return "nvarchar";
}
return "varchar";
| 501
| 49
| 550
|
<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.CreateDatabaseChangeLogLockTableStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.CreateDatabaseChangeLogLockTableStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.CreateDatabaseChangeLogLockTableStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/CreateDatabaseChangeLogTableGenerator.java
|
CreateDatabaseChangeLogTableGenerator
|
generateSql
|
class CreateDatabaseChangeLogTableGenerator extends AbstractSqlGenerator<CreateDatabaseChangeLogTableStatement> {
@Override
public boolean supports(CreateDatabaseChangeLogTableStatement statement, Database database) {
return !(database instanceof SybaseDatabase);
}
@Override
public ValidationErrors validate(CreateDatabaseChangeLogTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return new ValidationErrors();
}
@Override
public Sql[] generateSql(CreateDatabaseChangeLogTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected String getCharTypeName(Database database) {
if ((database instanceof MSSQLDatabase) && ((MSSQLDatabase) database).sendsStringParametersAsUnicode()) {
return "nvarchar";
}
return "varchar";
}
protected String getDateTimeTypeString(Database database) {
if (database instanceof MSSQLDatabase) {
return "datetime2(3)";
}
return "datetime";
}
protected String getLabelsSize() {
return "255";
}
protected String getContextsSize() {
return "255";
}
protected String getIdColumnSize() {
return "255";
}
protected String getAuthorColumnSize() {
return "255";
}
protected String getFilenameColumnSize() {
return "255";
}
}
|
String charTypeName = getCharTypeName(database);
String dateTimeTypeString = getDateTimeTypeString(database);
CreateTableStatement createTableStatement = new CreateTableStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogTableName())
.setTablespace(database.getLiquibaseTablespaceName())
.addColumn("ID", DataTypeFactory.getInstance().fromDescription(charTypeName + "(" + getIdColumnSize() + ")", database), null, null, new NotNullConstraint())
.addColumn("AUTHOR", DataTypeFactory.getInstance().fromDescription(charTypeName + "(" + getAuthorColumnSize() + ")", database), null, null, new NotNullConstraint())
.addColumn("FILENAME", DataTypeFactory.getInstance().fromDescription(charTypeName + "(" + getFilenameColumnSize() + ")", database), null, null, new NotNullConstraint())
.addColumn("DATEEXECUTED", DataTypeFactory.getInstance().fromDescription(dateTimeTypeString, database), null, null, new NotNullConstraint())
.addColumn("ORDEREXECUTED", DataTypeFactory.getInstance().fromDescription("int", database), null, null, new NotNullConstraint())
.addColumn("EXECTYPE", DataTypeFactory.getInstance().fromDescription(charTypeName + "(10)", database), null, null, new NotNullConstraint())
.addColumn("MD5SUM", DataTypeFactory.getInstance().fromDescription(charTypeName + "(35)", database))
.addColumn("DESCRIPTION", DataTypeFactory.getInstance().fromDescription(charTypeName + "(255)", database))
.addColumn("COMMENTS", DataTypeFactory.getInstance().fromDescription(charTypeName + "(255)", database))
.addColumn("TAG", DataTypeFactory.getInstance().fromDescription(charTypeName + "(255)", database))
.addColumn("LIQUIBASE", DataTypeFactory.getInstance().fromDescription(charTypeName + "(20)", database))
.addColumn("CONTEXTS", DataTypeFactory.getInstance().fromDescription(charTypeName + "("+getContextsSize()+")", database))
.addColumn("LABELS", DataTypeFactory.getInstance().fromDescription(charTypeName + "("+getLabelsSize()+")", database))
.addColumn("DEPLOYMENT_ID", DataTypeFactory.getInstance().fromDescription(charTypeName+"(10)", database));
// use LEGACY quoting since we're dealing with system objects
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
return SqlGeneratorFactory.getInstance().generateSql(createTableStatement, database);
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
| 369
| 696
| 1,065
|
<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.CreateDatabaseChangeLogTableStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.CreateDatabaseChangeLogTableStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.CreateDatabaseChangeLogTableStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/CreateDatabaseChangeLogTableGeneratorSybase.java
|
CreateDatabaseChangeLogTableGeneratorSybase
|
generateSql
|
class CreateDatabaseChangeLogTableGeneratorSybase extends AbstractSqlGenerator<CreateDatabaseChangeLogTableStatement> {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(CreateDatabaseChangeLogTableStatement statement, Database database) {
return database instanceof SybaseDatabase;
}
@Override
public ValidationErrors validate(CreateDatabaseChangeLogTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return new ValidationErrors();
}
@Override
public Sql[] generateSql(CreateDatabaseChangeLogTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Relation getAffectedTable(Database database) {
return new Table().setName(database.getDatabaseChangeLogTableName()).setSchema(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName());
}
}
|
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
return new Sql[]{
new UnparsedSql("CREATE TABLE " + database.escapeTableName(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogTableName()) + " (ID VARCHAR(150) NOT NULL, " +
"AUTHOR VARCHAR(150) NOT NULL, " +
"FILENAME VARCHAR(255) NOT NULL, " +
"DATEEXECUTED " + DataTypeFactory.getInstance().fromDescription("datetime", database).toDatabaseDataType(database) + " NOT NULL, " +
"ORDEREXECUTED INT NOT NULL, " +
"EXECTYPE VARCHAR(10) NOT NULL, " +
"MD5SUM VARCHAR(35) NULL, " +
"DESCRIPTION VARCHAR(255) NULL, " +
"COMMENTS VARCHAR(255) NULL, " +
"TAG VARCHAR(255) NULL, " +
"LIQUIBASE VARCHAR(20) NULL, " +
"CONTEXTS VARCHAR(255) NULL, " +
"LABELS VARCHAR(255) NULL, " +
"DEPLOYMENT_ID VARCHAR(10) NULL, " +
"PRIMARY KEY(ID, AUTHOR, FILENAME))",
getAffectedTable(database))
};
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
| 236
| 393
| 629
|
<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.CreateDatabaseChangeLogTableStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.CreateDatabaseChangeLogTableStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.CreateDatabaseChangeLogTableStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/CreateIndexGenerator.java
|
CreateIndexGenerator
|
generateSql
|
class CreateIndexGenerator extends AbstractSqlGenerator<CreateIndexStatement> {
@Override
public ValidationErrors validate(CreateIndexStatement createIndexStatement, Database database,
SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", createIndexStatement.getTableName());
validationErrors.checkRequiredField("columns", createIndexStatement.getColumns());
if (database instanceof HsqlDatabase) {
validationErrors.checkRequiredField("name", createIndexStatement.getIndexName());
}
return validationErrors;
}
@Override
public Warnings warn(CreateIndexStatement createIndexStatement, Database database,
SqlGeneratorChain sqlGeneratorChain) {
Warnings warnings = super.warn(createIndexStatement, database, sqlGeneratorChain);
if (!((database instanceof MSSQLDatabase) || (database instanceof OracleDatabase) || (database instanceof
AbstractDb2Database) || (database instanceof PostgresDatabase) || (database instanceof MockDatabase))) {
if ((createIndexStatement.isClustered() != null) && createIndexStatement.isClustered()) {
warnings.addWarning("Creating clustered index not supported with "+database);
}
}
return warnings;
}
/**
* Generate a CREATE INDEX SQL statement.
* Here, we are walking on thin ice, because the SQL Foundation standard (ISO/IEC 9075-2) does not concern itself
* with indexes at all and leaves them as an implementation-specific detail at the discretion of each RDBMS vendor.
* However, there is some common ground to most RDBMS, and we try to make an educated guess on how a CREATE INDEX
* statement might look like if we have no specific handler for the DBMS.
* @param statement A CreateIndexStatement with the desired properties of the SQL to be generated
* @param database The DBMS for whose SQL dialect the statement is to be made
* @param sqlGeneratorChain The other SQL generators in the same chain (but this method is not interested in them)
* @return An array of Sql objects containing the generated SQL statement(s).
*/
@Override
public Sql[] generateSql(CreateIndexStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain)
{<FILL_FUNCTION_BODY>}
protected Index getAffectedIndex(CreateIndexStatement statement) {
return new Index().setName(statement.getIndexName()).setRelation(new Table().setName(statement.getTableName()).setSchema(statement.getTableCatalogName(), statement.getTableSchemaName()));
}
}
|
if (database instanceof OracleDatabase) {
/*
* Oracle automatically creates indexes for PRIMARY KEY and UNIQUE constraints, but does not do so
* for FOREIGN KEY constraints, though it is highly recommended to do to avoid potentially severe
* performance problems when deleting rows from the parent table or changing the key column(s) in the
* parent table.
*/
List<String> associatedWith = StringUtil.splitAndTrim(statement.getAssociatedWith(), ",");
if ((associatedWith != null) && (associatedWith.contains(Index.MARK_PRIMARY_KEY) || associatedWith
.contains(Index.MARK_UNIQUE_CONSTRAINT))) {
return EMPTY_SQL;
}
} else {
// Default filter of index creation:
// creation of all indexes with associations are switched off.
List<String> associatedWith = StringUtil.splitAndTrim(statement.getAssociatedWith(), ",");
if ((associatedWith != null) && (associatedWith.contains(Index.MARK_PRIMARY_KEY) || associatedWith
.contains(Index.MARK_UNIQUE_CONSTRAINT) || associatedWith.contains(Index.MARK_FOREIGN_KEY))) {
return EMPTY_SQL;
}
}
StringBuilder buffer = new StringBuilder();
buffer.append("CREATE ");
if ((statement.isUnique() != null) && statement.isUnique()) {
buffer.append("UNIQUE ");
}
if (database instanceof MSSQLDatabase) {
if (statement.isClustered() != null) {
if (statement.isClustered()) {
buffer.append("CLUSTERED ");
} else {
buffer.append("NONCLUSTERED ");
}
}
}
buffer.append("INDEX ");
if (statement.getIndexName() != null) {
String indexSchema = statement.getTableSchemaName();
buffer.append(database.escapeIndexName(statement.getTableCatalogName(), indexSchema, statement.getIndexName())).append(" ");
}
buffer.append("ON ");
if ((database instanceof OracleDatabase) && (statement.isClustered() != null) && statement.isClustered()){
buffer.append("CLUSTER ");
}
buffer.append(database.escapeTableName(statement.getTableCatalogName(), statement.getTableSchemaName(), statement.getTableName())).append("(");
Iterator<AddColumnConfig> iterator = Arrays.asList(statement.getColumns()).iterator();
while (iterator.hasNext()) {
AddColumnConfig column = iterator.next();
if (column.getComputed() == null) {
buffer.append(database.escapeColumnName(statement.getTableCatalogName(), statement.getTableSchemaName(), statement.getTableName(), column.getName(), false));
} else {
if (column.getComputed()) {
buffer.append(column.getName());
} else {
buffer.append(database.escapeColumnName(statement.getTableCatalogName(), statement.getTableSchemaName(), statement.getTableName(), column.getName()));
}
}
if ((column.getDescending() != null) && column.getDescending()) {
buffer.append(" DESC");
}
if (iterator.hasNext()) {
buffer.append(", ");
}
}
buffer.append(")");
if ((StringUtil.trimToNull(statement.getTablespace()) != null) && database.supportsTablespaces()) {
if ((database instanceof MSSQLDatabase) || (database instanceof SybaseASADatabase)) {
buffer.append(" ON ").append(statement.getTablespace());
} else if ((database instanceof AbstractDb2Database) || (database instanceof InformixDatabase)) {
buffer.append(" IN ").append(statement.getTablespace());
} else {
buffer.append(" TABLESPACE ").append(statement.getTablespace());
}
}
if ((database instanceof AbstractDb2Database) && (statement.isClustered() != null) && statement.isClustered()){
buffer.append(" CLUSTER");
}
return new Sql[] {new UnparsedSql(buffer.toString(), getAffectedIndex(statement))};
| 628
| 1,102
| 1,730
|
<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.CreateIndexStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.CreateIndexStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.CreateIndexStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/CreateIndexGeneratorPostgres.java
|
CreateIndexGeneratorPostgres
|
generateSql
|
class CreateIndexGeneratorPostgres extends CreateIndexGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(CreateIndexStatement statement, Database database) {
return database instanceof PostgresDatabase;
}
@Override
public Sql[] generateSql(CreateIndexStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
// Default filter of index creation:
// creation of all indexes with associations are switched off.
List<String> associatedWith = StringUtil.splitAndTrim(statement.getAssociatedWith(), ",");
if ((associatedWith != null) && (associatedWith.contains(Index.MARK_PRIMARY_KEY) || associatedWith.contains
(Index.MARK_UNIQUE_CONSTRAINT) || associatedWith.contains(Index.MARK_FOREIGN_KEY))) {
return EMPTY_SQL;
}
StringBuilder buffer = new StringBuilder();
buffer.append("CREATE ");
if ((statement.isUnique() != null) && statement.isUnique()) {
buffer.append("UNIQUE ");
}
buffer.append("INDEX ");
if (statement.getIndexName() != null) {
// for postgres setting the schema name for the index name is invalid
buffer.append(database.escapeObjectName(statement.getIndexName(), Index.class)).append(" ");
}
buffer.append("ON ");
buffer.append(database.escapeTableName(statement.getTableCatalogName(), statement.getTableSchemaName(), statement.getTableName())).append("(");
Iterator<AddColumnConfig> iterator = Arrays.asList(statement.getColumns()).iterator();
while (iterator.hasNext()) {
AddColumnConfig column = iterator.next();
if (column.getComputed() == null) {
buffer.append(database.escapeColumnName(statement.getTableCatalogName(), statement.getTableSchemaName(), statement.getTableName(), column.getName(), false));
} else {
if (column.getComputed()) {
buffer.append(column.getName());
} else {
buffer.append(database.escapeColumnName(statement.getTableCatalogName(), statement.getTableSchemaName(), statement.getTableName(), column.getName()));
}
}
if (column.getDescending() != null && column.getDescending()) {
buffer.append(" DESC");
}
if (iterator.hasNext()) {
buffer.append(", ");
}
}
buffer.append(")");
if ((StringUtil.trimToNull(statement.getTablespace()) != null) && database.supportsTablespaces()) {
if ((database instanceof MSSQLDatabase) || (database instanceof SybaseASADatabase)) {
buffer.append(" ON ").append(statement.getTablespace());
} else if ((database instanceof AbstractDb2Database) || (database instanceof InformixDatabase)) {
buffer.append(" IN ").append(statement.getTablespace());
} else {
buffer.append(" TABLESPACE ").append(statement.getTablespace());
}
}
if ((statement.isClustered() != null) && statement.isClustered()) {
return new Sql[]{
new UnparsedSql(buffer.toString(), getAffectedIndex(statement)),
new UnparsedSql("CLUSTER " + database.escapeTableName(statement.getTableCatalogName(), statement.getTableSchemaName(), statement.getTableName()) + " USING " + database.escapeObjectName(statement.getIndexName(), Index.class))
};
} else {
return new Sql[]{new UnparsedSql(buffer.toString(), getAffectedIndex(statement))};
}
| 115
| 834
| 949
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.CreateIndexStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.CreateIndexStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.Warnings warn(liquibase.statement.core.CreateIndexStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/CreateSequenceGenerator.java
|
CreateSequenceGenerator
|
generateSql
|
class CreateSequenceGenerator extends AbstractSqlGenerator<CreateSequenceStatement> {
@Override
public boolean supports(CreateSequenceStatement statement, Database database) {
return database.supports(Sequence.class);
}
@Override
public ValidationErrors validate(CreateSequenceStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("sequenceName", statement.getSequenceName());
validationErrors.checkDisallowedField("startValue", statement.getStartValue(), database, FirebirdDatabase.class);
validationErrors.checkDisallowedField("incrementBy", statement.getIncrementBy(), database, FirebirdDatabase.class);
if (isH2WithMinMaxSupport(database)) {
validationErrors.checkDisallowedField("minValue", statement.getMinValue(), database, FirebirdDatabase.class, HsqlDatabase.class);
validationErrors.checkDisallowedField("maxValue", statement.getMaxValue(), database, FirebirdDatabase.class, HsqlDatabase.class);
} else {
validationErrors.checkDisallowedField("minValue", statement.getMinValue(), database, FirebirdDatabase.class, H2Database.class, HsqlDatabase.class);
validationErrors.checkDisallowedField("maxValue", statement.getMaxValue(), database, FirebirdDatabase.class, H2Database.class, HsqlDatabase.class);
}
validationErrors.checkDisallowedField("ordered", statement.getOrdered(), database, HsqlDatabase.class, PostgresDatabase.class, MSSQLDatabase.class);
//check datatype
if (database instanceof PostgresDatabase) {
if (isPostgreWithoutAsDatatypeSupport(database)) {
validationErrors.checkDisallowedField("dataType", statement.getDataType(), database, PostgresDatabase.class);
}
} else if (database instanceof H2Database) {
if (isH2WithoutAsDatatypeSupport(database) && statement.getDataType() != null && !statement.getDataType().equalsIgnoreCase("bigint")) {
validationErrors.checkDisallowedField("dataType", statement.getDataType(), database, H2Database.class);
}
} else {
validationErrors.checkDisallowedField("dataType", statement.getDataType(), database, HsqlDatabase.class, OracleDatabase.class, MySQLDatabase.class, MSSQLDatabase.class, CockroachDatabase.class, FirebirdDatabase.class);
}
return validationErrors;
}
@Override
public Sql[] generateSql(CreateSequenceStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Sequence getAffectedSequence(CreateSequenceStatement statement) {
return new Sequence().setName(statement.getSequenceName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
private boolean isH2WithMinMaxSupport(Database database) {
return H2Database.class.isAssignableFrom(database.getClass())
&& ((H2Database) database).supportsMinMaxForSequences();
}
private boolean isPostgreWithoutAsDatatypeSupport(Database database) {
try {
return database instanceof PostgresDatabase && database.getDatabaseMajorVersion() < 10;
} catch (DatabaseException e) {
// we can't determinate the PostgreSQL version so we shouldn't throw validation error as it might work for this DB
return false;
}
}
private boolean isH2WithoutAsDatatypeSupport(Database database) {
try {
// H2 supports the `AS <dataType>` clause since version 2.0
return database instanceof H2Database && database.getDatabaseMajorVersion() < 2;
} catch (DatabaseException e) {
// we can't determinate the H2 version so we shouldn't throw validation error as it might work for this DB
return false;
}
}
}
|
StringBuilder queryStringBuilder = new StringBuilder();
queryStringBuilder.append("CREATE SEQUENCE ");
if (database instanceof PostgresDatabase) {
// supported only for version >= 9.5 https://www.postgresql.org/docs/9.5/sql-createsequence.html
try {
if (database.getDatabaseMajorVersion() > 9
|| (database.getDatabaseMajorVersion() == 9 && database.getDatabaseMinorVersion() >= 5)) {
queryStringBuilder.append(" IF NOT EXISTS ");
}
} catch (DatabaseException e) {
// we can not determinate the PostgreSQL version so we do not add this statement
}
}
queryStringBuilder.append(database.escapeSequenceName(statement.getCatalogName(), statement.getSchemaName(), statement.getSequenceName()));
if (database instanceof HsqlDatabase || database instanceof Db2zDatabase) {
queryStringBuilder.append(" AS BIGINT ");
} else if (statement.getDataType() != null) {
if (!(isH2WithoutAsDatatypeSupport(database) || database instanceof CockroachDatabase || database instanceof SybaseASADatabase)) {
queryStringBuilder.append(" AS ").append(statement.getDataType());
}
}
if (!(database instanceof MariaDBDatabase) && statement.getStartValue() != null) {
queryStringBuilder.append(" START WITH ").append(statement.getStartValue());
}
if (statement.getIncrementBy() != null) {
queryStringBuilder.append(" INCREMENT BY ").append(statement.getIncrementBy());
}
if (statement.getMinValue() != null) {
queryStringBuilder.append(" MINVALUE ").append(statement.getMinValue());
}
if (statement.getMaxValue() != null) {
queryStringBuilder.append(" MAXVALUE ").append(statement.getMaxValue());
}
if (database instanceof MariaDBDatabase && statement.getStartValue() != null) {
queryStringBuilder.append(" START WITH ").append(statement.getStartValue());
}
if (statement.getCacheSize() != null) {
if (database instanceof OracleDatabase || database instanceof Db2zDatabase || database instanceof PostgresDatabase || database instanceof MariaDBDatabase || database instanceof SybaseASADatabase) {
if (BigInteger.ZERO.equals(statement.getCacheSize())) {
if (database instanceof OracleDatabase) {
queryStringBuilder.append(" NOCACHE ");
} else if (database instanceof SybaseASADatabase) {
queryStringBuilder.append(" NO CACHE ");
} else if (database instanceof MariaDBDatabase) {
queryStringBuilder.append(" CACHE 0");
}
} else {
queryStringBuilder.append(" CACHE ").append(statement.getCacheSize());
}
}
}
if (!(database instanceof MariaDBDatabase) && statement.getOrdered() != null) {
if (!(database instanceof SybaseASADatabase)) {
if (statement.getOrdered()) {
queryStringBuilder.append(" ORDER");
} else {
if (database instanceof OracleDatabase) {
queryStringBuilder.append(" NOORDER");
}
}
}
}
if (statement.getCycle() != null) {
if (statement.getCycle()) {
queryStringBuilder.append(" CYCLE");
}
}
return new Sql[]{new UnparsedSql(queryStringBuilder.toString(), getAffectedSequence(statement))};
| 966
| 884
| 1,850
|
<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.CreateSequenceStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.CreateSequenceStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.CreateSequenceStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/CreateTableGeneratorInformix.java
|
CreateTableGeneratorInformix
|
generateSql
|
class CreateTableGeneratorInformix extends CreateTableGenerator {
@Override
public boolean supports(CreateTableStatement statement, Database database) {
return database instanceof InformixDatabase;
}
@Override
public int getPriority() {
return PRIORITY_DATABASE + 1;
}
/**
* Informix SQL-specific implementation of the CREATE TABLE SQL generator.
* @param statement The properties of the statement that we will translate into SQL
* @param database For this implementation always an object of the InformixDatabase type
* @param sqlGeneratorChain Other generators in the pipeline for this command
* @return An array of Sql[] statements containing the requested SQL statements for Informix SQL
*/
@Override
public Sql[] generateSql(CreateTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
private boolean constraintNameAfterUnique() {
return true;
}
}
|
StringBuilder buffer = new StringBuilder();
// CREATE TABLE table_name ...
buffer.append("CREATE TABLE ");
if (statement.isIfNotExists() && database.supportsCreateIfNotExists(Table.class)) {
buffer.append("IF NOT EXISTS ");
}
buffer.append(database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()))
.append(" ")
.append("(");
Iterator<String> columnIterator = statement.getColumns().iterator();
List<String> primaryKeyColumns = new LinkedList<>();
/*
* Build the list of columns and constraints in the form
* (
* column1,
* ...,
* columnN,
* constraint1,
* ...,
* constraintN
* )
*/
while (columnIterator.hasNext()) {
String column = columnIterator.next();
buffer.append(database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), column));
buffer.append(" ").append(statement.getColumnTypes().get(column).toDatabaseDataType(database).toSql());
AutoIncrementConstraint autoIncrementConstraint = null;
for (AutoIncrementConstraint currentAutoIncrementConstraint : statement.getAutoIncrementConstraints()) {
if (column.equals(currentAutoIncrementConstraint.getColumnName())) {
autoIncrementConstraint = currentAutoIncrementConstraint;
break;
}
}
boolean isAutoIncrementColumn = autoIncrementConstraint != null;
boolean isPrimaryKeyColumn = (statement.getPrimaryKeyConstraint() != null) && statement
.getPrimaryKeyConstraint().getColumns().contains(column);
if (isPrimaryKeyColumn) {
primaryKeyColumns.add(column);
}
if (statement.getDefaultValue(column) != null) {
Object defaultValue = statement.getDefaultValue(column);
buffer.append(" DEFAULT ");
buffer.append(statement.getColumnTypes().get(column).objectToSql(defaultValue, database));
}
if (isAutoIncrementColumn) {
// TODO: check if database supports auto increment on non primary key column
if (database.supportsAutoIncrement()) {
String autoIncrementClause = database.getAutoIncrementClause(autoIncrementConstraint.getStartWith(), autoIncrementConstraint.getIncrementBy(), autoIncrementConstraint.getGenerationType(), autoIncrementConstraint.getDefaultOnNull());
if (!autoIncrementClause.isEmpty()) {
buffer.append(" ").append(autoIncrementClause);
}
} else {
Scope.getCurrentScope().getLog(getClass()).warning(database.getShortName() + " does not support autoincrement columns as requested for " + (database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())));
}
}
if (statement.getNotNullColumns().containsKey(column)) {
buffer.append(" NOT NULL");
}
if (columnIterator.hasNext()) {
buffer.append(", ");
}
}
buffer.append(",");
/*
* We only create a PRIMARY KEY constraint if one is defined and has at least 1 column.
* General Informix SQL syntax, according to the docs for 11.5
* https://www.ibm.com/support/knowledgecenter/SSGU8G_11.50.0/com.ibm.sqls.doc/ids_sqs_0100.htm
* is:
* ( columns ... --> PRIMARY KEY (column1, ..., columnN) [CONSTRAINT pk_name]
*/
//
PrimaryKeyConstraint pkConstraint = statement.getPrimaryKeyConstraint();
if ((statement.getPrimaryKeyConstraint() != null) && !statement.getPrimaryKeyConstraint().getColumns().isEmpty()) {
buffer.append(" PRIMARY KEY (");
buffer.append(StringUtil.join(primaryKeyColumns, ", "));
buffer.append(")");
if (!StringUtil.isEmpty(pkConstraint.getConstraintName())) {
buffer.append(" CONSTRAINT ");
buffer.append(database.escapeConstraintName(pkConstraint.getConstraintName()));
}
// Setting up table space for PK's index if it exist
buffer.append(",");
}
for (ForeignKeyConstraint fkConstraint : statement.getForeignKeyConstraints()) {
String referencesString = fkConstraint.getReferences();
if (!referencesString.contains(".") && (database.getDefaultSchemaName() != null)) {
referencesString = database.getDefaultSchemaName() + "." + referencesString;
}
buffer.append(" FOREIGN KEY (")
.append(database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), fkConstraint.getColumn()))
.append(") REFERENCES ")
.append(referencesString);
if (fkConstraint.isDeleteCascade()) {
buffer.append(" ON DELETE CASCADE");
}
buffer.append(" CONSTRAINT ");
buffer.append(database.escapeConstraintName(fkConstraint.getForeignKeyName()));
if (fkConstraint.isInitiallyDeferred()) {
buffer.append(" INITIALLY DEFERRED");
}
if (fkConstraint.isDeferrable()) {
buffer.append(" DEFERRABLE");
}
buffer.append(",");
}
// TODO: code duplication. Maybe we can merge this whole class into CreateTableGenerator again.
for (UniqueConstraint uniqueConstraint : statement.getUniqueConstraints()) {
if ((uniqueConstraint.getConstraintName() != null) && !constraintNameAfterUnique()) {
buffer.append(" CONSTRAINT ");
buffer.append(database.escapeConstraintName(uniqueConstraint.getConstraintName()));
}
buffer.append(" UNIQUE (");
buffer.append(database.escapeColumnNameList(StringUtil.join(uniqueConstraint.getColumns(), ", ")));
buffer.append(")");
if ((uniqueConstraint.getConstraintName() != null) && constraintNameAfterUnique()) {
buffer.append(" CONSTRAINT ");
buffer.append(database.escapeConstraintName(uniqueConstraint.getConstraintName()));
}
buffer.append(",");
}
/*
* Here, the list of columns and constraints in the form
* ( column1, ..., columnN, constraint1, ..., constraintN,
* ends. We cannot leave an expression like ", )", so we remove the last comma.
*/
String sql = buffer.toString().replaceFirst(",\\s*$", "") + ")";
if ((statement.getTablespace() != null) && database.supportsTablespaces()) {
sql += " IN " + statement.getTablespace();
}
return new Sql[]{new UnparsedSql(sql, new Table().setName(statement.getTableName()).setSchema(new Schema(statement.getCatalogName(), statement.getSchemaName())))};
| 232
| 1,802
| 2,034
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.CreateTableStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.CreateTableStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/CreateViewGenerator.java
|
CreateViewGenerator
|
generateSql
|
class CreateViewGenerator extends AbstractSqlGenerator<CreateViewStatement> {
@Override
public ValidationErrors validate(CreateViewStatement createViewStatement, Database database,
SqlGeneratorChain sqlGeneratorChain) {
if (database instanceof InformixDatabase) {
return new CreateViewGeneratorInformix().validate(createViewStatement, database, sqlGeneratorChain);
}
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("viewName", createViewStatement.getViewName());
if (createViewStatement.isReplaceIfExists()) {
//
// Special validation for DB2
// replaceIfExists is not allowed for version < 10.5
//
if (! db2VersionSupportsCreateOrReplace(database)) {
validationErrors.addError("'replaceIfExists' is not allowed on DB2 version < 10.5");
}
else {
validationErrors.checkDisallowedField("replaceIfExists", createViewStatement.isReplaceIfExists(), database, Db2zDatabase.class, DerbyDatabase.class, InformixDatabase.class);
}
}
return validationErrors;
}
@Override
public Sql[] generateSql(CreateViewStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
private String determineSchemaSpec(String schemaName) {
if (StringUtil.isEmpty(schemaName)) {
return "";
}
return "[" + schemaName + "].";
}
//
// Check to see if the collection of clauses are in the view definition
//
private boolean viewDefinitionContains(StringClauses viewDefinition, String phrase) {
return viewDefinition.toString()
.toUpperCase()
.replace('\n',' ')
.replaceAll("\\s{2,}"," ")
.contains(phrase.toUpperCase());
}
private boolean shouldPrependDropViewStatement(Database database) {
// allow overriding the value of the dropIfCannotReplace attribute
// from liquibase.properties or command line
boolean dropIfCannotReplace = GlobalConfiguration.ALWAYS_DROP_INSTEAD_OF_REPLACE.getDefaultValue();
if (GlobalConfiguration.ALWAYS_DROP_INSTEAD_OF_REPLACE.getCurrentValue() != null) {
dropIfCannotReplace = GlobalConfiguration.ALWAYS_DROP_INSTEAD_OF_REPLACE.getCurrentValue();
}
return database instanceof HsqlDatabase ||
(database instanceof PostgresDatabase && dropIfCannotReplace);
}
//
// Return true if non-DB2 database or DB2 version >= 10.5
//
private boolean db2VersionSupportsCreateOrReplace(Database database) {
//
// Return true for all non-DB2 databases
//
if (! (database instanceof DB2Database)) {
return true;
}
//
// ASSERT: We have a DB2 database
// DB2 must be version >= 10.5
//
int majorVersion = getMajorVersion(database);
if (majorVersion < 10) {
return false;
}
//
// ASSERT: We have a version >= 10
// If it is > 10 then we return true
// If it is == 10 then we check the minor version
//
int minorVersion = getMinorVersion(database);
return majorVersion > 10 || minorVersion >= 5;
}
private int getMajorVersion(Database database) {
int majorVersion;
try {
majorVersion = database.getDatabaseMajorVersion();
}
catch (DatabaseException dbe) {
majorVersion = -1;
}
return majorVersion;
}
private int getMinorVersion(Database database) {
int minorVersion;
try {
minorVersion = database.getDatabaseMinorVersion();
}
catch (DatabaseException dbe) {
minorVersion = -1;
}
return minorVersion;
}
protected Relation getAffectedView(CreateViewStatement statement) {
return new View().setName(statement.getViewName())
.setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
if (database instanceof InformixDatabase) {
return new CreateViewGeneratorInformix().generateSql(statement, database, sqlGeneratorChain);
}
List<Sql> sql = new ArrayList<>();
if (database instanceof SybaseASADatabase) {
// Switching off view definition checks to allow creation of dependent views even if dependency does not yet exist.
sql.add(new UnparsedSql("SET TEMPORARY OPTION force_view_creation='ON'"));
}
SqlParserFactory sqlParserFactory = Scope.getCurrentScope().getSingleton(SqlParserFactory.class);
LiquibaseSqlParser sqlParser = sqlParserFactory.getSqlParser();
StringClauses viewDefinition = sqlParser.parse(statement.getSelectQuery(), true, true);
if (!statement.isFullDefinition()) {
viewDefinition
.prepend(" ")
.prepend("AS")
.prepend(" ")
.prepend(database.escapeViewName(
statement.getCatalogName(), statement.getSchemaName(), statement.getViewName()))
.prepend(" ")
.prepend("VIEW")
.prepend(" ")
.prepend("CREATE");
}
if (statement.isReplaceIfExists()) {
if (database instanceof FirebirdDatabase) {
viewDefinition.replace("CREATE", "RECREATE");
} else if (database instanceof MSSQLDatabase) {
//
// If we find CREATE OR ALTER then we will let the SQL itself take
// care of the existence of the view
//
if (!viewDefinitionContains(viewDefinition, "CREATE OR ALTER")) {
//from http://stackoverflow.com/questions/163246/sql-server-equivalent-to-oracles-create-or-replace-view
CatalogAndSchema schema = new CatalogAndSchema(
statement.getCatalogName(), statement.getSchemaName()).customize(database);
String schemaSpec = determineSchemaSpec(schema.getSchemaName());
sql.add(new UnparsedSql(
"IF NOT EXISTS (SELECT * FROM sys.views WHERE object_id = OBJECT_ID(N'"
+ schemaSpec
+ "[" + statement.getViewName()
+ "]'))\n"
+ " EXEC sp_executesql N'CREATE VIEW " + schemaSpec + "["
+ statement.getViewName()
+ "] AS SELECT " +
"''This is a code stub which will be replaced by an Alter Statement'' as [code_stub]'"));
viewDefinition.replace("CREATE", "ALTER");
}
} else if (shouldPrependDropViewStatement(database)) {
sql.add(new UnparsedSql(
"DROP VIEW IF EXISTS " + database.escapeViewName(statement.getCatalogName(),
statement.getSchemaName(), statement.getViewName())));
} else {
//
// Do not generate CREATE OR REPLACE if:
// 1) It is already in the SQL
// 2) The DB2 version is < 10.5
//
if (!statement.getSelectQuery().toUpperCase().contains("OR REPLACE")) {
viewDefinition.replace("CREATE", "CREATE OR REPLACE");
}
}
}
sql.add(new UnparsedSql(viewDefinition.toString(), getAffectedView(statement)));
return sql.toArray(EMPTY_SQL);
| 1,056
| 852
| 1,908
|
<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.CreateViewStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.CreateViewStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.CreateViewStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/CreateViewGeneratorInformix.java
|
CreateViewGeneratorInformix
|
generateSql
|
class CreateViewGeneratorInformix extends AbstractSqlGenerator<CreateViewStatement> {
@Override
public boolean supports(CreateViewStatement statement, Database database) {
return database instanceof InformixDatabase;
}
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public ValidationErrors validate(CreateViewStatement createViewStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("viewName", createViewStatement.getViewName());
validationErrors.checkRequiredField("selectQuery", createViewStatement.getSelectQuery());
if (createViewStatement.isReplaceIfExists()) {
validationErrors.checkDisallowedField("replaceIfExists", createViewStatement.isReplaceIfExists(), database, HsqlDatabase.class, H2Database.class, DB2Database.class, MSSQLDatabase.class, DerbyDatabase.class, SybaseASADatabase.class, InformixDatabase.class);
}
return validationErrors;
}
@Override
public Sql[] generateSql(CreateViewStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
String viewName = database.escapeViewName(statement.getCatalogName(), statement.getSchemaName(), statement.getViewName());
String createClause = "CREATE VIEW " + viewName + " AS SELECT * FROM (" + statement.getSelectQuery() + ") AS v";
if (statement.isReplaceIfExists()) {
return new Sql[] {
new UnparsedSql("DROP VIEW IF EXISTS " + viewName),
new UnparsedSql(createClause, new View().setName(viewName).setSchema(statement.getCatalogName(), statement.getViewName()))
};
}
return new Sql[] {
new UnparsedSql(createClause)
};
| 305
| 177
| 482
|
<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.CreateViewStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.CreateViewStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.CreateViewStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/DeleteGenerator.java
|
DeleteGenerator
|
generateSql
|
class DeleteGenerator extends AbstractSqlGenerator<DeleteStatement> {
@Override
public ValidationErrors validate(DeleteStatement deleteStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", deleteStatement.getTableName());
if ((deleteStatement.getWhereParameters() != null) && !deleteStatement.getWhereParameters().isEmpty() &&
(deleteStatement.getWhere() == null)) {
validationErrors.addError("whereParams set but no whereClause");
}
return validationErrors;
}
@Override
public Sql[] generateSql(DeleteStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Relation getAffectedTable(DeleteStatement statement) {
return new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
StringBuilder sql = new StringBuilder("DELETE FROM ")
.append(database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()));
if (statement.getWhere() != null) {
sql.append(" WHERE ").append(replacePredicatePlaceholders(database, statement.getWhere(), statement.getWhereColumnNames(), statement.getWhereParameters()));
}
return new Sql[] { new UnparsedSql(sql.toString(), getAffectedTable(statement)) };
| 236
| 129
| 365
|
<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.DeleteStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.DeleteStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.DeleteStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/DropColumnGenerator.java
|
DropColumnGenerator
|
generateMultipleColumnSql
|
class DropColumnGenerator extends AbstractSqlGenerator<DropColumnStatement> {
@Override
public ValidationErrors validate(DropColumnStatement dropColumnStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
if (dropColumnStatement.isMultiple()) {
ValidationErrors validationErrors = new ValidationErrors();
DropColumnStatement firstColumn = dropColumnStatement.getColumns().get(0);
for (DropColumnStatement drop : dropColumnStatement.getColumns()) {
validationErrors.addAll(validateSingleColumn(drop));
if ((drop.getTableName() != null) && !drop.getTableName().equals(firstColumn.getTableName())) {
validationErrors.addError("All columns must be targeted at the same table");
}
if (drop.isMultiple()) {
validationErrors.addError("Nested multiple drop column statements are not supported");
}
}
return validationErrors;
} else {
return validateSingleColumn(dropColumnStatement);
}
}
private ValidationErrors validateSingleColumn(DropColumnStatement dropColumnStatement) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", dropColumnStatement.getTableName());
validationErrors.checkRequiredField("columnName", dropColumnStatement.getColumnName());
return validationErrors;
}
@Override
public Sql[] generateSql(DropColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
if (statement.isMultiple()) {
return generateMultipleColumnSql(statement.getColumns(), database);
} else {
return generateSingleColumnSql(statement, database);
}
}
private Sql[] generateMultipleColumnSql(List<DropColumnStatement> columns, Database database) {<FILL_FUNCTION_BODY>}
private Sql[] generateSingleColumnSql(DropColumnStatement statement, Database database) {
if (database instanceof DB2Database) {
return new Sql[] {new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP COLUMN " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()), getAffectedColumn(statement))};
} else if (database instanceof Db2zDatabase) {
return new Sql[]{new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP COLUMN " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " RESTRICT", getAffectedColumn(statement))};
} else if ((database instanceof SybaseDatabase) || (database instanceof SybaseASADatabase) || (database
instanceof FirebirdDatabase) || (database instanceof InformixDatabase)) {
return new Sql[] {new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()), getAffectedColumn(statement))};
} else if (database instanceof MSSQLDatabase) {
return new Sql[] {
generateDropDV(statement, database),
new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP COLUMN " +
database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()), getAffectedColumn(statement))
};
}
return new Sql[] {new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP COLUMN " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()), getAffectedColumn(statement))};
}
private Column[] getAffectedColumns(List<DropColumnStatement> columns) {
List<Column> affected = new ArrayList<>();
for (DropColumnStatement column : columns) {
affected.add(getAffectedColumn(column));
}
return affected.toArray(new Column[0]);
}
protected Column getAffectedColumn(DropColumnStatement statement) {
return new Column().setName(statement.getColumnName()).setRelation(new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName()));
}
private UnparsedSql generateDropDV(DropColumnStatement statement, Database database) {
return new UnparsedSql((String) DropDefaultValueGenerator.DROP_DF_MSSQL.apply(database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()),
database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName())));
}
}
|
List<Sql> result = new ArrayList<>();
if (database instanceof MySQLDatabase) {
final StringBuilder alterTable = new StringBuilder("ALTER TABLE " + database.escapeTableName(columns.get(0).getCatalogName(), columns.get(0).getSchemaName(), columns.get(0).getTableName()));
for (int i = 0; i < columns.size(); i++) {
alterTable.append(" DROP ").append(database.escapeColumnName(columns.get(i).getCatalogName(), columns.get(i).getSchemaName(), columns.get(i).getTableName(), columns.get(i).getColumnName()));
if (i < (columns.size() - 1)) {
alterTable.append(",");
}
}
result.add(new UnparsedSql(alterTable.toString(), getAffectedColumns(columns)));
} else {
if (database instanceof MSSQLDatabase) {
for (DropColumnStatement column : columns) {
final Sql[] sqls = generateSingleColumnSql(column, database);
result.add(sqls[0]);
result.add(sqls[1]);
}
} else {
for (DropColumnStatement column : columns) {
result.add(generateSingleColumnSql(column, database)[0]);
}
}
}
return result.toArray(EMPTY_SQL);
| 1,276
| 341
| 1,617
|
<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.DropColumnStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.DropColumnStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.DropColumnStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/DropDefaultValueGenerator.java
|
DropDefaultValueGenerator
|
generateSql
|
class DropDefaultValueGenerator extends AbstractSqlGenerator<DropDefaultValueStatement> {
public static BiFunction DROP_DF_MSSQL = (tableName, columnName) -> "DECLARE @sql [nvarchar](MAX)\r\n" +
"SELECT @sql = N'ALTER TABLE " + tableName + " DROP CONSTRAINT ' + QUOTENAME([df].[name]) " +
"FROM [sys].[columns] AS [c] " +
"INNER JOIN [sys].[default_constraints] AS [df] " +
"ON [df].[object_id] = [c].[default_object_id] " +
"WHERE [c].[object_id] = OBJECT_ID(N'" + tableName + "') " +
"AND [c].[name] = N'" + columnName + "'\r\n" +
"EXEC sp_executesql @sql";
@Override
public boolean supports(DropDefaultValueStatement statement, Database database) {
return !(database instanceof SQLiteDatabase);
}
@Override
public ValidationErrors validate(DropDefaultValueStatement dropDefaultValueStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", dropDefaultValueStatement.getTableName());
validationErrors.checkRequiredField("columnName", dropDefaultValueStatement.getColumnName());
if (database instanceof InformixDatabase) {
validationErrors.checkRequiredField("columnDataType", dropDefaultValueStatement.getColumnDataType());
}
return validationErrors;
}
@Override
public Sql[] generateSql(DropDefaultValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Column getAffectedColumn(DropDefaultValueStatement statement) {
return new Column().setName(statement.getColumnName()).setRelation(new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName()));
}
}
|
String sql;
String escapedTableName = database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName());
if (database instanceof MSSQLDatabase) {
sql = (String) DROP_DF_MSSQL.apply(database.escapeStringForDatabase(escapedTableName), database.escapeStringForDatabase(statement.getColumnName()));
} else if (database instanceof MySQLDatabase) {
sql = "ALTER TABLE " + escapedTableName + " ALTER " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " DROP DEFAULT";
} else if (database instanceof OracleDatabase) {
sql = "ALTER TABLE " + escapedTableName + " MODIFY " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " DEFAULT NULL";
} else if (database instanceof SybaseDatabase) {
sql = "ALTER TABLE " + escapedTableName + " REPLACE " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " DEFAULT NULL";
} else if (database instanceof SybaseASADatabase) {
sql = "ALTER TABLE " + escapedTableName + " ALTER " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " DEFAULT NULL";
} else if (database instanceof DerbyDatabase) {
sql = "ALTER TABLE " + escapedTableName + " ALTER COLUMN " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " WITH DEFAULT NULL";
} else if (database instanceof InformixDatabase) {
/*
* TODO If dropped from a not null column the not null constraint will be dropped, too.
* If the column is "NOT NULL" it has to be added behind the datatype.
*/
sql = "ALTER TABLE " + escapedTableName + " MODIFY (" + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " " + statement.getColumnDataType() + ")";
} else if (database instanceof AbstractDb2Database) {
sql = "ALTER TABLE " + escapedTableName + " ALTER COLUMN " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " DROP DEFAULT";
} else if (database instanceof PostgresDatabase) {
sql = "ALTER TABLE " + escapedTableName + " ALTER COLUMN " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " DROP DEFAULT";
} else {
sql = "ALTER TABLE " + escapedTableName + " ALTER COLUMN " + database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()) + " SET DEFAULT NULL";
}
return new Sql[] {
new UnparsedSql(sql, getAffectedColumn(statement))
};
| 499
| 810
| 1,309
|
<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.DropDefaultValueStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.DropDefaultValueStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.DropDefaultValueStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/DropForeignKeyConstraintGenerator.java
|
DropForeignKeyConstraintGenerator
|
validate
|
class DropForeignKeyConstraintGenerator extends AbstractSqlGenerator<DropForeignKeyConstraintStatement> {
@Override
public boolean supports(DropForeignKeyConstraintStatement statement, Database database) {
return (!(database instanceof SQLiteDatabase));
}
@Override
public ValidationErrors validate(DropForeignKeyConstraintStatement dropForeignKeyConstraintStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(DropForeignKeyConstraintStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
if ((database instanceof MySQLDatabase) || (database instanceof SybaseASADatabase)) {
return new Sql[] { new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getBaseTableCatalogName(), statement.getBaseTableSchemaName(), statement.getBaseTableName()) + " DROP FOREIGN KEY " + database.escapeConstraintName(statement.getConstraintName()), getAffectedForeignKey(statement)) };
} else {
return new Sql[] { new UnparsedSql("ALTER TABLE " + database.escapeTableName(statement.getBaseTableCatalogName(), statement.getBaseTableSchemaName(), statement.getBaseTableName()) + " DROP CONSTRAINT " + database.escapeConstraintName(statement.getConstraintName()), getAffectedForeignKey(statement)) };
}
}
protected ForeignKey getAffectedForeignKey(DropForeignKeyConstraintStatement statement) {
return new ForeignKey().setName(statement.getConstraintName()).setForeignKeyTable((Table) new Table().setName(statement.getBaseTableName()).setSchema(statement.getBaseTableCatalogName(), statement.getBaseTableSchemaName()));
}
}
|
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("baseTableName", dropForeignKeyConstraintStatement.getBaseTableName());
validationErrors.checkRequiredField("constraintName", dropForeignKeyConstraintStatement.getConstraintName());
return validationErrors;
| 416
| 70
| 486
|
<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.DropForeignKeyConstraintStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.DropForeignKeyConstraintStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.DropForeignKeyConstraintStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/DropIndexGenerator.java
|
DropIndexGenerator
|
generateSql
|
class DropIndexGenerator extends AbstractSqlGenerator<DropIndexStatement> {
@Override
public ValidationErrors validate(DropIndexStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("indexName", statement.getIndexName());
if ((database instanceof MySQLDatabase) || (database instanceof MSSQLDatabase) || database instanceof SybaseASADatabase) {
validationErrors.checkRequiredField("tableName", statement.getTableName());
}
return validationErrors;
}
@Override
public Sql[] generateSql(DropIndexStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Index getAffectedIndex(DropIndexStatement statement) {
Table table = null;
if (statement.getTableName() != null) {
table = (Table) new Table().setName(statement.getTableName()).setSchema(statement.getTableCatalogName(), statement.getTableSchemaName());
}
return new Index().setName(statement.getIndexName()).setRelation(table);
}
}
|
List<String> associatedWith = StringUtil.splitAndTrim(statement.getAssociatedWith(), ",");
if (associatedWith != null) {
if (associatedWith.contains(Index.MARK_PRIMARY_KEY) || associatedWith.contains(Index.MARK_UNIQUE_CONSTRAINT)) {
return EMPTY_SQL;
} else if (associatedWith.contains(Index.MARK_FOREIGN_KEY)) {
if (!((database instanceof OracleDatabase) || (database instanceof MSSQLDatabase))) {
return EMPTY_SQL;
}
}
}
String schemaName = statement.getTableSchemaName();
if (database instanceof MySQLDatabase) {
return new Sql[]{new UnparsedSql("DROP INDEX " + database.escapeIndexName(null, null, statement.getIndexName()) + " ON " + database.escapeTableName(statement.getTableCatalogName(), schemaName, statement.getTableName()), getAffectedIndex(statement))};
} else if (database instanceof MSSQLDatabase) {
return new Sql[]{new UnparsedSql("DROP INDEX " + database.escapeIndexName(null, null, statement.getIndexName()) + " ON " + database.escapeTableName(statement.getTableCatalogName(), schemaName, statement.getTableName()), getAffectedIndex(statement))};
} else if (database instanceof SybaseDatabase) {
return new Sql[]{new UnparsedSql("DROP INDEX " + statement.getTableName() + "." + statement.getIndexName(), getAffectedIndex(statement))};
} else if (database instanceof SybaseASADatabase) {
return new Sql[]{new UnparsedSql("DROP INDEX " + database.escapeTableName(statement.getTableCatalogName(), schemaName, statement.getTableName()) + "." + database.escapeIndexName(statement.getTableCatalogName(), schemaName, statement.getIndexName()), getAffectedIndex(statement))};
} else if (database instanceof PostgresDatabase) {
return new Sql[]{new UnparsedSql("DROP INDEX " + database.escapeIndexName(statement.getTableCatalogName(), schemaName, statement.getIndexName()), getAffectedIndex(statement))};
}
return new Sql[]{new UnparsedSql("DROP INDEX " + database.escapeIndexName(statement.getTableCatalogName(), schemaName, statement.getIndexName()), getAffectedIndex(statement))};
| 282
| 594
| 876
|
<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.DropIndexStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.DropIndexStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.DropIndexStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/DropPrimaryKeyGenerator.java
|
DropPrimaryKeyGenerator
|
generateSql
|
class DropPrimaryKeyGenerator extends AbstractSqlGenerator<DropPrimaryKeyStatement> {
@Override
public boolean supports(DropPrimaryKeyStatement statement, Database database) {
return (!(database instanceof SQLiteDatabase));
}
@Override
public ValidationErrors validate(DropPrimaryKeyStatement dropPrimaryKeyStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", dropPrimaryKeyStatement.getTableName());
if ((database instanceof FirebirdDatabase) || (database instanceof InformixDatabase) || (database instanceof
SybaseDatabase)) {
validationErrors.checkRequiredField("constraintName", dropPrimaryKeyStatement.getConstraintName());
}
return validationErrors;
}
@Override
public Sql[] generateSql(DropPrimaryKeyStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected PrimaryKey getAffectedPrimaryKey(DropPrimaryKeyStatement statement) {
return new PrimaryKey().setName(statement.getConstraintName()).setTable((Table) new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName()));
}
}
|
String sql;
if (database instanceof MSSQLDatabase) {
String escapedTableName = database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName());
if (statement.getConstraintName() == null) {
sql =
"DECLARE @sql [nvarchar](MAX)\r\n" +
"SELECT @sql = N'ALTER TABLE " + database.escapeStringForDatabase(escapedTableName) + " DROP CONSTRAINT ' + QUOTENAME([kc].[name]) " +
"FROM [sys].[key_constraints] AS [kc] " +
"WHERE [kc].[parent_object_id] = OBJECT_ID(N'" + database.escapeStringForDatabase(escapedTableName) + "') " +
"AND [kc].[type] = 'PK'\r\n" +
"EXEC sp_executesql @sql";
} else {
sql = "ALTER TABLE " + escapedTableName + " DROP CONSTRAINT " + database.escapeConstraintName(statement.getConstraintName());
}
} else if (database instanceof PostgresDatabase) {
if (statement.getConstraintName() == null) {
String schemaName = (statement.getSchemaName() != null) ? statement.getSchemaName() : database
.getDefaultSchemaName();
schemaName = database.correctObjectName(schemaName, Schema.class);
String tableName = database.correctObjectName(statement.getTableName(), Table.class);
sql = String.format(""
+ "DO $$ DECLARE constraint_name varchar;\n"
+ "BEGIN\n"
+ " SELECT tc.CONSTRAINT_NAME into strict constraint_name\n"
+ " FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc\n"
+ " WHERE CONSTRAINT_TYPE = 'PRIMARY KEY'\n"
+ " AND TABLE_NAME = '%2$s' AND TABLE_SCHEMA = '%1$s';\n"
+ " EXECUTE 'alter table %3$s.%4$s drop constraint \"' || constraint_name || '\"';\n"
+ "END $$;"
, schemaName, tableName
, database.escapeObjectName(schemaName, Schema.class), database.escapeObjectName(tableName, Table.class));
} else {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP CONSTRAINT " + database.escapeConstraintName(statement.getConstraintName());
}
} else if (database instanceof FirebirdDatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP CONSTRAINT "+database.escapeConstraintName(statement.getConstraintName());
} else if (database instanceof OracleDatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP PRIMARY KEY";
if ((statement.getDropIndex() == null) || statement.getDropIndex()) {
sql += " DROP INDEX";
} else {
sql += " KEEP INDEX";
}
} else if (database instanceof InformixDatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP CONSTRAINT " + database.escapeConstraintName(statement.getConstraintName());
} else if (database instanceof SybaseDatabase) {
String escapedTableName = database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName());
String escapedConstraintName = database.escapeConstraintName(statement.getConstraintName());
sql = "ALTER TABLE " + escapedTableName + " DROP CONSTRAINT " + escapedConstraintName;
} else {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP PRIMARY KEY";
}
return new Sql[] {
new UnparsedSql(sql, getAffectedPrimaryKey(statement))
};
| 299
| 1,051
| 1,350
|
<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.DropPrimaryKeyStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.DropPrimaryKeyStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.DropPrimaryKeyStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/DropProcedureGenerator.java
|
DropProcedureGenerator
|
generateSql
|
class DropProcedureGenerator extends AbstractSqlGenerator<DropProcedureStatement> {
@Override
public boolean supports(DropProcedureStatement statement, Database database) {
return !(database instanceof SQLiteDatabase);
}
@Override
public ValidationErrors validate(DropProcedureStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("procedureName", statement.getProcedureName());
validationErrors.checkDisallowedField("catalogName", statement.getCatalogName(), database, MSSQLDatabase.class);
return validationErrors;
}
@Override
public Sql[] generateSql(DropProcedureStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
return new Sql[] {
new UnparsedSql("DROP PROCEDURE "+database.escapeObjectName(statement.getCatalogName(), statement.getSchemaName(), statement.getProcedureName(), StoredProcedure.class),
new StoredProcedure().setName(statement.getProcedureName()).setSchema(new Schema(statement.getCatalogName(), statement.getSchemaName())))
};
| 198
| 101
| 299
|
<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.DropProcedureStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.DropProcedureStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.DropProcedureStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/DropSequenceGenerator.java
|
DropSequenceGenerator
|
generateSql
|
class DropSequenceGenerator extends AbstractSqlGenerator<DropSequenceStatement> {
@Override
public boolean supports(DropSequenceStatement statement, Database database) {
return database.supports(Sequence.class);
}
@Override
public ValidationErrors validate(DropSequenceStatement dropSequenceStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("sequenceName", dropSequenceStatement.getSequenceName());
return validationErrors;
}
@Override
public Sql[] generateSql(DropSequenceStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Sequence getAffectedSequence(DropSequenceStatement statement) {
return new Sequence().setName(statement.getSequenceName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
String sql = "DROP SEQUENCE ";
sql += database.escapeSequenceName(statement.getCatalogName(), statement.getSchemaName(), statement.getSequenceName());
if (database instanceof PostgresDatabase) {
sql += " CASCADE";
}
if (database instanceof DerbyDatabase) {
sql += " RESTRICT";
}
return new Sql[] {
new UnparsedSql(sql, getAffectedSequence(statement))
};
| 219
| 120
| 339
|
<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.DropSequenceStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.DropSequenceStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.DropSequenceStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/DropTableGenerator.java
|
DropTableGenerator
|
generateSql
|
class DropTableGenerator extends AbstractSqlGenerator<DropTableStatement> {
@Override
public ValidationErrors validate(DropTableStatement dropTableStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", dropTableStatement.getTableName());
return validationErrors;
}
@Override
public Sql[] generateSql(DropTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Relation getAffectedTable(DropTableStatement statement) {
return new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
StringBuilder buffer = new StringBuilder();
buffer.append("DROP TABLE ").append(database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()));
if (statement.isCascadeConstraints()) {
if (database.supportsDropTableCascadeConstraints()) {
if (database instanceof OracleDatabase) {
buffer.append(" CASCADE CONSTRAINTS");
} else {
buffer.append(" CASCADE");
}
}
}
return new Sql[]{
new UnparsedSql(buffer.toString(), getAffectedTable(statement))
};
| 183
| 162
| 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.DropTableStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.DropTableStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.DropTableStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/DropUniqueConstraintGenerator.java
|
DropUniqueConstraintGenerator
|
generateSql
|
class DropUniqueConstraintGenerator extends AbstractSqlGenerator<DropUniqueConstraintStatement> {
@Override
public boolean supports(DropUniqueConstraintStatement statement, Database database) {
return !(database instanceof SQLiteDatabase);
}
@Override
public ValidationErrors validate(DropUniqueConstraintStatement dropUniqueConstraintStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", dropUniqueConstraintStatement.getTableName());
validationErrors.checkRequiredField("constraintName", dropUniqueConstraintStatement.getConstraintName());
return validationErrors;
}
@Override
public Sql[] generateSql(DropUniqueConstraintStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected UniqueConstraint getAffectedUniqueConstraint(DropUniqueConstraintStatement statement) {
UniqueConstraint constraint = new UniqueConstraint().setName(statement.getConstraintName()).setRelation(new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName()));
if (statement.getUniqueColumns() != null) {
int i = 0;
for (ColumnConfig column : statement.getUniqueColumns()) {
constraint.addColumn(i++, new Column(column));
}
}
return constraint;
}
}
|
String sql;
if (database instanceof MySQLDatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP KEY " + database.escapeConstraintName(statement.getConstraintName());
} else if (database instanceof OracleDatabase) {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP CONSTRAINT " + database.escapeConstraintName(statement.getConstraintName()) + " DROP INDEX";
} else if (database instanceof SybaseASADatabase) {
// Syntax is pretty regular, according to:
// https://help.sap.com/viewer/40c01c3500744c85a02db71276495de5/17.0/en-US/8169d7966ce2101497b5ac611f7413ce.html
sql = "ALTER TABLE "
+ database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())
+ " DROP CONSTRAINT " + database.escapeConstraintName(statement.getConstraintName());
} else if (database instanceof CockroachDatabase) {
sql = "DROP INDEX " + database.escapeConstraintName(statement.getConstraintName()) + " CASCADE";
} else {
sql = "ALTER TABLE " + database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()) + " DROP CONSTRAINT " + database.escapeConstraintName(statement.getConstraintName());
}
return new Sql[] {
new UnparsedSql(sql, getAffectedUniqueConstraint(statement))
};
| 345
| 454
| 799
|
<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.DropUniqueConstraintStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.DropUniqueConstraintStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.DropUniqueConstraintStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/DropViewGenerator.java
|
DropViewGenerator
|
generateSql
|
class DropViewGenerator extends AbstractSqlGenerator<DropViewStatement> {
@Override
public ValidationErrors validate(DropViewStatement dropViewStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("viewName", dropViewStatement.getViewName());
validationErrors.checkDisallowedField("ifExists", dropViewStatement.isIfExists(), database, OracleDatabase.class);
return validationErrors;
}
@Override
public Sql[] generateSql(DropViewStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
protected Relation getAffectedView(DropViewStatement statement) {
return new View().setName(statement.getViewName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
final String command = "DROP VIEW " + (ObjectUtil.defaultIfNull(statement.isIfExists(), false) ? "IF EXISTS " : "");
return new Sql[] {
new UnparsedSql(command + database.escapeViewName(statement.getCatalogName(), statement.getSchemaName(), statement.getViewName()), getAffectedView(statement))
};
| 212
| 94
| 306
|
<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.DropViewStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.DropViewStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.DropViewStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/GetNextChangeSetSequenceValueGenerator.java
|
GetNextChangeSetSequenceValueGenerator
|
generateSql
|
class GetNextChangeSetSequenceValueGenerator extends AbstractSqlGenerator<GetNextChangeSetSequenceValueStatement> {
@Override
public ValidationErrors validate(GetNextChangeSetSequenceValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return new ValidationErrors();
}
@Override
public Sql[] generateSql(GetNextChangeSetSequenceValueStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
String quotedColumnName = database.escapeColumnName(null, null, null, "ORDEREXECUTED");
return SqlGeneratorFactory.getInstance()
.generateSql(new SelectFromDatabaseChangeLogStatement(new ColumnConfig().setName("MAX("+quotedColumnName+")", true)), database);
| 114
| 73
| 187
|
<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.GetNextChangeSetSequenceValueStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.GetNextChangeSetSequenceValueStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.GetNextChangeSetSequenceValueStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/GetViewDefinitionGenerator.java
|
GetViewDefinitionGenerator
|
generateSql
|
class GetViewDefinitionGenerator extends AbstractSqlGenerator<GetViewDefinitionStatement> {
@Override
public ValidationErrors validate(GetViewDefinitionStatement getViewDefinitionStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("viewName", getViewDefinitionStatement.getViewName());
return validationErrors;
}
@Override
public Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
CatalogAndSchema schema = new CatalogAndSchema(statement.getCatalogName(), statement.getSchemaName()).customize(database);
String sql;
if (database instanceof MSSQLDatabase)
sql = "select VIEW_DEFINITION from INFORMATION_SCHEMA.VIEWS where TABLE_NAME='" + database.correctObjectName(statement.getViewName(), View.class) + "'";
else
sql = "select view_definition from information_schema.views where table_name='" + database.correctObjectName(statement.getViewName(), View.class) + "'";
if (database instanceof MySQLDatabase) {
sql += " and table_schema='" + schema.getCatalogName() + "'";
} else {
if (database.supports(Schema.class)) {
String schemaName = schema.getSchemaName();
if (schemaName != null) {
if (database instanceof MSSQLDatabase)
sql += " and TABLE_SCHEMA='" + schemaName + "'";
else
sql += " and table_schema='" + schemaName + "'";
}
}
if (database.supports(Catalog.class)) {
String catalogName = schema.getCatalogName();
if (catalogName != null) {
if (database instanceof MSSQLDatabase)
sql += " and TABLE_CATALOG='" + catalogName + "'";
else
sql += " and table_catalog='" + catalogName + "'";
}
}
}
return new Sql[]{
new UnparsedSql(sql)
};
| 137
| 410
| 547
|
<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.GetViewDefinitionStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.GetViewDefinitionStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/GetViewDefinitionGeneratorDB2.java
|
GetViewDefinitionGeneratorDB2
|
generateSql
|
class GetViewDefinitionGeneratorDB2 extends GetViewDefinitionGenerator {
@Override
public int getPriority() {
return SqlGenerator.PRIORITY_DATABASE;
}
@Override
public boolean supports(GetViewDefinitionStatement statement, Database database) {
return database instanceof AbstractDb2Database;
}
@Override
public Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
CatalogAndSchema schema = new CatalogAndSchema(statement.getCatalogName(), statement.getSchemaName()).customize(database);
if (database instanceof Db2zDatabase) {
return new Sql[] {
new UnparsedSql("select STATEMENT AS view_definition from SYSIBM.SYSVIEWS where NAME='" + statement.getViewName() + "' and CREATOR = '" + schema.getSchemaName() + "'")
};
}
return new Sql[] {
new UnparsedSql("select view_definition from SYSIBM.VIEWS where TABLE_NAME='" + statement.getViewName() + "' and TABLE_SCHEMA='" + schema.getSchemaName() + "'")
};
| 122
| 179
| 301
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/GetViewDefinitionGeneratorDerby.java
|
GetViewDefinitionGeneratorDerby
|
generateSql
|
class GetViewDefinitionGeneratorDerby extends GetViewDefinitionGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(GetViewDefinitionStatement statement, Database database) {
return database instanceof DerbyDatabase;
}
@Override
public Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
CatalogAndSchema schema = new CatalogAndSchema(statement.getCatalogName(), statement.getSchemaName()).customize(database);
return new Sql[] {
new UnparsedSql("select V.VIEWDEFINITION from SYS.SYSVIEWS V, SYS.SYSTABLES T, SYS.SYSSCHEMAS S WHERE V.TABLEID=T.TABLEID AND T.SCHEMAID=S.SCHEMAID AND T.TABLETYPE='V' AND T.TABLENAME='" + statement.getViewName() + "' AND S.SCHEMANAME='"+schema.getSchemaName()+"'")
};
| 118
| 161
| 279
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/GetViewDefinitionGeneratorFirebird.java
|
GetViewDefinitionGeneratorFirebird
|
generateSql
|
class GetViewDefinitionGeneratorFirebird extends GetViewDefinitionGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(GetViewDefinitionStatement statement, Database database) {
return database instanceof FirebirdDatabase;
}
@Override
public Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
return new Sql[] {
new UnparsedSql("select rdb$view_source from rdb$relations where upper(rdb$relation_name)='" + statement.getViewName() + "'")
};
| 118
| 55
| 173
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/GetViewDefinitionGeneratorHsql.java
|
GetViewDefinitionGeneratorHsql
|
generateSql
|
class GetViewDefinitionGeneratorHsql extends GetViewDefinitionGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(GetViewDefinitionStatement statement, Database database) {
return database instanceof HsqlDatabase;
}
@Override
public Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
CatalogAndSchema schema = new CatalogAndSchema(statement.getCatalogName(), statement.getSchemaName()).customize(database);
return new Sql[] {
new UnparsedSql("SELECT VIEW_DEFINITION FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '" + statement.getViewName() + "' AND TABLE_SCHEMA='" + schema.getSchemaName() + "'")
};
| 118
| 106
| 224
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/GetViewDefinitionGeneratorInformix.java
|
GetViewDefinitionGeneratorInformix
|
generateSql
|
class GetViewDefinitionGeneratorInformix extends GetViewDefinitionGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(GetViewDefinitionStatement statement, Database database) {
return database instanceof InformixDatabase;
}
@Override
public Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
// TODO owner is schemaName ?
// view definition is distributed over multiple rows, each 64 chars
// see InformixDatabase.getViewDefinition
return new Sql[]{
new UnparsedSql("select v.viewtext from sysviews v, systables t where t.tabname = '" + statement.getViewName() + "' and v.tabid = t.tabid and t.tabtype = 'V' order by v.seqno")
};
| 119
| 113
| 232
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/GetViewDefinitionGeneratorMSSQL.java
|
GetViewDefinitionGeneratorMSSQL
|
generateSql
|
class GetViewDefinitionGeneratorMSSQL extends GetViewDefinitionGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(GetViewDefinitionStatement statement, Database database) {
return database instanceof MSSQLDatabase;
}
@Override
public Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
CatalogAndSchema schema = new CatalogAndSchema(statement.getCatalogName(), statement.getSchemaName()).customize(database);
String viewNameEscaped = database.escapeObjectName(schema.getCatalogName(), schema.getSchemaName(), statement.getViewName(), View.class);
String sql;
sql = "SELECT OBJECT_DEFINITION(OBJECT_ID(N'" + database.escapeStringForDatabase(viewNameEscaped) + "')) AS [ObjectDefinition]";
return new Sql[] { new UnparsedSql(sql) };
| 120
| 136
| 256
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/GetViewDefinitionGeneratorOracle.java
|
GetViewDefinitionGeneratorOracle
|
generateSql
|
class GetViewDefinitionGeneratorOracle extends GetViewDefinitionGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(GetViewDefinitionStatement statement, Database database) {
return database instanceof OracleDatabase;
}
@Override
public Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
CatalogAndSchema schema = new CatalogAndSchema(statement.getCatalogName(), statement.getSchemaName()).customize(database);
return new Sql[]{
new UnparsedSql("SELECT TEXT FROM ALL_VIEWS WHERE upper(VIEW_NAME)='" + statement.getViewName().toUpperCase() + "' AND OWNER='" + schema.getSchemaName() + "'")
};
| 117
| 102
| 219
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/GetViewDefinitionGeneratorPostgres.java
|
GetViewDefinitionGeneratorPostgres
|
generateSql
|
class GetViewDefinitionGeneratorPostgres extends GetViewDefinitionGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(GetViewDefinitionStatement statement, Database database) {
return database instanceof PostgresDatabase;
}
@Override
public Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
CatalogAndSchema schema = new CatalogAndSchema(statement.getCatalogName(), statement.getSchemaName()).customize(database);
return new Sql[] {
new UnparsedSql("select definition from pg_views where viewname='" + statement.getViewName() + "' AND schemaname='" + schema.getSchemaName() + "'" )
};
| 118
| 91
| 209
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/GetViewDefinitionGeneratorSybase.java
|
GetViewDefinitionGeneratorSybase
|
generateSql
|
class GetViewDefinitionGeneratorSybase extends GetViewDefinitionGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(GetViewDefinitionStatement statement, Database database) {
return database instanceof SybaseDatabase;
}
@Override
public Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
CatalogAndSchema schema = new CatalogAndSchema(statement.getCatalogName(), statement.getSchemaName()).customize(database);
String schemaName = schema.getSchemaName();
if (schemaName == null) {
schemaName = database.getDefaultSchemaName();
}
if (schemaName == null) {
schemaName = "dbo";
}
String sql = String.format("select text from syscomments where id = object_id('%s.%s') order by colid", schemaName, statement.getViewName());
return new Sql[]{
new UnparsedSql(sql)
};
| 119
| 156
| 275
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/GetViewDefinitionGeneratorSybaseASA.java
|
GetViewDefinitionGeneratorSybaseASA
|
generateSql
|
class GetViewDefinitionGeneratorSybaseASA extends GetViewDefinitionGenerator {
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public boolean supports(GetViewDefinitionStatement statement, Database database) {
return database instanceof SybaseASADatabase;
}
@Override
public Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
return new Sql[]{
new UnparsedSql("select viewtext from sysviews where upper(viewname)='" + statement.getViewName().toUpperCase() + "' and upper(vcreator) = '" + statement.getSchemaName().toUpperCase() + '\'')
};
| 124
| 73
| 197
|
<methods>public non-sealed void <init>() ,public liquibase.sql.Sql[] generateSql(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) ,public liquibase.exception.ValidationErrors validate(liquibase.statement.core.GetViewDefinitionStatement, liquibase.database.Database, SqlGeneratorChain#RAW) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/InitializeDatabaseChangeLogLockTableGenerator.java
|
InitializeDatabaseChangeLogLockTableGenerator
|
generateSql
|
class InitializeDatabaseChangeLogLockTableGenerator extends AbstractSqlGenerator<InitializeDatabaseChangeLogLockTableStatement> {
@Override
public ValidationErrors validate(InitializeDatabaseChangeLogLockTableStatement initializeDatabaseChangeLogLockTableStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return new ValidationErrors();
}
@Override
public Sql[] generateSql(InitializeDatabaseChangeLogLockTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
}
|
ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
try {
DeleteStatement deleteStatement = new DeleteStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogLockTableName());
InsertStatement insertStatement = new InsertStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogLockTableName())
.addColumnValue("ID", 1)
.addColumnValue("LOCKED", Boolean.FALSE);
List<Sql> sql = new ArrayList<>();
sql.addAll(Arrays.asList(SqlGeneratorFactory.getInstance().generateSql(deleteStatement, database)));
sql.addAll(Arrays.asList(SqlGeneratorFactory.getInstance().generateSql(insertStatement, database)));
return sql.toArray(EMPTY_SQL);
} finally {
database.setObjectQuotingStrategy(currentStrategy);
}
| 124
| 260
| 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.InitializeDatabaseChangeLogLockTableStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.InitializeDatabaseChangeLogLockTableStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.InitializeDatabaseChangeLogLockTableStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/InsertGenerator.java
|
InsertGenerator
|
validate
|
class InsertGenerator extends AbstractSqlGenerator<InsertStatement> {
private boolean previousInsertHasHeader;
@Override
public ValidationErrors validate(InsertStatement insertStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
@Override
public Sql[] generateSql(InsertStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
StringBuilder sql = new StringBuilder();
if(!previousInsertHasHeader) {
generateHeader(sql,statement,database);
} else {
sql.append(",");
}
generateValues(sql,statement,database);
return new Sql[] {
new UnparsedSql(sql.toString(), getAffectedTable(statement))
};
}
public void setPreviousInsertStatement(boolean previousInsertHasHeader) {
this.previousInsertHasHeader = previousInsertHasHeader;
}
public void generateHeader(StringBuilder sql,InsertStatement statement, Database database) {
sql.append("INSERT INTO ")
.append(database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()))
.append(" (");
for (String column : statement.getColumnValues().keySet()) {
sql.append(database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), column)).append(", ");
}
sql.deleteCharAt(sql.lastIndexOf(" "));
int lastComma = sql.lastIndexOf(",");
if (lastComma >= 0) {
sql.deleteCharAt(lastComma);
}
sql.append(") VALUES ");
}
public void generateValues(StringBuilder sql,InsertStatement statement, Database database) {
sql.append("(");
for (String column : statement.getColumnValues().keySet()) {
Object newValue = statement.getColumnValues().get(column);
if ((newValue == null) || "NULL".equalsIgnoreCase(newValue.toString())) {
sql.append("NULL");
} else if ((newValue instanceof String) && !looksLikeFunctionCall(((String) newValue), database)) {
sql.append(DataTypeFactory.getInstance().fromObject(newValue, database).objectToSql(newValue, database));
} else if (newValue instanceof Date) {
sql.append(database.getDateLiteral(((Date) newValue)));
} else if (newValue instanceof Boolean) {
if (((Boolean) newValue)) {
sql.append(DataTypeFactory.getInstance().getTrueBooleanValue(database));
} else {
sql.append(DataTypeFactory.getInstance().getFalseBooleanValue(database));
}
} else if (newValue instanceof DatabaseFunction) {
sql.append(database.generateDatabaseFunctionValue((DatabaseFunction) newValue));
}
else {
sql.append(newValue);
}
sql.append(", ");
}
sql.deleteCharAt(sql.lastIndexOf(" "));
int lastComma = sql.lastIndexOf(",");
if (lastComma >= 0) {
sql.deleteCharAt(lastComma);
}
sql.append(")");
}
protected Relation getAffectedTable(InsertStatement statement) {
return new Table().setName(statement.getTableName()).setSchema(statement.getCatalogName(), statement.getSchemaName());
}
}
|
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", insertStatement.getTableName());
validationErrors.checkRequiredField("columns", insertStatement.getColumnValues());
return validationErrors;
| 854
| 60
| 914
|
<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.InsertStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.InsertStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.InsertStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/InsertOrUpdateGenerator.java
|
InsertOrUpdateGenerator
|
getWhereClause
|
class InsertOrUpdateGenerator extends AbstractSqlGenerator<InsertOrUpdateStatement> {
protected abstract String getRecordCheck(InsertOrUpdateStatement insertOrUpdateStatement, Database database, String whereClause);
protected abstract String getElse(Database database);
protected String getPostUpdateStatements(Database database) {
return "";
}
@Override
public int getPriority() {
return PRIORITY_DATABASE;
}
@Override
public ValidationErrors validate(InsertOrUpdateStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
ValidationErrors validationErrors = new ValidationErrors();
validationErrors.checkRequiredField("tableName", statement.getTableName());
validationErrors.checkRequiredField("columns", statement.getColumnValues());
validationErrors.checkRequiredField("primaryKey", statement.getPrimaryKey());
return validationErrors;
}
protected String getWhereClause(InsertOrUpdateStatement insertOrUpdateStatement, Database database) {<FILL_FUNCTION_BODY>}
protected String getInsertStatement(InsertOrUpdateStatement insertOrUpdateStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
StringBuilder insertBuffer = new StringBuilder();
InsertGenerator insert = new InsertGenerator();
Sql[] insertSql = insert.generateSql(insertOrUpdateStatement, database, sqlGeneratorChain);
for (Sql s : insertSql) {
insertBuffer.append(s.toSql());
insertBuffer.append(";");
}
insertBuffer.append("\n");
return insertBuffer.toString();
}
/**
* Generates an SQL UPDATE statement for the specified insert or update statement, database, and SQL generator chain.
*
* @param insertOrUpdateStatement the insert or update statement to generate the update statement from
* @param database the database to generate the update statement for
* @param whereClause the WHERE clause to use in the update statement
* @param sqlGeneratorChain the SQL generator chain to use in the update statement
* @return the generated update statement, or {@code null} if there is nothing to update
* @throws LiquibaseException if there is an error generating the update statement
*/
protected String getUpdateStatement(InsertOrUpdateStatement insertOrUpdateStatement, Database database, String whereClause, SqlGeneratorChain sqlGeneratorChain) throws LiquibaseException {
StringBuilder updateSqlString = new StringBuilder();
UpdateGenerator update = new UpdateGenerator();
UpdateStatement updateStatement = new UpdateStatement(
insertOrUpdateStatement.getCatalogName(),
insertOrUpdateStatement.getSchemaName(),
insertOrUpdateStatement.getTableName());
if (!((database instanceof OracleDatabase) && (insertOrUpdateStatement.getOnlyUpdate() != null) &&
insertOrUpdateStatement.getOnlyUpdate())) {
whereClause += ";\n";
}
updateStatement.setWhereClause(whereClause);
String[] pkFields = insertOrUpdateStatement.getPrimaryKey().split(",");
HashSet<String> hashPkFields = new HashSet<>(Arrays.asList(pkFields));
for (String columnKey : insertOrUpdateStatement.getColumnValues().keySet()) {
if (!hashPkFields.contains(columnKey)) {
if (insertOrUpdateStatement.getAllowColumnUpdate(columnKey)) {
updateStatement.addNewColumnValue(columnKey, insertOrUpdateStatement.getColumnValue(columnKey));
}
}
}
// this isn't very elegant but the code fails above without any columns to update
if (updateStatement.getNewColumnValues().isEmpty()) {
throw new LiquibaseException("No fields to update in set clause");
}
Sql[] updateSql = update.generateSql(updateStatement, database, sqlGeneratorChain);
for (Sql s : updateSql) {
updateSqlString.append(s.toSql());
updateSqlString.append(";");
}
updateSqlString.deleteCharAt(updateSqlString.lastIndexOf(";"));
updateSqlString.append("\n");
return updateSqlString.toString();
}
@Override
public Sql[] generateSql(InsertOrUpdateStatement insertOrUpdateStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
StringBuilder completeSql = new StringBuilder();
String whereClause = getWhereClause(insertOrUpdateStatement, database);
if (!insertOrUpdateStatement.getOnlyUpdate()) {
completeSql.append(getRecordCheck(insertOrUpdateStatement, database, whereClause));
completeSql.append(getInsertStatement(insertOrUpdateStatement, database, sqlGeneratorChain));
}
try {
String updateStatement = getUpdateStatement(insertOrUpdateStatement, database, whereClause, sqlGeneratorChain);
if (!insertOrUpdateStatement.getOnlyUpdate()) {
completeSql.append(getElse(database));
}
completeSql.append(updateStatement);
} catch (LiquibaseException e) {
}
if (!insertOrUpdateStatement.getOnlyUpdate()) {
completeSql.append(getPostUpdateStatements(database));
}
return new Sql[]{
new UnparsedSql(completeSql.toString(), "", getAffectedTable(insertOrUpdateStatement))
};
}
protected Table getAffectedTable(InsertOrUpdateStatement insertOrUpdateStatement) {
return (Table) new Table().setName(insertOrUpdateStatement.getTableName()).setSchema(insertOrUpdateStatement.getCatalogName(), insertOrUpdateStatement.getSchemaName());
}
}
|
StringBuilder where = new StringBuilder();
String[] pkColumns = insertOrUpdateStatement.getPrimaryKey().split(",");
for (String thisPkColumn : pkColumns) {
Object newValue = insertOrUpdateStatement.getColumnValues().get(thisPkColumn);
where.append(database.escapeColumnName(insertOrUpdateStatement.getCatalogName(),
insertOrUpdateStatement.getSchemaName(),
insertOrUpdateStatement.getTableName(),
thisPkColumn)).append(((newValue == null) || "NULL".equalsIgnoreCase(newValue.toString())) ?
" is " : " = ");
if ((newValue == null) || "NULL".equalsIgnoreCase(newValue.toString())) {
where.append("NULL");
} else {
where.append(DataTypeFactory.getInstance().fromObject(newValue, database).objectToSql(newValue, database));
}
where.append(" AND ");
}
where.delete(where.lastIndexOf(" AND "), where.lastIndexOf(" AND ") + " AND ".length());
return where.toString();
| 1,352
| 273
| 1,625
|
<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.InsertOrUpdateStatement, liquibase.database.Database) ,public liquibase.exception.Warnings warn(liquibase.statement.core.InsertOrUpdateStatement, liquibase.database.Database, SqlGeneratorChain<liquibase.statement.core.InsertOrUpdateStatement>) <variables>
|
liquibase_liquibase
|
liquibase/liquibase-standard/src/main/java/liquibase/sqlgenerator/core/InsertOrUpdateGeneratorDB2.java
|
InsertOrUpdateGeneratorDB2
|
getRecordCheck
|
class InsertOrUpdateGeneratorDB2 extends InsertOrUpdateGenerator {
private static final String DB2_Z_INSERT_OR_UPDATE_PROCEDURE = "insertOrUpdateDb2Z";
@Override
protected String getElse(Database database) {
return "\tELSEIF v_reccount = 1 THEN\n";
}
@Override
public Sql[] generateSql(InsertOrUpdateStatement insertOrUpdateStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
Sql[] sqls = super.generateSql(insertOrUpdateStatement, database, sqlGeneratorChain);
if (database instanceof Db2zDatabase) {
List<Sql> list = new ArrayList<>(Arrays.asList(sqls));
list.add(new UnparsedSql("CALL " + DB2_Z_INSERT_OR_UPDATE_PROCEDURE + "()"));
list.add(new UnparsedSql("DROP PROCEDURE " + DB2_Z_INSERT_OR_UPDATE_PROCEDURE));
sqls = list.toArray(EMPTY_SQL);
}
return sqls;
}
@Override
protected String getRecordCheck(InsertOrUpdateStatement insertOrUpdateStatement, Database database, String whereClause) {<FILL_FUNCTION_BODY>}
@Override
public boolean supports(InsertOrUpdateStatement statement, Database database) {
return database instanceof AbstractDb2Database;
}
@Override
protected String getPostUpdateStatements(Database database) {
return "END IF;\nEND\n";
}
}
|
StringBuilder recordCheckSql = new StringBuilder();
if (database instanceof Db2zDatabase) {
recordCheckSql.append("CREATE PROCEDURE ").append(DB2_Z_INSERT_OR_UPDATE_PROCEDURE).append("()\n");
recordCheckSql.append("BEGIN\n");
} else {
recordCheckSql.append("BEGIN ATOMIC\n");
}
recordCheckSql.append("\tDECLARE v_reccount INTEGER;\n");
recordCheckSql.append("\tSET v_reccount = (SELECT COUNT(*) FROM ");
recordCheckSql.append(database.escapeTableName(insertOrUpdateStatement.getCatalogName(), insertOrUpdateStatement.getSchemaName(), insertOrUpdateStatement.getTableName()));
recordCheckSql.append(" WHERE ");
recordCheckSql.append(whereClause);
recordCheckSql.append(");\n");
recordCheckSql.append("\tIF v_reccount = 0 THEN\n");
return recordCheckSql.toString();
| 383
| 259
| 642
|
<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/InsertOrUpdateGeneratorHsql.java
|
InsertOrUpdateGeneratorHsql
|
getRecordCheck
|
class InsertOrUpdateGeneratorHsql extends InsertOrUpdateGenerator {
@Override
public boolean supports(InsertOrUpdateStatement statement, Database database) {
return database instanceof HsqlDatabase;
}
@Override
protected String getRecordCheck(InsertOrUpdateStatement insertOrUpdateStatement, Database database,
String whereClause) {<FILL_FUNCTION_BODY>}
@Override
protected String getInsertStatement(InsertOrUpdateStatement insertOrUpdateStatement, Database database,
SqlGeneratorChain sqlGeneratorChain) {
StringBuilder columns = new StringBuilder();
StringBuilder values = new StringBuilder();
for (String columnKey : insertOrUpdateStatement.getColumnValues().keySet()) {
columns.append(",");
columns.append(columnKey);
values.append(",");
values.append(convertToString(insertOrUpdateStatement.getColumnValue(columnKey), database));
}
columns.deleteCharAt(0);
values.deleteCharAt(0);
return "INSERT (" + columns + ") VALUES (" + values + ")";
}
@Override
protected String getElse(Database database) {
return " WHEN MATCHED THEN ";
}
@Override
protected String getUpdateStatement(InsertOrUpdateStatement insertOrUpdateStatement, Database database,
String whereClause, SqlGeneratorChain sqlGeneratorChain) throws LiquibaseException {
if (insertOrUpdateStatement.getOnlyUpdate()) {
return super.getUpdateStatement(insertOrUpdateStatement, database, whereClause, sqlGeneratorChain);
}
StringBuilder sql = new StringBuilder("UPDATE SET ");
for (String columnKey : insertOrUpdateStatement.getColumnValues().keySet()) {
if (insertOrUpdateStatement.getAllowColumnUpdate(columnKey)) {
sql.append(columnKey).append(" = ");
sql.append(convertToString(insertOrUpdateStatement.getColumnValue(columnKey), database));
sql.append(",");
}
}
int lastComma = sql.lastIndexOf(",");
if (lastComma > -1) {
sql.deleteCharAt(lastComma);
}
return sql.toString();
}
// Copied from liquibase.sqlgenerator.core.InsertOrUpdateGeneratorMySQL
private String convertToString(Object newValue, Database database) {
String sqlString;
if ((newValue == null) || "".equals(newValue.toString()) || "NULL".equalsIgnoreCase(newValue.toString())) {
sqlString = "NULL";
} 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;
}
}
|
return "MERGE INTO " +
insertOrUpdateStatement.getTableName() +
" USING (VALUES (1)) ON " +
whereClause +
" WHEN NOT MATCHED THEN ";
| 801
| 57
| 858
|
<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/InsertOrUpdateGeneratorInformix.java
|
InsertOrUpdateGeneratorInformix
|
getUpdateStatement
|
class InsertOrUpdateGeneratorInformix extends InsertOrUpdateGenerator {
// Table Aliases for Merge references
private static final String SOURCE_ALIAS = "src";
private static final String DEST_ALIAS = "dst";
@Override
public boolean supports(InsertOrUpdateStatement statement, Database database) {
return database instanceof InformixDatabase;
}
@Override
protected String getRecordCheck(InsertOrUpdateStatement insertOrUpdateStatement, Database database, String whereClause) {
StringBuilder sql = new StringBuilder();
String[] pkFields = insertOrUpdateStatement.getPrimaryKey().split(",");
String tableReference = database.escapeTableName(insertOrUpdateStatement.getCatalogName(), insertOrUpdateStatement.getSchemaName(), insertOrUpdateStatement.getTableName());
sql.append("MERGE INTO ").append(tableReference).append(" AS ").append(DEST_ALIAS).append("\n");
sql.append("USING (\n");
sql.append(getSelect(insertOrUpdateStatement, database));
sql.append(") AS ").append(SOURCE_ALIAS).append("\n");
sql.append("ON ");
// Merge and match upon the Primary key fields
for (int i = 0; i < pkFields.length; i++) {
sql.append(DEST_ALIAS).append(".").append(pkFields[i]).append(" = ").append(SOURCE_ALIAS).append(".").append(pkFields[i]);
if (i < pkFields.length - 1) {
sql.append(" AND ");
}
}
sql.append("\nWHEN NOT MATCHED THEN\n");
return sql.toString();
}
@Override
protected String getInsertStatement(InsertOrUpdateStatement insertOrUpdateStatement, Database database,
SqlGeneratorChain sqlGeneratorChain) {
StringBuilder columns = new StringBuilder();
StringBuilder values = new StringBuilder();
for (String columnKey : insertOrUpdateStatement.getColumnValues().keySet()) {
columns.append(", ");
columns.append(DEST_ALIAS).append(".").append(columnKey);
values.append(SOURCE_ALIAS).append(".").append(columnKey).append(", ");
}
columns.delete(0, 2);
int lastComma = values.lastIndexOf(",");
if (lastComma > -1) {
values.delete(lastComma, lastComma + 2);
}
return "INSERT (" + columns.toString() + ") VALUES (" + values.toString() + ")\n";
}
@Override
protected String getElse(Database database) {
return "";
}
@Override
protected String getUpdateStatement(InsertOrUpdateStatement insertOrUpdateStatement, Database database,
String whereClause, SqlGeneratorChain sqlGeneratorChain) {<FILL_FUNCTION_BODY>}
// Copied and modified from liquibase.sqlgenerator.core.InsertOrUpdateGeneratorMySQL
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;
}
private String getSelect(InsertOrUpdateStatement insertOrUpdateStatement, Database database) {
StringBuilder select = new StringBuilder();
select.append("\tSELECT ");
for (String columnKey : insertOrUpdateStatement.getColumnValues().keySet()) {
select.append(convertToString(insertOrUpdateStatement.getColumnValue(columnKey), database));
select.append(" AS ");
select.append(columnKey);
select.append(", ");
}
int lastComma = select.lastIndexOf(", ");
if (lastComma > -1) {
select.delete(lastComma, lastComma + 2);
}
select.append("\n\tFROM sysmaster:informix.sysdual\n");
return select.toString();
}
}
|
Map<String, Object> columnValues = insertOrUpdateStatement.getColumnValues();
String[] pkFields = insertOrUpdateStatement.getPrimaryKey().split(",");
// Only generate the update statement if non key columns exist
if (pkFields.length != columnValues.size()) {
StringBuilder sql = new StringBuilder("WHEN MATCHED THEN\n");
sql.append("UPDATE SET ");
HashSet<String> hashPkFields = new HashSet<String>(Arrays.asList(pkFields));
for (String columnKey : columnValues.keySet()) {
// Do not include Primary Key fields within the update
if (!hashPkFields.contains(columnKey) && insertOrUpdateStatement.getAllowColumnUpdate(columnKey)) {
sql.append(DEST_ALIAS).append(".").append(columnKey).append(" = ");
sql.append(SOURCE_ALIAS).append(".").append(columnKey);
sql.append(", ");
}
}
int lastComma = sql.lastIndexOf(",");
if (lastComma > -1) {
sql.delete(lastComma, lastComma + 2);
}
return sql.toString();
}
else {
return "";
}
| 1,189
| 319
| 1,508
|
<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/InsertOrUpdateGeneratorMSSQL.java
|
InsertOrUpdateGeneratorMSSQL
|
getRecordCheck
|
class InsertOrUpdateGeneratorMSSQL extends InsertOrUpdateGenerator {
@Override
public boolean supports(InsertOrUpdateStatement statement, Database database) {
return database instanceof MSSQLDatabase;
}
@Override
protected String getRecordCheck(InsertOrUpdateStatement insertOrUpdateStatement, Database database, String whereClause) {<FILL_FUNCTION_BODY>}
@Override
protected String getInsertStatement(InsertOrUpdateStatement insertOrUpdateStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return "BEGIN\n" +
super.getInsertStatement(insertOrUpdateStatement, database, sqlGeneratorChain) +
"END\n";
}
@Override
protected String getElse(Database database) {
return "ELSE\n";
}
@Override
protected String getUpdateStatement(InsertOrUpdateStatement insertOrUpdateStatement, Database database, String whereClause, SqlGeneratorChain sqlGeneratorChain) throws LiquibaseException {
return "BEGIN\n" +
super.getUpdateStatement(insertOrUpdateStatement, database, whereClause, sqlGeneratorChain) +
"END\n";
}
@Override
public Sql[] generateSql(InsertOrUpdateStatement insertOrUpdateStatement, Database database, SqlGeneratorChain sqlGeneratorChain) {
return super.generateSql(insertOrUpdateStatement, database, sqlGeneratorChain); //To change body of overridden methods use File | Settings | File Templates.
}
}
|
return String.format("DECLARE @reccount integer\n" +
"SELECT @reccount = count(*) FROM %s" +
" WHERE %s\n" +
"IF @reccount = 0\n",
database.escapeTableName(insertOrUpdateStatement.getCatalogName(), insertOrUpdateStatement.getSchemaName(), insertOrUpdateStatement.getTableName()),
whereClause
);
| 357
| 105
| 462
|
<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>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.