MySQL Befüllen einer MySQL DB mit großen Daten

[ElJarno]

Hi Leute,
soll in einer MySQL DB Datein speichern und bei bedarf auch wieder auslesen. Mein Code unfktioniert soweit. Jedoch hab ich das Problem dass sobald eine Dtaie ein größe von zirka 15 MB überschreitet der Heap von Java überläuft.

Hier mal meine Methode zum befüllen der DB:

	private void schreibePDFinDB(String dateiID, String pfad, int offsetDatei, int packetGroesse)
			throws IOException, SQLException {
		int partOffset = 0;
		int partBytesRead = 0;
		int partNr = 0;
		int partGroesse = 0;
		File datei = new File(pfad);
		BufferedInputStream is = new BufferedInputStream(new FileInputStream(datei));
		int bytesLeft = (int) datei.length();

		while (bytesLeft > 0) {
			if (bytesLeft < packetGroesse) {
				partGroesse = bytesLeft;
			} else {
				partGroesse = packetGroesse;
			}

			partNr += 1;
			byte[] bytes = this.liesDatei(is, partOffset, partGroesse);
			ByteArrayInputStream byteInpStr = new ByteArrayInputStream(bytes);
			dbBinaerDaten.writeBinaerDaten(dateiID, partNr, partBytesRead, byteInpStr);
			bytesLeft -= partGroesse;
			partOffset += partGroesse;
		}
	}

	private byte[] liesDatei(BufferedInputStream is, int offset, int length) throws IOException {
		byte[] bytes = new byte[(int) length];
		int numRead = 0;
		while (offset < bytes.length
				&& (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0) {
			offset += numRead;
		}

		is.close();
		return bytes;
	}

	public void writeBinaerDaten(String dateiID, int part, int leng, ByteArrayInputStream daten)
			throws SQLException {
		String objid = ObjectID.getOBJID(199);

		java.sql.PreparedStatement ps = this.getConnection().prepareStatement(
				"INSERT into BINAER_DATEN VALUES(?,?,?,?,?)");
		ps.setString(1, objid);
		ps.setString(2, dateiID);
		ps.setInt(3, part);
		ps.setInt(4, leng);
		ps.setBlob(5, daten);
		ps.execute();
	}

Bei der Methode liesDatei(datei, offsetDatei) entsteht noch kein Fehler. Also muss es an der Befüllung der Datenbank liegen.
Falls dies nicht genügt kann ich den Rest noch hinterher werfen.


Gruß Jan

 

[SlaterB]

hilft ein close() auf das PreparedStatement?

void close()
throws SQLException

Releases this Statement object's database and JDBC resources immediately instead of waiting for this to happen when it is automatically closed. It is generally good practice to release resources as soon as you are finished with them to avoid tying up database resources.

Calling the method close on a Statement object that is already closed has no effect.

Note:When a Statement object is closed, its current ResultSet object, if one exists, is also closed.

?
zu den offengehaltenen Ressourcen könnte auch der ByteArrayInputStream mit dem großen Array gehören

-------

werden die PreparedStatements überhaupt sofort ausgeführt und commited?
kannst du in der Schleife mit einem separaten select nachprüfen, ob die einzelnen DB-Einträge da sind?

wie groß sind überhaupt die Teile, funktioniert 15 MB = 5 * 3MB und gibts bei 20 MB dann die Exception beim 6. oder 7. Teil
oder schon früher?

--------

generell sparender:
lies die Daten nicht in ein Byte-Array sondern übergib an das PreparedStatement ein InputStream einer eigenen Klasse,
die dann je nach Anfrage Daten direkt aus der Datei einliest,

kommt dann im weiteren darauf an, wie das PreparedStatement auf den InputStream zugreift, wenn es auch ein riesiges Array abfragt,
ist vielleicht nichts gewonnen (obwohl dann dieses temporäre Array vielleicht nicht länger gehalten wird, ergo kein Speicherproblem bei mehreren),
wenn es aber in einer Schleife jeweils nur 1 KB Daten lädt, dann sollte die Speicherbelastung gar auch nicht viel höher gehen

 

[ElJarno]

Also ich hab eine 44 Mb große Test-Datei. Bei 2 MB splitte ich die Datei, dann gibts bei dem 12 Paket die Exception splitte ich bei 2 MB gibts die Excpeption bei dem 23 Paket. Also hat die Paktegröße nicht wirklich was damit zu tun.

generell sparender:
lies die Daten nicht in ein Byte-Array sondern übergib an das PreparedStatement ein InputStream einer eigenen Klasse,
die dann je nach Anfrage Daten direkt aus der Datei einliest,

kommt dann im weiteren darauf an, wie das PreparedStatement auf den InputStream zugreift, wenn es auch ein riesiges Array abfragt,
ist vielleicht nichts gewonnen (obwohl dann dieses temporäre Array vielleicht nicht länger gehalten wird, ergo kein Speicherproblem bei mehreren),
wenn es aber in einer Schleife jeweils nur 1 KB Daten lädt, dann sollte die Speicherbelastung gar auch nicht viel höher gehen

Kannst du mir eine Konkreten Code zeigen wie du das mit dem PreparedStatement meinst.
Zur Info die PreparedStatements werden sofort Commited. Gibts denn ne andere Möglichkeit. Wäre ja interessant damit, wenns beim letztetn Paket Exceptions gibt die vorherigen Pakete nicht gespeichert werden bzw. sowas wie ein rollback durchgeführt wird. Ne Idee?

Trotzdem schon mal danke für die vielen Anregungen

Gruß Jan

 

[SlaterB]

close() bringt nix?

-------

> bzw. sowas wie ein rollback durchgeführt wird. Ne Idee?

AutoCommit false falls eingeschaltet und am Ende eben kein Commit sondern rollback() oder gar nicht,
kann bei SQL jetzt wenig dazu sagen, nach Tutorials richten

> Kannst du mir eine Konkreten Code zeigen wie du das mit dem PreparedStatement meinst.

einfach einen anderen InputStream übergeben, den zu programmieren ist natürlich eine größere Aufgabe, mit Analyse, wie denn das PreparedStatement darauf zugreift, das werde ich nicht alles schreiben,
kann ich auch kaum ohne es zu testen und habe wie gesagt kein SQL-Zugriff verfügbar,
ganz grob

class MyStream {

// FileInputStream usw. vorbereiten

@Override
public int read(byte[]) {
  // hier kommt die Anfrage des PreparedStatement
  // hier genau zum richtigen Zeitpunkt genau die gewünschte Anzahl aus der Datei lesen
  // evtl. selber Anfang/ Ende des aktuellen Teils mitzählen und nach genügend Bytes -1 zurückgeben, was Ende signalisiert
  // auch wenn in der Datei noch was drinsteht -> das ist fürs nächste Paket
}


}

 

[ElJarno]

Wie blöd von mir der Fehler lag nicht beim schreiben in die Datenbank sondern beim wieder heraus holen.
Hier mal der Code für das Zusammensetzten der Pakte aus der DB:

	private void lesePDFausDB(String dateiID, String pfad) throws SQLException, IOException {
		String where = "DATEI_ID = '" + dateiID + "'";
		String sortBy = "PART";
		Vector<Byte> byteDaten = new Vector<Byte>();
		Vector<Vector<Object>> vectorDaten = this.dbBinaerDaten.readBinaerDaten(where, sortBy, 0);
		BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(pfad, true));
		for (Vector<Object> daten : vectorDaten) {
			byte[] bytePart = (byte[]) daten.get(4);
			for (byte by : bytePart) {
				byteDaten.add(by);
			}
		}
		byte[] by = new byte[byteDaten.size()];
		for (int i = 0; i < byteDaten.size(); i++) {
			by[i] = byteDaten.get(i);
		}
		output.write(by);
		output.close();
	}

Kann mir vorstellen dass es an den beiden Schleifen liegt. Vielleicht hast du ja einen anderen Ansatz.
Hier noch der Code zum Einlesen der Pakete aus der DB:

	public Vector<Vector<Object>> readBinaerDaten(String where, String sortBy, int sortOrder)
			throws SQLException {
		Vector<Vector<Object>> daten = null;
		StringBuffer sqlB = new StringBuffer();
		sqlB.append("select * from BINAER_DATEN ");
		sqlB.append("where ");
		sqlB.append(where);
		sqlB.append(" order by ");
		sqlB.append(sortBy);
		if (sortOrder == 1) {
			sqlB.append(" desc");
		}
		if (!where.contains(";"))
			sqlB.append(";");
		daten = this.readMySQLTable(sqlB.toString());

		return daten;
	}// end of readBlob where

 

[SlaterB]

nunja, Arbeitsspeicher ist begrenzt wie eine Einkaufstüte,

in letztere passen nicht mehr als 70 Salatköpfe, und ein Java-Programm kann nicht beliebig viele MB an bytes halten,
so ist das Leben,

du kannst einem Java-Programm mehr Speicher zuweisen, statt standardmäßig 64 MB auch paar GB, siehe google

oder du sparst wiederum Speicher, z.B. die byte-Arrays nicht alle gleichzeitig in eine Liste stecken,
sondern immer nur eins lesen, in den Stream schreiben, dann das nächste lesen usw.

 

[ElJarno]

So habs nun hinbekommen.
Danke noch mal.
Hier noch der Code für spätere Generationen:toll:

Zum schreiben einer Datei in die DB:

	public void writeBinaerDaten(String dateiID, int packetGroesse, File datei)
			throws SQLException, IOException {
		BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(datei));
		long dateiGroesse = datei.length();
		int partNr = 0;
		if (dateiGroesse <= Integer.MAX_VALUE) {
			int bytesLeft = (int) dateiGroesse;

			while (bytesLeft > 0) {
				String objid = ObjectID.getOBJID(199);

				java.sql.PreparedStatement ps = this.getConnection().prepareStatement(
						"INSERT into BINAER_DATEN VALUES(?,?,?,?,?)");
				ps.setString(1, objid);
				ps.setString(2, dateiID);
				ps.setInt(3, partNr);
				ps.setInt(4, packetGroesse);
				ps.setBinaryStream(5, inputStream, packetGroesse);
				ps.execute();
				ps.close();
				partNr += 1;
				bytesLeft -= packetGroesse;
			}
		} else {
			throw new IOException("Datei ist zu groß! " + datei.getName());
		}

	}

Zum herausholen einer Datei aus der DB und die abschließende Speicherung auf der Festplatte.

	public void readBinaerDaten(String dateiID, int packetGroesse, File datei) throws SQLException,
			IOException {
		ResultSet resultSet = null;
		StringBuffer sqlB = new StringBuffer();
		byte[] bytes = null;
		BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(datei, false));

		sqlB.append("select DATEN from BINAER_DATEN ");
		sqlB.append("where DATEI_ID = '" + dateiID + "'");
		sqlB.append(" order by PART");
		sqlB.append(";");
		resultSet = this.getStatement().executeQuery(sqlB.toString());

		while (resultSet.next()) {
			bytes = resultSet.getBytes("DATEN");
			output.write(bytes);

		}
		output.close();
		resultSet.close();
	}

Gruß Jan