Quadcap Embeddable Database

com/quadcap/sql/types/Value.java

Go to the documentation of this file.

package com.quadcap.sql.types;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

import java.util.Hashtable;

import java.sql.SQLException;
import java.sql.Types;

import com.quadcap.sql.file.Datafile;

import com.quadcap.sql.io.ObjectInputStream;
import com.quadcap.sql.io.ObjectOutputStream;

import com.quadcap.util.Debug;

/**
 * A runtime SQL value.
 *
 * <p>Types:
 * <ul>
 * <li>Numeric
 * <li>Decimal
 * <li>Integer
 * <li>SmallInt
 *
 * <li>Float
 * <li>Double
 *
 * <li>Timestamp
 * <li>Interval
 *
 * <li>Char
 *
 * <li>Binary
 *
 * <li>Boolean
 *
 * <li>BLOB</li>
 * <li>CLOB</li>
 * </ul>
 *
 * @author Stan Bailes
 */
public abstract class Value {
    public Value() {}

    public static boolean isCaseSensitive = true;

    /**
     * Two-level virtual operator dispatch.  Each subtype implements the
     * same basic template for this abstract function:
     * <pre>
     *
     * Value binop(int op, Value l) {
     *    return l.binop(op, this);
     * }
     *
     * </pre>
     * Then, type overloading allows for each type to implement all
     * ops for which it can be the left hand side for all allowed types
     * on the right hand side:
     * Value binop(int op, ValueInteger l);
     * Value binop(int op, ValueLong l);
     * ...
     */
    abstract public Value binop(int op, Value l) throws ValueException;

    abstract public Object asJavaObject() throws SQLException;

    abstract public Type getType() throws SQLException;

    abstract public void fromJavaObject(Object obj) throws ValueException;

    abstract public void serializeKey(KeyStream out) throws IOException;

    public static String tn(Value v) {
        String s = v.getClass().getName();
        int idx = s.lastIndexOf('.');
        if (idx > 0) s = s.substring(idx+1);
        return s;
    }
    
    public static final Value binop(int op, Value l, Value r)
        throws ValueException
    {
        Value ret = r.binop(op, l);
//          Debug.println("binop(" + Op.toString(op) + ", " +
//                        tn(l) + ":" +
//                        l + ", " +
//                        tn(r) + ":" +
//                        r + ") = " +
//                        tn(ret) + ":" +
//                        ret);
        return ret;
    }

    final ValueException badType(Type type) {
        return new ValueException("Not " + type + ": " +
                                 this.getClass().getName());
    }

    // grep alltypes (also io.Extern)
    public Value convert(TypeBigInt type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeBinary type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeBlob type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeBoolean type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeChar type) throws ValueException {
        String s = this.toString();
        final int max = type.getMax();
        if (max > 0 && s.length() > max) s = s.substring(0, max);
        if (s.length() < max) {
            StringBuffer sb = new StringBuffer(s);
            while (sb.length() < max) sb.append(' ');
            s = sb.toString();
        }
        return new ValueString(s);
    }

    public Value convert(TypeClob type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeDate type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeDecimal type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeInt type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeInterval type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeReal type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeSmallInt type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeVarChar type) throws ValueException {
        String s = this.toString();
        final int max = type.getMax();
        if (max > 0 && s.length() > max) s = s.substring(0, max);
        return new ValueString(s);
    }

    public Value convert(TypeVarBinary type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeTime type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeTimestamp type) throws ValueException {
        throw badType(type);
    }

    public Value convert(TypeTinyInt type) throws ValueException {
        throw badType(type);
    }


    public Value binop(int op, ValueBlob v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueBoolean v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueByte v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueClob v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueDate v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueDouble v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueFloat v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueInteger v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueInterval v) throws ValueException {
        throw badBinop(op, v);
    }

    public Value binop(int op, ValueLong v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueNull v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueOctets v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValuePattern v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueScaledInteger v) throws ValueException {
        throw badBinop(op, v);
    }
     
    public Value binop(int op, ValueShort v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueString l) throws ValueException {
        return ValueString.binop_convert(op, l, this);
    }

    public Value binop(int op, ValueTime v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueTimestamp v) throws ValueException {
        throw badBinop(op, v);
    }
    
    public Value binop(int op, ValueUnknown v) throws ValueException {
        return ValueUnknown.valueUnknown;
    }

    public static final ValueException badBinop(int op, Value l, Value r) {
        return new ValueException("not implemented: " +
                                  l.getClass().getName() + " " +
                                  Op.toString(op) + " " +
                                  r.getClass().getName());
    }
    
    public final ValueException badBinop(int op, Value v) {
        return badBinop(op, this, v);
    }

    public static final boolean isTrue(Value ret) throws ValueException {
        if (ret instanceof ValueBoolean) {
            return ((ValueBoolean)ret).isTrue();
        } else if (ret instanceof ValueUnknown) {
            return false;
        }
        throw new ValueException("Not boolean: " + ret);
    }
        
    public static final boolean boolOp(int op, Value l, Value r)
        throws ValueException
    {
        Value ret = binop(op, l, r);
        return isTrue(ret);
    }

    public Value unop(int op) throws ValueException {
        throw new ValueException("not implemented: " +
                                 getClass().getName() + " unary op: " +
                                 Op.toString(op));
    }

    public static final boolean isNull(Value val) {
        return val instanceof ValueNull;
    }

    public static final byte[] bytes(Value val) {
        try {
            ObjectOutputStream os = new ObjectOutputStream(null);
            os.writeObject(val);
            return os.toByteArray();
        } catch (IOException e) {
            Debug.print(e);
            throw new RuntimeException(e.toString());
        }
    }

    public static final Value fromBytes(byte[] b) {
        try {
            ByteArrayInputStream bis = new ByteArrayInputStream(b);
            ObjectInputStream is = new ObjectInputStream(bis);
            return (Value)is.readObject();
        } catch (Exception e) {
            Debug.print(e);
            throw new RuntimeException(e.toString());
        }
    }

    static final Hashtable      javaTypes               = new Hashtable();
    static final void jc(String javaClass, String valueClass) {
        try {
            javaTypes.put(javaClass, Class.forName(valueClass));
        } catch (ClassNotFoundException e) {
            Debug.print(e);
        }
    }

    static {
        jc("[B", "com.quadcap.sql.types.ValueOctets");
        jc("java.lang.Boolean", "com.quadcap.sql.types.ValueBoolean");
        jc("java.lang.Byte", "com.quadcap.sql.types.ValueByte");
        jc("java.lang.Double", "com.quadcap.sql.types.ValueDouble");
        jc("java.lang.Float", "com.quadcap.sql.types.ValueFloat");
        jc("java.lang.Integer", "com.quadcap.sql.types.ValueInteger");
        jc("java.lang.Long", "com.quadcap.sql.types.ValueLong");
        jc("java.lang.Short", "com.quadcap.sql.types.ValueShort");
        jc("java.lang.String", "com.quadcap.sql.types.ValueString");
        jc("java.math.BigDecimal", "com.quadcap.sql.types.ValueScaledInteger");
        jc("java.sql.Date", "com.quadcap.sql.types.ValueDate");
        jc("java.sql.Time", "com.quadcap.sql.types.ValueTime");
        jc("java.sql.Timestamp", "com.quadcap.sql.types.ValueTimestamp");
        jc("java.util.Date", "com.quadcap.sql.types.ValueTimestamp");
    }

    static final Hashtable jdbcTypes                    = new Hashtable();
    static final void jdbcType(int typeNum, Type type) {
        jdbcTypes.put(new Integer(typeNum), type);
    }
    static {
        jdbcType(Types.BIT, TypeBoolean.typeBoolean);
        jdbcType(Types.TINYINT, TypeTinyInt.typeTinyInt);
        jdbcType(Types.SMALLINT, TypeSmallInt.typeSmallInt);
        jdbcType(Types.INTEGER, TypeInt.typeInt);
        jdbcType(Types.BIGINT, TypeBigInt.typeBigInt);
        jdbcType(Types.FLOAT, TypeReal.typeFloat);
        jdbcType(Types.REAL, TypeReal.typeReal);
        jdbcType(Types.DOUBLE, TypeReal.typeDouble);
        jdbcType(Types.NUMERIC, TypeDecimal.typeDecimal);
        jdbcType(Types.DECIMAL, TypeDecimal.typeDecimal);
        jdbcType(Types.CHAR, TypeChar.typeChar);
        jdbcType(Types.VARCHAR, TypeVarChar.typeVarChar);
        jdbcType(Types.LONGVARCHAR, TypeVarChar.typeVarChar);
        jdbcType(Types.DATE, TypeDate.typeDate);
        jdbcType(Types.TIME, TypeTime.typeTime);
        jdbcType(Types.TIMESTAMP, TypeTimestamp.typeTimestamp);
        jdbcType(Types.BINARY, TypeBinary.typeBinary);
        jdbcType(Types.VARBINARY, TypeVarBinary.typeVarBinary);
        jdbcType(Types.LONGVARBINARY, TypeVarBinary.typeVarBinary);
        // JAVA_OBJECT
        // DISTINCT
        // STRUCT
        // ARRAY
        //#ifndef JDK11
        jdbcType(Types.BLOB, TypeBlob.typeBlob);
        jdbcType(Types.CLOB, TypeClob.typeClob);
        //#endif
        // ref
    }

    public static final Type typeForJdbcType(int type) {
        Type t = (Type)jdbcTypes.get(new Integer(type));
        return t;
    }

    public void setDatafile(Datafile db) {}

    public static final Value fromObject(Object obj) throws ValueException {
        if (obj == null) return ValueNull.valueNull;
        Class valueClass = (Class)javaTypes.get(obj.getClass().getName());
        if (valueClass != null) {
            try {
                Value v = (Value)(valueClass.newInstance());
                v.fromJavaObject(obj);
                return v;
            } catch (IllegalAccessException e) {
                Debug.print(e);
                throw new ValueException(e.toString());
            } catch (InstantiationException e) {
                Debug.print(e);
                throw new ValueException(e.toString());
            }           
        }
        throw new ValueException("No mapping for class: " +
                                 obj.getClass().getName());
    }

}