Java HDT类代码示例

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
@Override
protected Model createModel(String dbId) {
    Model model = null;
    try {
        File hdtFile = getHDTPath(dbId).toFile();
        if (hdtFile.exists()) {
            boolean useIdx = useIndex(dbId);
            String hdtFilePathStr = hdtFile.getAbsolutePath();
            logger.info(marker, "Loading '{}', useIndex={}", hdtFilePathStr, useIdx);
            HDT hdt = useIdx ? HDTManager.mapIndexedHDT(hdtFilePathStr, null) : HDTManager.loadHDT(hdtFilePathStr, null);
            HDTGraph graph = new HDTGraph(hdt);
            model = ModelFactory.createModelForGraph(graph);
            return model;
        }

       throw new FileNotFoundException("HDT file not found: '" + hdtFile + "'");

    } catch (Exception e) {
        throw new StarGraphException(e);
    }
    finally {
        if (model == null) {
            logger.error(marker, "No Graph Model instantiated for {}", dbId);
        }
    }
}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
static void label(WikidataQ wikidataQ) throws NotFoundException {

        Map<String, HDT> l = getMap();

        for (String lang : l.keySet()) {
            if(lang.equalsIgnoreCase("wikidata")){
                continue;
            }
            HDT hdt = l.get(lang);

            // Search pattern: Empty string means "any"
            try {
                IteratorTripleString it = hdt.search(wikidataQ.URI, "http://www.w3.org/2000/01/rdf-schema#label", "");
                while (it.hasNext()) {
                    TripleString ts = it.next();
                    wikidataQ.labels.add(ts.getObject().toString());
                }
            } catch (NotFoundException nfe) {
                //intentionally left blank.
                //hdt.search should return null, not an NF exception
            }
        }

    }
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
public static void main(String[] args) throws Throwable {

		// Download Semantic Web Dog Food dataset about papers and create HDT
		String url = "http://gaia.infor.uva.es/hdt/swdf-2012-11-28.hdt.gz";
		InputStream in = new BufferedInputStream(new GZIPInputStream(new URL(url).openStream()));
		try(HDT hdt = HDTManager.loadIndexedHDT(in)){
			in.close();

			// Create a Gremlin Graph
			try(HDTGraph hdtgraph = new HDTGraph(hdt)){

				// Find Mario's coauthors in SWDF dataset
				hdtgraph.traversal().V("http://data.semanticweb.org/person/mario-arias-gallego")
				.out("http://xmlns.com/foaf/0.1/made")
				.in("http://xmlns.com/foaf/0.1/made")
				.sideEffect( e-> System.out.println(e) )
				.iterate();
			}
		}
		
		System.exit(0);
	}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
public static void main(String[] args) throws Exception {		
		if(args.length!=2) {
			System.out.println("Usage: hdt2gremlin <file.hdt> <Gremlin Graph Config File>");
			System.out.println(" The config follows the syntax of gremlins factory Graph.open().");
			System.exit(-1);
		}
		
		// Create Graph
		Configuration p = new PropertiesConfiguration(args[1]);
		try(Graph gremlinGraph = GraphFactory.open(p)){
			
			// Open HDT
			try(HDT hdt = HDTManager.mapHDT("args[0]")){

				// Import HDT into Graph
				StopWatch st = new StopWatch();
				importGraph(hdt, gremlinGraph);
				System.out.println("Took "+st.stopAndShow());
			}
				
//			smallTest(gremlinGraph);
		}
		
		System.exit(0);
	}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
public LimayeGroundtruthAnnotationParser(Table table) {
		this.table = table;
		this.cellAnnotation = false;
		this.columnAnnotation = false;
		this.columnNr = 0;
		this.column = -1;
		this.row = -1;
		this.currentValue = new StringBuilder();
		HDT hdt = null;
		HDT hdt_l = null;
//		HDT hdt_d = null;
		try {
			hdt = HDTManager.mapIndexedHDT(REDIRECTS, null);
			hdt_l = HDTManager.mapIndexedHDT(LABELS, null);
//			hdt_d = HDTManager.mapIndexedHDT(TYPES, null);
		} catch (IOException e) {
			e.printStackTrace();
		}
		HDTGraph graph = new HDTGraph(hdt);
		m = ModelFactory.createModelForGraph(graph);
//		graph = new HDTGraph(hdt_d);
//		m_d = ModelFactory.createModelForGraph(graph);
		graph = new HDTGraph(hdt_l);
		m_l = ModelFactory.createModelForGraph(graph);

	}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
public static void main(String[] args) {
	HDT hdt = null;
	try {
		hdt = HDTManager.mapIndexedHDT(TYPES, null);
	} catch (IOException e) {
		e.printStackTrace();
	}
	
	HDTGraph graph = new HDTGraph(hdt);
	Model m = ModelFactory.createModelForGraph(graph);
	StmtIterator iter = m.listStatements();
	HashMap<String, Integer> hash = new HashMap<String, Integer>();
	int number = 0;
	while (iter.hasNext()) {
		if (number % 50000 == 0) {
			System.out.println("Processed Entries: " + number);
		}
		Statement stmt = iter.next();
		RDFNode object = stmt.getObject();
		String s = null;
		s = object.asResource().getURI();
		hash.put(s, 0);
		number++;
	}
	System.out.println("Anzahl an Typen: " +hash.size());
}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
@Test
// Load an HDT and perform a search. (examples/ExampleSearch.java)
public void main(String[] args) throws Exception
{
	// Load HDT file.
	// NOTE: Use loadIndexedHDT() for ?P?, ?PO or ??O queries
	HDT hdt = HDTManager.loadHDT("/media/sf_projects/experiments/hdt/raw_infobox_properties_en.hdt", null);

	// Search pattern: Empty string means "any"
	IteratorTripleString it = hdt.search("", "http://dbpedia.org/property/date", "");
	TripleString ts;
	while (it.hasNext())
	{
		ts = it.next();
		System.out.println(ts);
	}
}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
private static void importGraph(HDT hdt, Graph graph) {
		
		Dictionary d = hdt.getDictionary();
		
		long [] sharedMap = new long[(int)d.getNshared()];
		long [] subjectMap = new long[(int)(d.getNsubjects()-d.getNshared())];
//		long [] predicateMap = new long[(int)d.getNpredicates()];
		long [] objectMap = new long[(int)(d.getNobjects()-d.getNshared())];
		
//		load(predicateMap, d.getPredicates().getSortedEntries(), to);
		loadSection(sharedMap, d.getShared().getSortedEntries(), graph, DictionarySectionRole.SHARED);
		loadSection(subjectMap, d.getSubjects().getSortedEntries(), graph, DictionarySectionRole.SUBJECT);
		loadSection(objectMap, d.getObjects().getSortedEntries(), graph, DictionarySectionRole.OBJECT);
		
		IteratorTripleID it = hdt.getTriples().searchAll();
		
		int count=0;
		while(it.hasNext()) {
			TripleID triple = it.next();
			long s = getIDShared(sharedMap, subjectMap, triple.getSubject());
//			long p = predicateMap[triple.getPredicate()-1];
			long o = getIDShared(sharedMap, objectMap, triple.getObject());
			
			Vertex subj = graph.vertices(s).next();
			Vertex obj = graph.vertices(o).next();
			
			subj.addEdge(d.idToString(triple.getPredicate(), TripleComponentRole.PREDICATE).toString(), obj);
			
			if((count%10000)==0) {
				System.out.println("Edges: "+(count/1000)+"K");
			}
			count++;
		}
	}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
public MainEvaluation(String maindir) {
	File maind = new File(maindir);
	HDT redirectsHDT;
	try {
		redirectsHDT = HDTManager.mapIndexedHDT("/home/quh/dbpedia_redirects.hdt", null);
		final HDTGraph redirectsHDTgraph = new HDTGraph(redirectsHDT);
		this.redirects = ModelFactory.createModelForGraph(redirectsHDTgraph);
	} catch (IOException e) {
		e.printStackTrace();
	}
	evaluate(maind);
}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
CreateDBPediaIndex() {
	super();
	this.LABELS = new HashMap<String, HashSet<String>>();
	this.UNIQUELABELSTRINGS = new HashMap<String, HashSet<String>>();
	this.OCCURRENCES = new HashMap<String, HashMap<String, Integer>>();
	this.relationmap = new HashMap<String, LinkedList<String>>();
	this.pattymap = new HashMap<String, LinkedList<String>>();
	this.pattyfreebasemap = new HashMap<String, LinkedList<String>>();
	this.evidencemap = new HashMap<String, HashSet<String>>();
	HDT labelhdt;
	HDT shortdeschdt;
	HDT longdeschdt;
	try {
		labelhdt = HDTManager.mapIndexedHDT(LABELHDT, null);
		shortdeschdt = HDTManager.mapIndexedHDT(SHORTDESCHDT, null);
		longdeschdt = HDTManager.mapIndexedHDT(LONGDESCHDT, null);
		final HDTGraph labelhdtgraph = new HDTGraph(labelhdt);
		final HDTGraph shortdeschdtgraph = new HDTGraph(shortdeschdt);
		final HDTGraph longdeschdtgraph = new HDTGraph(longdeschdt);
		this.labelmodel = ModelFactory.createModelForGraph(labelhdtgraph);
		this.shortdescmodel = ModelFactory
				.createModelForGraph(shortdeschdtgraph);
		this.longdescmodel = ModelFactory
				.createModelForGraph(longdeschdtgraph);
	} catch (IOException e) {
		e.printStackTrace();
	}
	this.counter = 0;
}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
public Test1() {
	HDT mappingbasedproperties;
	try {
		mappingbasedproperties = HDTManager.mapIndexedHDT(
				MAPPINGPROPERTIESHDT, null);
		final HDTGraph instancemappingtypesgraph = new HDTGraph(
				mappingbasedproperties);
		this.mappingbasedproperties = ModelFactory
				.createModelForGraph(instancemappingtypesgraph);
	} catch (IOException e) {
		e.printStackTrace();
	}
}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
/**
 *
 * @throws Exception
 */
@BeforeClass
public static void setUpClass() throws Exception {
    final String typeName = "HdtTestSourceType";
    if ( ! DataSourceTypesRegistry.isRegistered(typeName) ) {
        DataSourceTypesRegistry.register( typeName, new HdtDataSourceType() );
    }

    // HDT does not seem to support an InputReader, so write to temp file
    File temp = getResourceAsFile();

    HDT mgr = HDTManager.generateHDT(temp.getAbsolutePath(),
                    "http://linkeddatafragments.org",
                    RDFNotation.NTRIPLES, new HDTSpecification(), null);
    hdtfile = File.createTempFile("ldf-hdt-test", ".hdt");
    mgr.saveToHDT(hdtfile.getAbsolutePath(), null);
    
    temp.getAbsoluteFile().delete();
    
    // Everything is in place, now create the LDF datasource
    JsonObject config = createConfig("hdt test", "hdt test", typeName);
    
    JsonObject settings = new JsonObject();
    settings.addProperty("file", hdtfile.getAbsolutePath());
    config.add("settings", settings);
    
    setDatasource(DataSourceFactory.create(config));
}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
public PageRankHDT(HDT hdt, double dampingFactor, double startValue, int numberOfIterations){
    this.hdt = hdt;
    this.dampingFactor = dampingFactor;
    this.startValue = startValue;
    this.numberOfIterations = numberOfIterations;
}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
public HDTGraph(HDT hdt) {
	this.rawGraph = hdt;
	this.weLoaded=false;
	populateInternal();
}
 

import org.rdfhdt.hdt.hdt.HDT; //导入依赖的package包/类
@Override
public HDT getBaseGraph() {
	return rawGraph;
}