Examples with DataType org.h2.value.DataType used on opensource projects

Example 31 with DataType

use of org.h2.value.DataType in project h2database by h2database.

the class CreateUserDataType method update.

@Override
public int update() {
    session.getUser().checkAdmin();
    session.commit(true);
    Database db = session.getDatabase();
    session.getUser().checkAdmin();
    if (db.findUserDataType(typeName) != null) {
        if (ifNotExists) {
            return 0;
        }
        throw DbException.get(ErrorCode.USER_DATA_TYPE_ALREADY_EXISTS_1, typeName);
    }
    DataType builtIn = DataType.getTypeByName(typeName, session.getDatabase().getMode());
    if (builtIn != null) {
        if (!builtIn.hidden) {
            throw DbException.get(ErrorCode.USER_DATA_TYPE_ALREADY_EXISTS_1, typeName);
        }
        Table table = session.getDatabase().getFirstUserTable();
        if (table != null) {
            throw DbException.get(ErrorCode.USER_DATA_TYPE_ALREADY_EXISTS_1, typeName + " (" + table.getSQL() + ")");
        }
    }
    int id = getObjectId();
    UserDataType type = new UserDataType(db, id, typeName);
    type.setColumn(column);
    db.addDatabaseObject(session, type);
    return 0;
}

Example 32 with DataType

use of org.h2.value.DataType in project h2database by h2database.

the class TableFunction method getSimpleResultSet.

private static SimpleResultSet getSimpleResultSet(LocalResult rs, int maxrows) {
    int columnCount = rs.getVisibleColumnCount();
    SimpleResultSet simple = new SimpleResultSet();
    simple.setAutoClose(false);
    for (int i = 0; i < columnCount; i++) {
        String name = rs.getColumnName(i);
        DataType dataType = DataType.getDataType(rs.getColumnType(i));
        int sqlType = dataType.sqlType;
        String sqlTypeName = dataType.name;
        int precision = MathUtils.convertLongToInt(rs.getColumnPrecision(i));
        int scale = rs.getColumnScale(i);
        simple.addColumn(name, sqlType, sqlTypeName, precision, scale);
    }
    rs.reset();
    for (int i = 0; i < maxrows && rs.next(); i++) {
        Object[] list = new Object[columnCount];
        for (int j = 0; j < columnCount; j++) {
            list[j] = rs.currentRow()[j].getObject();
        }
        simple.addRow(list);
    }
    return simple;
}

Example 33 with DataType

use of org.h2.value.DataType in project h2database by h2database.

the class ConditionInSelect method getValue.

@Override
public Value getValue(Session session) {
    query.setSession(session);
    if (!query.hasOrder()) {
        query.setDistinct(true);
    }
    ResultInterface rows = query.query(0);
    Value l = left.getValue(session);
    if (!rows.hasNext()) {
        return ValueBoolean.get(all);
    } else if (l == ValueNull.INSTANCE) {
        return l;
    }
    if (!session.getDatabase().getSettings().optimizeInSelect) {
        return getValueSlow(rows, l);
    }
    if (all || (compareType != Comparison.EQUAL && compareType != Comparison.EQUAL_NULL_SAFE)) {
        return getValueSlow(rows, l);
    }
    int dataType = rows.getColumnType(0);
    if (dataType == Value.NULL) {
        return ValueBoolean.FALSE;
    }
    l = l.convertTo(dataType);
    if (rows.containsDistinct(new Value[] { l })) {
        return ValueBoolean.TRUE;
    }
    if (rows.containsDistinct(new Value[] { ValueNull.INSTANCE })) {
        return ValueNull.INSTANCE;
    }
    return ValueBoolean.FALSE;
}

Example 34 with DataType

use of org.h2.value.DataType in project h2database by h2database.

the class Function method optimize.

@Override
public Expression optimize(Session session) {
    boolean allConst = info.deterministic;
    for (int i = 0; i < args.length; i++) {
        Expression e = args[i];
        if (e == null) {
            continue;
        }
        e = e.optimize(session);
        args[i] = e;
        if (!e.isConstant()) {
            allConst = false;
        }
    }
    int t, s, d;
    long p;
    Expression p0 = args.length < 1 ? null : args[0];
    switch(info.type) {
        case IFNULL:
        case NULLIF:
        case COALESCE:
        case LEAST:
        case GREATEST:
            {
                t = Value.UNKNOWN;
                s = 0;
                p = 0;
                d = 0;
                for (Expression e : args) {
                    if (e != ValueExpression.getNull()) {
                        int type = e.getType();
                        if (type != Value.UNKNOWN && type != Value.NULL) {
                            t = Value.getHigherOrder(t, type);
                            s = Math.max(s, e.getScale());
                            p = Math.max(p, e.getPrecision());
                            d = Math.max(d, e.getDisplaySize());
                        }
                    }
                }
                if (t == Value.UNKNOWN) {
                    t = Value.STRING;
                    s = 0;
                    p = Integer.MAX_VALUE;
                    d = Integer.MAX_VALUE;
                }
                break;
            }
        case CASE:
        case DECODE:
            {
                t = Value.UNKNOWN;
                s = 0;
                p = 0;
                d = 0;
                // (expr, when, then, when, then, else)
                for (int i = 2, len = args.length; i < len; i += 2) {
                    Expression then = args[i];
                    if (then != ValueExpression.getNull()) {
                        int type = then.getType();
                        if (type != Value.UNKNOWN && type != Value.NULL) {
                            t = Value.getHigherOrder(t, type);
                            s = Math.max(s, then.getScale());
                            p = Math.max(p, then.getPrecision());
                            d = Math.max(d, then.getDisplaySize());
                        }
                    }
                }
                if (args.length % 2 == 0) {
                    Expression elsePart = args[args.length - 1];
                    if (elsePart != ValueExpression.getNull()) {
                        int type = elsePart.getType();
                        if (type != Value.UNKNOWN && type != Value.NULL) {
                            t = Value.getHigherOrder(t, type);
                            s = Math.max(s, elsePart.getScale());
                            p = Math.max(p, elsePart.getPrecision());
                            d = Math.max(d, elsePart.getDisplaySize());
                        }
                    }
                }
                if (t == Value.UNKNOWN) {
                    t = Value.STRING;
                    s = 0;
                    p = Integer.MAX_VALUE;
                    d = Integer.MAX_VALUE;
                }
                break;
            }
        case CASEWHEN:
            t = Value.getHigherOrder(args[1].getType(), args[2].getType());
            p = Math.max(args[1].getPrecision(), args[2].getPrecision());
            d = Math.max(args[1].getDisplaySize(), args[2].getDisplaySize());
            s = Math.max(args[1].getScale(), args[2].getScale());
            break;
        case NVL2:
            switch(args[1].getType()) {
                case Value.STRING:
                case Value.CLOB:
                case Value.STRING_FIXED:
                case Value.STRING_IGNORECASE:
                    t = args[1].getType();
                    break;
                default:
                    t = Value.getHigherOrder(args[1].getType(), args[2].getType());
                    break;
            }
            p = Math.max(args[1].getPrecision(), args[2].getPrecision());
            d = Math.max(args[1].getDisplaySize(), args[2].getDisplaySize());
            s = Math.max(args[1].getScale(), args[2].getScale());
            break;
        case CAST:
        case CONVERT:
        case TRUNCATE_VALUE:
            // data type, precision and scale is already set
            t = dataType;
            p = precision;
            s = scale;
            d = displaySize;
            break;
        case TRUNCATE:
            t = p0.getType();
            s = p0.getScale();
            p = p0.getPrecision();
            d = p0.getDisplaySize();
            if (t == Value.NULL) {
                t = Value.INT;
                p = ValueInt.PRECISION;
                d = ValueInt.DISPLAY_SIZE;
                s = 0;
            } else if (t == Value.TIMESTAMP) {
                t = Value.DATE;
                p = ValueDate.PRECISION;
                s = 0;
                d = ValueDate.PRECISION;
            }
            break;
        case ABS:
        case FLOOR:
        case ROUND:
            t = p0.getType();
            s = p0.getScale();
            p = p0.getPrecision();
            d = p0.getDisplaySize();
            if (t == Value.NULL) {
                t = Value.INT;
                p = ValueInt.PRECISION;
                d = ValueInt.DISPLAY_SIZE;
                s = 0;
            }
            break;
        case SET:
            {
                Expression p1 = args[1];
                t = p1.getType();
                p = p1.getPrecision();
                s = p1.getScale();
                d = p1.getDisplaySize();
                if (!(p0 instanceof Variable)) {
                    throw DbException.get(ErrorCode.CAN_ONLY_ASSIGN_TO_VARIABLE_1, p0.getSQL());
                }
                break;
            }
        case FILE_READ:
            {
                if (args.length == 1) {
                    t = Value.BLOB;
                } else {
                    t = Value.CLOB;
                }
                p = Integer.MAX_VALUE;
                s = 0;
                d = Integer.MAX_VALUE;
                break;
            }
        case SUBSTRING:
        case SUBSTR:
            {
                t = info.returnDataType;
                p = args[0].getPrecision();
                s = 0;
                if (args[1].isConstant()) {
                    // if only two arguments are used,
                    // subtract offset from first argument length
                    p -= args[1].getValue(session).getLong() - 1;
                }
                if (args.length == 3 && args[2].isConstant()) {
                    // if the third argument is constant it is at most this value
                    p = Math.min(p, args[2].getValue(session).getLong());
                }
                p = Math.max(0, p);
                d = MathUtils.convertLongToInt(p);
                break;
            }
        default:
            t = info.returnDataType;
            DataType type = DataType.getDataType(t);
            p = PRECISION_UNKNOWN;
            d = 0;
            s = type.defaultScale;
    }
    dataType = t;
    precision = p;
    scale = s;
    displaySize = d;
    if (allConst) {
        Value v = getValue(session);
        if (v == ValueNull.INSTANCE) {
            if (info.type == CAST || info.type == CONVERT) {
                return this;
            }
        }
        return ValueExpression.get(v);
    }
    return this;
}

Example 35 with DataType

use of org.h2.value.DataType in project h2database by h2database.

the class JavaAggregate method getValue.

@Override
public Value getValue(Session session) {
    HashMap<Expression, Object> group = select.getCurrentGroup();
    if (group == null) {
        throw DbException.get(ErrorCode.INVALID_USE_OF_AGGREGATE_FUNCTION_1, getSQL());
    }
    try {
        Aggregate agg = (Aggregate) group.get(this);
        if (agg == null) {
            agg = getInstance();
        }
        Object obj = agg.getResult();
        if (obj == null) {
            return ValueNull.INSTANCE;
        }
        return DataType.convertToValue(session, obj, dataType);
    } catch (SQLException e) {
        throw DbException.convert(e);
    }
}