public String fromMetacatType()

in metacat-connector-postgresql/src/main/java/com/netflix/metacat/connector/postgresql/PostgreSqlTypeConverter.java [183:269]
79 lines of code
30 McCabe index (conditional complexity)

    public String fromMetacatType(@Nonnull @NonNull final Type type) {
        switch (type.getTypeSignature().getBase()) {
            case ARRAY:
                if (!(type instanceof ArrayType)) {
                    throw new IllegalArgumentException("Expected an ARRAY type but was " + type.getClass().getName());
                }
                final ArrayType arrayType = (ArrayType) type;
                final String array;
                final Type elementType;
                // Check for nested arrays
                if (arrayType.getElementType() instanceof ArrayType) {
                    array = MULTI_ARRAY;
                    elementType = ((ArrayType) arrayType.getElementType()).getElementType();
                } else {
                    array = SINGLE_ARRAY;
                    elementType = arrayType.getElementType();
                }

                // Recursively determine the type of the array
                return this.fromMetacatType(elementType) + array;
            case BIGINT:
                return "BIGINT";
            case BOOLEAN:
                return "BOOLEAN";
            case CHAR:
                if (!(type instanceof CharType)) {
                    throw new IllegalArgumentException("Expected CHAR type but was " + type.getClass().getName());
                }
                final CharType charType = (CharType) type;
                return "CHAR(" + charType.getLength() + ")";
            case DATE:
                return "DATE";
            case DECIMAL:
                if (!(type instanceof DecimalType)) {
                    throw new IllegalArgumentException("Expected decimal type but was " + type.getClass().getName());
                }
                final DecimalType decimalType = (DecimalType) type;
                return "NUMERIC(" + decimalType.getPrecision() + ", " + decimalType.getScale() + ")";
            case DOUBLE:
                return "DOUBLE PRECISION";
            case FLOAT:
                return "REAL";
            case INT:
                return "INT";
            case INTERVAL_DAY_TO_SECOND:
                // TODO: It does but not sure how best to represent now
                throw new UnsupportedOperationException("PostgreSQL doesn't support interval types");
            case INTERVAL_YEAR_TO_MONTH:
                // TODO: It does but not sure how best to represent now
                throw new UnsupportedOperationException("PostgreSQL doesn't support interval types");
            case JSON:
                return "JSON";
            case MAP:
                throw new UnsupportedOperationException("PostgreSQL doesn't support map types");
            case ROW:
                // TODO: Well it does but how do we know what the internal type is?
                throw new UnsupportedOperationException("PostgreSQL doesn't support row types");
            case SMALLINT:
                return "SMALLINT";
            case STRING:
                return "TEXT";
            case TIME:
                return "TIME";
            case TIME_WITH_TIME_ZONE:
                return "TIME WITH TIME ZONE";
            case TIMESTAMP:
                return "TIMESTAMP";
            case TIMESTAMP_WITH_TIME_ZONE:
                return "TIMESTAMP WITH TIME ZONE";
            case TINYINT:
                // NOTE: There is no tiny int type in PostgreSQL so using slightly larger SMALLINT
                return "SMALLINT";
            case UNKNOWN:
                throw new IllegalArgumentException("Can't map an unknown type");
            case VARBINARY:
                return "BYTEA";
            case VARCHAR:
                if (!(type instanceof VarcharType)) {
                    throw new IllegalArgumentException("Expected varchar type but was " + type.getClass().getName());
                }
                final VarcharType varcharType = (VarcharType) type;
                // NOTE: PostgreSQL lets you store up to 1GB in a varchar field which is about the same as TEXT
                return "CHARACTER VARYING(" + varcharType.getLength() + ")";
            default:
                throw new IllegalArgumentException("Unknown type " + type.getTypeSignature().getBase());
        }
    }