column.java

Java写的含有一个jdbc驱动的小型数据库数据库引擎

	case SMALLINT:
	    return new Short((short) (((Short) a).shortValue() / count));

	case BIGINT:
	    return new Long(((Long) a).longValue() / count);

	case REAL:
	    return new Float(((Float) a).floatValue() / count);

	default:
	    Trace.error(Trace.SUM_OF_NON_NUMERIC);
	}

	return null;
    }

    /**
     * Method declaration
     *
     *
     * @param a
     * @param b
     * @param type
     *
     * @return
     *
     * @throws SQLException
     */
    static Object min(Object a, Object b, int type) throws SQLException {
	if (a == null) {
	    return b;
	}

	if (b == null) {
	    return a;
	}

	if (compare(a, b, type) < 0) {
	    return a;
	}

	return b;
    }

    /**
     * Method declaration
     *
     *
     * @param a
     * @param b
     * @param type
     *
     * @return
     *
     * @throws SQLException
     */
    static Object max(Object a, Object b, int type) throws SQLException {
	if (a == null) {
	    return b;
	}

	if (b == null) {
	    return a;
	}

	if (compare(a, b, type) > 0) {
	    return a;
	}

	return b;
    }

    /**
     * Method declaration
     *
     *
     * @param a
     * @param b
     * @param type
     *
     * @return
     *
     * @throws SQLException
     */
    static int compare(Object a, Object b, int type) throws SQLException {
	int i = 0;

	// null handling: null==null and smaller any value
	// todo: implement standard SQL null handling
	// it is also used for grouping ('null' is one group)
	if (a == null) {
	    if (b == null) {
		return 0;
	    }

	    return -1;
	}

	if (b == null) {
	    return 1;
	}

	switch (type) {

	case NULL:
	    return 0;

	case INTEGER:
	    int ai = ((Integer) a).intValue();
	    int bi = ((Integer) b).intValue();

	    return (ai > bi) ? 1 : (bi > ai ? -1 : 0);

	case FLOAT:

	case DOUBLE:
	    double ad = ((Double) a).doubleValue();
	    double bd = ((Double) b).doubleValue();

	    return (ad > bd) ? 1 : (bd > ad ? -1 : 0);

	case VARCHAR:

	case LONGVARCHAR:
	    i = ((String) a).compareTo((String) b);

	    break;

// [e-mail] 20010707
// patch 418022 by [e-mail]
// to mimic SQL92 behaviour
	case CHAR:
            i = Library.rtrim((String) a).compareTo(Library.rtrim((String) b));

            break;

	case VARCHAR_IGNORECASE:

	    // for jdk 1.1 compatibility; jdk 1.2 could use compareToIgnoreCase
	    i = ((String) a).toUpperCase().compareTo(((String) b).toUpperCase());

	    break;

	case DATE:
	    if (((java.sql.Date) a).after((java.sql.Date) b)) {
		return 1;
	    } else if (((java.sql.Date) a).before((java.sql.Date) b)) {
		return -1;
	    } else {
		return 0;
	    }

	case TIME:
	    if (((Time) a).after((Time) b)) {
		return 1;
	    } else if (((Time) a).before((Time) b)) {
		return -1;
	    } else {
		return 0;
	    }

	case TIMESTAMP:
	    if (((Timestamp) a).after((Timestamp) b)) {
		return 1;
	    } else if (((Timestamp) a).before((Timestamp) b)) {
		return -1;
	    } else {
		return 0;
	    }

	case NUMERIC:

	case DECIMAL:
	    i = ((BigDecimal) a).compareTo((BigDecimal) b);

	    break;

	case BIT:
	    boolean boola = ((Boolean) a).booleanValue();
	    boolean boolb = ((Boolean) b).booleanValue();

	    return (boola == boolb) ? 0 : (boolb ? -1 : 1);

	case TINYINT:

	case SMALLINT:
	    short shorta = ((Short) a).shortValue();
	    short shortb = ((Short) b).shortValue();

	    return (shorta > shortb) ? 1 : (shortb > shorta ? -1 : 0);

	case BIGINT:
	    long longa = ((Long) a).longValue();
	    long longb = ((Long) b).longValue();

	    return (longa > longb) ? 1 : (longb > longa ? -1 : 0);

	case REAL:
	    float floata = ((Float) a).floatValue();
	    float floatb = ((Float) b).floatValue();

	    return (floata > floatb) ? 1 : (floatb > floata ? -1 : 0);

	case BINARY:

	case VARBINARY:

	case LONGVARBINARY:

	case OTHER:
	    i = ((ByteArray) a).compareTo((ByteArray) b);

	    break;

	default:
	    throw Trace.error(Trace.FUNCTION_NOT_SUPPORTED, type);
	}

	return (i > 0) ? 1 : (i < 0 ? -1 : 0);
    }

    /**
     * Method declaration
     *
     *
     * @param s
     * @param type
     *
     * @return
     *
     * @throws SQLException
     */
    static Object convertString(String s, int type) throws SQLException {
	if (s == null) {
	    return null;
	}

	switch (type) {

	case NULL:
	    return null;

	case INTEGER:
	    return new Integer(s);

	case FLOAT:

	case DOUBLE:
	    return new Double(s);

	case VARCHAR_IGNORECASE:

	case VARCHAR:

	case CHAR:

	case LONGVARCHAR:
	    return s;

	case DATE:
	    return java.sql.Date.valueOf(s);

	case TIME:
	    return Time.valueOf(s);

// [e-mail] 20010701
// patch 418019 by [e-mail]
	case TIMESTAMP:
            return HsqlTimestamp.valueOf(s);

	case NUMERIC:

	case DECIMAL:
	    return new BigDecimal(s.trim());

	case BIT:
	    return new Boolean(s);

	case TINYINT:

	case SMALLINT:
	    return new Short(s);

	case BIGINT:
	    return new Long(s);

	case REAL:
	    return new Float(s);

	case BINARY:

	case VARBINARY:

	case LONGVARBINARY:

	case OTHER:
	    return new ByteArray(s);

	default:
	    throw Trace.error(Trace.FUNCTION_NOT_SUPPORTED, type);
	}
    }

    /**
     * Method declaration
     *
     *
     * @param o
     *
     * @return
     */
    static String convertObject(Object o) {
	if (o == null) {
	    return null;
	}

	return o.toString();
    }

    /**
     * Method declaration
     *
     *
     * @param o
     * @param type
     *
     * @return
     *
     * @throws SQLException
     */
    static Object convertObject(Object o, int type) throws SQLException {
	if (o == null) {
	    return null;
	}
	switch(type) {
		case BINARY:
		case VARBINARY:
		case LONGVARBINARY:
		if (o instanceof byte[])
			return new ByteArray( (byte[])o);
		else
			return convertString(o.toString(), type);
		default:
		return convertString(o.toString(), type);
	}
    }

    /**
     * Method declaration
     *
     *
     * @param o
     * @param type
     *
     * @return
     *
     * @throws SQLException
     */
    static String createString(Object o, int type) throws SQLException {
	if (o == null) {
	    return "NULL";
	}

	switch (type) {

	case NULL:
	    return "NULL";

	case BINARY:

	case VARBINARY:

	case LONGVARBINARY:

	case DATE:

	case TIME:

	case TIMESTAMP:

	case OTHER:
	    return "'" + o.toString() + "'";

	case VARCHAR_IGNORECASE:

	case VARCHAR:

	case CHAR:

	case LONGVARCHAR:
	    return createString((String) o);

	default:
	    return o.toString();
	}
    }

    /**
     * Method declaration
     *
     *
     * @param s
     *
     * @return
     */
    static String createString(String s) {
	StringBuffer b = new StringBuffer().append('\'');

	if (s != null) {
	    for (int i = 0, len = s.length(); i < len; i++) {
		char c = s.charAt(i);

		if (c == '\'') {
		    b.append(c);
		}

		b.append(c);
	    }
	}

	return b.append('\'').toString();
    }

    /**
     * Method declaration
     *
     *
     * @param in
     * @param l
     *
     * @return
     *
     * @throws IOException
     * @throws SQLException
     */
    static Object[] readData(DataInput in,
			     int l) throws IOException, SQLException {
	Object data[] = new Object[l];

	for (int i = 0; i < l; i++) {
	    int    type = in.readInt();
	    Object o = null;

	    switch (type) {

	    case NULL:
		o = null;

		break;

	    case INTEGER:
		o = new Integer(in.readInt());

		break;

	    case FLOAT:

	    case DOUBLE:
		o = new Double(Double.longBitsToDouble(in.readLong()));

		// some JDKs have a problem with this:
		// o=new Double(in.readDouble());
		break;

	    case VARCHAR_IGNORECASE:

	    case VARCHAR:

	    case CHAR:

	    case LONGVARCHAR:
		o = in.readUTF();

		break;

	    case DATE:
		o = java.sql.Date.valueOf(in.readUTF());

		break;

	    case TIME:
		o = Time.valueOf(in.readUTF());

		break;

	    case TIMESTAMP:
		o = Timestamp.valueOf(in.readUTF());

		break;

	    case NUMERIC:

	    case DECIMAL:
		o = new BigDecimal(in.readUTF());

		break;

	    case BIT:
		o = new Boolean(in.readUTF());

		break;

	    case TINYINT:

	    case SMALLINT:
		o = new Short(in.readUTF());

		break;

	    case BIGINT:
		o = new Long(in.readUTF());

		break;

	    case REAL:
		o = new Float(in.readUTF());

		break;

	    case BINARY:

	    case VARBINARY:

	    case LONGVARBINARY:

	    case OTHER:

	    String str = in.readUTF();
	    if (str.equals("**")) {
			//new format
			int len = in.readInt();
			byte[] b = new byte[len];
			in.readFully(b);
			o = new ByteArray(b);
		}
		else {
			// old format
			o = new ByteArray(str);
		}

		break;

	    default:
		throw Trace.error(Trace.FUNCTION_NOT_SUPPORTED, type);
	    }

	    data[i] = o;
	}

	return data;
    }

    /**
     * Method declaration
     *
     *
     * @param out
     * @param data
     * @param t
     *
     * @throws IOException
     */
    static void writeData(DataOutput out, Object data[],
			  Table t) throws IOException {
	int len = t.getInternalColumnCount();
	int type[] = new int[len];

	for (int i = 0; i < len; i++) {
	    type[i] = t.getType(i);
	}

	writeData(out, len, type, data);
    }

    /**
     * Method declaration
     *
     *
     * @param out
     * @param l
     * @param type
     * @param data
     *
     * @throws IOException
     */
    static void writeData(DataOutput out, int l, int type[],
			  Object data[]) throws IOException {
	for (int i = 0; i < l; i++) {
	    Object o = data[i];

	    if (o == null) {
		out.writeInt(NULL);
	    } else {
		int t = type[i];

		out.writeInt(t);

		switch (t) {

		case INTEGER:
		    out.writeInt(((Integer) o).intValue());

		    break;

		case FLOAT:

		case DOUBLE:
		    out.writeLong(Double.doubleToLongBits(((Double) o).doubleValue()));

		    // some JDKs have a problem with this:
		    // out.writeDouble(((Double)o).doubleValue());
		    break;

		case BINARY:
		case VARBINARY:
		case LONGVARBINARY:
		case OTHER:
			out.writeUTF("**"); //new format flag
			byte [] b = ((ByteArray)o).byteValue();
			out.writeInt(b.length);
			out.write(b,0,b.length);

			break;

		default:
		    out.writeUTF(o.toString());

		    break;
		}
	    }
	}
    }

    /**
     * Method declaration
     *
     *
     * @param data
     * @param t
     *
     * @return
     */
    static int getSize(Object data[], Table t) {
	int l = data.length;
	int type[] = new int[l];

	for (int i = 0; i < l; i++) {
	    type[i] = t.getType(i);
	}

	return getSize(data, l, type);
    }

    /**
     * Method declaration
     *
     *
     * @param data
     * @param l
     * @param type
     *
     * @return
     */
    private static int getSize(Object data[], int l, int type[]) {
	int s = 0;

	for (int i = 0; i < l; i++) {
	    Object o = data[i];

	    s += 4;    // type

	    if (o != null) {
		switch (type[i]) {

		case INTEGER:
		    s += 4;

		    break;

		case FLOAT:

		case DOUBLE:
		    s += 8;

		    break;

		case BINARY:
		case VARBINARY:
		case LONGVARBINARY:
		case OTHER:
			s += getUTFsize("**"); //new format flag
			s += 4;
			s += ((ByteArray)o).byteValue().length;

			break;

		default:
		    s += getUTFsize(o.toString());
		}
	    }
	}

	return s;
    }

    /**
     * Method declaration
     *
     *
     * @param s
     *
     * @return
     */
    private static int getUTFsize(String s) {

	// a bit bigger is not really a problem, but never smaller!
	if (s == null) {
	    s = "";
	}

	int len = s.length();
	int l = 2;

	for (int i = 0; i < len; i++) {
	    int c = s.charAt(i);

	    if ((c >= 0x0001) && (c <= 0x007F)) {
		l++;
	    } else if (c > 0x07FF) {
		l += 3;
	    } else {
		l += 2;
	    }
	}

	return l;
    }

}