Semantics and the MarkLogic NoSQL Database

Explore how a triple expresses semantic data with subject, predicate, and object. See how multiple triples form a graph, and learn to traverse it with path expressions and visualization tools.

Explore where triples come from—creating them yourself or using public repos like DBpedia, GeoNames, FOAF, and Data.gov—and visualize with DBpedia using Elvis Presley as an example.

Understand formats for expressing triples—subject, predicate, object—and how data types apply. Compare RDF, Turtle, N-Triples, and quads with graph names in MarkLogic.

Understand how data are structured as triples (subject, predicate, object) and how those triples form graphs you can traverse, load into MarkLogic, or generate in the database without text files.

Learn how to load triples into a MarkLogic database using various formats and methods, with options like MarkLogic content pump, rest api, and language-specific apis.

Store triples in a MarkLogic database with subject, predicate, and object, organizing them by graph names in collections for targeted queries.

Discover how to load triples into MarkLogic using RDF load and RDF insert with JavaScript and XQuery, from file systems or in-memory, including optional graph specification.

Learn how to load triples into a MarkLogic database using the MarkLogic REST API, curl, and REST calls to insert triples into a named graph.

Load RDF triples into a MarkLogic database using the content pump (MSCP) from the command line, specifying input files, RDF type, port, and an optional graph.

discover how to embed triples in XML or JSON documents in MarkLogic, preserving document permissions, and load them with standard interfaces while enabling semantic queries.

Load embedded triples documents and adjacent triple documents into the MarkLogic sandbox using XQuery document load and JavaScript, then query them with SPARQL and note deletion behavior.

Load and store triples in a MarkLogic NoSQL database using standard formats and interfaces, including XQuery, JavaScript, RESTful API, and content pump; embed triples in documents.

Create a top songs database and load RDF triples into it using a RESTful interface. Stand up an app that uses the database and verify contents in the admin console.

Load content documents into the MarkLogic database, including song documents and album images, then set up the HTP observer app server for the top songs database and apply index settings.

Enable the triple index to run Sparkle queries against triples in the database. It scans documents for subject, predicate, and object, stores multiple permutations for fast querying.

Turn on the triple index in the admin interface by setting the triple index to true and clicking ok; the system reindexes existing documents online while queries continue to run.

Turn on the triple index in the sandbox database and verify it. Use the things endpoint to browse triples and confirm indexing, then observe how sparker queries behave when reindexing.

Learn how to turn on and verify the triple index in a MarkLogic NoSQL database and understand its role in running queries.

Turn on the triple index for the top songs database via the admin interface, enabling sparkle queries against the triples.

Explore SPARQL, the RDF query language for querying triples, compare it to SQL, and learn basic SPARQL queries to query Mark logic data.

Write simple sparkle queries using select and where clauses with variable question marks, and restrict results to specific graphs via from, retrieving subject-predicate-object triples.

Explore using prefixes to shorten sparkle queries, define and apply prefixes in the where clause, escape special characters, and mix prefixed with full terms for readable, efficient data retrieval.

Explore how to include more criteria in sparkle queries by chaining with dots, using semicolons to repeat subjects, applying union for or conditions, and incorporating optional clauses for non-mandatory data.

Explore using labels to provide human readable names for resources in semantics, and return course and student labels in queries for friendly results.

Learn how to control query results in marklogic using filter, limit, distinct, and order by clauses, with examples shaping birthdate-based results and ascending/descending sorting.

Explore built-in SPARQL functions, including regex, contains, substring, and bind, and learn how case-insensitive matching and not patterns refine triple queries in the animals graph.

Explore SPARQL functions in practice by loading language-tagged descriptions, using the lang function to filter English literals, and applying bind to strip the language marker for clean results.

Explore aggregate functions, including count, average, min, and max, and learn to group results with group by and filter with having to summarize data like countries and course enrollments.

Explore query forms beyond the select clause in semantics for the MarkLogic NoSQL database, including construct, ask, and describe for triples.

Explore Sparkle, the query language for acquiring triples, and learn variables, prefixes, labels, filters, limit, distinct, order by, and aggregates such as sum, average, min, max.

Execute SPARQL queries against a MarkLogic database using the REST API, sending queries from files or inline, and receive results in XML or JSON for application integration.

Discover how to execute SPARQL queries from Java or Node.js against a MarkLogic database using REST API-based pre-built offerings, with Java and Node.js clients and JSON results.

Execute sparkle queries from XQuery and JavaScript in MarkLogic for semantics, importing the library module, running the query against triples, and displaying results in a browser-based application.

Demonstrate passing values into a sparql query with MarkLogic's sparkle function in XQuery, binding a course label via map and map-put to retrieve matching courses and students.

Learn how to serialize query results into json, xml, or rdf formats using JavaScript or XQuery, and apply this to fetch and display student emails in a web app.

Implement semantics by querying triples in a MarkLogic database with SPARQL from multiple languages using APIs, including Java, Node, JavaScript XQuery, and REST, through practical top songs exercises.

implement semantics in an application by running sparkle queries to fetch artists and their band members from the top songs database, then display related artist facts via xquery-driven UI.

Fetch triples from DBpedia and insert them into a MarkLogic database using a SPARQL-like query, handling band member and former band member relations with RDF inserts.

Learn how to run combination queries on documents with embedded triples, filtering by document content and triple criteria using sparkle queries in MarkLogic and JavaScript.

Explore using XQuery and JavaScript functions within MarkLogic to query and manipulate triples, including CTX contains, binding dates to days of the week, and REST API usage.

Learn to send a sparkle file to a MarkLogic database using a curl command, fetch results in all formats, and explore using XQuery and JavaScript functions in sparkle queries.

Explore how to send sparkle queries to a MarkLogic database via APIs, pass values from application code, and return results in JSON or XML, including combination queries and JavaScript functions.

Begin a lab to build a semantics-enabled Node.js app with marklogic and jade. Allocate at least 4 gb ram to the vm, clone the project, and run npm install.

Install and explore dependencies, then configure a MarkLogic database with a forest on port 5003 via rest setup. Run setup scripts to apply indexes and prepare for Google's geocoding api.

Learn to use a Node.js workflow with Google geocoding to resolve coordinates, load photos into a MarkLogic database, and store semantic triples derived from the NDBPDA semantic data.

Start the node application for the geo photo project, view an interactive map with photo markers, and explore semantic metadata such as country, flag, currency, and time zone.

Explore property paths to traverse graphs and reveal relationships, from families and movies to professional networks and locations, using slash and pipe syntax in the W3C PAH specification.

Learn to write a slash-based path to traverse a graph and return names from Joe’s family—parents, grandparents, and related name predicates—in a hands-on exercise.

Learn to use the carrot symbol to specify an inverse step in a path expression, retrieving Sue's parents' names by traversing opposite relationships.

Use the pipe character to express or in path expressions and fetch Joe's parents and grandparents, then practice retrieving Mary's children and grandchildren in a hands-on exercise.

Discover how path step matching works in MarkLogic NoSQL semantics, using ?, +, and * to specify zero or more, one or more, or zero or one ancestors.

explores path expressions with symbols like slash, pipe, caret, question mark, asterisk, and plus, and when to use them to traverse a sparkle quarry.

Learn how inferencing derives new facts from existing triples and quads in a graph, using real examples like color, product types, and subclass relationships.

Create ontology triples to define vocabulary and relationships, such as blouse subclass of shirts and navy equals blue, using inferencing; explore web ontology language and editing tools like Protege.

Learn to perform inferencing with a path in MarkLogic by traversing RDF type and subclass relationships to return shirts and blouses, including zero or many times and same as relationships.

Discover how to use inferencing rules in MarkLogic, including same as, subclass of, and equivalent class, by applying rule sets to queries and comparing path and rule inference performance.

Explore how rule-based inferencing compares to path-based inferencing in MarkLogic, analyzing performance timings, caching effects, and using shipped and custom rules within sparker queries.

Specify default rule sets for your database so queries automatically apply those rules. Use the admin interface to add or remove default rule sets and opt out for particular queries.

Pop quiz covers inferencing with ontology triples in a database, compares path-based and rule-based approaches, discusses default rule sets, and tests understanding of ontologies and performance.

Explore SPARQL update concepts, including insert data, delete data, and updating triples via delete-and-insert, within the Sparkle 1.1 update recommendation and its graph management guidance.

Master inserting triples with sparkle update: specify a target graph or default graph, and insert multiple triples into product and customer graphs in one operation.

Learn to delete triples in a graph using delete data with exact subject, predicate, and object, or delete where with a pattern and variables, and compare performance.

Update triples in a NoSQL setting by using delete, insert, and where to modify product attributes, such as changing the price of product 3 and the color of product 007.

Explore updating embedded triples in an SML document using XQuery and JavaScript. Learn to replace, insert, and delete embedded triples, and verify results.

Set and update graph permissions for regular triples stored in a graph, and define roles and users to grant read access.

Learn how to create a role, assign a user, and grant read permissions to a graph of triples in MarkLogic, and how embedded triples inherit permissions from their containing document.

Explore clearing a graph to delete its triples while preserving the graph document, or dropping the graph entirely; use silent to suppress missing-graph errors.

Master concepts of Sparkle update for inserting and deleting triples, updating triples and embedded triples, and managing graph permissions to clear or remove a graph.

Access a wealth of resources: books, tutorials, webinars, and MarkLogic University videos, to deepen your understanding of semantics, triples, graph traversal, and inferencing.