Java DataStore.getSchema方法代碼示例

import org.geotools.data.DataStore; //導入方法依賴的package包/類
private static SimpleFeatureType getStatementFeatureType(final DataStore dataStore) throws IOException, SchemaException {
    SimpleFeatureType featureType;

    final String[] datastoreFeatures = dataStore.getTypeNames();
    if (Arrays.asList(datastoreFeatures).contains(FEATURE_NAME)) {
        featureType = dataStore.getSchema(FEATURE_NAME);
    } else {
        featureType = DataUtilities.createType(FEATURE_NAME,
            SUBJECT_ATTRIBUTE + ":String," +
            PREDICATE_ATTRIBUTE + ":String," +
            OBJECT_ATTRIBUTE + ":String," +
            CONTEXT_ATTRIBUTE + ":String," +
            GEOMETRY_ATTRIBUTE + ":Geometry:srid=4326," +
            GEO_ID_ATTRIBUTE + ":String");

        dataStore.createSchema(featureType);
    }
    return featureType;
}
 

import org.geotools.data.DataStore; //導入方法依賴的package包/類
private static SimpleFeatureType getStatementFeatureType(final DataStore dataStore) throws IOException, SchemaException {
    SimpleFeatureType featureType;

    final String[] datastoreFeatures = dataStore.getTypeNames();
    if (Arrays.asList(datastoreFeatures).contains(FEATURE_NAME)) {
        featureType = dataStore.getSchema(FEATURE_NAME);
    } else {
        final String featureSchema = SUBJECT_ATTRIBUTE + ":String," //
                + PREDICATE_ATTRIBUTE + ":String," //
                + OBJECT_ATTRIBUTE + ":String," //
                + CONTEXT_ATTRIBUTE + ":String," //
                + GEOMETRY_ATTRIBUTE + ":Geometry:srid=4326;geomesa.mixed.geometries='true'";
        featureType = SimpleFeatureTypes.createType(FEATURE_NAME, featureSchema);
        dataStore.createSchema(featureType);
    }
    return featureType;
}
 

import org.geotools.data.DataStore; //導入方法依賴的package包/類
private static void example2() throws IOException {
    System.out.println("example2 start\n");
    // example2 start
    Map<String, Serializable> params = new HashMap<String, Serializable>();
    params.put("directory", directory);
    DataStore store = DataStoreFinder.getDataStore(params);

    SimpleFeatureType type = store.getSchema("example");

    System.out.println("       typeName: " + type.getTypeName());
    System.out.println("           name: " + type.getName());
    System.out.println("attribute count: " + type.getAttributeCount());

    AttributeDescriptor id = type.getDescriptor(0);
    System.out.println("attribute 'id'    name:" + id.getName());
    System.out.println("attribute 'id'    type:" + id.getType().toString());
    System.out.println("attribute 'id' binding:"
            + id.getType().getDescription());

    AttributeDescriptor name = type.getDescriptor("name");
    System.out.println("attribute 'name'    name:" + name.getName());
    System.out.println("attribute 'name' binding:"
            + name.getType().getBinding());
    // example2 end
    System.out.println("\nexample2 end\n");
}
 

import org.geotools.data.DataStore; //導入方法依賴的package包/類
public void prepare(Map map, TopologyContext topologyContext, OutputCollector outputCollector) {
    final DataStore ds;
    try {
        ds = DataStoreFinder.getDataStore(connectionParams);
        SimpleFeatureType featureType = ds.getSchema(featureName);
        featureBuilder = new SimpleFeatureBuilder(featureType);
        featureWriter = ds.getFeatureWriterAppend(featureName, Transaction.AUTO_COMMIT);
    } catch (IOException e) {
        throw new RuntimeException("Unable to initialize feature writer", e);
    }
}
 

import org.geotools.data.DataStore; //導入方法依賴的package包/類
/**
 * Clones the given SimpleFeature using a DataStore fetch schema.
 * 
 * @param store
 * @param typeName
 * @param feature
 * @return
 * @throws IOException
 */
public static SimpleFeature cloneFeature(DataStore store, String typeName,
		SimpleFeature feature, Map<String, String> attributeMappings) throws IOException {
	SimpleFeatureType schema = store.getSchema(typeName);
	SimpleFeatureBuilder builder = new SimpleFeatureBuilder(schema);
	for(AttributeDescriptor attribute : schema.getAttributeDescriptors()) {			
		String sourceAttributeName = mapAttributeName(attributeMappings,
				attribute.getLocalName());
		builder.add(feature.getAttribute(sourceAttributeName));
	}
	return builder.buildFeature(null);
}
 

import org.geotools.data.DataStore; //導入方法依賴的package包/類
@Override
public List<String> getShapefileFieldnames(File shapefileOrODLRG) {
	// turn an .odlrg file reference into a shapefile reference 
	if(Strings.equalsStd(FilenameUtils.getExtension(shapefileOrODLRG.getName()), RogReaderUtils.RENDER_GEOMETRY_FILE_EXT)){
		String s = FilenameUtils.removeExtension(shapefileOrODLRG.getAbsolutePath());
		s += ".shp";
		shapefileOrODLRG = new File(s);
	}

	DataStore shapefile = null;
	try {
		Map<String, URL> map = new HashMap<String, URL>();
		map.put("url", shapefileOrODLRG.toURI().toURL());
		shapefile = DataStoreFinder.getDataStore(map);

		// check not corrupt
		if (shapefile.getTypeNames().length != 1) {
			throw new RuntimeException("Shapefile should only contain one type");
		}

		String typename = shapefile.getTypeNames()[0];
		SimpleFeatureType schema = shapefile.getSchema(typename);
		int nAttrib = schema.getAttributeCount();
		ArrayList<String> ret = new ArrayList<>();
		for (int i = 0; i < nAttrib; i++) {
			ret.add(schema.getDescriptor(i).getLocalName());
		}
		return ret;

	} catch (Throwable e) {
		throw Exceptions.asUnchecked(e);
	} finally {

		if (shapefile != null) {
			shapefile.dispose();
		}
	}
}
 

import org.geotools.data.DataStore; //導入方法依賴的package包/類
/**
 * 
 * @param features
 * @param name
 * @param storeInfo
 * @return
 * @throws IOException
 * @throws ProcessException
 */
private SimpleFeatureType importDataIntoStore(SimpleFeatureCollection features, String name,
        DataStoreInfo storeInfo) throws IOException, ProcessException {
    SimpleFeatureType targetType;
    // grab the data store
    DataStore ds = (DataStore) storeInfo.getDataStore(null);

    // decide on the target ft name
    SimpleFeatureType sourceType = features.getSchema();
    if (name != null) {
        SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder();
        tb.init(sourceType);
        tb.setName(name);
        sourceType = tb.buildFeatureType();
    }

    // create the schema
    ds.createSchema(sourceType);

    // try to get the target feature type (might have slightly different
    // name and structure)
    targetType = ds.getSchema(sourceType.getTypeName());
    if (targetType == null) {
        // ouch, the name was changed... we can only guess now...
        // try with the typical Oracle mangling
        targetType = ds.getSchema(sourceType.getTypeName().toUpperCase());
    }

    if (targetType == null) {
        throw new WPSException(
                "The target schema was created, but with a name "
                        + "that we cannot relate to the one we provided the data store. Cannot proceeed further");
    } else {
        // check the layer is not already there
        String newLayerName = storeInfo.getWorkspace().getName() + ":"
                + targetType.getTypeName();
        LayerInfo layer = this.catalog.getLayerByName(newLayerName);
        // todo: we should not really reach here and know beforehand what the targetType
        // name is, but if we do we should at least get a way to drop it
        if (layer != null) {
            throw new ProcessException("Target layer " + newLayerName
                    + " already exists in the catalog");
        }
    }

    // try to establish a mapping with old and new attributes. This is again
    // just guesswork until we have a geotools api that will give us the
    // exact mapping to be performed
    Map<String, String> mapping = buildAttributeMapping(sourceType, targetType);

    // start a transaction and fill the target with the input features
    Transaction t = new DefaultTransaction();
    SimpleFeatureStore fstore = (SimpleFeatureStore) ds.getFeatureSource(targetType.getTypeName());
    fstore.setTransaction(t);
    SimpleFeatureIterator fi = features.features();
    SimpleFeatureBuilder fb = new SimpleFeatureBuilder(targetType);
    while (fi.hasNext()) {
        SimpleFeature source = fi.next();
        fb.reset();
        for (String sname : mapping.keySet()) {
            fb.set(mapping.get(sname), source.getAttribute(sname));
        }
        SimpleFeature target = fb.buildFeature(null);
        fstore.addFeatures(DataUtilities.collection(target));
    }
    t.commit();
    t.close();

    return targetType;
}
 

import org.geotools.data.DataStore; //導入方法依賴的package包/類
/**
 * getAttributesForDatasource
 * Returns a list of attribute types for a datasource. If your DataStore was
 * a database, this would return the columns in the table to be imported.
 * You will probably use this when setting up the attributes on the Datasource.
 * Note that these are Geotools AttributeTypes and have nothing to do with
 * Tombolo's Attribute objects.
 * @param datasource The datasource being imported
 * @return A list of attributes for the datasource
 * @throws IOException
 */
protected List<AttributeType> getAttributesForDatasource(Datasource datasource) throws IOException {
    DataStore dataStore = null;
    try {
        dataStore = getDataStoreForDatasource(datasource);
        SimpleFeatureType schema = dataStore.getSchema(getTypeNameForDatasource(datasource));
        return schema.getTypes();
    } finally {
        if (null != dataStore) dataStore.dispose();
    }
}