/*
- * put your module comment here
+ * Copyright (C) 2001, 2002 The Mir-coders group
+ *
+ * This file is part of Mir.
+ *
+ * Mir is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Mir is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Mir; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * In addition, as a special exception, The Mir-coders gives permission to link
+ * the code of this program with the com.oreilly.servlet library, any library
+ * licensed under the Apache Software License, The Sun (tm) Java Advanced
+ * Imaging library (JAI), The Sun JIMI library (or with modified versions of
+ * the above that use the same license as the above), and distribute linked
+ * combinations including the two. You must obey the GNU General Public
+ * License in all respects for all of the code used other than the above
+ * mentioned libraries. If you modify this file, you may extend this exception
+ * to your version of the file, but you are not obligated to do so. If you do
+ * not wish to do so, delete this exception statement from your version.
*/
+
package mir.storage;
import java.sql.*;
import java.lang.*;
import java.io.*;
import java.util.*;
+import java.text.SimpleDateFormat;
+import java.text.ParseException;
import freemarker.template.*;
+import com.codestudio.sql.*;
+import com.codestudio.util.*;
+
import mir.storage.StorageObject;
+import mir.storage.store.*;
import mir.entity.*;
import mir.misc.*;
-import com.codestudio.sql.*;
-import com.codestudio.util.*;
/**
* Treiber, Host, User und Passwort, ueber den der Zugriff auf die
* Datenbank erfolgt.
*
- * @author RK
- * @version 16.7.1999
+ * @version $Revision: 1.21.2.4 $ $Date: 2002/12/20 03:01:01 $
+ * @author $Author: mh $
+ *
*/
public class Database implements StorageObject {
protected String theTable;
protected String theCoreTable=null;
protected String thePKeyName="id";
- protected int thePKeyType;
+ protected int thePKeyType, thePKeyIndex;
protected boolean evaluatedMetaData=false;
protected ArrayList metadataFields,metadataLabels,
metadataNotNullFields;
protected int[] metadataTypes;
protected Class theEntityClass;
protected StorageObject myselfDatabase;
-
- /** @todo DatabaseCache will soon be replaced by
- * ObjectStore. Points to interweave Database with
- * ObjectStore are marked "todo: OS:" below */
- protected DatabaseCache cache;
-
protected SimpleList popupCache=null;
protected boolean hasPopupCache = false;
protected SimpleHash hashCache=null;
protected boolean hasTimestamp=true;
- private String database_driver;
- private String database_url;
+ private String database_driver, database_url;
private int defaultLimit;
protected DatabaseAdaptor theAdaptor;
protected Logfile theLog;
- protected static final SimpleHash POPUP_EMTYLINE=new SimpleHash();
+ private static Class GENERIC_ENTITY_CLASS=null,
+ STORABLE_OBJECT_ENTITY_CLASS=null;
+ private static SimpleHash POPUP_EMTYLINE=new SimpleHash();
+ protected static final ObjectStore o_store=ObjectStore.getInstance();
+ private SimpleDateFormat _dateFormatterOut =
+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+ private SimpleDateFormat _dateFormatterIn =
+ new SimpleDateFormat("yyyy-MM-dd HH:mm");
+ private Calendar _cal = new GregorianCalendar();
+
+ private static final int _millisPerHour = 60 * 60 * 1000;
+ private static final int _millisPerMinute = 60 * 1000;
static {
// always same object saves a little space
POPUP_EMTYLINE.put("key", ""); POPUP_EMTYLINE.put("value", "--");
+ try {
+ GENERIC_ENTITY_CLASS = Class.forName("mir.entity.StorableObjectEntity");
+ STORABLE_OBJECT_ENTITY_CLASS = Class.forName("mir.entity.StorableObjectEntity");
+ }
+ catch (Exception e) {
+ System.err.println("FATAL: Database.java could not initialize" + e.toString());
+ }
+ }
- /** @todo OS: init ObjectStore*/
- }
/**
* Kontruktor bekommt den Filenamen des Konfigurationsfiles übergeben.
String theAdaptorName=MirConfig.getProp("Database.Adaptor");
defaultLimit = Integer.parseInt(MirConfig.getProp("Database.Limit"));
try {
- theEntityClass = Class.forName("mir.entity.GenericEntity");
+ theEntityClass = GENERIC_ENTITY_CLASS;
theAdaptor = (DatabaseAdaptor)Class.forName(theAdaptorName).newInstance();
} catch (Exception e){
theLog.printError("Error in Database() constructor with "+
break;
case java.sql.Types.CHAR:case java.sql.Types.VARCHAR:case java.sql.Types.LONGVARCHAR:
outValue = rs.getString(valueIndex);
- //if (outValue != null)
- //outValue = StringUtil.encodeHtml(StringUtil.unquote(outValue));
break;
case java.sql.Types.LONGVARBINARY:
outValue = rs.getString(valueIndex);
- //if (outValue != null)
- //outValue = StringUtil.encodeHtml(StringUtil.unquote(outValue));
break;
case java.sql.Types.TIMESTAMP:
- Timestamp timestamp = (rs.getTimestamp(valueIndex));
- if (!rs.wasNull()) {
- outValue = timestamp.toString();
- }
+ // it's important to use Timestamp here as getting it
+ // as a string is undefined and is only there for debugging
+ // according to the API. we can make it a string through formatting.
+ // -mh
+ Timestamp timestamp = (rs.getTimestamp(valueIndex));
+ if(!rs.wasNull()) {
+ java.util.Date date = new java.util.Date(timestamp.getTime());
+ outValue = _dateFormatterOut.format(date);
+ _cal.setTime(date);
+ int offset = _cal.get(Calendar.ZONE_OFFSET)+
+ _cal.get(Calendar.DST_OFFSET);
+ String tzOffset = StringUtil.zeroPaddingNumber(
+ offset/_millisPerHour,2,2);
+ outValue = outValue+"+"+tzOffset;
+ }
break;
default:
outValue = "<unsupported value>";
* @param id Primaerschluessel des Datensatzes.
* @return liefert EntityObject des gefundenen Datensatzes oder null.
*/
- public Entity selectById(String id)
- throws StorageObjectException {
-
+ public Entity selectById(String id) throws StorageObjectException
+ {
if (id==null||id.equals(""))
throw new StorageObjectException("id war null");
- /** @todo OS: build StoreIdenfier and check ObjectStore for StoreIdentifier */
- if (cache != null && (cache.containsKey(id) > -1))
- return (Entity)cache.get(id); // wenn cache gesetzt, evtl. kein roundtrip zur Datenbank
+ // ask object store for object
+ if ( StoreUtil.implementsStorableObject(theEntityClass) ) {
+ String uniqueId = id;
+ if ( theEntityClass.equals(StorableObjectEntity.class) )
+ uniqueId+="@"+theTable;
+ StoreIdentifier search_sid = new StoreIdentifier(theEntityClass, uniqueId);
+ theLog.printDebugInfo("CACHE: (dbg) looking for sid " + search_sid.toString());
+ Entity hit = (Entity)o_store.use(search_sid);
+ if ( hit!=null ) return hit;
+ }
Statement stmt=null;Connection con=getPooledCon();
Entity returnEntity=null;
*/
public EntityList selectByWhereClause(String wc, String ob, int offset, int limit)
- throws StorageObjectException {
+ throws StorageObjectException
+ {
+
+ // check o_store for entitylist
+ if ( StoreUtil.implementsStorableObject(theEntityClass) ) {
+ StoreIdentifier search_sid =
+ new StoreIdentifier( theEntityClass,
+ StoreContainerType.STOC_TYPE_ENTITYLIST,
+ StoreUtil.getEntityListUniqueIdentifierFor(theTable,wc,ob,offset,limit) );
+ EntityList hit = (EntityList)o_store.use(search_sid);
+ if ( hit!=null ) {
+ theLog.printDebugInfo("CACHE (hit): " + search_sid.toString());
+ return hit;
+ }
+ }
// local
EntityList theReturnList=null;
- Connection con=null;
- Statement stmt=null;
+ Connection con=null; Statement stmt=null;
ResultSet rs;
int offsetCount = 0, count=0;
}
}
- /** @todo OS: make StoreIdentifier and ask Ostore*/
-
// execute sql
try {
con = getPooledCon();
theReturnList.setOffset(offset);
theReturnList.setWhere(wc);
theReturnList.setOrder(ob);
- if (offset >= limit) {
+ theReturnList.setStorage(this);
+ theReturnList.setLimit(limit);
+ if ( offset >= limit )
theReturnList.setPrevBatch(offset - limit);
- }
- if (offset + offsetCount < count) {
+ if ( offset+offsetCount < count )
theReturnList.setNextBatch(offset + limit);
- }
+ if ( StoreUtil.implementsStorableObject(theEntityClass) ) {
+ StoreIdentifier sid=theReturnList.getStoreIdentifier();
+ theLog.printDebugInfo("CACHE (add): " + sid.toString());
+ o_store.add(sid);
+ }
}
}
- catch (SQLException sqe) {
- throwSQLException(sqe, "selectByWhereClause");
- }
- finally {
- freeConnection(con, stmt);
- }
+ catch (SQLException sqe) { throwSQLException(sqe, "selectByWhereClause"); }
+ finally { freeConnection(con, stmt); }
return theReturnList;
}
// alle durchlaufen bis nix mehr da
theType = metadataTypes[i];
if (theType == java.sql.Types.LONGVARBINARY) {
- InputStream us = rs.getAsciiStream(i + 1);
- if (us != null) {
- InputStreamReader is = new InputStreamReader(us);
+ InputStreamReader is = (InputStreamReader)rs.getCharacterStream(i + 1);
+ if (is != null) {
char[] data = new char[32768];
StringBuffer theResultString = new StringBuffer();
int len;
theResultHash.put(metadataFields.get(i), theResult);
}
}
-
- /** @todo why fetching all data (above) and then consulting the
- * cache? we should fetch pkeyname first // rk */
- if (cache != null && theResultHash.containsKey(thePKeyName) &&
- (cache.containsKey((String)theResultHash.get(thePKeyName)) > -1)) {
- returnEntity = (Entity)cache.get((String)theResultHash.get(thePKeyName));
- } else {
- if (theEntityClass != null) {
- returnEntity = (Entity)theEntityClass.newInstance();
- returnEntity.setValues(theResultHash);
- returnEntity.setStorage(myselfDatabase);
- if (cache != null) {
- //theLog.printDebugInfo("CACHE: ( in) " + returnEntity.getId() + " :"+theTable);
- /** @todo put element into ObjectStore */
- cache.put(returnEntity.getId(), returnEntity);
- }
- } else {
- throwStorageObjectException("Internal Error: theEntityClass not set!");
- }
- }
+ if (theEntityClass != null) {
+ returnEntity = (Entity)theEntityClass.newInstance();
+ returnEntity.setValues(theResultHash);
+ returnEntity.setStorage(myselfDatabase);
+ if ( returnEntity instanceof StorableObject ) {
+ theLog.printDebugInfo("CACHE: ( in) " + returnEntity.getId() + " :"+theTable);
+ o_store.add(((StorableObject)returnEntity).getStoreIdentifier());
+ }
+ } else {
+ throwStorageObjectException("Internal Error: theEntityClass not set!");
+ }
} catch (IllegalAccessException e) {
throwStorageObjectException("Kein Zugriff! -- " + e.toString());
} catch (IOException e) {
* @return der Wert des Primary-keys der eingefügten Entity
*/
public String insert (Entity theEntity) throws StorageObjectException {
- String returnId = null;
- Connection con = null;
- PreparedStatement pstmt = null;
//cache
invalidatePopupCache();
- /** @todo OS: if Entity is StorableObject, invalidate in ObjectStore
- * careful: Entity has no id yet! */
- try {
+
+ // invalidating all EntityLists corresponding with theEntityClass
+ if ( StoreUtil.implementsStorableObject(theEntityClass) ) {
+ StoreContainerType stoc_type =
+ StoreContainerType.valueOf( theEntityClass,
+ StoreContainerType.STOC_TYPE_ENTITYLIST);
+ o_store.invalidate(stoc_type);
+ }
+
+ String returnId = null;
+ Connection con = null; PreparedStatement pstmt = null;
+
+ try {
ArrayList streamedInput = theEntity.streamedInput();
StringBuffer f = new StringBuffer();
StringBuffer v = new StringBuffer();
if (!aField.equals(thePKeyName)) {
aValue = null;
// sonderfaelle
- if (aField.equals("webdb_create")) {
+ if (aField.equals("webdb_create") ||
+ aField.equals("webdb_lastchange")) {
aValue = "NOW()";
}
else {
}
else {
if (theEntity.hasValueForField(aField)) {
- aValue = "'" + StringUtil.quote((String)theEntity.getValue(aField))
+ aValue = "'" + StringUtil.JDBCescapeStringLiteral((String)theEntity.getValue(aField))
+ "'";
}
}
// insert into db
StringBuffer sqlBuf = new StringBuffer("insert into ").append(theTable).append("(").append(f).append(") values (").append(v).append(")");
String sql = sqlBuf.toString();
- theLog.printInfo("INSERT: " + sql);
+ //theLog.printInfo("INSERT: " + sql);
con = getPooledCon();
con.setAutoCommit(false);
pstmt = con.prepareStatement(sql);
}
freeConnection(con, pstmt);
}
+ /** @todo store entity in o_store */
return returnId;
}
*
* @param theEntity
*/
- public void update (Entity theEntity) throws StorageObjectException {
- Connection con = null;
+ public void update (Entity theEntity) throws StorageObjectException
+ {
+ Connection con = null; PreparedStatement pstmt = null;
/** @todo this is stupid: why do we prepare statement, when we
* throw it away afterwards. should be regular statement
* update/insert could better be one routine called save()
* that chooses to either insert or update depending if we
* have a primary key in the entity. i don't know if we
* still need the streamed input fields. // rk */
- /** @todo extension: check if Entity did change, otherwise we don't need */
- /** @todo OS: invalidate in Ostore if Entity is StorableObject */
- PreparedStatement pstmt = null;
+
+ /** @todo extension: check if Entity did change, otherwise we don't need
+ * the roundtrip to the database */
+
+ /** invalidating corresponding entitylists in o_store*/
+ if ( StoreUtil.implementsStorableObject(theEntityClass) ) {
+ StoreContainerType stoc_type =
+ StoreContainerType.valueOf( theEntityClass,
+ StoreContainerType.STOC_TYPE_ENTITYLIST);
+ o_store.invalidate(stoc_type);
+ }
+
ArrayList streamedInput = theEntity.streamedInput();
String id = theEntity.getId();
String aField;
else {
firstField = false;
}
- fv.append(aField).append("='").append(StringUtil.quote((String)theEntity.getValue(aField))).append("'");
+ fv.append(aField).append("='").append(StringUtil.JDBCescapeStringLiteral((String)theEntity.getValue(aField))).append("'");
}
}
}
if (metadataFields.contains("webdb_lastchange")) {
sql.append(",webdb_lastchange=NOW()");
}
+ // special case: the webdb_create requires the field in yyyy-mm-dd HH:mm
+ // format so anything extra will be ignored. -mh
+ if (metadataFields.contains("webdb_create") &&
+ theEntity.hasValueForField("webdb_create")) {
+ // minimum of 10 (yyyy-mm-dd)...
+ if (theEntity.getValue("webdb_create").length() >= 10) {
+ String dateString = theEntity.getValue("webdb_create");
+ // if only 10, then add 00:00 so it doesn't throw a ParseException
+ if (dateString.length() == 10)
+ dateString=dateString+" 00:00";
+
+ // TimeStamp stuff
+ try {
+ java.util.Date d = _dateFormatterIn.parse(dateString);
+ Timestamp tStamp = new Timestamp(d.getTime());
+ sql.append(",webdb_create='"+tStamp.toString()+"'");
+ } catch (ParseException e) {
+ throw new StorageObjectException(e.toString());
+ }
+ }
+ }
if (streamedInput != null) {
for (int i = 0; i < streamedInput.size(); i++) {
sql.append(",").append(streamedInput.get(i)).append("=?");
}
}
sql.append(" where id=").append(id);
- theLog.printInfo("UPDATE: " + sql);
+ //theLog.printInfo("UPDATE: " + sql);
// execute sql
try {
con = getPooledCon();
* @return boolean liefert true zurueck, wenn loeschen erfolgreich war.
*/
public boolean delete (String id) throws StorageObjectException {
- Statement stmt = null;
- Connection con = null;
- String sql;
- int res = 0;
- // loeschen des caches
+
invalidatePopupCache();
- /** @todo OS: invalidate if StorableObject */
+ // ostore send notification
+ if ( StoreUtil.implementsStorableObject(theEntityClass) ) {
+ String uniqueId = id;
+ if ( theEntityClass.equals(StorableObjectEntity.class) )
+ uniqueId+="@"+theTable;
+ theLog.printInfo("CACHE: (del) " + id);
+ StoreIdentifier search_sid =
+ new StoreIdentifier(theEntityClass, StoreContainerType.STOC_TYPE_ENTITY, uniqueId);
+ o_store.invalidate(search_sid);
+ }
+
/** @todo could be prepared Statement */
- sql = "delete from " + theTable + " where " + thePKeyName + "='" + id +
- "'";
- theLog.printInfo("DELETE " + sql);
+ Statement stmt = null; Connection con = null;
+ int res = 0;
+ String sql="delete from "+theTable+" where "+thePKeyName+"='"+id+"'";
+ //theLog.printInfo("DELETE " + sql);
try {
- con = getPooledCon();
- stmt = con.createStatement();
+ con = getPooledCon(); stmt = con.createStatement();
res = stmt.executeUpdate(sql);
- } catch (SQLException sqe) {
- throwSQLException(sqe, "delete");
- } finally {
- freeConnection(con, stmt);
- }
- /** @todo should take place before we delete */
- if (cache != null) {
- theLog.printInfo("CACHE: deleted " + id);
- cache.remove(id);
}
+ catch (SQLException sqe) { throwSQLException(sqe, "delete"); }
+ finally { freeConnection(con, stmt); }
+
return (res > 0) ? true : false;
}
freeConnection(con,stmt);
}
//theLog.printInfo(theTable + " has "+ result +" rows where " + where);
- theLog.printInfo((System.currentTimeMillis() - startTime) + "ms. for: "
- + sql);
+ //theLog.printInfo((System.currentTimeMillis() - startTime) + "ms. for: " + sql);
return result;
}
try
{
rs = stmt.executeUpdate(sql);
- theLog.printInfo((new java.util.Date().getTime() - startTime) + "ms. for: "
- + sql);
+ //theLog.printInfo((new java.util.Date().getTime() - startTime) + "ms. for: " + sql);
}
catch (SQLException e)
{
result = pstmt.executeUpdate();
}
catch (Exception e) {
- theLog.printDebugInfo("settimage :: setImage gescheitert: "+e.toString());
+ theLog.printDebugInfo("executeUpdate failed: "+e.toString());
throw new StorageObjectException("executeUpdate failed: "+e.toString());
}
finally { freeConnection(con,pstmt); }
- theLog.printInfo((new java.util.Date().getTime() - startTime) + "ms. for: "
- + sql);
+ //theLog.printInfo((new java.util.Date().getTime() - startTime) + "ms. for: " + sql);
return result;
}
aType = md.getColumnType(i);
metadataTypes[i - 1] = aType;
if (aField.equals(thePKeyName)) {
- thePKeyType = aType;
+ thePKeyType = aType; thePKeyIndex = i;
}
if (md.isNullable(i) == md.columnNullable) {
metadataNotNullFields.add(aField);
try {
con = getPooledCon();
pstmt = con.prepareStatement(sql);
- theLog.printInfo("METADATA: " + sql);
+ //theLog.printInfo("METADATA: " + sql);
ResultSet rs = pstmt.executeQuery();
evalMetaData(rs.getMetaData());
rs.close();