column.java

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

/*
 * Column.java
 */

package org.hsql;
import java.sql.*;
import java.math.BigDecimal;
import java.io.*;
import java.util.*;

class Column {
  private static Hashtable hTypes;
  final static int BIT=Types.BIT,TINYINT=Types.TINYINT,BIGINT=Types.BIGINT,
  LONGVARBINARY=Types.LONGVARBINARY,VARBINARY=Types.VARBINARY,
  BINARY=Types.BINARY,LONGVARCHAR=Types.LONGVARCHAR,CHAR=Types.CHAR,
  NUMERIC=Types.NUMERIC,DECIMAL=Types.DECIMAL,INTEGER=Types.INTEGER,
  SMALLINT=Types.SMALLINT,FLOAT=Types.FLOAT,REAL=Types.REAL,DOUBLE=Types.DOUBLE,
  VARCHAR=Types.VARCHAR,DATE=Types.DATE,TIME=Types.TIME,
  TIMESTAMP=Types.TIMESTAMP,OTHER=Types.OTHER,NULL=Types.NULL,
  VARCHAR_IGNORECASE=100; // this is the only non-standard type
  // NULL is not part of TYPES
  final static int TYPES[]=
  {BIT,TINYINT,BIGINT,LONGVARBINARY,VARBINARY,BINARY,LONGVARBINARY,CHAR,
  NUMERIC,DECIMAL,INTEGER,SMALLINT,FLOAT,REAL,DOUBLE,VARCHAR,DATE,TIME,
  TIMESTAMP,OTHER};
  String sName;
  int iType;
  private boolean bNullable;
  private boolean bIdentity;
  static {
    hTypes=new Hashtable();
    addTypes(INTEGER,"INTEGER","int","java.lang.Integer");
    addType(INTEGER,"INT");
    addTypes(DOUBLE,"DOUBLE","double","java.lang.Double");
    addType(FLOAT,"FLOAT"); // this is a Double
    addTypes(VARCHAR,"VARCHAR","java.lang.String",null);
    addTypes(CHAR,"CHAR","CHARACTER",null);
    addType(LONGVARCHAR,"LONGVARCHAR");
    // for ignorecase data types, the 'original' type name is lost
    addType(VARCHAR_IGNORECASE,"VARCHAR_IGNORECASE");
    addTypes(DATE,"DATE","java.sql.Date",null);
    addTypes(TIME,"TIME","java.sql.Time",null);
    // DATETIME is for compatibility with MS SQL 7
    addTypes(TIMESTAMP,"TIMESTAMP","java.sql.Timestamp","DATETIME");
    addTypes(DECIMAL,"DECIMAL","java.math.BigDecimal",null);
    addType(NUMERIC,"NUMERIC");
    addTypes(BIT,"BIT","java.lang.Boolean","boolean");
    addTypes(TINYINT,"TINYINT","java.lang.Short","short");
    addType(SMALLINT,"SMALLINT");
    addTypes(BIGINT,"BIGINT","java.lang.Long","long");
    addTypes(REAL,"REAL","java.lang.Float","float");
    addTypes(BINARY,"BINARY","byte[]",null); // maybe better "[B"
    addType(VARBINARY,"VARBINARY");
    addType(LONGVARBINARY,"LONGVARBINARY");
    addTypes(OTHER,"OTHER","java.lang.Object","OBJECT");
  }
  private static void addTypes(int type,String name,String n2,String n3) {
    addType(type,name);
    addType(type,n2);
    addType(type,n3);
  }
  private static void addType(int type,String name) {
    if(name!=null) {
      hTypes.put(name,new Integer(type));
    }
  }

  Column(String name,boolean nullable,int type,boolean identity) {
    sName=name;
    bNullable=nullable;
    iType=type;
    bIdentity=identity;
  }
  boolean isIdentity() {
    return bIdentity;
  }
  static int getTypeNr(String type) throws SQLException {
    Integer i=(Integer)hTypes.get(type);
    Trace.check(i!=null,Trace.WRONG_DATA_TYPE,type);
    return i.intValue();
  }
  static String getType(int type) throws SQLException {
    switch(type) {
    case NULL:
      return "NULL";
    case INTEGER:
      return "INTEGER";
    case DOUBLE:
      return "DOUBLE";
    case VARCHAR_IGNORECASE:
      return "VARCHAR_IGNORECASE";
    case VARCHAR:
      return "VARCHAR";
    case CHAR:
      return "CHAR";
    case LONGVARCHAR:
      return "LONGVARCHAR";
    case DATE:
      return "DATE";
    case TIME:
      return "TIME";
    case DECIMAL:
      return "DECIMAL";
    case BIT:
      return "BIT";
    case TINYINT:
      return "TINYINT";
    case SMALLINT:
      return "SMALLINT";
    case BIGINT:
      return "BIGINT";
    case REAL:
      return "REAL";
    case FLOAT:
      return "FLOAT";
    case NUMERIC:
      return "NUMERIC";
    case TIMESTAMP:
      return "TIMESTAMP";
    case BINARY:
      return "BINARY";
    case VARBINARY:
      return "VARBINARY";
    case LONGVARBINARY:
      return "LONGVARBINARY";
    case OTHER:
      return "OBJECT";
    default:
      throw Trace.error(Trace.WRONG_DATA_TYPE,type);
    }
  }
  boolean isNullable() {
    return bNullable;
  }
  static Object add(Object a,Object b,int type) throws SQLException {
    if(a==null || b==null) {
      return null;
    }
    switch(type) {
    case NULL:
      return null;
    case INTEGER:
      int ai=((Integer)a).intValue();
      int bi=((Integer)b).intValue();
      return new Integer(ai+bi);
    case FLOAT:
    case DOUBLE:
      double ad=((Double)a).doubleValue();
      double bd=((Double)b).doubleValue();
      return new Double(ad+bd);
    case VARCHAR:
    case CHAR:
    case LONGVARCHAR:
    case VARCHAR_IGNORECASE:
      return (String)a+(String)b;
    case NUMERIC:
    case DECIMAL:
      BigDecimal abd=(BigDecimal)a;
      BigDecimal bbd=(BigDecimal)b;
      return abd.add(bbd);
    case TINYINT:
    case SMALLINT:
      short shorta=((Short)a).shortValue();
      short shortb=((Short)b).shortValue();
      return new Short((short)(shorta+shortb));
    case BIGINT:
      long longa=((Long)a).longValue();
      long longb=((Long)b).longValue();
      return new Long(longa+longb);
    case REAL:
      float floata=((Float)a).floatValue();
      float floatb=((Float)b).floatValue();
      return new Float(floata+floatb);
    default:
      throw Trace.error(Trace.FUNCTION_NOT_SUPPORTED,type);
    }
  }
  static Object concat(Object a,Object b) throws SQLException {
    if(a==null) {
      return b;
    } else if(b==null) {
      return a;
    }
    return convertObject(a)+convertObject(b);
  }
  static Object negate(Object a,int type) throws SQLException {
    if(a==null) {
      return null;
    }
    switch(type) {
    case NULL:
      return null;
    case INTEGER:
      return new Integer(-((Integer)a).intValue());
    case FLOAT:
    case DOUBLE:
      return new Double(-((Double)a).doubleValue());
    case NUMERIC:
    case DECIMAL:
      return ((BigDecimal)a).negate();
    case TINYINT:
    case SMALLINT:
      return new Short((short)-((Short)a).shortValue());
    case BIGINT:
      return new Long(-((Long)a).longValue());
    case REAL:
      return new Float(-((Float)a).floatValue());
    default:
      throw Trace.error(Trace.FUNCTION_NOT_SUPPORTED,type);
    }
  }
  static Object multiply(Object a,Object b,int type) throws SQLException {
    if(a==null || b==null) {
      return null;
    }
    switch(type) {
    case NULL:
      return null;
    case INTEGER:
      int ai=((Integer)a).intValue();
      int bi=((Integer)b).intValue();
      return new Integer(ai*bi);
    case FLOAT:
    case DOUBLE:
      double ad=((Double)a).doubleValue();
      double bd=((Double)b).doubleValue();
      return new Double(ad*bd);
    case NUMERIC:
    case DECIMAL:
      BigDecimal abd=(BigDecimal)a;
      BigDecimal bbd=(BigDecimal)b;
      return abd.multiply(bbd);
    case TINYINT:
    case SMALLINT:
      short shorta=((Short)a).shortValue();
      short shortb=((Short)b).shortValue();
      return new Short((short)(shorta*shortb));
    case BIGINT:
      long longa=((Long)a).longValue();
      long longb=((Long)b).longValue();
      return new Long(longa*longb);
    case REAL:
      float floata=((Float)a).floatValue();
      float floatb=((Float)b).floatValue();
      return new Float(floata*floatb);
    default:
      throw Trace.error(Trace.FUNCTION_NOT_SUPPORTED,type);
    }
  }
  static Object divide(Object a,Object b,int type) throws SQLException {
    if(a==null || b==null) {
      return null;
    }
    switch(type) {
    case NULL:
      return null;
    case INTEGER:
      int ai=((Integer)a).intValue();
      int bi=((Integer)b).intValue();
      Trace.check(bi!=0,Trace.DIVISION_BY_ZERO);
      return new Integer(ai/bi);
    case FLOAT:
    case DOUBLE:
      double ad=((Double)a).doubleValue();
      double bd=((Double)b).doubleValue();
      return bd==0 ? null : new Double(ad/bd);
    case NUMERIC:
    case DECIMAL:
      BigDecimal abd=(BigDecimal)a;
      BigDecimal bbd=(BigDecimal)b;
      return bbd.signum()==0?null:abd.divide(bbd,BigDecimal.ROUND_HALF_DOWN);
    case TINYINT:
    case SMALLINT:
      short shorta=((Short)a).shortValue();
      short shortb=((Short)b).shortValue();
      return shortb==0 ? null : new Short((short)(shorta/shortb));
    case BIGINT:
      long longa=((Long)a).longValue();
      long longb=((Long)b).longValue();
      return longb==0 ? null : new Long(longa/longb);
    case REAL:
      float floata=((Float)a).floatValue();
      float floatb=((Float)b).floatValue();
      return floatb==0 ? null : new Float(floata/floatb);
    default:
      throw Trace.error(Trace.FUNCTION_NOT_SUPPORTED,type);
    }
  }
  static Object subtract(Object a,Object b,int type) throws SQLException {
    if(a==null || b==null) {
      return null;
    }
    switch(type) {
    case NULL:
      return null;
    case INTEGER:
      int ai=((Integer)a).intValue();
      int bi=((Integer)b).intValue();
      return new Integer(ai-bi);
    case FLOAT:
    case DOUBLE:
      double ad=((Double)a).doubleValue();
      double bd=((Double)b).doubleValue();
      return new Double(ad-bd);
    case NUMERIC:
    case DECIMAL:
      BigDecimal abd=(BigDecimal)a;
      BigDecimal bbd=(BigDecimal)b;
      return abd.subtract(bbd);
    case TINYINT:
    case SMALLINT:
      short shorta=((Short)a).shortValue();
      short shortb=((Short)b).shortValue();
      return new Short((short)(shorta-shortb));
    case BIGINT:
      long longa=((Long)a).longValue();
      long longb=((Long)b).longValue();
      return new Long(longa-longb);
    case REAL:
      float floata=((Float)a).floatValue();
      float floatb=((Float)b).floatValue();
      return new Float(floata-floatb);
    default:
      throw Trace.error(Trace.FUNCTION_NOT_SUPPORTED,type);
    }
  }
  static Object sum(Object a,Object b,int type) throws SQLException {
    if(a==null) {
      return b;
    }
    if(b==null) {
      return a;
    }
    switch(type) {
    case NULL:
      return null;
    case INTEGER:
      return new Integer(((Integer)a).intValue()+((Integer)b).intValue());
    case FLOAT:
    case DOUBLE:
      return new Double(((Double)a).doubleValue()+((Double)b).doubleValue());
    case NUMERIC:
    case DECIMAL:
      return ((BigDecimal)a).add((BigDecimal)b);
    case TINYINT:
    case SMALLINT:
      return new Short((short)(((Short)a).shortValue()+
      ((Short)b).shortValue()));
    case BIGINT:
      return new Long(((Long)a).longValue()+((Long)b).longValue());
    case REAL:
      return new Float(((Float)a).floatValue()+((Float)b).floatValue());
    default:
      Trace.error(Trace.SUM_OF_NON_NUMERIC);
    }
    return null;
  }
  static Object avg(Object a,int type,int count) throws SQLException {
    if(a==null || count==0) {
      return null;
    }
    switch(type) {
    case NULL:
      return null;
    case INTEGER:
      return new Integer(((Integer)a).intValue()/count);
    case FLOAT:
    case DOUBLE:
      return new Double(((Double)a).doubleValue()/count);
    case NUMERIC:
    case DECIMAL:
      return ((BigDecimal)a).divide(