Introduce Tarantool client DSL

This DSL includes set of request builders that can be used as a public
API to construct requests. The main idea here is to provide more
natural DSL-like approach to build operations instead of current
abstract types like List<?> or List<Object>.

Affects: #212

Author: nicktorwald

src/main/java/org/tarantool/AbstractTarantoolOps.java

@@ -1,10 +1,20 @@
 package org.tarantool;
 
-import static org.tarantool.RequestArguments.cacheLookupValue;
-import static org.tarantool.RequestArguments.value;
-
+import static org.tarantool.dsl.Requests.callRequest;
+import static org.tarantool.dsl.Requests.deleteRequest;
+import static org.tarantool.dsl.Requests.evalRequest;
+import static org.tarantool.dsl.Requests.insertRequest;
+import static org.tarantool.dsl.Requests.pingRequest;
+import static org.tarantool.dsl.Requests.replaceRequest;
+import static org.tarantool.dsl.Requests.selectRequest;
+import static org.tarantool.dsl.Requests.updateRequest;
+import static org.tarantool.dsl.Requests.upsertRequest;
+
+import org.tarantool.dsl.Operation;
+import org.tarantool.dsl.TarantoolRequestConvertible;
 import org.tarantool.schema.TarantoolSchemaMeta;
 
+import java.util.Arrays;
 import java.util.List;
 
 public abstract class AbstractTarantoolOps<Result>
@@ -17,188 +27,132 @@ public abstract class AbstractTarantoolOps<Result>
     protected abstract TarantoolSchemaMeta getSchemaMeta();
 
     public Result select(Integer space, Integer index, List<?> key, int offset, int limit, Iterator iterator) {
-        return select(space, index, key, offset, limit, iterator.getValue());
+        return execute(
+            selectRequest(space, index)
+                .key(key)
+                .offset(offset).limit(limit)
+                .iterator(iterator)
+        );
     }
 
     @Override
     public Result select(String space, String index, List<?> key, int offset, int limit, Iterator iterator) {
-        return select(space, index, key, offset, limit, iterator.getValue());
+        return execute(
+            selectRequest(space, index)
+                .key(key)
+                .offset(offset).limit(limit)
+                .iterator(iterator)
+        );
     }
 
     @Override
     public Result select(Integer space, Integer index, List<?> key, int offset, int limit, int iterator) {
-        return exec(
-            new TarantoolRequest(
-                Code.SELECT,
-                value(Key.SPACE), value(space),
-                value(Key.INDEX), value(index),
-                value(Key.KEY), value(key),
-                value(Key.ITERATOR), value(iterator),
-                value(Key.LIMIT), value(limit),
-                value(Key.OFFSET), value(offset)
-            )
+        return execute(
+            selectRequest(space, index)
+                .key(key)
+                .offset(offset).limit(limit)
+                .iterator(iterator)
         );
     }
 
     @Override
     public Result select(String space, String index, List<?> key, int offset, int limit, int iterator) {
-        return exec(
-            new TarantoolRequest(
-                Code.SELECT,
-                value(Key.SPACE), cacheLookupValue(() -> getSchemaMeta().getSpace(space).getId()),
-                value(Key.INDEX), cacheLookupValue(() -> getSchemaMeta().getSpaceIndex(space, index).getId()),
-                value(Key.KEY), value(key),
-                value(Key.ITERATOR), value(iterator),
-                value(Key.LIMIT), value(limit),
-                value(Key.OFFSET), value(offset)
-            )
+        return execute(
+            selectRequest(space, index)
+                .key(key)
+                .offset(offset).limit(limit)
+                .iterator(iterator)
         );
     }
 
     @Override
     public Result insert(Integer space, List<?> tuple) {
-        return exec(new TarantoolRequest(
-                Code.INSERT,
-                value(Key.SPACE), value(space),
-                value(Key.TUPLE), value(tuple)
-            )
-        );
+        return execute(insertRequest(space, tuple));
     }
 
     @Override
     public Result insert(String space, List<?> tuple) {
-        return exec(
-            new TarantoolRequest(
-                Code.INSERT,
-                value(Key.SPACE), cacheLookupValue(() -> getSchemaMeta().getSpace(space).getId()),
-                value(Key.TUPLE), value(tuple)
-            )
-        );
+        return execute(insertRequest(space, tuple));
     }
 
     @Override
     public Result replace(Integer space, List<?> tuple) {
-        return exec(
-            new TarantoolRequest(
-                Code.REPLACE,
-                value(Key.SPACE), value(space),
-                value(Key.TUPLE), value(tuple)
-            )
-        );
+        return execute(replaceRequest(space, tuple));
     }
 
     @Override
     public Result replace(String space, List<?> tuple) {
-        return exec(
-            new TarantoolRequest(
-                Code.REPLACE,
-                value(Key.SPACE), cacheLookupValue(() -> getSchemaMeta().getSpace(space).getId()),
-                value(Key.TUPLE), value(tuple)
-            )
-        );
+        return execute(replaceRequest(space, tuple));
     }
 
     @Override
     public Result update(Integer space, List<?> key, Object... operations) {
-        return exec(
-            new TarantoolRequest(
-                Code.UPDATE,
-                value(Key.SPACE), value(space),
-                value(Key.KEY), value(key),
-                value(Key.TUPLE), value(operations)
-            )
-        );
+        Operation[] ops = Arrays.stream(operations)
+            .map(Operation::fromArray)
+            .toArray(org.tarantool.dsl.Operation[]::new);
+        return execute(updateRequest(space, key, ops));
     }
 
     @Override
     public Result update(String space, List<?> key, Object... operations) {
-        return exec(
-            new TarantoolRequest(
-                Code.UPDATE,
-                value(Key.SPACE), cacheLookupValue(() -> getSchemaMeta().getSpace(space).getId()),
-                value(Key.KEY), value(key),
-                value(Key.TUPLE), value(operations)
-            )
-        );
+        Operation[] ops = Arrays.stream(operations)
+            .map(Operation::fromArray)
+            .toArray(org.tarantool.dsl.Operation[]::new);
+        return execute(updateRequest(space, key, ops));
     }
 
     @Override
     public Result upsert(Integer space, List<?> key, List<?> defTuple, Object... operations) {
-        return exec(
-            new TarantoolRequest(
-                Code.UPSERT,
-                value(Key.SPACE), value(space),
-                value(Key.KEY), value(key),
-                value(Key.TUPLE), value(defTuple),
-                value(Key.UPSERT_OPS), value(operations)
-            )
-        );
+        Operation[] ops = Arrays.stream(operations)
+            .map(Operation::fromArray)
+            .toArray(Operation[]::new);
+        return execute(upsertRequest(space, key, defTuple, ops));
     }
 
     @Override
     public Result upsert(String space, List<?> key, List<?> defTuple, Object... operations) {
-        return exec(
-            new TarantoolRequest(
-                Code.UPSERT,
-                value(Key.SPACE), cacheLookupValue(() -> getSchemaMeta().getSpace(space).getId()),
-                value(Key.KEY), value(key),
-                value(Key.TUPLE), value(defTuple),
-                value(Key.UPSERT_OPS), value(operations)
-            )
-        );
+        Operation[] ops = Arrays.stream(operations)
+            .map(Operation::fromArray)
+            .toArray(Operation[]::new);
+        return execute(upsertRequest(space, key, defTuple, ops));
     }
 
     @Override
     public Result delete(Integer space, List<?> key) {
-        return exec(
-            new TarantoolRequest(
-                Code.DELETE,
-                value(Key.SPACE), value(space),
-                value(Key.KEY), value(key)
-            )
-        );
+        return execute(deleteRequest(space, key));
     }
 
     @Override
     public Result delete(String space, List<?> key) {
-        return exec(
-            new TarantoolRequest(
-                Code.DELETE,
-                value(Key.SPACE), cacheLookupValue(() -> getSchemaMeta().getSpace(space).getId()),
-                value(Key.KEY), value(key)
-            )
-        );
+        return execute(deleteRequest(space, key));
     }
 
     @Override
     public Result call(String function, Object... args) {
-        return exec(
-            new TarantoolRequest(
-                callCode,
-                value(Key.FUNCTION), value(function),
-                value(Key.TUPLE), value(args)
-            )
+        return execute(
+            callRequest(function)
+                .arguments(args)
+                .useCall16(callCode == Code.OLD_CALL)
         );
     }
 
     @Override
     public Result eval(String expression, Object... args) {
-        return exec(
-            new TarantoolRequest(
-                Code.EVAL,
-                value(Key.EXPRESSION), value(expression),
-                value(Key.TUPLE), value(args)
-            )
-        );
+        return execute(evalRequest(expression).arguments(args));
     }
 
     @Override
     public void ping() {
-        exec(new TarantoolRequest(Code.PING));
+        execute(pingRequest());
+    }
+
+    @Override
+    public Result execute(TarantoolRequestConvertible requestSpec) {
+        return exec(requestSpec.toTarantoolRequest(getSchemaMeta()));
     }
 
     public void setCallCode(Code callCode) {
         this.callCode = callCode;
     }
 
-}
+}

src/main/java/org/tarantool/TarantoolClientOps.java

@@ -1,5 +1,7 @@
 package org.tarantool;
 
+import org.tarantool.dsl.TarantoolRequestConvertible;
+
 public interface TarantoolClientOps<O, P, R> {
     R select(Integer space, Integer index, O key, int offset, int limit, int iterator);
 
@@ -33,7 +35,10 @@ public interface TarantoolClientOps<O, P, R> {
 
     R eval(String expression, Object... args);
 
+    R execute(TarantoolRequestConvertible requestSpec);
+
     void ping();
 
     void close();
+
 }

src/main/java/org/tarantool/dsl/AbstractRequestSpec.java

@@ -0,0 +1,46 @@
+package org.tarantool.dsl;
+
+import org.tarantool.Code;
+import org.tarantool.TarantoolRequest;
+import org.tarantool.schema.TarantoolSchemaMeta;
+
+import java.time.Duration;
+
+public abstract class AbstractRequestSpec<B extends AbstractRequestSpec<B>>
+    implements TarantoolRequestConvertible {
+
+    final Code code;
+    Duration duration = Duration.ZERO;
+    boolean useDefaultTimeout = true;
+
+    AbstractRequestSpec(Code code) {
+        this.code = code;
+    }
+
+    AbstractRequestSpec(Code code, Duration duration) {
+        this.code = code;
+        this.duration = duration;
+    }
+
+    @SuppressWarnings("unchecked")
+    public B timeout(Duration duration) {
+        this.duration = duration;
+        this.useDefaultTimeout = false;
+        return (B) this;
+    }
+
+    @SuppressWarnings("unchecked")
+    public B useDefaultTimeout() {
+        this.duration = Duration.ZERO;
+        this.useDefaultTimeout = true;
+        return (B) this;
+    }
+
+    @Override
+    public TarantoolRequest toTarantoolRequest(TarantoolSchemaMeta schemaMeta) {
+        TarantoolRequest request = new TarantoolRequest(code);
+        request.setTimeout(useDefaultTimeout ? null : duration);
+        return request;
+    }
+
+}

src/main/java/org/tarantool/dsl/CallRequestSpec.java

@@ -0,0 +1,63 @@
+package org.tarantool.dsl;
+
+import static org.tarantool.RequestArguments.value;
+
+import org.tarantool.Code;
+import org.tarantool.Key;
+import org.tarantool.TarantoolRequest;
+import org.tarantool.schema.TarantoolSchemaMeta;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public class CallRequestSpec extends AbstractRequestSpec<CallRequestSpec> {
+
+    private String functionName;
+    private List<Object> arguments = new ArrayList<>();
+    private boolean useCall16 = false;
+
+    CallRequestSpec(String functionName) {
+        super(Code.CALL);
+        this.functionName = Objects.requireNonNull(functionName);
+    }
+
+    public CallRequestSpec function(String functionName) {
+        Objects.requireNonNull(functionName);
+        this.functionName = functionName;
+        return this;
+    }
+
+    public CallRequestSpec arguments(Object... arguments) {
+        this.arguments.clear();
+        Collections.addAll(this.arguments, arguments);
+        return this;
+    }
+
+    public CallRequestSpec arguments(Collection<?> arguments) {
+        this.arguments.clear();
+        this.arguments.addAll(arguments);
+        return this;
+    }
+
+    public CallRequestSpec useCall16(boolean flag) {
+        this.useCall16 = flag;
+        return this;
+    }
+
+    @Override
+    public TarantoolRequest toTarantoolRequest(TarantoolSchemaMeta schemaMeta) {
+        TarantoolRequest request = super.toTarantoolRequest(schemaMeta);
+        if (useCall16) {
+            request.setCode(Code.OLD_CALL);
+        }
+        request.addArguments(
+            value(Key.FUNCTION), value(functionName),
+            value(Key.TUPLE), value(arguments)
+        );
+        return request;
+    }
+
+}