| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.jena.sparql; |
| |
| import java.util.ArrayList ; |
| import java.util.Iterator ; |
| import java.util.List ; |
| |
| import org.apache.jena.atlas.lib.Sync ; |
| import org.apache.jena.graph.Graph ; |
| import org.apache.jena.graph.compose.Polyadic ; |
| import org.apache.jena.graph.impl.WrappedGraph ; |
| import org.apache.jena.query.ARQ ; |
| import org.apache.jena.query.Dataset ; |
| import org.apache.jena.rdf.model.Model ; |
| import org.apache.jena.reasoner.InfGraph ; |
| import org.apache.jena.sparql.core.DatasetGraph ; |
| import org.apache.jena.sparql.core.GraphView ; |
| import org.apache.jena.sparql.graph.GraphWrapper ; |
| import org.apache.jena.sparql.mgt.ARQMgt ; |
| import org.apache.jena.sparql.mgt.SystemInfo ; |
| import org.apache.jena.sparql.util.Symbol ; |
| |
| public class SystemARQ |
| { |
| // Various system wide settings, "constants" that might change e.g. test setups |
| // ** This can be loaded before the rest of ARQ is initialized ** |
| |
| // NodeValues work without the context so some things only have global settings. |
| |
| /** Control whether addition datatypes, over and above strict, minimal SPARQL compliance, are handled. |
| * Examples include xsd:date and simple literal/xsd:string. |
| */ |
| public static boolean ValueExtensions = true ; |
| |
| /** |
| * Under strict {@literal F&O}, dateTimes and dates with no timezone have one magically applied. |
| * This default timezone is implementation dependent and can lead to different answers |
| * to queries depending on the timezone. Normally, ARQ uses XMLSchema dateTime comparions, |
| * which an yield "indeterminate", which in turn is an evaluation error. |
| * {@literal F&O} insists on true/false and so can lead to false positves and negatives. |
| */ |
| public static boolean StrictDateTimeFO = false ; |
| |
| /** Whether support for roman numerals (datatype http://rome.example.org/Numeral). |
| * Mainly a test of datatype extension. |
| */ |
| public static boolean EnableRomanNumerals = true ; |
| |
| /** |
| * Use a plain graph (sameValueAs is term equality) |
| */ |
| public static boolean UsePlainGraph = false ; |
| |
| /** |
| * Whether to use StAX or SAX XML parsing for result sets (StAX preferred). |
| */ |
| public static boolean UseSAX = false ; |
| |
| /** |
| * Sync a Model if it provides the underlying graph provides sync . Do nothing |
| * otherwise. |
| */ |
| public static void sync(Model model) { |
| sync(model.getGraph()) ; |
| } |
| |
| /** Sync if provided. Do nothing if not. */ |
| public static void sync(Graph graph) { |
| syncGraph(graph) ; |
| } |
| |
| private static void syncGraph(Graph graph) { |
| // "Temporary" hack. Graph ought to implement sync and casade it down. |
| if ( graph instanceof InfGraph ) |
| syncGraph(((InfGraph)graph).getRawGraph()) ; |
| else if ( graph instanceof Polyadic ) // MultiUnion |
| // Only the base graph is updatable. |
| syncGraph(((Polyadic)graph).getBaseGraph()) ; |
| else if ( graph instanceof GraphWrapper ) |
| syncGraph(((GraphWrapper)graph).get()) ; |
| else if ( graph instanceof WrappedGraph ) |
| syncGraph(((WrappedGraph)graph).getWrapped()) ; |
| else |
| syncObject(graph) ; |
| } |
| |
| /** Sync a Dataset, if underlying storage provides sync. */ |
| public static void sync(Dataset dataset) { |
| sync(dataset.asDatasetGraph()) ; |
| } |
| |
| /** Sync carefully for compound objects */ |
| public static void sync(DatasetGraph dataset) { |
| if ( dataset instanceof Sync ) { |
| ((Sync)dataset).sync() ; |
| return ; |
| } else { |
| Graph gDft = dataset.getDefaultGraph() ; |
| syncIfNotView(gDft) ; |
| // Go through each graph. |
| dataset.listGraphNodes().forEachRemaining( gn->syncIfNotView(dataset.getGraph(gn) )) ; |
| } |
| } |
| |
| private static void syncIfNotView(Graph g) { |
| // GraphView sync calls the DatasetGraph lead to possible recursion. |
| if ( !( g instanceof GraphView) ) |
| sync(g) ; |
| } |
| |
| /** Sync an object if synchronizable (model, graph, dataset). */ |
| public static void syncObject(Object object) { |
| if ( object instanceof Sync ) |
| ((Sync)object).sync() ; |
| } |
| |
| private static List<SystemInfo> versions = new ArrayList<>() ; |
| public static void registerSubSystem(SystemInfo systemInfo) |
| { |
| ARQMgt.register(systemInfo.getJmxPath() + ".system:type=SystemInfo", systemInfo) ; |
| versions.add(systemInfo) ; |
| } |
| |
| public static Iterator<SystemInfo> registeredSubsystems() { |
| return versions.iterator() ; |
| } |
| |
| public static Symbol allocSymbol(String shortName) { |
| // This must work even if initialization is happening. |
| // Touching final constant explicit strings in ARQ is fine (compile time constants). |
| if ( shortName.startsWith(ARQ.arqSymbolPrefix) ) |
| throw new ARQInternalErrorException("Symbol short name begins with the ARQ namespace prefix: " + shortName) ; |
| if ( shortName.startsWith("http:") ) |
| throw new ARQInternalErrorException("Symbol short name begins with http: " + shortName) ; |
| return SystemARQ.allocSymbol(ARQ.arqParamNS, shortName) ; |
| } |
| public static Symbol allocSymbol(String base, String shortName) { |
| return Symbol.create(base + shortName) ; |
| } |
| } |