[opt](maxcompute)Optimize maxcompute performance for select in scenarios with small limits.

Issue Number: None

Related PR: None

Author: hubgeter

fe/be-java-extensions/max-compute-connector/src/main/java/org/apache/doris/maxcompute/MaxComputeJniScanner.java

@@ -56,10 +56,14 @@
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
+import java.time.format.DateTimeParseException;
+import java.util.ArrayList;
 import java.util.Base64;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -634,6 +638,9 @@ public void unpackArray(List<ColumnValue> values) {
             ColumnType childType = columnType.getChildTypes().get(0);
             Object arrayObject = value;
             try {
+                if (arrayObject instanceof String) {
+                    arrayObject = new ComplexValueParser((String) arrayObject).parseArray(childType);
+                }
                 if (arrayObject instanceof java.sql.Array) {
                     arrayObject = ((java.sql.Array) arrayObject).getArray();
                 }
@@ -655,7 +662,12 @@ public void unpackArray(List<ColumnValue> values) {
 
         @Override
         public void unpackMap(List<ColumnValue> keys, List<ColumnValue> values) {
-            Map<?, ?> map = (Map<?, ?>) value;
+            Object mapObject = value;
+            if (mapObject instanceof String) {
+                mapObject = new ComplexValueParser((String) mapObject).parseMap(
+                        columnType.getChildTypes().get(0), columnType.getChildTypes().get(1));
+            }
+            Map<?, ?> map = (Map<?, ?>) mapObject;
             ColumnType keyType = columnType.getChildTypes().get(0);
             ColumnType valueType = columnType.getChildTypes().get(1);
             for (Map.Entry<?, ?> entry : map.entrySet()) {
@@ -668,6 +680,22 @@ public void unpackMap(List<ColumnValue> keys, List<ColumnValue> values) {
         public void unpackStruct(List<Integer> structFieldIndex, List<ColumnValue> values) {
             List<ColumnType> childTypes = columnType.getChildTypes();
             try {
+                if (value instanceof String) {
+                    List<Object> fieldValues = new ComplexValueParser((String) value).parseStruct(columnType);
+                    for (Integer fieldIndex : structFieldIndex) {
+                        values.add(new ResultSetColumnValue(fieldValues.get(fieldIndex),
+                                childTypes.get(fieldIndex), timeZone));
+                    }
+                    return;
+                }
+                if (value instanceof List<?>) {
+                    List<?> fieldValues = (List<?>) value;
+                    for (Integer fieldIndex : structFieldIndex) {
+                        values.add(new ResultSetColumnValue(fieldValues.get(fieldIndex),
+                                childTypes.get(fieldIndex), timeZone));
+                    }
+                    return;
+                }
                 if (value instanceof Struct) {
                     Struct struct = (Struct) value;
                     for (Integer fieldIndex : structFieldIndex) {
@@ -704,7 +732,192 @@ private Instant asInstant() {
             if (value instanceof java.util.Date) {
                 return ((java.util.Date) value).toInstant();
             }
+            if (value instanceof CharSequence) {
+                String text = normalizeTemporalText(value.toString());
+                try {
+                    return OffsetDateTime.parse(text).toInstant();
+                } catch (DateTimeParseException e) {
+                    // fall through
+                }
+                try {
+                    return ZonedDateTime.parse(text).toInstant();
+                } catch (DateTimeParseException e) {
+                    // fall through
+                }
+                try {
+                    return Instant.parse(text);
+                } catch (DateTimeParseException e) {
+                    // fall through
+                }
+                try {
+                    return LocalDateTime.parse(text).atZone(timeZone).toInstant();
+                } catch (DateTimeParseException e) {
+                    // fall through
+                }
+                try {
+                    return LocalDate.parse(text).atStartOfDay(timeZone).toInstant();
+                } catch (DateTimeParseException e) {
+                    throw new IllegalStateException("Unsupported temporal string value: " + text, e);
+                }
+            }
             throw new IllegalStateException("Unsupported temporal value type: " + value.getClass().getName());
         }
+
+        private String normalizeTemporalText(String text) {
+            String normalized = text.trim();
+            if (normalized.length() > 10 && normalized.charAt(10) == ' ') {
+                return normalized.substring(0, 10) + "T" + normalized.substring(11);
+            }
+            return normalized;
+        }
+    }
+
+    private static final class ComplexValueParser {
+        private final String text;
+        private int position;
+
+        private ComplexValueParser(String text) {
+            this.text = text == null ? "" : text;
+        }
+
+        private List<Object> parseArray(ColumnType childType) {
+            skipLeadingSpaces();
+            expect('[');
+            List<Object> values = new ArrayList<>();
+            skipLeadingSpaces();
+            if (consumeIf(']')) {
+                return values;
+            }
+            while (true) {
+                values.add(parseValue(childType, ',', ']'));
+                skipLeadingSpaces();
+                if (consumeIf(',')) {
+                    skipLeadingSpaces();
+                    continue;
+                }
+                expect(']');
+                return values;
+            }
+        }
+
+        private Map<Object, Object> parseMap(ColumnType keyType, ColumnType valueType) {
+            skipLeadingSpaces();
+            expect('{');
+            Map<Object, Object> values = new LinkedHashMap<>();
+            skipLeadingSpaces();
+            if (consumeIf('}')) {
+                return values;
+            }
+            while (true) {
+                Object key = parseValue(keyType, ':');
+                expect(':');
+                Object value = parseValue(valueType, ',', '}');
+                values.put(key, value);
+                skipLeadingSpaces();
+                if (consumeIf(',')) {
+                    skipLeadingSpaces();
+                    continue;
+                }
+                expect('}');
+                return values;
+            }
+        }
+
+        private List<Object> parseStruct(ColumnType structType) {
+            skipLeadingSpaces();
+            expect('{');
+            List<Object> values = new ArrayList<>();
+            for (int i = 0; i < structType.getChildTypes().size(); i++) {
+                values.add(null);
+            }
+            skipLeadingSpaces();
+            if (consumeIf('}')) {
+                return values;
+            }
+            while (true) {
+                String fieldName = asString(parseScalar(':'));
+                int fieldIndex = structType.getChildNames().indexOf(fieldName);
+                if (fieldIndex < 0) {
+                    throw new IllegalStateException("Unknown struct field '" + fieldName + "' in value: " + text);
+                }
+                expect(':');
+                values.set(fieldIndex, parseValue(structType.getChildTypes().get(fieldIndex), ',', '}'));
+                skipLeadingSpaces();
+                if (consumeIf(',')) {
+                    skipLeadingSpaces();
+                    continue;
+                }
+                expect('}');
+                return values;
+            }
+        }
+
+        private Object parseValue(ColumnType type, char... terminators) {
+            skipLeadingSpaces();
+            if (isNullToken(terminators)) {
+                position += 4;
+                return null;
+            }
+            if (type.isArray()) {
+                return parseArray(type.getChildTypes().get(0));
+            }
+            if (type.isMap()) {
+                return parseMap(type.getChildTypes().get(0), type.getChildTypes().get(1));
+            }
+            if (type.isStruct()) {
+                return parseStruct(type);
+            }
+            return parseScalar(terminators);
+        }
+
+        private Object parseScalar(char... terminators) {
+            int start = position;
+            while (position < text.length() && !isTerminator(text.charAt(position), terminators)) {
+                position++;
+            }
+            return text.substring(start, position);
+        }
+
+        private boolean isNullToken(char... terminators) {
+            if (!text.regionMatches(true, position, "NULL", 0, 4)) {
+                return false;
+            }
+            int end = position + 4;
+            return end >= text.length() || isTerminator(text.charAt(end), terminators);
+        }
+
+        private boolean isTerminator(char current, char... terminators) {
+            for (char terminator : terminators) {
+                if (current == terminator) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private void skipLeadingSpaces() {
+            while (position < text.length() && text.charAt(position) == ' ') {
+                position++;
+            }
+        }
+
+        private boolean consumeIf(char expected) {
+            if (position < text.length() && text.charAt(position) == expected) {
+                position++;
+                return true;
+            }
+            return false;
+        }
+
+        private void expect(char expected) {
+            if (!consumeIf(expected)) {
+                throw new IllegalStateException("Expected '" + expected + "' at position "
+                        + position + " in value: " + text);
+            }
+        }
+
+        private String asString(Object value) {
+            return value == null ? null : String.valueOf(value);
+        }
     }
 }

fe/be-java-extensions/max-compute-connector/src/test/java/org/apache/doris/maxcompute/MaxComputeJniScannerTest.java

@@ -0,0 +1,124 @@
+// 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.doris.maxcompute;
+
+import org.apache.doris.common.jni.vec.ColumnType;
+import org.apache.doris.common.jni.vec.ColumnValue;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.lang.reflect.Constructor;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class MaxComputeJniScannerTest {
+    private static final ZoneId SHANGHAI = ZoneId.of("Asia/Shanghai");
+
+    @Test
+    public void testResultSetColumnValueParsesStringDateTime() throws Exception {
+        ColumnValue value = newResultSetColumnValue("2026-04-12 15:16:17.123", "datetimev2(3)");
+
+        Assert.assertEquals(LocalDateTime.of(2026, 4, 12, 15, 16, 17, 123_000_000), value.getDateTime());
+    }
+
+    @Test
+    public void testResultSetColumnValueParsesOffsetDateTimeString() throws Exception {
+        ColumnValue value = newResultSetColumnValue("2026-04-12T15:16:17Z", "datetimev2(3)");
+
+        Assert.assertEquals(LocalDateTime.of(2026, 4, 12, 23, 16, 17), value.getDateTime());
+    }
+
+    @Test
+    public void testResultSetColumnValueParsesStringDate() throws Exception {
+        ColumnValue value = newResultSetColumnValue("2026-04-12", "datev2");
+
+        Assert.assertEquals(LocalDate.of(2026, 4, 12), value.getDate());
+    }
+
+    @Test
+    public void testResultSetColumnValueUnpacksArrayString() throws Exception {
+        ColumnValue value = newResultSetColumnValue("[value1, value2, NULL]", "array<string>");
+        List<ColumnValue> elements = new ArrayList<>();
+
+        value.unpackArray(elements);
+
+        Assert.assertEquals(3, elements.size());
+        Assert.assertEquals("value1", elements.get(0).getString());
+        Assert.assertEquals("value2", elements.get(1).getString());
+        Assert.assertTrue(elements.get(2).isNull());
+    }
+
+    @Test
+    public void testResultSetColumnValueUnpacksMapString() throws Exception {
+        ColumnValue value = newResultSetColumnValue("{key1:value1, key2:NULL}", "map<string,string>");
+        List<ColumnValue> keys = new ArrayList<>();
+        List<ColumnValue> values = new ArrayList<>();
+
+        value.unpackMap(keys, values);
+
+        Assert.assertEquals(2, keys.size());
+        Assert.assertEquals("key1", keys.get(0).getString());
+        Assert.assertEquals("value1", values.get(0).getString());
+        Assert.assertEquals("key2", keys.get(1).getString());
+        Assert.assertTrue(values.get(1).isNull());
+    }
+
+    @Test
+    public void testResultSetColumnValueUnpacksStructString() throws Exception {
+        ColumnValue value = newResultSetColumnValue("{field1:abc, field2:123}", "struct<field1:string,field2:int>");
+        List<ColumnValue> fields = new ArrayList<>();
+
+        value.unpackStruct(Arrays.asList(0, 1), fields);
+
+        Assert.assertEquals(2, fields.size());
+        Assert.assertEquals("abc", fields.get(0).getString());
+        Assert.assertEquals(123, fields.get(1).getInt());
+    }
+
+    @Test
+    public void testResultSetColumnValueUnpacksNestedComplexString() throws Exception {
+        ColumnValue value = newResultSetColumnValue("{key:[{s_int:-123}]}", "map<string,array<struct<s_int:int>>>");
+        List<ColumnValue> keys = new ArrayList<>();
+        List<ColumnValue> values = new ArrayList<>();
+
+        value.unpackMap(keys, values);
+
+        Assert.assertEquals(1, keys.size());
+        Assert.assertEquals("key", keys.get(0).getString());
+
+        List<ColumnValue> arrayElements = new ArrayList<>();
+        values.get(0).unpackArray(arrayElements);
+        Assert.assertEquals(1, arrayElements.size());
+
+        List<ColumnValue> structFields = new ArrayList<>();
+        arrayElements.get(0).unpackStruct(Arrays.asList(0), structFields);
+        Assert.assertEquals(-123, structFields.get(0).getInt());
+    }
+
+    private ColumnValue newResultSetColumnValue(Object value, String type) throws Exception {
+        Class<?> clazz = Class.forName("org.apache.doris.maxcompute.MaxComputeJniScanner$ResultSetColumnValue");
+        Constructor<?> constructor = clazz.getDeclaredConstructor(Object.class, ColumnType.class, ZoneId.class);
+        constructor.setAccessible(true);
+        return (ColumnValue) constructor.newInstance(value, ColumnType.parseType("c1", type), SHANGHAI);
+    }
+}