@Deprecated
    private static String compatibleTypeDeclare(String declare) {
        switch (declare.trim().toUpperCase()) {
            case "LONG":
                return "BIGINT";
            case "SHORT":
                return "SMALLINT";
            case "BYTE":
                return "TINYINT";
            default:
                return declare;
        }
    }
@Test
    public void testCompatibleTypeDeclare() {
        SeaTunnelDataType<?> longType =
                SeaTunnelDataTypeConvertorUtil.deserializeSeaTunnelDataType("c_long", "long");
        Assertions.assertEquals(BasicType.LONG_TYPE, longType);

        SeaTunnelDataType<?> shortType =
                SeaTunnelDataTypeConvertorUtil.deserializeSeaTunnelDataType("c_short", "short");
        Assertions.assertEquals(BasicType.SHORT_TYPE, shortType);

        SeaTunnelDataType<?> byteType =
                SeaTunnelDataTypeConvertorUtil.deserializeSeaTunnelDataType("c_byte", "byte");
        Assertions.assertEquals(BasicType.BYTE_TYPE, byteType);

        ArrayType<?, ?> longArrayType =
                (ArrayType<?, ?>)
                        SeaTunnelDataTypeConvertorUtil.deserializeSeaTunnelDataType(
                                "c_long_array", "array<long>");
        Assertions.assertEquals(ArrayType.LONG_ARRAY_TYPE, longArrayType);

        ArrayType<?, ?> shortArrayType =
                (ArrayType<?, ?>)
                        SeaTunnelDataTypeConvertorUtil.deserializeSeaTunnelDataType(
                                "c_short_array", "array<short>");
        Assertions.assertEquals(ArrayType.SHORT_ARRAY_TYPE, shortArrayType);

        ArrayType<?, ?> byteArrayType =
                (ArrayType<?, ?>)
                        SeaTunnelDataTypeConvertorUtil.deserializeSeaTunnelDataType(
                                "c_byte_array", "array<byte>");
        Assertions.assertEquals(ArrayType.BYTE_ARRAY_TYPE, byteArrayType);

        MapType<?, ?> longMapType =
                (MapType<?, ?>)
                        SeaTunnelDataTypeConvertorUtil.deserializeSeaTunnelDataType(
                                "c_long_map", "map<long, long>");
        Assertions.assertEquals(BasicType.LONG_TYPE, longMapType.getKeyType());
        Assertions.assertEquals(BasicType.LONG_TYPE, longMapType.getValueType());

        MapType<?, ?> shortMapType =
                (MapType<?, ?>)
                        SeaTunnelDataTypeConvertorUtil.deserializeSeaTunnelDataType(
                                "c_short_map", "map<short, short>");
        Assertions.assertEquals(BasicType.SHORT_TYPE, shortMapType.getKeyType());
        Assertions.assertEquals(BasicType.SHORT_TYPE, shortMapType.getValueType());

        MapType<?, ?> byteMapType =
                (MapType<?, ?>)
                        SeaTunnelDataTypeConvertorUtil.deserializeSeaTunnelDataType(
                                "c_byte_map", "map<byte, byte>");
        Assertions.assertEquals(BasicType.BYTE_TYPE, byteMapType.getKeyType());
        Assertions.assertEquals(BasicType.BYTE_TYPE, byteMapType.getValueType());

        SeaTunnelRowType longRow =
                (SeaTunnelRowType)
                        SeaTunnelDataTypeConvertorUtil.deserializeSeaTunnelDataType(
                                "c_long_row", "{c = long}");
        Assertions.assertEquals(BasicType.LONG_TYPE, longRow.getFieldType(0));

        SeaTunnelRowType shortRow =
                (SeaTunnelRowType)
                        SeaTunnelDataTypeConvertorUtil.deserializeSeaTunnelDataType(
                                "c_short_row", "{c = short}");
        Assertions.assertEquals(BasicType.SHORT_TYPE, shortRow.getFieldType(0));

        SeaTunnelRowType byteRow =
                (SeaTunnelRowType)
                        SeaTunnelDataTypeConvertorUtil.deserializeSeaTunnelDataType(
                                "c_byte_row", "{c = byte}");
        Assertions.assertEquals(BasicType.BYTE_TYPE, byteRow.getFieldType(0));
    }