public void upgradeBaseSchema(Connection conn, int currentVersion) {
if (!isLoaded()) {
throw new TajoInternalError("Database schema files are not loaded.");
}
final List<SchemaPatch> candidatePatches = new ArrayList<>();
Statement stmt;
for (SchemaPatch patch : this.catalogStore.getPatches()) {
if (currentVersion >= patch.getPriorVersion()) {
candidatePatches.add(patch);
}
}
Collections.sort(candidatePatches);
try {
stmt = conn.createStatement();
} catch (SQLException e) {
throw new TajoInternalError(e);
}
for (SchemaPatch patch : candidatePatches) {
for (DatabaseObject object : patch.getObjects()) {
try {
stmt.executeUpdate(object.getSql());
LOG.info(object.getName() + " " + object.getType() + " was created or altered.");
} catch (SQLException e) {
throw new TajoInternalError(e);
}
}
}
CatalogUtil.closeQuietly(stmt);
}
public static <C> List<C> fetch(Class<C> cls, DatabaseObject filteredBy) {
Database database = filteredBy.getDatabase();
@SuppressWarnings("unchecked")
AnnotatedRecordMapper<DatabaseObject> parentMapper =
(AnnotatedRecordMapper<DatabaseObject>) create(filteredBy.getClass());
AnnotatedRecordMapper<?> mapper = create(cls);
List<String> relationColumnNames = mapper.getRelationColumnNames(filteredBy.getClass());
List<String> idColumnNames = parentMapper.getIdColumnNames();
Map<String, Object> values = parentMapper.extractIds(filteredBy);
String relationExpression = "";
Object[] parameters = new Object[relationColumnNames.size()];
for (int i = 0; i < relationColumnNames.size(); i++) {
relationExpression += relationColumnNames.get(i) + "=?";
parameters[i] = values.get(idColumnNames.get(i));
if (parameters[i] == null) {
return new ArrayList<>();
}
}
try (Transaction transaction = database.beginReadOnlyTransaction()) {
transaction.associate(filteredBy);
return transaction.select(cls, relationExpression, parameters);
}
}
public Object toJavaType(Map<String, Object> map, Transaction transaction) {
try {
if (isEmbedded()) {
Class<?>[] types = new Class<?>[names.length];
Object[] idValues = new Object[names.length];
for (int i = 0; i < names.length; i++) {
Object value = map.get(names[i]);
if (value == null) {
return null;
}
types[i] = value.getClass();
idValues[i] = value;
}
Constructor<?> constructor = getType().getConstructor(types);
return constructor.newInstance(idValues);
} else if (isRelation(getType())) {
Object[] idValues = new Object[names.length];
for (int i = 0; i < names.length; i++) {
idValues[i] = map.get(names[i]);
}
DatabaseObject associatedObject = transaction.findAssociatedObject(getType(), idValues);
if (associatedObject == null) {
associatedObject = (DatabaseObject) getType().newInstance();
associatedObject.setDatabase(transaction.getDatabase());
associateStub(associatedObject, idValues);
}
return associatedObject;
}
return dataTypeConverter.toJavaType(map.get(names[0]), getType());
} catch (NoSuchMethodException
| SecurityException
| IllegalAccessException
| IllegalArgumentException
| InvocationTargetException
| InstantiationException e) {
throw new RuntimeException(e);
}
}
protected List<DatabaseObject> mergeDatabaseObjects(List<DatabaseObject> objects) {
int maxIdx = -1;
for (DatabaseObject object : objects) {
maxIdx = Math.max(maxIdx, object.getOrder());
}
final List<DatabaseObject> orderedObjects = createListAndFillNull(maxIdx);
final List<DatabaseObject> unorderedObjects = new ArrayList<>();
final List<DatabaseObject> mergedObjects = new ArrayList<>();
for (DatabaseObject object : objects) {
if (object.getOrder() > -1) {
int objIdx = object.getOrder();
if (objIdx < orderedObjects.size() && orderedObjects.get(objIdx) != null) {
throw new TajoInternalError(
"This catalog configuration contains duplicated order of DatabaseObject");
}
orderedObjects.add(objIdx, object);
} else {
unorderedObjects.add(object);
}
}
for (DatabaseObject object : orderedObjects) {
if (object != null) {
mergedObjects.add(object);
}
}
for (DatabaseObject object : unorderedObjects) {
if (object != null) {
mergedObjects.add(object);
}
}
return mergedObjects;
}
public void createBaseSchema(Connection conn) {
Statement stmt;
if (!isLoaded()) {
throw new TajoInternalError("Database schema files are not loaded.");
}
try {
stmt = conn.createStatement();
} catch (SQLException e) {
throw new TajoInternalError(e);
}
for (DatabaseObject object : catalogStore.getSchema().getObjects()) {
try {
String[] params;
if (DatabaseObjectType.INDEX == object.getType()) {
params = new String[2];
params[0] = object.getDependsOn();
params[1] = object.getName();
} else {
params = new String[1];
params[0] = object.getName();
}
if (checkExistence(conn, object.getType(), params)) {
LOG.info("Skip to create " + object.getName() + " databse object. Already exists.");
} else {
stmt.executeUpdate(object.getSql());
LOG.info(object.getName() + " " + object.getType() + " is created.");
}
} catch (SQLException e) {
throw new TajoInternalError(e);
}
}
CatalogUtil.closeQuietly(stmt);
}
public void dropBaseSchema(Connection conn) {
if (!isLoaded()) {
throw new TajoInternalError("Schema files are not loaded yet.");
}
List<DatabaseObject> failedObjects = new ArrayList<>();
Statement stmt = null;
try {
stmt = conn.createStatement();
} catch (SQLException e) {
throw new TajoInternalError(e);
}
for (DatabaseObject object : catalogStore.getSchema().getObjects()) {
try {
if (DatabaseObjectType.TABLE == object.getType()
|| DatabaseObjectType.SEQUENCE == object.getType()
|| DatabaseObjectType.VIEW == object.getType()) {
stmt.executeUpdate(getDropSQL(object.getType(), object.getName()));
}
} catch (SQLException e) {
failedObjects.add(object);
}
}
CatalogUtil.closeQuietly(stmt);
if (failedObjects.size() > 0) {
StringBuffer errorMessage = new StringBuffer(64);
errorMessage.append("Failed to drop database objects ");
for (int idx = 0; idx < failedObjects.size(); idx++) {
DatabaseObject object = failedObjects.get(idx);
errorMessage.append(object.getType().toString()).append(" ").append(object.getName());
if ((idx + 1) < failedObjects.size()) {
errorMessage.append(',');
}
}
LOG.warn(errorMessage.toString());
}
}
@Override
public void invokeAfterLoadStore(T object, Database database) throws DatabaseException {
if (object instanceof DatabaseObject) {
((DatabaseObject) object).setDatabase(database);
}
if (afterLoadStore != null) {
try {
afterLoadStore.invoke(object, database);
} catch (DatabaseException e) {
throw e;
} catch (Throwable e) {
throw new RuntimeException(e);
}
}
}
public boolean isInitialized(Connection conn) {
if (!isLoaded()) {
throw new TajoInternalError("Database schema files are not loaded.");
}
boolean result = true;
for (DatabaseObject object : catalogStore.getSchema().getObjects()) {
try {
if (DatabaseObjectType.INDEX == object.getType()) {
result &= checkExistence(conn, object.getType(), object.getDependsOn(), object.getName());
} else {
result &= checkExistence(conn, object.getType(), object.getName());
}
} catch (SQLException e) {
throw new TajoInternalError(e);
}
if (!result) {
break;
}
}
return result;
}
public boolean equals(DatabaseObject otherObject, Database accordingTo) {
return equals(otherObject.getName(), accordingTo);
}
