Merge branch 'dev' of dolphindb.net:dolphindb/api-java

Author: chengyitian

README.md

@@ -1,5 +1,7 @@
 # DolphinDB Java API
 
+**Note**: This README documents DolphinDB Java API version 1.30.20.1 and earlier. As of version 1.30.20.1, this README is no longer maintained. For documentation on the latest DolphinDB Java API, please refer to [DolphinDB Documentation](https://docs.dolphindb.com/en/API/Java.html).
+
 - [DolphinDB Java API](#dolphindb-java-api)
   - [1. Introduction](#1-introduction)
   - [2. Establish DolphinDB Connection](#2-establish-dolphindb-connection)

README_CN.md

@@ -1,6 +1,6 @@
 # JAVA API 使用说明
 
-> 注意：该 Readme 不再进行维护。用户可移步至 DolphinDB 官方文档中心 [Java API 手册](https://docs.dolphindb.cn/zh/api/java/java.html)。 
+> 注意：该 Readme 不再进行维护。用户可移步至 DolphinDB 官方文档中心 [Java API 手册](https://docs.dolphindb.cn/zh/api/java_api/newjava.html)。 
 
 本教程主要介绍以下内容：
 - [JAVA API 使用说明](#java-api-使用说明)

pom.xml

@@ -2,11 +2,11 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.dolphindb</groupId>
     <artifactId>dolphindb-javaapi</artifactId>
-    <version>3.00.0.2</version>
+    <version>3.00.1.0</version>
     <packaging>jar</packaging>
 
     <properties>
-        <dolphindb.version>3.00.0.2</dolphindb.version>
+        <dolphindb.version>3.00.1.0</dolphindb.version>
     </properties>
     <name>DolphinDB Java API</name>
     <description>The messaging and data conversion protocol between Java and DolphinDB server</description>
@@ -31,7 +31,7 @@
         <connection>scm:git:git@github.com:dolphindb/api-java.git</connection>
         <developerConnection>scm:git:git@github.com:dolphindb/api-java.git</developerConnection>
         <url>git@github.com:dolphindb/api-java.git</url>
-        <tag>api-java-3.00.0.2</tag>
+        <tag>api-java-3.00.1.0</tag>
     </scm>
     <dependencies>
         <dependency>

src/com/xxdb/data/AbstractTensor.java

@@ -0,0 +1,15 @@
+package com.xxdb.data;
+
+public abstract class AbstractTensor  extends AbstractEntity implements Tensor {
+
+    @Override
+    public DATA_FORM getDataForm() {
+        return DATA_FORM.DF_TENSOR;
+    }
+
+    @Override
+    public int columns() {
+        return 1;
+    }
+
+}

src/com/xxdb/data/BasicDecimal128Vector.java

@@ -231,7 +231,15 @@ public void setExtraParamForType(int scale){
 
     @Override
     public Vector combine(Vector vector) {
-        throw new RuntimeException("BasicDecimal128Vector not support combine yet!");
+        BasicDecimal128Vector v = (BasicDecimal128Vector)vector;
+        if (v.getScale() != this.scale_)
+            throw new RuntimeException("The scale of the vector to be combine does not match the scale of the current vector.");
+        int newSize = this.rows() + v.rows();
+        BigInteger[] newValue = new BigInteger[newSize];
+        System.arraycopy(this.unscaledValues,0, newValue,0,this.rows());
+        System.arraycopy(v.unscaledValues,0, newValue,this.rows(),v.rows());
+
+        return new BasicDecimal128Vector(newValue, this.scale_);
     }
 
     @Override

src/com/xxdb/data/BasicDecimal32Vector.java

@@ -151,7 +151,15 @@ protected void writeVectorToOutputStream(ExtendedDataOutput out) throws IOExcept
 
     @Override
     public Vector combine(Vector vector) {
-        return null;
+        BasicDecimal32Vector v = (BasicDecimal32Vector)vector;
+        if (v.getScale() != this.scale_)
+            throw new RuntimeException("The scale of the vector to be combine does not match the scale of the current vector.");
+        int newSize = this.rows() + v.rows();
+        int[] newValue = new int[newSize];
+        System.arraycopy(this.unscaledValues,0, newValue,0,this.rows());
+        System.arraycopy(v.unscaledValues,0, newValue,this.rows(),v.rows());
+
+        return new BasicDecimal32Vector(newValue, this.scale_);
     }
 
     @Override

src/com/xxdb/data/BasicDecimal64Vector.java

@@ -159,7 +159,15 @@ public void setExtraParamForType(int scale){
 
     @Override
     public Vector combine(Vector vector) {
-        return null;
+        BasicDecimal64Vector v = (BasicDecimal64Vector)vector;
+        if (v.getScale() != this.scale_)
+            throw new RuntimeException("The scale of the vector to be combine does not match the scale of the current vector.");
+        int newSize = this.rows() + v.rows();
+        long[] newValue = new long[newSize];
+        System.arraycopy(this.unscaledValues,0, newValue,0,this.rows());
+        System.arraycopy(v.unscaledValues,0, newValue,this.rows(),v.rows());
+
+        return new BasicDecimal64Vector(newValue, this.scale_);
     }
 
     @Override

src/com/xxdb/data/BasicDictionary.java

@@ -115,7 +115,7 @@ public Entity get(Scalar key) {
 
 	@Override
 	public boolean put(Scalar key, Entity value) {
-		if(key.getDataType() != getKeyDataType() || (value.getDataType() != getDataType()))
+		if(key.getDataType() != getKeyDataType() || ((value.getDataType() == DATA_TYPE.DT_ANY) &&  (value.getDataType() != getDataType())))
 			return false;
 		else{
 			dict.put(key, value);
@@ -198,8 +198,14 @@ public void write(ExtendedDataOutput out) throws IOException{
 			throw new IOException("Can't streamlize the dictionary with value type " + valueType.name());
 
 		BasicEntityFactory factory = new BasicEntityFactory();
-		Vector keys = (Vector)factory.createVectorWithDefaultValue(keyType, dict.size(), -1);
-		Vector values = (Vector)factory.createVectorWithDefaultValue(valueType, dict.size(), -1);
+		Vector keys = factory.createVectorWithDefaultValue(keyType, dict.size(), -1);
+		Vector values;
+		if (valueType == DATA_TYPE.DT_ANY) {
+			 values = new BasicAnyVector(dict.size());
+		} else {
+			 values = factory.createVectorWithDefaultValue(valueType, dict.size(), -1);
+		}
+
 		int index = 0;
 		try{
 			for(Map.Entry<Entity, Entity> entry : dict.entrySet()){

src/com/xxdb/data/BasicEntityFactory.java

@@ -77,6 +77,8 @@ else if(form == Entity.DATA_FORM.DF_SET)
 			return new BasicSet(type, in);
 		else if(form == Entity.DATA_FORM.DF_CHUNK)
 			return new BasicChunkMeta(in);
+		else if (form == Entity.DATA_FORM.DF_TENSOR)
+			return new BasicTensor(type, in);
 		else if(type == Entity.DATA_TYPE.DT_ANY && (form == Entity.DATA_FORM.DF_VECTOR || form == Entity.DATA_FORM.DF_PAIR))
 			return new BasicAnyVector(in);
 		else if(type.getValue() >= Entity.DATA_TYPE.DT_BOOL_ARRAY.getValue() && type.getValue() <= DT_DECIMAL128_ARRAY.getValue())
@@ -1004,6 +1006,10 @@ private static Scalar createScalar(DATA_TYPE dataType, String val, int extraPara
 			}
 			case DT_STRING:
 				return new BasicString(val);
+			case DT_DECIMAL32:
+				return new BasicDecimal32(val, extraParam);
+			case DT_DECIMAL64:
+				return new BasicDecimal64(val, extraParam);
 			case DT_DECIMAL128:
 				return new BasicDecimal128(val, extraParam);
 			default:

src/com/xxdb/data/BasicTensor.java

@@ -0,0 +1,169 @@
+package com.xxdb.data;
+
+import com.xxdb.io.ExtendedDataInput;
+import com.xxdb.io.ExtendedDataOutput;
+import java.io.IOException;
+
+public class BasicTensor extends AbstractTensor {
+
+    private DATA_TYPE dataType;
+    private int tensorType;
+    private int deviceType;
+    private int tensorFlags;
+    private int dimensions;
+
+    /**
+     * shapes: shape[i] represents the size of the i-th dimension.
+     */
+    private long[] shapes;
+
+    /**
+     * strides: strides[i] represents the distance between elements in the i-th dimension.
+     */
+    private long[] strides;
+
+    private long preserveValue;
+
+    private long elemCount;
+
+    private Vector data;
+
+    protected BasicTensor(DATA_TYPE dataType, ExtendedDataInput in) throws IOException {
+        deserialize(dataType, in);
+    }
+
+    protected void deserialize(DATA_TYPE dataType, ExtendedDataInput in) throws IOException {
+        this.dataType = dataType;
+        tensorType = in.readByte();
+        deviceType = in.readByte();
+        tensorFlags = in.readInt();
+        dimensions = in.readInt();
+
+        shapes = new long[dimensions];
+        strides = new long[dimensions];
+
+        for (int d = 0; d < dimensions; d++)
+            shapes[d] = in.readLong();
+
+        for (int d = 0; d < dimensions; d++)
+            strides[d] = in.readLong();
+
+        preserveValue = in.readLong();
+        elemCount = in.readLong();
+
+        if (elemCount > Integer.MAX_VALUE)
+            throw new RuntimeException("tensor element count more than 2,147,483,647(Integer.MAX_VALUE).");
+
+        Vector subVector = BasicEntityFactory.instance().createVectorWithDefaultValue(dataType, (int) elemCount, -1);
+        subVector.deserialize(0, (int) elemCount, in);
+        this.data = subVector;
+    }
+
+    @Override
+    public DATA_CATEGORY getDataCategory() {
+        return getDataCategory(dataType);
+    }
+
+    @Override
+    public DATA_TYPE getDataType() {
+        return dataType;
+    }
+
+    @Override
+    public int rows() {
+        return data.rows();
+    }
+
+    @Override
+    public void write(ExtendedDataOutput output) throws IOException {
+        throw new RuntimeException("BasicTensor not support write method.");
+    }
+
+    public int getDimensions() {
+        return dimensions;
+    }
+
+    public long[] getShapes() {
+        return shapes;
+    }
+
+    public long[] getStrides() {
+        return strides;
+    }
+
+    public long getElemCount() {
+        return elemCount;
+    }
+
+    public Vector getData() {
+        return data;
+    }
+
+    @Override
+    public String getString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("tensor<").append(getDataTypeString());;
+        for (long shape : shapes) {
+            sb.append("[").append(shape).append("]");
+        }
+        sb.append(">(");
+        printTensor(sb, 0, 0, new int[dimensions]);
+        sb.append(")");
+        return sb.toString();
+    }
+
+    private void printTensor(StringBuilder sb, int depth, int index, int[] indices) {
+        if (depth == dimensions) {
+            int flatIndex = getFlatIndex(indices);
+            sb.append(data.get(flatIndex));
+            return;
+        }
+
+        sb.append("[");
+        long size = shapes[depth];
+        for (int i = 0; i < size; i++) {
+            indices[depth] = i;
+            if (depth == dimensions - 1 && size > 11 && i == 11) {
+                sb.append("...");
+                break;
+            } else {
+                if (i > 0) {
+                    sb.append(",");
+                }
+                printTensor(sb, depth + 1, index * (int) size + i, indices);
+            }
+        }
+        sb.append("]");
+    }
+
+    private String getDataTypeString() {
+        switch (dataType) {
+            case DT_BOOL:
+                return "bool";
+            case DT_BYTE:
+                return "char";
+            case DT_SHORT:
+                return "short";
+            case DT_INT:
+                return "int";
+            case DT_LONG:
+                return "long";
+            case DT_FLOAT:
+                return "float";
+            case DT_DOUBLE:
+                return "double";
+            default:
+                throw new IllegalArgumentException("Unsupported data type: " + dataType);
+        }
+    }
+
+    private int getFlatIndex(int[] indices) {
+        int flatIndex = 0;
+        int stride = 1;
+        for (int i = dimensions - 1; i >= 0; i--) {
+            flatIndex += indices[i] * stride;
+            stride *= shapes[i];
+        }
+        return flatIndex;
+    }
+}

src/com/xxdb/data/Entity.java

@@ -64,7 +64,7 @@ public static DATA_TYPE valueOfTypeName(String name){
 	};
 
 	enum DATA_CATEGORY {NOTHING,LOGICAL,INTEGRAL,FLOATING,TEMPORAL,LITERAL,SYSTEM,MIXED,BINARY,ARRAY,DENARY};
-	enum DATA_FORM {DF_SCALAR,DF_VECTOR,DF_PAIR,DF_MATRIX,DF_SET,DF_DICTIONARY,DF_TABLE,DF_CHART,DF_CHUNK,DF_SYSOBJ};
+	enum DATA_FORM {DF_SCALAR,DF_VECTOR,DF_PAIR,DF_MATRIX,DF_SET,DF_DICTIONARY,DF_TABLE,DF_CHART,DF_CHUNK,DF_SYSOBJ,DF_TENSOR};
 	enum PARTITION_TYPE {SEQ, VALUE, RANGE, LIST, COMPO, HASH}
 	enum DURATION {NS, US, MS, SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, YEAR, BDAY, TDAY};
 	DATA_FORM getDataForm();

src/com/xxdb/data/Tensor.java

@@ -0,0 +1,4 @@
+package com.xxdb.data;
+
+public interface Tensor extends Entity {
+}