国产一级a片免费看高清,亚洲熟女中文字幕在线视频,黄三级高清在线播放,免费黄色视频在线看

// URI declarations
                        String familyUri = "http://family/";
                        String relationshipUri = "http://purl.org/vocab/relationship/";
                        // Create an empty Model
                        Model model = ModelFactory.createDefaultModel();
                        // Create a Resource for each family member, identified by their
                        URI Resource adam = model.createResource(familyUri+"adam");
                        Resource beth = model.createResource(familyUri+"beth");
                        Resource chuck = model.createResource(familyUri+"chuck");
                        Resource dotty = model.createResource(familyUri+"dotty");
                        // and so on for other family members
                        // Create properties for the different types of relationship to represent
                        Property childOf = model.createProperty(relationshipUri,"childOf");
                        Property parentOf = model.createProperty(relationshipUri,"parentOf");
                        Property siblingOf = model.createProperty(relationshipUri,"siblingOf");
                        Property spouseOf = model.createProperty(relationshipUri,"spouseOf");
                        // Add properties to adam describing relationships to other family members
                        adam.addProperty(siblingOf,beth);
                        adam.addProperty(spouseOf,dotty);
                        adam.addProperty(parentOf,edward);
                        // Can also create statements directly .. .
                        Statement statement = model.createStatement(adam,parentOf,fran);
                        // but remember to add the created statement to the model
                        model.add(statement);
                        

// List everyone in the model who has a child:
                        ResIterator parents = model.listSubjectsWithProperty(parentOf);
                        // Because subjects of statements are Resources, the method returned a ResIterator
                        while (parents.hasNext()) {
                        // ResIterator has a typed nextResource() method
                        Resource person = parents.nextResource();
                        // Print the URI of the resource
                        System.out.println(person.getURI()); }
                        // Can also find all the parents by getting the objects of all "childOf" statements
                        // Objects of statements could be Resources or literals, so the Iterator returned
                        // contains RDFNodes
                        NodeIterator moreParents = model.listObjectsOfProperty(childOf);
                        // To find all the siblings of a specific person, the model itself can be queried
                        NodeIterator siblings = model.listObjectsOfProperty(edward, siblingOf);
                        // But it's more elegant to ask the Resource directly
                        // This method yields an iterator over Statements
                        StmtIterator moreSiblings = edward.listProperties(siblingOf);
                        

// Find the exact statement "adam is a spouse of dotty"
                        model.listStatements(adam,spouseOf,dotty);
                        // Find all statements with adam as the subject and dotty as the object
                        model.listStatements(adam,null,dotty);
                        // Find any statements made about adam
                        model.listStatements(adam,null,null);
                        // Find any statement with the siblingOf property
                        model.listStatements(null,siblingOf,null);
                        

// Instantiate the MySQL driver
                        Class.forName("com.mysql.jdbc.Driver");
                        // Create a database connection object
                        DBConnection connection = new DBConnection(DB_URL, DB_USER, DB_PASSWORD, DB_TYPE);
                        // Get a ModelMaker for database-backed models
                        ModelMaker maker = ModelFactory.createModelRDBMaker(connection);
                        // Create a new model named "wordnet."Setting the second parameter to "true" causes an
                        // AlreadyExistsException to be thrown if the db already has a model with this name
                        Model wordnetModel = maker.createModel("wordnet",true);
                        // Start a database transaction.Without one, each statement will be auto-committed
                        // as it is added, which slows down the model import significantly.
                        model.begin();
                        // For each wordnet model .. .
                        InputStream in = this.getClass().getClassLoader().getResourceAsStream(filename);
                        model.read(in,null);
                        // Commit the database transaction model.
                        commit();

$java jena.rdfquery --data jdbc:mysql://localhost/jena --user dbuser --password dbpass
                        --driver com.mysql.jdbc.Driver --dbType MySQL --dbName wordnet --query example_query.rdql
                        

SELECT
                        ?definition
                        WHERE
                        (?concept, <wn:wordForm>, "domestic dog"),
                        (?concept, <wn:glossaryEntry>, ?definition)
                        USING
                        wn FOR <http://www.cogsci.princeton.edu/~wn/schema/>
                        

definition
                        ===============================================================================
                        "a member of the genus Canis (probably descended from the common wolf) that has
                        been domesticated by man since prehistoric times; occurs in many breeds; "the
                        dog barked all night""
                        

SELECT
                        ?definition
                        WHERE
                        (?concept, <wn:wordForm>, "bear"),
                        (?concept, <wn:glossaryEntry>, ?definition)
                        USING
                        wn FOR <http://www.cogsci.princeton.edu/~wn/schema/>
                        

definition
                        ===============================================================================
                        "massive plantigrade carnivorous or omnivorous mammals with long shaggy coats
                        and strong claws"
                        "an investor with a pessimistic market outlook"
                        "have on one's person; "He wore a red ribbon"; "bear a scar""
                        "give birth (to a newborn); "My wife had twins yesterday!""
                        

SELECT
                        ?wordform, ?definition
                        WHERE
                        (?firstconcept, <wn:wordForm>, "panther"),
                        (?secondconcept, <wn:wordForm>, "tiger"),
                        (?firstconcept, <wn:hyponymOf>, ?hypernym),
                        (?secondconcept, <wn:hyponymOf>, ?hypernym),
                        (?hypernym, <wn:wordForm>, ?wordform),
                        (?hypernym, <wn:glossaryEntry>, ?definition)
                        USING
                        wn FOR <http://www.cogsci.princeton.edu/~wn/schema/>
                        

wordform  | definition
                        =====================================================================================
                        "big cat" | "any of several large cats typically able to roar and living in the wild"
                        "cat"     | "any of several large cats typically able to roar and living in the wild"
                        

// Create a new query passing a String containing the RDQL to execute
                        Query query = new Query(queryString);
                        // Set the model to run the query against
                        query.setSource(model);
                        // Use the query to create a query engine
                        QueryEngine qe = new QueryEngine(query);
                        // Use the query engine to execute the query
                        QueryResults results = qe.exec();
                        

// Create a query that has variables x and y
                        Query query = new Query(queryString);
                        // A ResultBinding specifies mappings between query variables and values
                        ResultBinding initialBinding = new ResultBinding() ;
                        // Bind the query's first variable to a resource
                        Resource someResource = getSomeResource();
                        initialBinding.add("x", someResource);
                        // Bind the query's second variable to a literal value
                        RDFNode foo = model.createLiteral("bar");
                        initialBinding.add("y", foo);
                        // Execute the query with the specified values for x and y
                        QueryEngine qe = new QueryEngine(query);
                        QueryResults results = qe.exec(initialBinding);
                        

SELECT
                        ?definition
                        WHERE
                        (?concept, <wn:wordForm>, "domestic dog"),
                        (?concept, <wn:glossaryEntry>, ?definition)
                        USING
                        wn FOR <http://www.cogsci.princeton.edu/~wn/schema/>";
                        

// Execute a query
                        QueryResults results = qe.exec();
                        // Loop over the results
                        while (results.hasNext()) {
                        ResultBinding binding = (ResultBinding)results.next();
                        // Print the literal value of the "definition" variable
                        RDFNode definition = (RDFNode) binding.get("definition");
                        System.out.println(definition.toString());
                        // Get the RDF resource used in the query
                        Resource concept = (Resource)binding.get("concept");
                        // Query the concept directly to find other wordforms it has
                        List wordforms = concept.listObjectsOfProperty(wordForm);
                        }
                        

SELECT
                        ?hypernym, ?definition
                        WHERE
                        (?firstconcept, <wn:wordForm>, ?hyponym),
                        (?firstconcept, <wn:hyponymOf>, ?secondconcept),
                        (?secondconcept, <wn:wordForm>, ?hypernym),
                        (?secondconcept, <wn:glossaryEntry>, ?definition)
                        USING
                        wn FOR <http://www.cogsci.princeton.edu/~wn/schema/>
                        

$ java FindHypernym "wisteria"
                        Hypernyms found for 'wisteria':
                        vine:weak-stemmed plant that derives support from climbing, twining,
                        or creeping along a surface

// Make a new model to act as an OWL ontology for WordNet
                        OntModel wnOntology = ModelFactory.createOntologyModel();
                        // Use OntModel's convenience method to describe
                        // WordNet's hyponymOf property as transitive
                        wnOntology.createTransitiveProperty(WordnetVocab.hyponymOf.getURI());
                        // Alternatively, just add a statement to the underlying model to express that
                        // hyponymOf is of type TransitiveProperty
                        wnOntology.add(WordnetVocab.hyponymOf, RDF.type, OWL.TransitiveProperty);

// Get a reference to the WordNet plants model
                        ModelMaker maker = ModelFactory.createModelRDBMaker(connection);
                        Model model = maker.openModel("wordnet-plants",true);
                        // Create an OWL reasoner
                        Reasoner owlReasoner = ReasonerRegistry.getOWLReasoner();
                        // Bind the reasoner to the WordNet ontology model
                        Reasoner wnReasoner = owlReasoner.bindSchema(wnOntology);
                        // Use the reasoner to create an inference model
                        InfModel infModel = ModelFactory.createInfModel(wnReasoner, model);
                        // Set the inference model as the source of the
                        query query.setSource(infModel);
                        // Execute the query as normal
                        QueryEngine qe = new QueryEngine(query);
                        QueryResults results = qe.exec(initialBinding);
                        

$ java FindInferredHypernyms wisteria
                        Hypernyms found for 'wisteria':
                        vine:weak-stemmed plant that derives support from climbing, twining, or creeping along a surface
                        tracheophyte:green plant having a vascular system:ferns, gymnosperms, angiosperms
                        vascular plant:green plant having a vascular system:ferns, gymnosperms, angiosperms
                        plant life:a living organism lacking the power of locomotion
                        flora:a living organism lacking the power of locomotion
                        plant:a living organism lacking the power of locomotion