Ideer til program, der kan finde ud af udnyttelsesgraden af en db

getColumns returnerer et ResultSet som bl.a. indeholdr en kolonne COLUMN_SIZE

rs.getString(ix).length() kan vel bruges

Det lyder super Arne. Jeg kigger på det i aften, men mon ikke godt du kan smide et svar. Din hjælp plejer trods alt at være meget brugbar!
Vil man kunne gøre sådan som du foreskriver på alle typer? Altså, hvad nu hvis der fx ligger en BLOB eller anden datatype i databasen?

Nej - rs.getString(ix).length() er nok til VARCHAR og deslige.

rs.getBytes(ix).length kan nok klare mere.

Men i ekstreme tilfælde må det vel blive rs.getBlob(ix).

Hvis der er gemt 2 GB BLOB's i databasen, så er princippet med
at læse det op i en memory variabel ikke så god.

svar

hvis der er noget der driller så skriv

Og det rs jeg snakke rom i de sidste indlæg er naturligvis fra en normal
query og ikke relateret til ResultSet fra første kommentar.

Det lyder godt Arne.
Jeg kigger på det i aften, tak for hjælpen.

Hej igen Arne, så er jeg stødt i et par problemer... Jeg har fundet ud af, at getColumns ligger i interfacet DatabaseMetaData, men jeg har et par problemer:

1) Jeg kan ikke finde ud af, hvad det er for en klasse jeg skal bruge som implementerer DatabaseMetaData

2) Jeg er ikke med på, hvad getColumns parametre er:
  public ResultSet getColumns ( 
    String catalog,
    String schemaPattern,
    String tableNamePattern,
    String columnNamePattern
  )

Håber du har et par ideer :)

re 1)

Ingen.

Du kalder conn.getMetaData() for at få en !

Prøv:

conn.getColumns(null,null,"%","%")

Til andres orientering, så er her hvad jeg nåede frem til:

    private String getType(int i) {
      String desc = null;

      switch (i) {
      case Types.BIT:
          desc = "BIT";
          break;
      case Types.TINYINT:
          desc = "TINYINT";
          break;
      case Types.SMALLINT:
          desc = "SMALLINT";
          break;
      case Types.INTEGER:
          desc = "INTEGER";
          break;
      case Types.BIGINT:
          desc = "BIGINT";
          break;
      case Types.FLOAT:
          desc = "FLOAT";
          break;
      case Types.REAL:
          desc = "REAL";
          break;
      case Types.DOUBLE:
          desc = "DOUBLE";
          break;
      case Types.NUMERIC:
          desc = "NUMERIC";
          break;
      case Types.DECIMAL:
          desc = "DECIMAL";
          break;
      case Types.CHAR:
          desc = "CHAR";
          break;
      case Types.VARCHAR:
          desc = "VARCHAR";
          break;
      case Types.LONGVARCHAR:
          desc = "LONGVARCHAR";
          break;
      case Types.DATE:
          desc = "DATE";
          break;
      case Types.TIME:
          desc = "TIME";
          break;
      case Types.TIMESTAMP:
          desc = "TIMESTAMP";
          break;
      case Types.BINARY:
          desc = "BINARY";
          break;
      case Types.VARBINARY:
          desc = "VARBINARY";
          break;
      case Types.LONGVARBINARY:
          desc = "LONGVARBINARY";
          break;
      case Types.NULL:
          desc = "NULL";
          break;
      case Types.OTHER:
          desc = "OTHER";
          break;
      case Types.JAVA_OBJECT:
          desc = "JAVA_OBJECT";
          break;
      case Types.DISTINCT:
          desc = "DISTINCT";
          break;
      case Types.STRUCT:
          desc = "STRUCT";
          break;
      case Types.ARRAY:
          desc = "ARRAY";
          break;
      case Types.BLOB:
          desc = "BLOB";
          break;
      case Types.CLOB:
          desc = "CLOB";
          break;
      case Types.REF:
          desc = "REF";
          break;
      default:
          desc = "UNKNOWN";
          break;
      }
      return desc;
    }

public void meta2() throws SQLException
{
  DatabaseMetaData dbmd = conn.getMetaData();
  ResultSet rsColumns = dbmd.getColumns(null, null, "%", "%");
  while (rsColumns.next()) {
        String cn = rsColumns.getString("COLUMN_NAME");
        String cdt = getType(rsColumns.getInt("DATA_TYPE"));
        String cnt = rsColumns.getString("TYPE_NAME");
        String cs = rsColumns.getString("COLUMN_SIZE");
        String cnull = rsColumns.getString("IS_NULLABLE");
        System.out.println("Kolonne navn: "+cn+"\t Data type: "+cdt+"\t Native " type: "+cnt+"\t Kolonne str: "+cs+"\t Null: "+cnull);
    }
}

Det ser desværre ud til, at hvis man fx har defineret en VARCHAR så bliver columnsize 0, hvorimod hvis man har defineret en VARCHAR(256), så bliver columnsize 256. Det samme gælder for andre typer. Derved bliver det altså svært at finde ud af, hvor meget plads der er afsat når det ikke explicit er defineret ved oprettelsen af tabellerne i databasen. Jeg har endnu kun prøvet på HSQLDB. Hvorvidt MySQL og andre reagerer på andre måder må kommer an på en test :)

Jeg tror at de fleste databaser vil give syntax fejl hvis du forsøger
at lave en VARCHAR uden at angive max størrelse.

Nå så har jeg forsøgt med mysql og det ser mere lovende ud :)
Ja, de fleste databaser kræver en angivelse af maxstørrelse ved varchar, men de fleste tillader jo også, at man fx laver en INTERGER uden at angive maxstørrelsen. Her angiver MySQL dog selv størrelsen til 11. Hvorvidt det også gælder for andre typer har jeg ikke tjekket.

De 11 i INT(11) i MySQL har ikke noget at gøre med hvor meget en INT fylder.

Den fylder 4 bytes. Det er et hint om hvormange cifre kollonnen skal vises med
ved udskrift.

Nå for søren, ja det er jo så ret væsentligt når jeg gerne vil tjekke udnyttelsesgraden af databasen! :)

Jeg har siddet og kigget lidt i mysql doc, men kan ikke rigtig finde en oversigt over, hvor mange bytes, der sættes til side til de enkelte datatyper. Så det bliver måske lidt svært at lave en app. som viser en reel udnyttelsesgrad af databasen.

http://dev.mysql.com/doc/mysql/en/storage-requirements.html