Add parameters in AqlQueryOptions

* AqlQueryOptions.failOnWarning(Boolean)
* AqlQueryOptions.maxTransactionSize(Long)
* AqlQueryOptions.maxWarningCount(Long)
* AqlQueryOptions.intermediateCommitCount(Long)
* AqlQueryOptions.intermediateCommitSize(Long)
* AqlQueryOptions.satelliteSyncWait(Double)

Author: mpv1989

ChangeLog

@@ -1,7 +1,13 @@
 v4.3.3 (2018-xx-xx)
 ---------------------------
-* added AqlQueryOptions.memoryLimit(Long)
 * fixed inconsistency of getDocument() variants (Issue #168)
+* added AqlQueryOptions.memoryLimit(Long)
+* added AqlQueryOptions.failOnWarning(Boolean)
+* added AqlQueryOptions.maxTransactionSize(Long)
+* added AqlQueryOptions.maxWarningCount(Long)
+* added AqlQueryOptions.intermediateCommitCount(Long)
+* added AqlQueryOptions.intermediateCommitSize(Long)
+* added AqlQueryOptions.satelliteSyncWait(Double)
 
 v4.3.2 (2017-11-30)
 ---------------------------

src/main/java/com/arangodb/model/AqlQueryOptions.java

@@ -153,6 +153,24 @@ protected AqlQueryOptions query(final String query) {
 		return this;
 	}
 
+	public Boolean getFailOnWarning() {
+		return options != null ? options.failOnWarning : null;
+	}
+
+	/**
+	 * @param failOnWarning
+	 *            When set to true, the query will throw an exception and abort instead of producing a warning. This
+	 *            option should be used during development to catch potential issues early. When the attribute is set to
+	 *            false, warnings will not be propagated to exceptions and will be returned with the query result. There
+	 *            is also a server configuration option --query.fail-on-warning for setting the default value for
+	 *            failOnWarning so it does not need to be set on a per-query level.
+	 * @return options
+	 */
+	public AqlQueryOptions failOnWarning(final Boolean failOnWarning) {
+		getOptions().failOnWarning = failOnWarning;
+		return this;
+	}
+
 	/**
 	 * @return If set to true, then the additional query profiling information will be returned in the sub-attribute
 	 *         profile of the extra return attribute if the query result is not served from the query cache.
@@ -172,6 +190,81 @@ public AqlQueryOptions profile(final Boolean profile) {
 		return this;
 	}
 
+	public Long getMaxTransactionSize() {
+		return options != null ? options.maxTransactionSize : null;
+	}
+
+	/**
+	 * @param maxTransactionSize
+	 *            Transaction size limit in bytes. Honored by the RocksDB storage engine only.
+	 * @return options
+	 */
+	public AqlQueryOptions maxTransactionSize(final Long maxTransactionSize) {
+		getOptions().maxTransactionSize = maxTransactionSize;
+		return this;
+	}
+
+	public Long getMaxWarningCount() {
+		return options != null ? options.maxWarningCount : null;
+	}
+
+	/**
+	 * @param maxWarningCount
+	 *            Limits the maximum number of warnings a query will return. The number of warnings a query will return
+	 *            is limited to 10 by default, but that number can be increased or decreased by setting this attribute.
+	 * @return options
+	 */
+	public AqlQueryOptions maxWarningCount(final Long maxWarningCount) {
+		getOptions().maxWarningCount = maxWarningCount;
+		return this;
+	}
+
+	public Long getIntermediateCommitCount() {
+		return options != null ? options.intermediateCommitCount : null;
+	}
+
+	/**
+	 * @param intermediateCommitCount
+	 *            Maximum number of operations after which an intermediate commit is performed automatically. Honored by
+	 *            the RocksDB storage engine only.
+	 * @return options
+	 */
+	public AqlQueryOptions intermediateCommitCount(final Long intermediateCommitCount) {
+		getOptions().intermediateCommitCount = intermediateCommitCount;
+		return this;
+	}
+
+	public Long getIntermediateCommitSize() {
+		return options != null ? options.intermediateCommitSize : null;
+	}
+
+	/**
+	 * @param intermediateCommitSize
+	 *            Maximum total size of operations after which an intermediate commit is performed automatically.
+	 *            Honored by the RocksDB storage engine only.
+	 * @return options
+	 */
+	public AqlQueryOptions intermediateCommitSize(final Long intermediateCommitSize) {
+		getOptions().intermediateCommitSize = intermediateCommitSize;
+		return this;
+	}
+
+	public Double getSatelliteSyncWait() {
+		return options != null ? options.satelliteSyncWait : null;
+	}
+
+	/**
+	 * @param satelliteSyncWait
+	 *            This enterprise parameter allows to configure how long a DBServer will have time to bring the
+	 *            satellite collections involved in the query into sync. The default value is 60.0 (seconds). When the
+	 *            max time has been reached the query will be stopped.
+	 * @return options
+	 */
+	public AqlQueryOptions satelliteSyncWait(final Double satelliteSyncWait) {
+		getOptions().satelliteSyncWait = satelliteSyncWait;
+		return this;
+	}
+
 	public Boolean getFullCount() {
 		return options != null ? options.fullCount : null;
 	}
@@ -234,7 +327,13 @@ private Options getOptions() {
 	}
 
 	private static class Options {
+		private Boolean failOnWarning;
 		private Boolean profile;
+		private Long maxTransactionSize;
+		private Long maxWarningCount;
+		private Long intermediateCommitCount;
+		private Long intermediateCommitSize;
+		private Double satelliteSyncWait;
 		private Optimizer optimizer;
 		private Boolean fullCount;
 		private Integer maxPlans;

src/test/java/com/arangodb/ArangoDatabaseTest.java

@@ -642,6 +642,28 @@ public void queryWithMemoryLimit() {
 		}
 	}
 
+	@Test(expected = ArangoDBException.class)
+	public void queryWithFailOnWarningTrue() {
+		db.query("RETURN 1 / 0", null, new AqlQueryOptions().failOnWarning(true), String.class);
+	}
+
+	@Test
+	public void queryWithFailOnWarningFalse() {
+		final ArangoCursor<String> cursor = db.query("RETURN 1 / 0", null, new AqlQueryOptions().failOnWarning(false),
+			String.class);
+		assertThat(cursor.next(), is("null"));
+	}
+
+	@Test
+	public void queryWithMaxWarningCount() {
+		final ArangoCursor<String> cursorWithWarnings = db.query("RETURN 1 / 0", null, new AqlQueryOptions(),
+			String.class);
+		assertThat(cursorWithWarnings.getWarnings().size(), is(1));
+		final ArangoCursor<String> cursorWithLimitedWarnings = db.query("RETURN 1 / 0", null,
+			new AqlQueryOptions().maxWarningCount(0L), String.class);
+		assertThat(cursorWithLimitedWarnings.getWarnings().size(), is(0));
+	}
+
 	@Test
 	public void queryCursor() {
 		try {