All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.torodb.backend.BackendServiceImpl Maven / Gradle / Ivy
/*
* ToroDB
* Copyright © 2014 8Kdata Technology (www.8kdata.com)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see enableDataImportMode(MetaDatabase db)
throws RollbackException {
if (!sqlInterface.getDbBackend().isOnDataInsertMode(db)) {
sqlInterface.getDbBackend().enableDataInsertMode(db);
}
return CompletableFuture.completedFuture(Empty.getInstance());
}
@Override
public CompletableFuture disableDataImportMode(MetaDatabase db)
throws RollbackException {
if (!sqlInterface.getDbBackend().isOnDataInsertMode(db)) {
LOGGER.debug("Ignoring attempt to disable import mode on {} as it is not on that mode",
db.getIdentifier());
return CompletableFuture.completedFuture(Empty.getInstance());
}
sqlInterface.getDbBackend().disableDataInsertMode(db);
//create internal indexes
Stream> createInternalIndexesJobs = db.streamMetaCollections().flatMap(
col -> col.streamContainedMetaDocParts().flatMap(
docPart -> enableInternalIndexJobs(db, col, docPart)
)
);
//create indexes
Stream> createIndexesJobs = db.streamMetaCollections().flatMap(
col -> enableIndexJobs(db, col)
);
//backend specific jobs
Stream> backendSpecificJobs = sqlInterface.getStructureInterface()
.streamDataInsertFinishTasks(db).map(job -> {
return (Consumer) dsl -> {
String index = job.apply(dsl);
LOGGER.info("Task {} completed", index);
};
});
Stream> jobs = Stream
.concat(createInternalIndexesJobs, createIndexesJobs);
jobs = Stream.concat(jobs, backendSpecificJobs);
Stream runnables = jobs.map(this::dslConsumerToRunnable);
return streamExecutor.executeRunnables(runnables);
}
private Stream> enableInternalIndexJobs(MetaDatabase db, MetaCollection col,
MetaDocPart docPart) {
StructureInterface structureInterface = sqlInterface.getStructureInterface();
Stream> consumerStream;
if (docPart.getTableRef().isRoot()) {
consumerStream = structureInterface.streamRootDocPartTableIndexesCreation(
db.getIdentifier(),
docPart.getIdentifier(),
docPart.getTableRef()
);
} else {
MetaDocPart parentDocPart = col.getMetaDocPartByTableRef(
docPart.getTableRef().getParent().get()
);
assert parentDocPart != null;
consumerStream = structureInterface.streamDocPartTableIndexesCreation(
db.getIdentifier(),
docPart.getIdentifier(),
docPart.getTableRef(),
parentDocPart.getIdentifier()
);
}
return consumerStream.map(job -> {
return (Consumer) dsl -> {
String index = job.apply(dsl);
LOGGER.info("Created internal index {} for table {}", index, docPart.getIdentifier());
};
});
}
private Stream> enableIndexJobs(MetaDatabase db, MetaCollection col) {
List> consumerList = new ArrayList<>();
Iterator docPartIterator = col.streamContainedMetaDocParts().iterator();
while (docPartIterator.hasNext()) {
MetaDocPart docPart = docPartIterator.next();
Iterator docPartIndexIterator = docPart.streamIndexes()
.iterator();
while (docPartIndexIterator.hasNext()) {
MetaIdentifiedDocPartIndex docPartIndex = docPartIndexIterator.next();
consumerList.add(createIndexJob(db, docPart, docPartIndex));
}
}
return consumerList.stream();
}
private Consumer createIndexJob(MetaDatabase db, MetaDocPart docPart,
MetaIdentifiedDocPartIndex docPartIndex) {
return dsl -> {
List> columnList = new ArrayList<>(docPartIndex.size());
for (Iterator indexColumnIterator = docPartIndex
.iteratorColumns(); indexColumnIterator.hasNext();) {
MetaDocPartIndexColumn indexColumn = indexColumnIterator.next();
columnList.add(new Tuple2<>(indexColumn.getIdentifier(), indexColumn.getOrdering()
.isAscending()));
}
try {
sqlInterface.getStructureInterface().createIndex(
dsl, docPartIndex.getIdentifier(), db.getIdentifier(), docPart.getIdentifier(),
columnList,
docPartIndex.isUnique());
} catch (UserException userException) {
throw new SystemException(userException);
}
LOGGER.info("Created index {} for table {}", docPartIndex.getIdentifier(), docPart
.getIdentifier());
};
}
private Runnable dslConsumerToRunnable(Consumer consumer) {
return () -> {
try {
retrier.retry(() -> {
try (Connection connection = sqlInterface.getDbBackend().createWriteConnection()) {
DSLContext dsl = sqlInterface.getDslContextFactory()
.createDslContext(connection);
consumer.accept(dsl);
connection.commit();
return null;
} catch (SQLException ex) {
throw sqlInterface.getErrorHandler().handleException(Context.CREATE_INDEX, ex);
}
}, Hint.CRITICAL);
} catch (RetrierGiveUpException ex) {
throw new ToroRuntimeException(ex);
}
};
}
@Override
protected void startUp() throws Exception {
LOGGER.debug("Starting backend...");
streamExecutor.startAsync();
streamExecutor.awaitRunning();
LOGGER.trace("Waiting for {} to be running...", dbBackendService);
dbBackendService.awaitRunning();
LOGGER.debug("Backend started");
}
@Override
protected void shutDown() throws Exception {
streamExecutor.stopAsync();
streamExecutor.awaitTerminated();
}
void onConnectionClosed(BackendConnectionImpl connection) {
}
KvMetainfoHandler getMetaInfoHandler() {
return metainfoHandler;
}
SchemaUpdater getSchemaUpdater() {
return schemaUpdater;
}
}
