use of io.crate.metadata.table.SchemaInfo in project crate by crate.
the class CreateSnapshotAnalyzer method analyze.
public CreateSnapshotAnalyzedStatement analyze(CreateSnapshot node, Analysis analysis) {
Optional<QualifiedName> repositoryName = node.name().getPrefix();
// validate repository
Preconditions.checkArgument(repositoryName.isPresent(), "Snapshot must be specified by \"<repository_name>\".\"<snapshot_name>\"");
Preconditions.checkArgument(repositoryName.get().getParts().size() == 1, String.format(Locale.ENGLISH, "Invalid repository name '%s'", repositoryName.get()));
repositoryService.failIfRepositoryDoesNotExist(repositoryName.get().toString());
// snapshot existence in repo is validated upon execution
String snapshotName = node.name().getSuffix();
SnapshotId snapshotId = new SnapshotId(repositoryName.get().toString(), snapshotName);
// validate and extract settings
Settings settings = GenericPropertiesConverter.settingsFromProperties(node.properties(), analysis.parameterContext(), SETTINGS).build();
boolean ignoreUnavailable = settings.getAsBoolean(IGNORE_UNAVAILABLE.name(), IGNORE_UNAVAILABLE.defaultValue());
// iterate tables
if (node.tableList().isPresent()) {
List<Table> tableList = node.tableList().get();
Set<String> snapshotIndices = new HashSet<>(tableList.size());
for (Table table : tableList) {
TableInfo tableInfo;
try {
tableInfo = schemas.getTableInfo(TableIdent.of(table, analysis.sessionContext().defaultSchema()));
} catch (ResourceUnknownException e) {
if (ignoreUnavailable) {
LOGGER.info("ignoring: {}", e.getMessage());
continue;
} else {
throw e;
}
}
if (!(tableInfo instanceof DocTableInfo)) {
throw new IllegalArgumentException(String.format(Locale.ENGLISH, "Cannot create snapshot of tables in schema '%s'", tableInfo.ident().schema()));
}
Operation.blockedRaiseException(tableInfo, Operation.READ);
DocTableInfo docTableInfo = (DocTableInfo) tableInfo;
if (table.partitionProperties().isEmpty()) {
snapshotIndices.addAll(Arrays.asList(docTableInfo.concreteIndices()));
} else {
PartitionName partitionName = PartitionPropertiesAnalyzer.toPartitionName(docTableInfo, table.partitionProperties(), analysis.parameterContext().parameters());
if (!docTableInfo.partitions().contains(partitionName)) {
if (!ignoreUnavailable) {
throw new PartitionUnknownException(tableInfo.ident().fqn(), partitionName.ident());
} else {
LOGGER.info("ignoring unknown partition of table '{}' with ident '{}'", partitionName.tableIdent(), partitionName.ident());
}
} else {
snapshotIndices.add(partitionName.asIndexName());
}
}
}
/**
* For now, we always (in case there are indices to restore) include the globalMetaData,
* not only if one of the tables in the table list is partitioned.
* Previously we only included it in snapshots of full partitioned tables.
* However, to make restoring of shapshots of single partitions work
* we also need to include the global metadata (index templates).
*/
return CreateSnapshotAnalyzedStatement.forTables(snapshotId, settings, ImmutableList.copyOf(snapshotIndices), !snapshotIndices.isEmpty());
} else {
for (SchemaInfo schemaInfo : schemas) {
for (TableInfo tableInfo : schemaInfo) {
// only check for user generated tables
if (tableInfo instanceof DocTableInfo) {
Operation.blockedRaiseException(tableInfo, Operation.READ);
}
}
}
return CreateSnapshotAnalyzedStatement.all(snapshotId, settings);
}
}
use of io.crate.metadata.table.SchemaInfo in project crate by crate.
the class DocIndexMetaDataTest method getDocIndexMetaDataFromStatement.
private DocIndexMetaData getDocIndexMetaDataFromStatement(String stmt) throws IOException {
Statement statement = SqlParser.createStatement(stmt);
ClusterService clusterService = new NoopClusterService();
final TransportPutIndexTemplateAction transportPutIndexTemplateAction = mock(TransportPutIndexTemplateAction.class);
Provider<TransportPutIndexTemplateAction> indexTemplateActionProvider = new Provider<TransportPutIndexTemplateAction>() {
@Override
public TransportPutIndexTemplateAction get() {
return transportPutIndexTemplateAction;
}
};
DocTableInfoFactory docTableInfoFactory = new InternalDocTableInfoFactory(functions, new IndexNameExpressionResolver(Settings.EMPTY), indexTemplateActionProvider, executorService);
DocSchemaInfo docSchemaInfo = new DocSchemaInfo(Schemas.DEFAULT_SCHEMA_NAME, clusterService, docTableInfoFactory);
CreateTableStatementAnalyzer analyzer = new CreateTableStatementAnalyzer(new Schemas(Settings.EMPTY, ImmutableMap.<String, SchemaInfo>of("doc", docSchemaInfo), clusterService, new DocSchemaInfoFactory(docTableInfoFactory)), new FulltextAnalyzerResolver(clusterService, new IndicesAnalysisService(Settings.EMPTY)), functions, new NumberOfShards(clusterService));
Analysis analysis = new Analysis(SessionContext.SYSTEM_SESSION, ParameterContext.EMPTY, ParamTypeHints.EMPTY);
CreateTableAnalyzedStatement analyzedStatement = analyzer.analyze((CreateTable) statement, analysis.parameterContext(), analysis.sessionContext());
Settings.Builder settingsBuilder = Settings.builder().put("index.number_of_shards", 1).put("index.number_of_replicas", 0).put("index.version.created", org.elasticsearch.Version.CURRENT).put(analyzedStatement.tableParameter().settings());
IndexMetaData indexMetaData = IndexMetaData.builder(analyzedStatement.tableIdent().name()).settings(settingsBuilder).putMapping(new MappingMetaData(Constants.DEFAULT_MAPPING_TYPE, analyzedStatement.mapping())).build();
return newMeta(indexMetaData, analyzedStatement.tableIdent().name());
}
use of io.crate.metadata.table.SchemaInfo in project crate by crate.
the class Schemas method getTableInfo.
/**
* @param ident the table ident to get a TableInfo for
* @return an instance of TableInfo for the given ident, guaranteed to be not null
* @throws io.crate.exceptions.SchemaUnknownException if schema given in <code>ident</code>
* does not exist
* @throws RelationUnknown if table given in <code>ident</code> does
* not exist in the given schema
*/
public <T extends TableInfo> T getTableInfo(RelationName ident) {
SchemaInfo schemaInfo = getSchemaInfo(ident);
TableInfo info = schemaInfo.getTableInfo(ident.name());
if (info == null) {
throw new RelationUnknown(ident);
}
return (T) info;
}
use of io.crate.metadata.table.SchemaInfo in project crate by crate.
the class Schemas method resolveView.
/**
* @throws RelationUnknown if the view cannot be resolved against the search path.
*/
public Tuple<ViewMetadata, RelationName> resolveView(QualifiedName ident, SearchPath searchPath) {
ViewsMetadata views = clusterService.state().metadata().custom(ViewsMetadata.TYPE);
ViewMetadata view = null;
RelationName viewRelationName = null;
String identSchema = schemaName(ident);
String viewName = relationName(ident);
if (views != null) {
if (identSchema == null) {
for (String pathSchema : searchPath) {
SchemaInfo schemaInfo = schemas.get(pathSchema);
if (schemaInfo != null) {
viewRelationName = new RelationName(pathSchema, viewName);
view = views.getView(viewRelationName);
if (view != null) {
break;
}
}
}
} else {
viewRelationName = new RelationName(identSchema, viewName);
view = views.getView(viewRelationName);
}
}
if (view == null) {
throw new RelationUnknown(viewName);
}
return Tuple.tuple(view, viewRelationName);
}
use of io.crate.metadata.table.SchemaInfo in project crate by crate.
the class Schemas method clusterChanged.
@Override
public void clusterChanged(ClusterChangedEvent event) {
if (!event.metadataChanged()) {
return;
}
Set<String> newCurrentSchemas = getNewCurrentSchemas(event.state().metadata());
synchronized (schemas) {
Set<String> nonBuiltInSchemas = Sets.difference(schemas.keySet(), builtInSchemas.keySet());
Set<String> deleted = Sets.difference(nonBuiltInSchemas, newCurrentSchemas);
Set<String> added = Sets.difference(newCurrentSchemas, schemas.keySet());
for (String deletedSchema : deleted) {
try {
schemas.remove(deletedSchema).close();
} catch (Exception e) {
LOGGER.error(e.getMessage(), e);
}
}
for (String addedSchema : added) {
schemas.put(addedSchema, getCustomSchemaInfo(addedSchema));
}
// update all existing schemas
for (SchemaInfo schemaInfo : this) {
schemaInfo.update(event);
}
}
}
Aggregations