column.java

一个可以在applet窗体上持行sql语句并显示返回结果的程序

      new BigDecimal(count),BigDecimal.ROUND_HALF_DOWN);
    case TINYINT:
    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;
  }
  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;
  }
  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;
  }
  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 CHAR:
    case LONGVARCHAR:
      i=((String)a).compareTo((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);
  }
  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);
    case TIMESTAMP:
      return Timestamp.valueOf(s);
    case NUMERIC:
    case DECIMAL:
      return new BigDecimal(new Double(s.trim()).doubleValue());
    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);
    }
  }
  static String convertObject(Object o) {
    if(o==null) {
      return null;
    }
    return o.toString();
  }
  static Object convertObject(Object o,int type) throws SQLException {
    if(o==null) {
      return null;
    }
    return convertString(o.toString(),type);
  }
  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();
    }
  }
  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();
  }
  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:
        // todo: directly use byte array
        o=new ByteArray(in.readUTF());
        break;
      default:
        throw Trace.error(Trace.FUNCTION_NOT_SUPPORTED,type);
      }
      data[i]=o;
    }
    return data;
  }
  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);
  }
  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;
        default:
          out.writeUTF(o.toString());
          break;
        }
      }
    }
  }
  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);
  }
  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;
        default:
          s+=getUTFsize(o.toString());
        }
      }
    }
    return s;
  }
  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;
  }
}