public String convertToConnectFieldSchema()

in connectors/rocketmq-connect-jdbc/src/main/java/org/apache/rocketmq/connect/jdbc/converter/DefaultColumnConverter.java [289:427]
124 lines of code
51 McCabe index (conditional complexity)

    public String convertToConnectFieldSchema(ColumnDefinition columnDefinition, SchemaBuilder builder) {
        int precision = columnDefinition.precision();
        int scale = columnDefinition.scale();
        int sqlType = columnDefinition.type();
        boolean optional = columnDefinition.isOptional();
        String fieldName = fieldNameFor(columnDefinition);
        switch (sqlType) {
            case Types.NULL:
                log.debug("JDBC type 'NULL' not currently supported for column '{}'", fieldName);
                return null;

            case Types.BOOLEAN:
                builder.field(fieldName, SchemaBuilder.bool().build());
                break;

            case Types.BIT:
                builder.field(fieldName, SchemaBuilder.int8().build());
                break;

            case Types.TINYINT:
                if (columnDefinition.isSignedNumber()) {
                    builder.field(fieldName, SchemaBuilder.int8().build());
                } else {
                    builder.field(fieldName, SchemaBuilder.int32().build());
                }
                break;

            case Types.SMALLINT:
                builder.field(fieldName, SchemaBuilder.int32().build());
                break;

            case Types.INTEGER:
                if (columnDefinition.isSignedNumber()) {
                    builder.field(fieldName, SchemaBuilder.int32().build());
                } else {
                    builder.field(fieldName, SchemaBuilder.int64().build());
                }
                break;

            case Types.BIGINT:
                builder.field(fieldName, SchemaBuilder.int64().build());
                break;

            case Types.REAL:
                builder.field(fieldName, SchemaBuilder.float32().build());
                break;

            case Types.FLOAT:
            case Types.DOUBLE:
                builder.field(fieldName, SchemaBuilder.float64().build());
                break;
            case Types.DECIMAL:
                scale = decimalScale(columnDefinition);
                SchemaBuilder fieldBuilder = Decimal.builder(scale);
                if (optional) {
                    fieldBuilder.optional();
                }
                builder.field(fieldName, fieldBuilder.build());
                break;

            case Types.NUMERIC:
                if (numericMapping == NumericMapping.PRECISION_ONLY) {
                    log.debug("NUMERIC with precision: '{}' and scale: '{}'", precision, scale);
                    if (scale == 0 && precision <= MAX_INTEGER_TYPE_PRECISION) { // integer
                        builder.field(fieldName, integerSchema(optional, precision));
                        break;
                    }
                } else if (numericMapping == NumericMapping.BEST_FIT) {
                    log.debug("NUMERIC with precision: '{}' and scale: '{}'", precision, scale);
                    if (precision <= MAX_INTEGER_TYPE_PRECISION) {
                        if (scale < 1 && scale >= NUMERIC_TYPE_SCALE_LOW) {
                            builder.field(fieldName, integerSchema(optional, precision));
                            break;
                        } else if (scale > 0) {
                            builder.field(fieldName, SchemaBuilder.float64().build());
                            break;
                        }
                    }
                } else if (numericMapping == NumericMapping.BEST_FIT_EAGER_DOUBLE) {
                    log.debug("NUMERIC with precision: '{}' and scale: '{}'", precision, scale);
                    if (scale < 1 && scale >= NUMERIC_TYPE_SCALE_LOW) { // integer
                        if (precision <= MAX_INTEGER_TYPE_PRECISION) { // fits in primitive data types.
                            builder.field(fieldName, integerSchema(optional, precision));
                            break;
                        }
                    } else if (scale > 0) {
                        builder.field(fieldName, SchemaBuilder.float64().build());
                        break;
                    }
                }

            case Types.CHAR:
            case Types.VARCHAR:
            case Types.LONGVARCHAR:
            case Types.NCHAR:
            case Types.NVARCHAR:
            case Types.LONGNVARCHAR:
            case Types.CLOB:
            case Types.NCLOB:
            case Types.DATALINK:
            case Types.SQLXML:
                builder.field(fieldName, SchemaBuilder.string().build());
                break;

            case Types.BINARY:
            case Types.BLOB:
            case Types.VARBINARY:
            case Types.LONGVARBINARY:
                builder.field(fieldName, SchemaBuilder.bytes().build());
                break;

            case Types.DATE:
                SchemaBuilder dateSchemaBuilder = Date.builder();
                builder.field(fieldName, dateSchemaBuilder.build());
                break;

            case Types.TIME:
                SchemaBuilder timeSchemaBuilder = Time.builder();
                builder.field(fieldName, timeSchemaBuilder.build());
                break;

            case Types.TIMESTAMP:
                SchemaBuilder tsSchemaBuilder = io.openmessaging.connector.api.data.logical.Timestamp.builder();
                builder.field(fieldName, tsSchemaBuilder.build());
                break;

            case Types.ARRAY:
            case Types.JAVA_OBJECT:
            case Types.OTHER:
            case Types.DISTINCT:
            case Types.STRUCT:
            case Types.REF:
            case Types.ROWID:
            default:
                log.warn("JDBC type {} ({}) not supported", sqlType, columnDefinition.typeName());
                return null;
        }
        return fieldName;
    }