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

Example 11 with ValueArray

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

the class LocalResult method addRow.

/**
 * Add a row to this object.
 *
 * @param values the row to add
 */
@Override
public void addRow(Value[] values) {
    cloneLobs(values);
    if (distinct) {
        if (distinctRows != null) {
            ValueArray array = getArrayOfVisible(values);
            distinctRows.put(array, values);
            rowCount = distinctRows.size();
            if (rowCount > maxMemoryRows) {
                external = new ResultTempTable(session, expressions, true, sort);
                rowCount = external.addRows(distinctRows.values());
                distinctRows = null;
            }
        } else {
            rowCount = external.addRow(values);
        }
        return;
    }
    rows.add(values);
    rowCount++;
    if (rows.size() > maxMemoryRows) {
        if (external == null) {
            external = new ResultTempTable(session, expressions, false, sort);
        }
        addRowsToDisk();
    }
}

Example 12 with ValueArray

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

the class LocalResult method containsDistinct.

/**
 * Check if this result set contains the given row.
 *
 * @param values the row
 * @return true if the row exists
 */
@Override
public boolean containsDistinct(Value[] values) {
    if (external != null) {
        return external.contains(values);
    }
    if (distinctRows == null) {
        distinctRows = ValueHashMap.newInstance();
        for (Value[] row : rows) {
            ValueArray array = getArrayOfVisible(row);
            distinctRows.put(array, array.getList());
        }
    }
    ValueArray array = ValueArray.get(values);
    return distinctRows.get(array) != null;
}

Example 13 with ValueArray

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

the class Select method queryGroup.

private void queryGroup(int columnCount, LocalResult result) {
    ValueHashMap<HashMap<Expression, Object>> groups = ValueHashMap.newInstance();
    int rowNumber = 0;
    setCurrentRowNumber(0);
    currentGroup = null;
    ValueArray defaultGroup = ValueArray.get(new Value[0]);
    int sampleSize = getSampleSizeValue(session);
    while (topTableFilter.next()) {
        setCurrentRowNumber(rowNumber + 1);
        if (isConditionMet()) {
            Value key;
            rowNumber++;
            if (groupIndex == null) {
                key = defaultGroup;
            } else {
                Value[] keyValues = new Value[groupIndex.length];
                // update group
                for (int i = 0; i < groupIndex.length; i++) {
                    int idx = groupIndex[i];
                    Expression expr = expressions.get(idx);
                    keyValues[i] = expr.getValue(session);
                }
                key = ValueArray.get(keyValues);
            }
            HashMap<Expression, Object> values = groups.get(key);
            if (values == null) {
                values = new HashMap<>();
                groups.put(key, values);
            }
            currentGroup = values;
            currentGroupRowId++;
            for (int i = 0; i < columnCount; i++) {
                if (groupByExpression == null || !groupByExpression[i]) {
                    Expression expr = expressions.get(i);
                    expr.updateAggregate(session);
                }
            }
            if (sampleSize > 0 && rowNumber >= sampleSize) {
                break;
            }
        }
    }
    if (groupIndex == null && groups.size() == 0) {
        groups.put(defaultGroup, new HashMap<Expression, Object>());
    }
    ArrayList<Value> keys = groups.keys();
    for (Value v : keys) {
        ValueArray key = (ValueArray) v;
        currentGroup = groups.get(key);
        Value[] keyValues = key.getList();
        Value[] row = new Value[columnCount];
        for (int j = 0; groupIndex != null && j < groupIndex.length; j++) {
            row[groupIndex[j]] = keyValues[j];
        }
        for (int j = 0; j < columnCount; j++) {
            if (groupByExpression != null && groupByExpression[j]) {
                continue;
            }
            Expression expr = expressions.get(j);
            row[j] = expr.getValue(session);
        }
        if (isHavingNullOrFalse(row)) {
            continue;
        }
        row = keepOnlyDistinct(row, columnCount);
        result.addRow(row);
    }
}

Example 14 with ValueArray

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

the class Aggregate method sortWithOrderBy.

private void sortWithOrderBy(Value[] array) {
    final SortOrder sortOrder = orderBySort;
    if (sortOrder != null) {
        Arrays.sort(array, new Comparator<Value>() {

            @Override
            public int compare(Value v1, Value v2) {
                return sortOrder.compare(((ValueArray) v1).getList(), ((ValueArray) v2).getList());
            }
        });
    } else {
        final Database database = select.getSession().getDatabase();
        Arrays.sort(array, new Comparator<Value>() {

            @Override
            public int compare(Value v1, Value v2) {
                return database.compare(v1, v2);
            }
        });
    }
}

Example 15 with ValueArray

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

the class Data method writeValue.

/**
 * Append a value.
 *
 * @param v the value
 */
public void writeValue(Value v) {
    int start = pos;
    if (v == ValueNull.INSTANCE) {
        data[pos++] = 0;
        return;
    }
    int type = v.getType();
    switch(type) {
        case Value.BOOLEAN:
            writeByte((byte) (v.getBoolean() ? BOOLEAN_TRUE : BOOLEAN_FALSE));
            break;
        case Value.BYTE:
            writeByte((byte) type);
            writeByte(v.getByte());
            break;
        case Value.SHORT:
            writeByte((byte) type);
            writeShortInt(v.getShort());
            break;
        case Value.ENUM:
        case Value.INT:
            {
                int x = v.getInt();
                if (x < 0) {
                    writeByte((byte) INT_NEG);
                    writeVarInt(-x);
                } else if (x < 16) {
                    writeByte((byte) (INT_0_15 + x));
                } else {
                    writeByte((byte) type);
                    writeVarInt(x);
                }
                break;
            }
        case Value.LONG:
            {
                long x = v.getLong();
                if (x < 0) {
                    writeByte((byte) LONG_NEG);
                    writeVarLong(-x);
                } else if (x < 8) {
                    writeByte((byte) (LONG_0_7 + x));
                } else {
                    writeByte((byte) type);
                    writeVarLong(x);
                }
                break;
            }
        case Value.DECIMAL:
            {
                BigDecimal x = v.getBigDecimal();
                if (BigDecimal.ZERO.equals(x)) {
                    writeByte((byte) DECIMAL_0_1);
                } else if (BigDecimal.ONE.equals(x)) {
                    writeByte((byte) (DECIMAL_0_1 + 1));
                } else {
                    int scale = x.scale();
                    BigInteger b = x.unscaledValue();
                    int bits = b.bitLength();
                    if (bits <= 63) {
                        if (scale == 0) {
                            writeByte((byte) DECIMAL_SMALL_0);
                            writeVarLong(b.longValue());
                        } else {
                            writeByte((byte) DECIMAL_SMALL);
                            writeVarInt(scale);
                            writeVarLong(b.longValue());
                        }
                    } else {
                        writeByte((byte) type);
                        writeVarInt(scale);
                        byte[] bytes = b.toByteArray();
                        writeVarInt(bytes.length);
                        write(bytes, 0, bytes.length);
                    }
                }
                break;
            }
        case Value.TIME:
            if (STORE_LOCAL_TIME) {
                writeByte((byte) LOCAL_TIME);
                ValueTime t = (ValueTime) v;
                long nanos = t.getNanos();
                long millis = nanos / 1_000_000;
                nanos -= millis * 1_000_000;
                writeVarLong(millis);
                writeVarLong(nanos);
            } else {
                writeByte((byte) type);
                writeVarLong(DateTimeUtils.getTimeLocalWithoutDst(v.getTime()));
            }
            break;
        case Value.DATE:
            {
                if (STORE_LOCAL_TIME) {
                    writeByte((byte) LOCAL_DATE);
                    long x = ((ValueDate) v).getDateValue();
                    writeVarLong(x);
                } else {
                    writeByte((byte) type);
                    long x = DateTimeUtils.getTimeLocalWithoutDst(v.getDate());
                    writeVarLong(x / MILLIS_PER_MINUTE);
                }
                break;
            }
        case Value.TIMESTAMP:
            {
                if (STORE_LOCAL_TIME) {
                    writeByte((byte) LOCAL_TIMESTAMP);
                    ValueTimestamp ts = (ValueTimestamp) v;
                    long dateValue = ts.getDateValue();
                    writeVarLong(dateValue);
                    long nanos = ts.getTimeNanos();
                    long millis = nanos / 1_000_000;
                    nanos -= millis * 1_000_000;
                    writeVarLong(millis);
                    writeVarLong(nanos);
                } else {
                    Timestamp ts = v.getTimestamp();
                    writeByte((byte) type);
                    writeVarLong(DateTimeUtils.getTimeLocalWithoutDst(ts));
                    writeVarInt(ts.getNanos() % 1_000_000);
                }
                break;
            }
        case Value.TIMESTAMP_TZ:
            {
                ValueTimestampTimeZone ts = (ValueTimestampTimeZone) v;
                writeByte((byte) type);
                writeVarLong(ts.getDateValue());
                writeVarLong(ts.getTimeNanos());
                writeVarInt(ts.getTimeZoneOffsetMins());
                break;
            }
        case Value.GEOMETRY:
        // fall though
        case Value.JAVA_OBJECT:
            {
                writeByte((byte) type);
                byte[] b = v.getBytesNoCopy();
                int len = b.length;
                writeVarInt(len);
                write(b, 0, len);
                break;
            }
        case Value.BYTES:
            {
                byte[] b = v.getBytesNoCopy();
                int len = b.length;
                if (len < 32) {
                    writeByte((byte) (BYTES_0_31 + len));
                    write(b, 0, len);
                } else {
                    writeByte((byte) type);
                    writeVarInt(len);
                    write(b, 0, len);
                }
                break;
            }
        case Value.UUID:
            {
                writeByte((byte) type);
                ValueUuid uuid = (ValueUuid) v;
                writeLong(uuid.getHigh());
                writeLong(uuid.getLow());
                break;
            }
        case Value.STRING:
            {
                String s = v.getString();
                int len = s.length();
                if (len < 32) {
                    writeByte((byte) (STRING_0_31 + len));
                    writeStringWithoutLength(s, len);
                } else {
                    writeByte((byte) type);
                    writeString(s);
                }
                break;
            }
        case Value.STRING_IGNORECASE:
        case Value.STRING_FIXED:
            writeByte((byte) type);
            writeString(v.getString());
            break;
        case Value.DOUBLE:
            {
                double x = v.getDouble();
                if (x == 1.0d) {
                    writeByte((byte) (DOUBLE_0_1 + 1));
                } else {
                    long d = Double.doubleToLongBits(x);
                    if (d == ValueDouble.ZERO_BITS) {
                        writeByte((byte) DOUBLE_0_1);
                    } else {
                        writeByte((byte) type);
                        writeVarLong(Long.reverse(d));
                    }
                }
                break;
            }
        case Value.FLOAT:
            {
                float x = v.getFloat();
                if (x == 1.0f) {
                    writeByte((byte) (FLOAT_0_1 + 1));
                } else {
                    int f = Float.floatToIntBits(x);
                    if (f == ValueFloat.ZERO_BITS) {
                        writeByte((byte) FLOAT_0_1);
                    } else {
                        writeByte((byte) type);
                        writeVarInt(Integer.reverse(f));
                    }
                }
                break;
            }
        case Value.BLOB:
        case Value.CLOB:
            {
                writeByte((byte) type);
                if (v instanceof ValueLob) {
                    ValueLob lob = (ValueLob) v;
                    lob.convertToFileIfRequired(handler);
                    byte[] small = lob.getSmall();
                    if (small == null) {
                        int t = -1;
                        if (!lob.isLinkedToTable()) {
                            t = -2;
                        }
                        writeVarInt(t);
                        writeVarInt(lob.getTableId());
                        writeVarInt(lob.getObjectId());
                        writeVarLong(lob.getPrecision());
                        writeByte((byte) (lob.isCompressed() ? 1 : 0));
                        if (t == -2) {
                            writeString(lob.getFileName());
                        }
                    } else {
                        writeVarInt(small.length);
                        write(small, 0, small.length);
                    }
                } else {
                    ValueLobDb lob = (ValueLobDb) v;
                    byte[] small = lob.getSmall();
                    if (small == null) {
                        writeVarInt(-3);
                        writeVarInt(lob.getTableId());
                        writeVarLong(lob.getLobId());
                        writeVarLong(lob.getPrecision());
                    } else {
                        writeVarInt(small.length);
                        write(small, 0, small.length);
                    }
                }
                break;
            }
        case Value.ARRAY:
            {
                writeByte((byte) type);
                Value[] list = ((ValueArray) v).getList();
                writeVarInt(list.length);
                for (Value x : list) {
                    writeValue(x);
                }
                break;
            }
        case Value.RESULT_SET:
            {
                writeByte((byte) type);
                try {
                    ResultSet rs = ((ValueResultSet) v).getResultSet();
                    rs.beforeFirst();
                    ResultSetMetaData meta = rs.getMetaData();
                    int columnCount = meta.getColumnCount();
                    writeVarInt(columnCount);
                    for (int i = 0; i < columnCount; i++) {
                        writeString(meta.getColumnName(i + 1));
                        writeVarInt(meta.getColumnType(i + 1));
                        writeVarInt(meta.getPrecision(i + 1));
                        writeVarInt(meta.getScale(i + 1));
                    }
                    while (rs.next()) {
                        writeByte((byte) 1);
                        for (int i = 0; i < columnCount; i++) {
                            int t = DataType.getValueTypeFromResultSet(meta, i + 1);
                            Value val = DataType.readValue(null, rs, i + 1, t);
                            writeValue(val);
                        }
                    }
                    writeByte((byte) 0);
                    rs.beforeFirst();
                } catch (SQLException e) {
                    throw DbException.convert(e);
                }
                break;
            }
        default:
            DbException.throwInternalError("type=" + v.getType());
    }
    if (SysProperties.CHECK2) {
        if (pos - start != getValueLen(v, handler)) {
            throw DbException.throwInternalError("value size error: got " + (pos - start) + " expected " + getValueLen(v, handler));
        }
    }
}