コード例 #1
0
ファイル: FilterBuilder.java プロジェクト: Fedict/rdf4j
  public GroupBuilder<T, E> regex(ValueExpr theExpr, String thePattern, String theFlags) {
    Regex aRegex = new Regex();
    aRegex.setArg(theExpr);
    aRegex.setPatternArg(
        new ValueConstant(SimpleValueFactory.getInstance().createLiteral(thePattern)));
    if (theFlags != null) {
      aRegex.setFlagsArg(
          new ValueConstant(SimpleValueFactory.getInstance().createLiteral(theFlags)));
    }

    return filter(aRegex);
  }
コード例 #2
0
ファイル: EARL.java プロジェクト: Fedict/rdf4j
  static {
    ValueFactory factory = SimpleValueFactory.getInstance();
    ASSERTOR = factory.createIRI(EARL.NAMESPACE, "Assertor");
    ASSERTION = factory.createIRI(EARL.NAMESPACE, "Assertion");
    ASSERTEDBY = factory.createIRI(EARL.NAMESPACE, "assertedBy");
    SUBJECT = factory.createIRI(EARL.NAMESPACE, "subject");
    TEST = factory.createIRI(EARL.NAMESPACE, "test");
    TEST_SUBJECT = factory.createIRI(EARL.NAMESPACE, "TestSubject");
    RESULT = factory.createIRI(EARL.NAMESPACE, "result");
    MODE = factory.createIRI(EARL.NAMESPACE, "mode");
    TESTRESULT = factory.createIRI(EARL.NAMESPACE, "TestResult");
    OUTCOME = factory.createIRI(EARL.NAMESPACE, "outcome");
    SOFTWARE = factory.createIRI(EARL.NAMESPACE, "Software");

    // Outcome values

    PASS = factory.createIRI(EARL.NAMESPACE, "pass");
    FAIL = factory.createIRI(EARL.NAMESPACE, "fail");
    CANNOTTELL = factory.createIRI(EARL.NAMESPACE, "cannotTell");
    NOTAPPLICABLE = factory.createIRI(EARL.NAMESPACE, "notApplicable");
    NOTTESTED = factory.createIRI(EARL.NAMESPACE, "notTested");

    // Test modes
    MANUAL = factory.createIRI(EARL.NAMESPACE, "manual");
    AUTOMATIC = factory.createIRI(EARL.NAMESPACE, "automatic");
    SEMIAUTOMATIC = factory.createIRI(EARL.NAMESPACE, "semiAutomatic");
    NOTAVAILABLE = factory.createIRI(EARL.NAMESPACE, "notAvailable");
    HEURISTIC = factory.createIRI(EARL.NAMESPACE, "heuristic");
  }
コード例 #3
0
  private ModelAndView startTransaction(
      Repository repository, HttpServletRequest request, HttpServletResponse response)
      throws IOException, ClientHTTPException, ServerHTTPException {
    ProtocolUtil.logRequestParameters(request);
    Map<String, Object> model = new HashMap<String, Object>();

    IsolationLevel isolationLevel = null;
    final String isolationLevelString = request.getParameter(Protocol.ISOLATION_LEVEL_PARAM_NAME);
    if (isolationLevelString != null) {
      final IRI level = SimpleValueFactory.getInstance().createIRI(isolationLevelString);

      // FIXME this needs to be adapted to accommodate custom isolation levels
      // from third party stores.
      for (IsolationLevel standardLevel : IsolationLevels.values()) {
        if (standardLevel.getURI().equals(level)) {
          isolationLevel = standardLevel;
          break;
        }
      }
    }

    try {
      Transaction txn = new Transaction(repository);
      txn.begin(isolationLevel);

      UUID txnId = txn.getID();

      ActiveTransactionRegistry.INSTANCE.register(txn);

      model.put(SimpleResponseView.SC_KEY, SC_CREATED);
      final StringBuffer txnURL = request.getRequestURL();
      txnURL.append("/" + txnId.toString());
      Map<String, String> customHeaders = new HashMap<String, String>();
      customHeaders.put("Location", txnURL.toString());
      model.put(SimpleResponseView.CUSTOM_HEADERS_KEY, customHeaders);
      return new ModelAndView(SimpleResponseView.getInstance(), model);
    } catch (RepositoryException | InterruptedException | ExecutionException e) {
      throw new ServerHTTPException("Transaction start error: " + e.getMessage(), e);
    }
  }
コード例 #4
0
/** @author Jeen Broekstra */
public class QueryEvaluationUtilTest {

  private ValueFactory f = SimpleValueFactory.getInstance();

  private Literal arg1simple;

  private Literal arg2simple;

  private Literal arg1en;

  private Literal arg2en;

  private Literal arg1cy;

  private Literal arg2cy;

  private Literal arg1string;

  private Literal arg2string;

  private Literal arg1int;

  private Literal arg2int;

  private Literal arg1year;

  private Literal arg2year;

  private Literal arg1dateTime;

  private Literal arg2dateTime;

  private Literal arg1unknown;

  private Literal arg2unknown;

  @Before
  public void setUp() throws Exception {
    arg1simple = f.createLiteral("abc");
    arg2simple = f.createLiteral("b");

    arg1en = f.createLiteral("abc", "en");
    arg2en = f.createLiteral("b", "en");

    arg1cy = f.createLiteral("abc", "cy");
    arg2cy = f.createLiteral("b", "cy");

    arg1string = f.createLiteral("abc", XMLSchema.STRING);
    arg2string = f.createLiteral("b", XMLSchema.STRING);

    arg1year = f.createLiteral("2007", XMLSchema.GYEAR);
    arg2year = f.createLiteral("2009", XMLSchema.GYEAR);

    arg1dateTime = f.createLiteral("2009-01-01T20:20:20Z", XMLSchema.DATETIME);
    arg2dateTime = f.createLiteral("2007-01-01T20:20:20+02:00", XMLSchema.DATETIME);

    arg1int = f.createLiteral(10);
    arg2int = f.createLiteral(1);

    arg1unknown = f.createLiteral("foo", f.createIRI("http://example.com/datatype"));
    arg2unknown = f.createLiteral("bar", f.createIRI("http://example.com/datatype"));
  }

  @Test
  public void testCompatibleArguments() throws Exception {

    assertTrue(QueryEvaluationUtil.compatibleArguments(arg1simple, arg2simple));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1simple, arg2en));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1simple, arg2cy));
    assertTrue(QueryEvaluationUtil.compatibleArguments(arg1simple, arg2string));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1simple, arg2int));

    assertTrue(QueryEvaluationUtil.compatibleArguments(arg1en, arg2simple));
    assertTrue(QueryEvaluationUtil.compatibleArguments(arg1en, arg2en));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg2en, arg2cy));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1en, arg2cy));
    assertTrue(QueryEvaluationUtil.compatibleArguments(arg1en, arg2string));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1en, arg2int));

    assertTrue(QueryEvaluationUtil.compatibleArguments(arg1cy, arg2simple));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1cy, arg2en));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg2cy, arg2en));
    assertTrue(QueryEvaluationUtil.compatibleArguments(arg1cy, arg2cy));
    assertTrue(QueryEvaluationUtil.compatibleArguments(arg1cy, arg2string));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1cy, arg2int));

    assertTrue(QueryEvaluationUtil.compatibleArguments(arg1string, arg2simple));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1string, arg2en));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1string, arg2cy));
    assertTrue(QueryEvaluationUtil.compatibleArguments(arg1string, arg2string));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1string, arg2int));

    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1int, arg2simple));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1int, arg2en));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1int, arg2cy));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1int, arg2string));
    assertFalse(QueryEvaluationUtil.compatibleArguments(arg1int, arg2int));
  }

  @Test
  public void testCompareEQ() throws Exception {
    assertCompareTrue(arg1simple, arg1simple, EQ);
    assertCompareTrue(arg1en, arg1en, EQ);
    assertCompareTrue(arg2cy, arg2cy, EQ);
    assertCompareTrue(arg1string, arg1string, EQ);
    assertCompareTrue(arg1int, arg1int, EQ);
    assertCompareTrue(arg1year, arg1year, EQ);
    assertCompareTrue(arg1dateTime, arg1dateTime, EQ);
    assertCompareException(arg1unknown, arg2unknown, EQ);

    assertCompareFalse(arg1simple, arg2simple, EQ);
    assertCompareFalse(arg1simple, arg2en, EQ);
    assertCompareFalse(arg1simple, arg2cy, EQ);
    assertCompareFalse(arg1simple, arg2string, EQ);
    assertCompareException(arg1simple, arg2int, EQ);
    assertCompareException(arg1simple, arg2year, EQ);
    assertCompareException(arg1simple, arg2unknown, EQ);

    assertCompareFalse(arg1en, arg2simple, EQ);
    assertCompareFalse(arg1en, arg2en, EQ);
    assertCompareFalse(arg2en, arg2cy, EQ);
    assertCompareFalse(arg1en, arg2cy, EQ);
    assertCompareFalse(arg1en, arg2string, EQ);
    assertCompareFalse(arg1en, arg2int, EQ);
    assertCompareFalse(arg1en, arg2unknown, EQ);

    assertCompareFalse(arg1cy, arg2simple, EQ);
    assertCompareFalse(arg1cy, arg2en, EQ);
    assertCompareFalse(arg2cy, arg2en, EQ);
    assertCompareFalse(arg1cy, arg2cy, EQ);
    assertCompareFalse(arg1cy, arg2string, EQ);
    assertCompareFalse(arg1cy, arg2int, EQ);
    assertCompareFalse(arg1cy, arg2unknown, EQ);

    assertCompareFalse(arg1string, arg2simple, EQ);
    assertCompareFalse(arg1string, arg2en, EQ);
    assertCompareFalse(arg1string, arg2cy, EQ);
    assertCompareFalse(arg1string, arg2string, EQ);
    assertCompareException(arg1string, arg2int, EQ);
    assertCompareException(arg1string, arg2year, EQ);
    assertCompareException(arg1string, arg2unknown, EQ);

    assertCompareException(arg1int, arg2simple, EQ);
    assertCompareFalse(arg1int, arg2en, EQ);
    assertCompareFalse(arg1int, arg2cy, EQ);
    assertCompareException(arg1int, arg2string, EQ);
    assertCompareFalse(arg1int, arg2int, EQ);
    assertCompareException(arg1int, arg2year, EQ);
    assertCompareException(arg1int, arg2unknown, EQ);

    assertCompareException(arg1year, arg2simple, EQ);
    assertCompareFalse(arg1year, arg2en, EQ);
    assertCompareException(arg1year, arg2string, EQ);
    assertCompareException(arg1year, arg2int, EQ);
    assertCompareFalse(arg1year, arg2year, EQ);
    assertCompareFalse(arg1year, arg2dateTime, EQ);
    assertCompareException(arg1year, arg2unknown, EQ);

    assertCompareException(arg1dateTime, arg2simple, EQ);
    assertCompareFalse(arg1dateTime, arg2en, EQ);
    assertCompareException(arg1dateTime, arg2string, EQ);
    assertCompareException(arg1dateTime, arg2int, EQ);
    assertCompareFalse(arg1dateTime, arg2year, EQ);
    assertCompareFalse(arg1dateTime, arg2dateTime, EQ);
    assertCompareException(arg1dateTime, arg2unknown, EQ);
  }

  @Test
  public void testCompareNE() throws Exception {
    assertCompareFalse(arg1simple, arg1simple, NE);
    assertCompareFalse(arg1en, arg1en, NE);
    assertCompareFalse(arg1cy, arg1cy, NE);
    assertCompareFalse(arg1string, arg1string, NE);
    assertCompareFalse(arg1int, arg1int, NE);
    assertCompareFalse(arg1year, arg1year, NE);
    assertCompareFalse(arg1dateTime, arg1dateTime, NE);
    assertCompareException(arg1unknown, arg2unknown, NE);

    assertCompareTrue(arg1simple, arg2simple, NE);
    assertCompareTrue(arg1simple, arg2en, NE);
    assertCompareTrue(arg1simple, arg2cy, NE);
    assertCompareTrue(arg1simple, arg2string, NE);
    assertCompareException(arg1simple, arg2int, NE);
    assertCompareException(arg1simple, arg2year, NE);
    assertCompareException(arg1unknown, arg2unknown, NE);

    assertCompareTrue(arg1en, arg2simple, NE);
    assertCompareTrue(arg1en, arg2en, NE);
    assertCompareTrue(arg2en, arg2cy, NE);
    assertCompareTrue(arg1en, arg2cy, NE);
    assertCompareTrue(arg1en, arg2string, NE);
    assertCompareTrue(arg1en, arg2int, NE);
    assertCompareTrue(arg1en, arg2unknown, NE);

    assertCompareTrue(arg1cy, arg2simple, NE);
    assertCompareTrue(arg1cy, arg2en, NE);
    assertCompareTrue(arg2cy, arg2en, NE);
    assertCompareTrue(arg1cy, arg2cy, NE);
    assertCompareTrue(arg1cy, arg2string, NE);
    assertCompareTrue(arg1cy, arg2int, NE);
    assertCompareTrue(arg1cy, arg2unknown, NE);

    assertCompareTrue(arg1string, arg2simple, NE);
    assertCompareTrue(arg1string, arg2en, NE);
    assertCompareTrue(arg1string, arg2cy, NE);
    assertCompareTrue(arg1string, arg2string, NE);
    assertCompareException(arg1string, arg2int, NE);
    assertCompareException(arg1string, arg2year, NE);
    assertCompareException(arg1string, arg2unknown, NE);

    assertCompareException(arg1int, arg2simple, NE);
    assertCompareTrue(arg1int, arg2en, NE);
    assertCompareTrue(arg1int, arg2cy, NE);
    assertCompareException(arg1int, arg2string, NE);
    assertCompareTrue(arg1int, arg2int, NE);
    assertCompareException(arg1int, arg2year, NE);
    assertCompareException(arg1int, arg2unknown, NE);

    assertCompareException(arg1year, arg2simple, NE);
    assertCompareTrue(arg1year, arg2en, NE);
    assertCompareException(arg1year, arg2string, NE);
    assertCompareException(arg1year, arg2int, NE);
    assertCompareTrue(arg1year, arg2year, NE);
    assertCompareTrue(arg1year, arg2dateTime, NE);
    assertCompareException(arg1year, arg2unknown, NE);

    assertCompareException(arg1dateTime, arg2simple, NE);
    assertCompareTrue(arg1dateTime, arg2en, NE);
    assertCompareException(arg1dateTime, arg2string, NE);
    assertCompareException(arg1dateTime, arg2int, NE);
    assertCompareTrue(arg1dateTime, arg2year, NE);
    assertCompareTrue(arg1dateTime, arg2dateTime, NE);
    assertCompareException(arg1dateTime, arg2unknown, NE);
  }

  @Test
  public void testCompareLT() throws Exception {
    assertCompareFalse(arg1simple, arg1simple, LT);
    assertCompareException(arg1en, arg1en, LT);
    assertCompareFalse(arg1string, arg1string, LT);
    assertCompareFalse(arg1int, arg1int, LT);
    assertCompareFalse(arg1year, arg1year, LT);
    assertCompareFalse(arg1dateTime, arg1dateTime, LT);
    assertCompareException(arg1unknown, arg2unknown, LT);

    assertCompareTrue(arg1simple, arg2simple, LT);
    assertCompareException(arg1simple, arg2en, LT);
    assertCompareTrue(arg1simple, arg2string, LT);
    assertCompareException(arg1simple, arg2int, LT);
    assertCompareException(arg1simple, arg2year, LT);
    assertCompareException(arg1unknown, arg2unknown, LT);

    assertCompareException(arg1en, arg2simple, LT);
    assertCompareException(arg1en, arg2en, LT);
    assertCompareException(arg1en, arg2string, LT);
    assertCompareException(arg1en, arg2int, LT);
    assertCompareException(arg1en, arg2unknown, LT);

    assertCompareTrue(arg1string, arg2simple, LT);
    assertCompareException(arg1string, arg2en, LT);
    assertCompareTrue(arg1string, arg2string, LT);
    assertCompareException(arg1string, arg2int, LT);
    assertCompareException(arg1string, arg2year, LT);
    assertCompareException(arg1string, arg2unknown, LT);

    assertCompareException(arg1int, arg2simple, LT);
    assertCompareException(arg1int, arg2en, LT);
    assertCompareException(arg1int, arg2string, LT);
    assertCompareFalse(arg1int, arg2int, LT);
    assertCompareException(arg1int, arg2year, LT);
    assertCompareException(arg1int, arg2unknown, LT);

    assertCompareException(arg1year, arg2simple, LT);
    assertCompareException(arg1year, arg2en, LT);
    assertCompareException(arg1year, arg2string, LT);
    assertCompareException(arg1year, arg2int, LT);
    assertCompareTrue(arg1year, arg2year, LT);

    // comparison between xsd:gYear and xsd:dateTime should raise type error in strict mode
    assertCompareException(arg1year, arg1dateTime, LT);

    // ... but should succeed in extended mode.
    assertCompareTrue(arg1year, arg1dateTime, LT, false);

    assertCompareException(arg1year, arg2dateTime, LT);
    assertCompareException(arg1year, arg2unknown, LT);

    assertCompareException(arg1dateTime, arg2simple, LT);
    assertCompareException(arg1dateTime, arg2en, LT);
    assertCompareException(arg1dateTime, arg2string, LT);
    assertCompareException(arg1dateTime, arg2int, LT);
    assertCompareFalse(arg1dateTime, arg1year, LT, false);
    assertCompareException(arg1dateTime, arg2year, LT);
    assertCompareFalse(arg1dateTime, arg2dateTime, LT);
    assertCompareException(arg1dateTime, arg2unknown, LT);
  }

  /**
   * Assert that there is an exception as a result of comparing the two literals with the given
   * operator.
   *
   * @param lit1 The left literal
   * @param lit2 The right literal
   * @param op The operator for the comparison
   */
  private void assertCompareException(Literal lit1, Literal lit2, CompareOp op) throws Exception {
    try {
      boolean returnValue = QueryEvaluationUtil.compareLiterals(lit1, lit2, op);
      fail(
          "Did not receive expected ValueExprEvaluationException (return value was "
              + returnValue
              + ") for "
              + lit1.toString()
              + op.getSymbol()
              + lit2.toString());
    } catch (ValueExprEvaluationException e) {
      // Expected exception
    }
  }

  private void assertCompareFalse(Literal lit1, Literal lit2, CompareOp op) throws Exception {
    assertCompareFalse(lit1, lit2, op, true);
  }

  /**
   * Assert that there is no exception as a result of comparing the two literals with the given
   * operator and it returns false.
   *
   * @param lit1 The left literal
   * @param lit2 The right literal
   * @param op The operator for the comparison
   */
  private void assertCompareFalse(Literal lit1, Literal lit2, CompareOp op, boolean strict)
      throws Exception {
    assertFalse(
        "Compare did not return false for " + lit1.toString() + op.getSymbol() + lit2.toString(),
        QueryEvaluationUtil.compareLiterals(lit1, lit2, op, strict));
  }

  private void assertCompareTrue(Literal lit1, Literal lit2, CompareOp op) throws Exception {
    assertCompareTrue(lit1, lit2, op, true);
  }

  /**
   * Assert that there is no exception as a result of comparing the two literals with the given
   * operator and it returns true.
   *
   * @param lit1 The left literal
   * @param lit2 The right literal
   * @param op The operator for the comparison
   * @param strict boolean switch between strict and extended comparison
   */
  private void assertCompareTrue(Literal lit1, Literal lit2, CompareOp op, boolean strict)
      throws Exception {
    assertTrue(
        "Compare did not return true for " + lit1.toString() + op.getSymbol() + lit2.toString(),
        QueryEvaluationUtil.compareLiterals(lit1, lit2, op, strict));
  }
}
コード例 #5
0
ファイル: Doap.java プロジェクト: josephw/mivvi
public class Doap {
  public static final IRI MIVVI_DESKTOP_CLIENT =
      SimpleValueFactory.getInstance().createIRI("http://mivvi.net/code/#desktop-client");
  private static final IRI DOWNLOAD_PAGE =
      SimpleValueFactory.getInstance().createIRI("http://usefulinc.com/ns/doap#download-page");

  private final Version latest;
  private final String downloadUrl;

  private Doap(Version latest, String downloadUrl) {
    this.latest = latest;
    this.downloadUrl = downloadUrl;
  }

  public static Doap check(RepositoryConnection cn) throws RepositoryException {
    return new Doap(getLatestAvailableVersion(cn), getDownloadPage(cn));
  }

  public Version getLatestAvailableVersion() {
    return latest;
  }

  public String getDownloadPage() {
    return downloadUrl;
  }

  public static Version getLatestAvailableVersion(RepositoryConnection cn)
      throws RepositoryException {
    List<Version> allVersions = new ArrayList<Version>();

    RepositoryResult<Statement> res =
        cn.getStatements(MIVVI_DESKTOP_CLIENT, RdfUtil.Doap.release, null, false);

    while (res.hasNext()) {
      Statement stmt = res.next();

      Resource v = RdfUtil.asResource(stmt.getObject());
      if (v != null) {
        String rev = RdfUtil.getStringProperty(cn, v, RdfUtil.Doap.revision);
        if (rev != null) {
          try {
            allVersions.add(Version.parse(rev));
          } catch (ParseException pe) {
            // Ignore this version
          }
        }
      }
    }

    Collections.sort(allVersions);

    if (allVersions.size() > 0) {
      return allVersions.get(allVersions.size() - 1);
    } else {
      return null;
    }
  }

  public static String getDownloadPage(RepositoryConnection cn) throws RepositoryException {
    Resource r = RdfUtil.getResProperty(cn, MIVVI_DESKTOP_CLIENT, DOWNLOAD_PAGE);
    if (r instanceof IRI) {
      return ((IRI) r).toString();
    } else {
      return null;
    }
  }
}
コード例 #6
0
ファイル: BaseSailSchema.java プロジェクト: eclipse/rdf4j
 static {
   ValueFactory factory = SimpleValueFactory.getInstance();
   EVALUATION_STRATEGY_FACTORY = factory.createIRI(NAMESPACE, "evaluationStrategyFactory");
 }