--- a/build.sh	Wed Nov 06 21:21:53 2024 -0700
+++ b/build.sh	Sun Oct 05 17:24:15 2025 -0600
@@ -1,5 +1,8 @@
+#!/bin/bash
 set -e
+
 . classpath.sh
 cd src
+javac fschmidt/tools/Mmake.java
 java fschmidt.tools.Mmake
 make

Binary file lib/fschmidt.jar has changed

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbArcana.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,38 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+
+public interface DbArcana {
+	public String quoteIdentifier(String identifier);
+	public String getLastSeqValFn();
+	public String dateSub(String date,int n,String units);
+	public void setValue(PreparedStatement stmt,int idx,Object value) throws SQLException;
+	public String quote(String s);
+	public String stringEncode(String s);
+	public String quote(java.util.Date date);
+	public String stringEncode(java.util.Date date);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbDatabase.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,47 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Map;
+
+
+public interface DbDatabase {
+	public void setProperty(String key,String value);
+	public DbArcana arcana();
+	public Connection getConnection() throws SQLException;
+	public <K extends DbKey,V extends DbObject<K,V>> DbTable<K,V> newTable(String tableName,DbKeySetter<K> keySetter,DbObjectFactory<K,V> objectFactory);
+	public boolean isInTransaction();
+	public void beginTransaction() throws SQLRuntimeException;
+	public void commitTransaction() throws SQLRuntimeException;
+	public void endTransaction() throws SQLRuntimeException;
+	public Map<String,Object> transactionMap();
+	public void runBeforeCommit(Runnable r);
+	public void runAfterCommit(Runnable r);
+	public void ignoreRunnablesInThisTransaction();
+
+	public DbKeySetter<LongKey> newIdentityLongKeySetter(String fieldName);
+	public DbKeySetter<LongKey> newAssignedLongKeySetter(String fieldName);
+	public DbKeySetter<StringKey> newAssignedStringKeySetter(String fieldName);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbExpression.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,38 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+
+public class DbExpression {
+	private final String expr;
+
+	public DbExpression(String expr) {
+		this.expr = expr;
+	}
+
+	public String toString() {
+		return expr;
+	}
+
+	public static final DbExpression NOW = new DbExpression("now()");
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbFinder.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,49 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+
+public class DbFinder {
+
+	public static DbDatabase getDatabase(String url,String user,String password) {
+		return
+			new fschmidt.db.cache.DbDatabaseImpl(
+				new fschmidt.db.pool.DbDatabaseImpl(
+					getBaseDatabase(url,user,password)
+				)
+			)
+		;
+	}
+
+	public static DbDatabase getBaseDatabase(String url,String user,String password) {
+		if( url.startsWith("jdbc:mysql:") )
+			return new fschmidt.db.mysql.DbDatabaseImpl(url,user,password);
+		if( url.startsWith("jdbc:postgresql:") )
+			return new fschmidt.db.postgres.DbDatabaseImpl(url,user,password);
+		if( url.startsWith("jdbc:h2:") )
+			return new fschmidt.db.h2.DbDatabaseImpl(url,user,password);
+		throw new IllegalArgumentException("unrecognized database type");
+	}
+
+	private DbFinder() {}  // never
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbKey.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,26 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+
+public interface DbKey {}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbKeySetter.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,40 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Collection;
+
+
+public interface DbKeySetter<K extends DbKey> {
+	public PreparedStatement prepareStatement(Connection con,K key,String sql,int keyIndex)
+		throws SQLException;
+	public PreparedStatement prepareStatement(Connection con,Collection<K> keys,String sql,DbArcana dbArcana)
+		throws SQLException;
+	public K refreshKeyAfterInsert(Connection con,DbRecord<K,? extends DbObject> record) throws SQLException;
+	public K getKey(ResultSet rs) throws SQLException;
+	public K getKey(ResultSet rs,String tableName) throws SQLException;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbNull.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,63 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+import java.util.Date;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Types;
+
+
+public final class DbNull implements DbStorable {
+	public final int sqlType;
+
+	public DbNull(int sqlType) {
+		this.sqlType = sqlType;
+	}
+
+	public void setField(PreparedStatement stmt,int idx) throws SQLException {
+		stmt.setNull(idx,sqlType);
+	}
+
+	public static final DbNull BOOLEAN = new DbNull(Types.BOOLEAN);
+	public static final DbNull STRING = new DbNull(Types.VARCHAR);
+	public static final DbNull TIMESTAMP = new DbNull(Types.TIMESTAMP);
+	public static final DbNull INTEGER = new DbNull(Types.INTEGER);
+	public static final DbNull FLOAT = new DbNull(Types.FLOAT);
+
+	public static Object fix(boolean b) {
+		return b ? Boolean.TRUE : BOOLEAN;
+	}
+	public static Object fix(Boolean b) {
+		return b!=null ? b : BOOLEAN;
+	}
+	public static Object fix(String s) {
+		return s!=null ? s : STRING;
+	}
+	public static Object fix(Date date) {
+		return date!=null ? date : TIMESTAMP;
+	}
+	public static Object fix(int i) {
+		return i!=0 ? Integer.valueOf(i) : INTEGER;
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbObject.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,28 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+
+public interface DbObject<K extends DbKey,V extends DbObject> {
+	public DbRecord<K,V> getDbRecord();
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbObjectFactory.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,32 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+
+public interface DbObjectFactory<K extends DbKey,V extends DbObject> {
+	public V makeDbObject(K key,ResultSet rs,String tableName)
+		throws SQLException;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbRecord.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,38 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+import java.util.Map;
+
+
+public interface DbRecord<K extends DbKey,V extends DbObject> {
+	public V getDbObject();
+	public K getPrimaryKey();
+	public void insert() throws SQLRuntimeException;
+	public void update() throws SQLRuntimeException;
+	public void delete() throws SQLRuntimeException;
+	public boolean isStale();
+	public boolean isInDb();
+	public DbTable<K,V> getDbTable();
+	public Map<String,Object> fields();
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbStorable.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,31 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+
+public interface DbStorable {
+	public void setField(PreparedStatement stmt,int idx) throws SQLException;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbTable.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,47 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Collection;
+import java.util.Map;
+
+
+public interface DbTable<K extends DbKey,V extends DbObject> {
+	public String getTableName();
+	public V findByPrimaryKey(K key);
+	public Map<K,V> findByPrimaryKey(Collection<K> keys);
+	public V getDbObject(ResultSet rs) throws SQLException;
+	public V getDbObject(ResultSet rs,String tableName) throws SQLException;
+	public DbRecord<K,V> newRecord(V obj,K key);  // in db
+	public DbRecord<K,V> newRecord(V obj);  // not in db
+	public DbDatabase getDbDatabase();
+	public ListenerList<V> getPreInsertListeners();
+	public ListenerList<V> getPostInsertListeners();
+	public ListenerList<V> getPreUpdateListeners();
+	public ListenerList<V> getPostUpdateListeners();
+	public ListenerList<V> getPreDeleteListeners();
+	public ListenerList<V> getPostDeleteListeners();
+	public void uncache(K key);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/DbUtils.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,89 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.Date;
+
+
+public final class DbUtils {
+	private DbUtils() {}  // never
+
+	public static <K extends DbKey,V extends DbObject<K,V>> V getGoodCopy(V obj) {
+		if( obj==null )
+			return null;
+		DbRecord<K,V> record = obj.getDbRecord();
+		return !record.isStale() ? obj
+			: record.getDbTable().findByPrimaryKey(record.getPrimaryKey());
+	}
+
+	public static <K extends DbKey,V extends DbObject<K,V>> void uncache(V obj) {
+		DbRecord<K,V> record = obj.getDbRecord();
+		record.getDbTable().uncache(record.getPrimaryKey());
+	}
+
+	public static boolean isStale(DbObject obj) {
+		return obj==null || obj.getDbRecord().isStale();
+	}
+
+	public static boolean isStale(DbObject[] objs) {
+		if( objs==null )
+			return true;
+		for( int i=0; i<objs.length; i++ ) {
+			if( isStale(objs[i]) )
+				return true;
+		}
+		return false;
+	}
+
+	public static boolean isEqual(DbObject o1,DbObject o2) {
+		DbRecord r1 = o1.getDbRecord();
+		DbRecord r2 = o2.getDbRecord();
+		if( !r1.isInDb() )
+			return o1.equals(o2);
+		return r1.getPrimaryKey().equals(r2.getPrimaryKey());
+	}
+
+	public static Date getDate(ResultSet rs,String columnName) throws SQLException {
+		java.sql.Timestamp ts = rs.getTimestamp(columnName);
+		return ts==null ? null : new Date(ts.getTime());
+	}
+
+	public static void test(DbDatabase db) {
+		try {
+			Connection con = db.getConnection();
+			try {
+				Statement stmt = con.createStatement();
+				stmt.executeQuery("select 1");
+				stmt.close();
+			} finally {
+				con.close();
+			}
+		} catch(SQLException e) {
+			throw new RuntimeException("test failed",e);
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/Listener.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,28 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+
+public interface Listener<T> {
+	public void event(T source);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/ListenerList.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,56 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+import java.util.List;
+import java.util.ArrayList;
+
+
+public final class ListenerList<T> implements Listener<T> {
+	private List<Listener<? super T>> listeners = new ArrayList<Listener<? super T>>();
+	private Exception firstFired = null;
+
+	public synchronized void add(Listener<? super T> listener) {
+		if( firstFired != null )
+			throw new IllegalStateException("adding to ListenerList after already in use",firstFired);
+		listeners.add(listener);
+	}
+/*
+	public synchronized void remove(Listener<? super T> listener) {
+		listeners.remove(listener);
+	}
+*/
+	public void event(T obj) {
+		synchronized(this) {
+			if( firstFired == null )
+				firstFired = new Exception("first fired");
+		}
+		for( Listener<? super T> listener : listeners ) {
+			listener.event(obj);
+		}
+	}
+
+	public boolean isEmpty() {
+		return listeners.isEmpty();
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/LongKey.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,48 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+
+public final class LongKey implements DbKey {
+	private final long id;
+
+	public LongKey(long id) {
+		this.id = id;
+	}
+
+	public long value() {
+		return id;
+	}
+
+	public int hashCode() {
+		return (int)id;
+	}
+
+	public boolean equals(Object obj) {
+		return obj instanceof LongKey && ((LongKey)obj).id==id;
+	}
+
+	public String toString() {
+		return Long.toString(id);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/NoKey.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,6 @@
+package fschmidt.db;
+
+
+public enum NoKey implements DbKey {
+	INSTANCE
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/NoKeySetter.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,52 @@
+package fschmidt.db;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Connection;
+import java.sql.Statement;
+import java.util.Collection;
+import java.util.Iterator;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbKeySetter;
+import fschmidt.db.DbObject;
+import fschmidt.db.NoKey;
+import fschmidt.db.DbArcana;
+import fschmidt.db.DbRecord;
+
+
+public enum NoKeySetter implements DbKeySetter<NoKey> {
+
+	INSTANCE;
+
+	public PreparedStatement prepareStatement(Connection con,NoKey key,String sql,int keyIndex)
+		throws SQLException
+	{
+		PreparedStatement stmt = con.prepareStatement(
+			sql
+		);
+		return stmt;
+	}
+
+	public PreparedStatement prepareStatement(Connection con,Collection<NoKey> keys,String sql,DbArcana dbArcana)
+		throws SQLException
+	{
+		return prepareStatement(con,NoKey.INSTANCE,sql,0);
+	}
+
+	public NoKey refreshKeyAfterInsert(Connection con,DbRecord<NoKey,? extends DbObject> record) throws SQLException {
+		return NoKey.INSTANCE;
+	}
+
+	public NoKey getKey(ResultSet rs)
+		throws SQLException
+	{
+		return NoKey.INSTANCE;
+	}
+
+	public NoKey getKey(ResultSet rs,String tableName)
+		throws SQLException
+	{
+		return NoKey.INSTANCE;
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/SQLRuntimeException.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,41 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+import java.sql.SQLException;
+
+
+public class SQLRuntimeException extends RuntimeException {
+
+	public SQLRuntimeException(SQLException e) {
+		super(e);
+	}
+
+	public SQLRuntimeException(String msg,SQLException e) {
+		super(msg,e);
+	}
+
+	public SQLException getSQLException() {
+		return (SQLException)getCause();
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/StringKey.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,51 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db;
+
+
+public final class StringKey implements DbKey {
+	private final String id;
+
+	public StringKey(String id) {
+		if( id==null )
+			throw new NullPointerException();
+		this.id = id;
+	}
+
+	public int hashCode() {
+		return id.hashCode();
+	}
+
+	public String value() {
+		return id;
+	}
+
+	public boolean equals(Object obj) {
+		return obj!=null && obj instanceof StringKey
+				&& ((StringKey)obj).id.equals(id);
+	}
+
+	public String toString() {
+		return id;
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/base/DbDatabaseImpl.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,197 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.base;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Properties;
+import fschmidt.db.DbObject;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbKeySetter;
+import fschmidt.db.DbObjectFactory;
+import fschmidt.db.SQLRuntimeException;
+import fschmidt.db.LongKey;
+import fschmidt.db.StringKey;
+import fschmidt.db.DbStorable;
+import fschmidt.db.extend.DbRecordExt;
+import fschmidt.db.extend.DbDatabaseExt;
+import fschmidt.db.extend.DbTableExt;
+import fschmidt.db.extend.DbTransaction;
+
+
+public abstract class DbDatabaseImpl extends DbDatabaseExt {
+	private final String url;
+	private final Properties props = new Properties();
+
+	public DbDatabaseImpl(String url,String user,String password) {
+		this.url = url;
+		props.setProperty("user",user);
+		props.setProperty("password",password);
+	}
+
+	public void setProperty(String key,String value) {
+		props.setProperty(key,value);
+	}
+
+	public Properties getProperties() {
+		return props;
+	}
+
+	public Connection getConnection()
+		throws SQLException
+	{
+		return DriverManager.getConnection(url,props);
+	}
+
+	public <K extends DbKey,V extends DbObject<K,V>> DbTableExt<K,V> newTable(DbDatabaseExt database,String tableName,DbKeySetter<K> keySetter,DbObjectFactory<K,V> objectFactory) {
+		return new DbTableImpl<K,V>(database,tableName,keySetter,objectFactory);
+	}
+
+	public <K extends DbKey,V extends DbObject<K,V>> DbRecordExt<K,V> newRecord(DbTableExt<K,V> table,V obj,K key) {
+		return new DbRecordImpl<K,V>(table,obj,key);
+	}
+
+	public <K extends DbKey,V extends DbObject<K,V>> DbRecordExt<K,V> newRecord(DbTableExt<K,V> table,V obj) {
+		return new DbRecordImpl<K,V>(table,obj);
+	}
+
+	public boolean isInTransaction() {
+		throw new UnsupportedOperationException();
+	}
+
+	public void beginTransaction()
+		throws SQLRuntimeException
+	{
+		throw new UnsupportedOperationException();
+	}
+
+	public void commitTransaction()
+		throws SQLRuntimeException
+	{
+		throw new UnsupportedOperationException();
+	}
+
+	public void endTransaction()
+		throws SQLRuntimeException
+	{
+		throw new UnsupportedOperationException();
+	}
+
+	public void runBeforeCommit(Runnable r) {
+		r.run();
+	}
+
+	public void runAfterCommit(Runnable r) {
+		r.run();
+	}
+
+	public DbTransaction getTransaction() {
+		return null;
+	}
+
+	public void ignoreRunnablesInThisTransaction() {
+		throw new UnsupportedOperationException();
+	}
+
+
+	public DbKeySetter<LongKey> newIdentityLongKeySetter(String fieldName) {
+		return new LongKeySetter(fieldName);
+	}
+
+	public DbKeySetter<LongKey> newAssignedLongKeySetter(String fieldName) {
+		return new LongForeignKeySetter(fieldName);
+	}
+
+	public DbKeySetter<StringKey> newAssignedStringKeySetter(String fieldName) {
+		return new StringKeySetter(fieldName);
+	}
+
+	public void setValue(PreparedStatement stmt,int idx,Object value)
+		throws SQLException
+	{
+		if( value==null ) {
+			throw new SQLException("null value");
+		} else if( value instanceof DbStorable ) {
+			((DbStorable)value).setField(stmt,idx);
+		} else if( value instanceof Character ) {
+			stmt.setString(idx,value.toString());
+		} else if( value instanceof java.util.Date ) {
+			stmt.setTimestamp(idx,new java.sql.Timestamp(((java.util.Date)value).getTime()));
+		} else if( (new byte[0]).getClass().isInstance(value) ) {
+			stmt.setBytes(idx,(byte[])value);
+		} else if( value instanceof Boolean ) {
+			stmt.setBoolean( idx, ((Boolean)value).booleanValue() );
+		} else if( value instanceof Float ) {
+			stmt.setFloat( idx, ((Float)value).floatValue() );
+		} else {
+			stmt.setObject(idx,value);
+		}
+	}
+
+
+
+
+	public String quote(String s) {
+		return "'" + stringEncode(s) + "'";
+	}
+
+	public String stringEncode(String s) {
+		StringBuilder buf = new StringBuilder();
+		int n = s.length();
+		for( int i=0; i<n; i++ ) {
+			char c = s.charAt(i);
+			switch(c) {
+				case '\n': 
+					buf.append("\\n");
+					break;
+				case '\t':
+					buf.append("\\t");
+					break;
+				case '\r':
+					buf.append("\\r");
+					break;
+				case '\'':
+					buf.append("\\'");
+					break;
+				default:
+					buf.append(c);
+			}
+		}
+		return buf.toString();
+	}
+
+	private static final DateFormat dateFmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+	public String quote(java.util.Date date) {
+		return "'" + stringEncode(date) + "'";
+	}
+
+	public String stringEncode(java.util.Date date) {
+		return dateFmt.format(date);
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/base/DbRecordImpl.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,333 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.base;
+
+import java.sql.SQLException;
+import java.sql.PreparedStatement;
+import java.sql.Connection;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import fschmidt.db.DbTable;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbKeySetter;
+import fschmidt.db.DbObject;
+import fschmidt.db.DbRecord;
+import fschmidt.db.SQLRuntimeException;
+import fschmidt.db.DbExpression;
+import fschmidt.db.LongKey;
+import fschmidt.db.DbUtils;
+import fschmidt.db.DbArcana;
+import fschmidt.db.ListenerList;
+import fschmidt.db.extend.DbRecordExt;
+import fschmidt.db.extend.DbTableExt;
+import fschmidt.db.extend.DbTransaction;
+
+
+final class DbRecordImpl<K extends DbKey,V extends DbObject<K,V>> implements DbRecordExt<K,V> {
+	private static final Logger logger = LoggerFactory.getLogger(DbRecordImpl.class);
+
+	public static boolean hasStackTrace = false;
+	private final V obj;
+	private K key;
+	private final DbTableExt<K,V> table;
+	private Map<String,Object> fields = new HashMap<String,Object>();
+	private boolean isInDb;
+	private boolean isStale = false;
+//	private final long whenLoaded = System.currentTimeMillis();
+	private DbTransaction trans;
+
+	public DbRecordImpl(DbTableExt<K,V> table,V obj,K key) {
+		this.table = table;
+		this.obj = obj;
+		this.key = key;
+		this.isInDb = true;
+		this.trans = table.getDbDatabaseExt().getTransaction();
+	}
+
+	public DbRecordImpl(DbTableExt<K,V> table,V obj) {
+		this.table = table;
+		this.obj = obj;
+		this.key = null;
+		this.isInDb = false;
+		this.trans = table.getDbDatabaseExt().getTransaction();
+	}
+
+	public V getDbObject() {
+		return obj;
+	}
+
+	public K getPrimaryKey() {
+		return key;
+	}
+
+	public DbTable<K,V> getDbTable() {
+		return table;
+	}
+
+	public Map<String,Object> fields() {
+		return fields;
+	}
+
+/*
+	public long whenLoaded() {
+		return whenLoaded;
+	}
+*/
+	private void checkTrans() {
+		if( trans != table.getDbDatabaseExt().getTransaction() ) {
+			if( trans==null )
+				throw new IllegalStateException("record read outside of a transaction cannot be updated inside a transaction");
+			else
+				throw new IllegalStateException("transaction mismatch");
+		}
+	}
+
+	public void insert() {
+		if( isInDb() )
+			throw new IllegalStateException("already in database");
+		try {
+			ListenerList<V> list = table.getPreInsertListeners();
+			list.event(obj);
+			store();
+			this.trans = table.getDbDatabaseExt().getTransaction();
+			final Map<String,Object> updatedFields = fields;
+			final Exception ex = hasStackTrace ? new Exception("in "+Thread.currentThread()) : null;
+			table.getDbDatabaseExt().runBeforeCommit( new Runnable() {
+				public void run() {
+					ListenerList<V> list = table.getPostInsertListeners();
+					if( !list.isEmpty() ) {
+						V obj2 = DbUtils.getGoodCopy(obj);
+						if( obj2==null ) {
+							DbRecord<K,V> rec = obj.getDbRecord();
+							K key = rec.getPrimaryKey();
+							if( ex != null )
+								logger.error("insert null in "+Thread.currentThread()+" table="+table+" key="+key, ex);
+							throw new NullPointerException("in "+Thread.currentThread()+" table="+table+" key="+key);
+						}
+						DbRecordImpl rec2 = (DbRecordImpl)obj2.getDbRecord();
+						try {
+							list.event(obj2);
+						} finally {
+							updatedFields.clear();
+						}
+					}
+				}
+			} );
+		} finally {
+			fields = new HashMap<String,Object>();
+			makeStale();
+		}
+	}
+
+	public void update() {
+		checkTrans();
+		if( !isInDb() )
+			throw new IllegalStateException("not in database");
+		try {
+			ListenerList<V> list = table.getPreUpdateListeners();
+			list.event(obj);
+			if( fields.isEmpty() ) {
+				table.uncache(key);
+			} else {
+				store();
+			}
+			final Map<String,Object> updatedFields = fields;
+			table.getDbDatabaseExt().runBeforeCommit( new Runnable() {
+				public void run() {
+					ListenerList<V> list = table.getPostUpdateListeners();
+					if( !list.isEmpty() && isInDb ) {
+						V obj2 = DbUtils.getGoodCopy(obj);
+						if( obj2==null )
+							return;  // presumably deleted later in transaction
+						DbRecordImpl rec2 = (DbRecordImpl)obj2.getDbRecord();
+						try {
+							list.event(obj2);
+						} finally {
+							updatedFields.clear();
+						}
+					}
+				}
+			} );
+		} finally {
+			fields = new HashMap<String,Object>();
+		}
+	}
+
+	private void store() {
+		StringBuilder buf = new StringBuilder();
+		try {
+			DbArcana arcana = table.getDbDatabase().arcana();
+			int n = 0;
+			if( isInDb() ) {  // update
+				buf.append( "update " );
+				buf.append( table.getTableName() );
+				buf.append( " set " );
+				boolean first = true;
+				for( Map.Entry<String,Object> entry : fields.entrySet() ) {
+					if( first ) {
+						first = false;
+					} else {
+						buf.append( ',' );
+					}
+					buf.append( arcana.quoteIdentifier(entry.getKey()) );
+					if( entry.getValue() instanceof DbExpression ) {
+						buf.append( '=' );
+						buf.append( entry.getValue() );
+					} else {
+						buf.append( "=?" );
+						n++;
+					}
+				}
+			} else {  // insert
+				buf.append( "insert into " );
+				buf.append( table.getTableName() );
+				if( fields.isEmpty() ) {
+					buf.append( " DEFAULT VALUES" );
+				} else {
+					buf.append( " (" );
+					boolean first = true;
+					for( Map.Entry<String,Object> entry : fields.entrySet() ) {
+						if( first ) {
+							first = false;
+						} else {
+							buf.append( ',' );
+						}
+						buf.append( arcana.quoteIdentifier(entry.getKey()) );
+					}
+					buf.append( ") values (" );
+					first = true;
+					for( Map.Entry<String,Object> entry : fields.entrySet() ) {
+						if( first ) {
+							first = false;
+						} else {
+							buf.append(',');
+						}
+						if( entry.getValue() instanceof DbExpression ) {
+							buf.append( entry.getValue() );
+						} else {
+							buf.append( '?' );
+							n++;
+						}
+					}
+					buf.append( ")" );
+				}
+			}
+			Connection con = table.getDbDatabaseExt().getConnection();
+			try {
+				DbKeySetter<K> keySetter = table.getKeySetter();
+				PreparedStatement stmt;
+				if( isInDb() ) {
+					stmt = keySetter.prepareStatement(
+						con, key, buf.toString(), 1+n
+					);
+				} else {
+					stmt = con.prepareStatement( buf.toString() );
+				}
+				int idx = 1;
+				for( Map.Entry<String,Object> entry : fields.entrySet() ) {
+					Object value = entry.getValue();
+					if( value instanceof DbExpression )
+						continue;
+					try {
+						arcana.setValue(stmt,idx++,value);
+					} catch(SQLException e) {
+						throw new SQLRuntimeException("field="+entry.getKey()+" value="+value,e);
+					}
+				}
+				stmt.executeUpdate();
+				boolean wasInDb = isInDb;
+				isInDb = true;
+				stmt.close();
+				if( !wasInDb ) {
+					key = keySetter.refreshKeyAfterInsert(con,this);
+				}
+			} finally {
+				try {
+					con.close();
+				} catch(SQLException e) {
+					logger.error("couldn't close connection",e);
+					throw e;
+				} catch(RuntimeException e) {
+					logger.error("couldn't close connection",e);
+					throw e;
+				}
+			}
+		} catch(SQLException e) {
+			throw new SQLRuntimeException("key = "+key+"  sql = "+buf.toString(),e);
+		} finally {
+			table.uncache(key);
+		}
+	}
+
+	public void delete() {
+		checkTrans();
+		ListenerList<V> list = table.getPreDeleteListeners();
+		list.event(obj);
+		if( !isInDb() )
+			throw new IllegalStateException("not in database");
+		try {
+			Connection con = table.getDbDatabaseExt().getConnection();
+			PreparedStatement stmt = table.getKeySetter().prepareStatement(
+				con, key, "delete from "+table.getTableName(), 1
+			);
+			stmt.executeUpdate();
+			isInDb = false;
+			stmt.close();
+			con.close();
+/*
+			table.getDbDatabaseExt().runBeforeCommit( new Runnable() {
+				public void run() {
+					table.getPostDeleteListeners().event(obj);
+				}
+			} );
+*/
+		} catch(SQLException e) {
+			throw new SQLRuntimeException("key = "+key,e);
+		} finally {
+			table.uncache(key);
+			fields.clear();
+		}
+		table.getDbDatabaseExt().runBeforeCommit( new Runnable() {
+			public void run() {
+				ListenerList<V> list = table.getPostDeleteListeners();
+				list.event(obj);
+			}
+		} );
+	}
+
+	public boolean isStale() {
+		return isStale || (isInDb || trans!=null) && trans != table.getDbDatabaseExt().getTransaction();
+	}
+
+	public void makeStale() {
+		isStale = true;
+	}
+
+	public boolean isInDb() {
+		return isInDb;
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/base/DbTableImpl.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,159 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.base;
+
+import fschmidt.db.DbKey;
+import fschmidt.db.DbKeySetter;
+import fschmidt.db.DbObject;
+import fschmidt.db.DbObjectFactory;
+import fschmidt.db.ListenerList;
+import fschmidt.db.SQLRuntimeException;
+import fschmidt.db.extend.DbDatabaseExt;
+import fschmidt.db.extend.DbTableExt;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+
+final class DbTableImpl<K extends DbKey,V extends DbObject<K,V>> extends DbTableExt<K,V> {
+	private final String tableName;
+	private final DbKeySetter<K> keySetter;
+	private final DbObjectFactory<K,V> objFactory;
+
+	DbTableImpl(DbDatabaseExt database,String tableName,DbKeySetter<K> keySetter,DbObjectFactory<K,V> objFactory) {
+		super(database);
+		this.tableName = tableName;
+		this.keySetter = keySetter;
+		this.objFactory = objFactory;
+	}
+
+	public String getTableName() {
+		return tableName;
+	}
+
+	public DbKeySetter<K> getKeySetter() {
+		return keySetter;
+	}
+
+	public final V findByPrimaryKey(K key) {
+		try {
+			Connection con = database.getConnection();
+			try {
+				PreparedStatement stmt = keySetter.prepareStatement(
+					con, key, "select * from "+tableName, 1
+				);
+				ResultSet rs = stmt.executeQuery();
+				V obj = null;
+				if( rs.next() )
+					obj = getDbObject(key,rs);
+				stmt.close();
+				return obj;
+			} finally {
+				con.close();
+			}
+		} catch(SQLException e) {
+			throw new SQLRuntimeException("key = "+key,e);
+		}
+	}
+
+	public final Map<K,V> findByPrimaryKey(Collection<K> keys) {
+		Map<K,V> map = new HashMap<K,V>();
+		try {
+			Connection con = database.getConnection();
+			try {
+				PreparedStatement stmt = keySetter.prepareStatement(
+					con, keys, "select * from "+tableName, getDbDatabase().arcana()
+				);
+				ResultSet rs = stmt.executeQuery();
+				while( rs.next() ) {
+					K key = keySetter.getKey(rs);
+					map.put( key, getDbObject(key,rs) );
+				}
+				stmt.close();
+			} finally {
+				con.close();
+			}
+		} catch(SQLException e) {
+			throw new SQLRuntimeException("keys = "+keys,e);
+		}
+		return map;
+	}
+
+	public V getDbObject(K key,ResultSet rs,String tableName)
+		throws SQLException
+	{
+		return objFactory.makeDbObject(key,rs,tableName);
+	}
+
+
+	private ListenerList<V> preInsertListeners;
+	private ListenerList<V> preUpdateListeners;
+	private ListenerList<V> preDeleteListeners;
+	private ListenerList<V> postInsertListeners;
+	private ListenerList<V> postUpdateListeners;
+	private ListenerList<V> postDeleteListeners;
+
+	public synchronized ListenerList<V> getPreInsertListeners() {
+		if (preInsertListeners == null)
+			preInsertListeners = new ListenerList<V>();
+		return preInsertListeners;
+	}
+
+	public synchronized ListenerList<V> getPreUpdateListeners() {
+		if (preUpdateListeners == null)
+			preUpdateListeners = new ListenerList<V>();
+		return preUpdateListeners;
+	}
+
+	public synchronized ListenerList<V> getPreDeleteListeners() {
+		if (preDeleteListeners == null)
+			preDeleteListeners = new ListenerList<V>();
+		return preDeleteListeners;
+	}
+
+	public synchronized ListenerList<V> getPostInsertListeners() {
+		if (postInsertListeners == null)
+			postInsertListeners = new ListenerList<V>();
+		return postInsertListeners;
+	}
+
+	public synchronized ListenerList<V> getPostUpdateListeners() {
+		if (postUpdateListeners == null)
+			postUpdateListeners = new ListenerList<V>();
+		return postUpdateListeners;
+	}
+
+	public synchronized ListenerList<V> getPostDeleteListeners() {
+		if (postDeleteListeners == null)
+			postDeleteListeners = new ListenerList<V>();
+		return postDeleteListeners;
+	}
+
+	public void uncache(DbKey key) {}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/base/LongForeignKeySetter.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,46 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.base;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbObject;
+import fschmidt.db.LongKey;
+import fschmidt.db.DbRecord;
+
+
+final class LongForeignKeySetter extends LongKeySetter {
+
+	public LongForeignKeySetter(String fieldName) {
+		super(fieldName);
+	}
+
+	public LongKey refreshKeyAfterInsert(Connection con,DbRecord<LongKey,? extends DbObject> record)
+		throws SQLException
+	{
+//		return record.getPrimaryKey();
+		Long id = (Long)record.fields().get(fieldName);
+		return new LongKey(id.longValue());
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/base/LongKeySetter.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,101 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.base;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Connection;
+import java.sql.Statement;
+import java.util.Collection;
+import java.util.Iterator;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbKeySetter;
+import fschmidt.db.DbObject;
+import fschmidt.db.LongKey;
+import fschmidt.db.DbArcana;
+import fschmidt.db.DbRecord;
+
+
+class LongKeySetter implements DbKeySetter<LongKey> {
+	protected final String fieldName;
+
+	public LongKeySetter(String fieldName) {
+		this.fieldName = fieldName;
+	}
+
+	public PreparedStatement prepareStatement(Connection con,LongKey key,String sql,int keyIndex)
+		throws SQLException
+	{
+		PreparedStatement stmt = con.prepareStatement(
+			sql + " where " + fieldName + "=?"
+		);
+		stmt.setLong(keyIndex,((LongKey)key).value());
+		return stmt;
+	}
+
+	public PreparedStatement prepareStatement(Connection con,Collection<LongKey> keys,String sql,DbArcana dbArcana)
+		throws SQLException
+	{
+		StringBuilder buf = new StringBuilder();
+		buf.append( sql );
+		buf.append( " where " );
+		buf.append( fieldName );
+		buf.append( " in (" );
+		Iterator<LongKey> iter = keys.iterator();
+		buf.append( iter.next().value() );
+		while( iter.hasNext() ) {
+			buf.append( ',' ).append( iter.next().value() );
+		}
+		buf.append( ")" );
+		return con.prepareStatement(buf.toString());
+	}
+
+	public LongKey refreshKeyAfterInsert(Connection con,DbRecord<LongKey,? extends DbObject> record) throws SQLException {
+		if( record.fields().containsKey(fieldName) ) {
+			Long key = (Long)record.fields().get(fieldName);
+			return new LongKey(key);
+		}
+		Statement stmt = con.createStatement();
+		ResultSet rs = stmt.executeQuery(
+			"select " + record.getDbTable().getDbDatabase().arcana().getLastSeqValFn() + " as id"
+		);
+		rs.next();
+		LongKey key = new LongKey( rs.getLong("id") );
+		rs.close();
+		stmt.close();
+		return key;
+	}
+
+	public LongKey getKey(ResultSet rs)
+		throws SQLException
+	{
+		return new LongKey(rs.getLong(fieldName));
+	}
+
+	public LongKey getKey(ResultSet rs,String tableName)
+		throws SQLException
+	{
+		return new LongKey(rs.getLong(tableName+'.'+fieldName));
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/base/StringKeySetter.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,91 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.base;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.util.Collection;
+import java.util.Iterator;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbObject;
+import fschmidt.db.StringKey;
+import fschmidt.db.DbArcana;
+import fschmidt.db.DbKeySetter;
+import fschmidt.db.DbRecord;
+
+
+final class StringKeySetter implements DbKeySetter<StringKey> {
+	private final String fieldName;
+
+	public StringKeySetter(String fieldName) {
+		this.fieldName = fieldName;
+	}
+
+	public PreparedStatement prepareStatement(Connection con,StringKey key,String sql,int keyIndex)
+		throws SQLException
+	{
+		PreparedStatement stmt = con.prepareStatement(
+			sql + " where " + fieldName + "=?"
+		);
+		stmt.setString(keyIndex,key.value());
+		return stmt;
+	}
+
+	public PreparedStatement prepareStatement(Connection con,Collection<StringKey> keys,String sql,DbArcana dbArcana)
+		throws SQLException
+	{
+		StringBuilder buf = new StringBuilder();
+		buf.append( sql );
+		buf.append( " where " );
+		buf.append( fieldName );
+		buf.append( " in (" );
+		Iterator<StringKey> iter = keys.iterator();
+		buf.append( dbArcana.quote(iter.next().value()) );
+		while( iter.hasNext() ) {
+			buf.append( ',' ).append( dbArcana.quote(iter.next().value()) );
+		}
+		buf.append( ")" );
+		return con.prepareStatement(buf.toString());
+	}
+
+	public StringKey refreshKeyAfterInsert(Connection con,DbRecord<StringKey,? extends DbObject> record) throws SQLException {
+//		throw new RuntimeException();
+//		return record.getPrimaryKey();  // ?
+		String id = (String)record.fields().get(fieldName);
+		return new StringKey(id);
+	}
+
+	public StringKey getKey(ResultSet rs)
+		throws SQLException
+	{
+		return new StringKey(rs.getString(fieldName));
+	}
+
+	public StringKey getKey(ResultSet rs,String tableName)
+		throws SQLException
+	{
+		return new StringKey(rs.getString(tableName+'.'+fieldName));
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/cache/DbDatabaseImpl.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,55 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.cache;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.Collections;
+import fschmidt.db.DbDatabase;
+import fschmidt.db.DbObject;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbKeySetter;
+import fschmidt.db.DbObjectFactory;
+import fschmidt.db.extend.DbDatabaseExt;
+import fschmidt.db.extend.DbTableExt;
+import fschmidt.db.extend.DbRecordExt;
+import fschmidt.db.extend.FilterDatabase;
+
+
+public final class DbDatabaseImpl extends FilterDatabase {
+
+	public DbDatabaseImpl(DbDatabase database) {
+		super((DbDatabaseExt)database);
+	}
+
+	public <K extends DbKey,V extends DbObject<K,V>> DbTableExt<K,V> newTable(DbDatabaseExt database,String tableName,DbKeySetter<K> keySetter,DbObjectFactory<K,V> objFactory) {
+		return new DbTableImpl<K,V>(this.database.newTable(database,tableName,keySetter,objFactory),this);
+	}
+
+	public static void clearCache() {
+		DbTableImpl.clearCache();
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/cache/DbTableImpl.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,261 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.cache;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Collections;
+import java.util.Collection;
+import java.util.NoSuchElementException;
+import fschmidt.db.util.Unique;
+import fschmidt.db.util.WeakCacheMap;
+import fschmidt.db.DbObject;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbRecord;
+import fschmidt.db.extend.DbRecordExt;
+import fschmidt.db.extend.DbTableExt;
+import fschmidt.db.extend.DbDatabaseExt;
+import fschmidt.db.extend.DbTransaction;
+import fschmidt.db.extend.FilterTable;
+
+
+final class DbTableImpl<K extends DbKey,V extends DbObject<K,V>> extends FilterTable<K,V> {
+	private static final DbObject NULL0 = new DbObject(){
+		public DbRecord getDbRecord() { throw new RuntimeException(); }
+	};
+
+	@SuppressWarnings("unchecked")
+	private final V NULL = (V)NULL0;  // hack
+
+	private static class CacheKey {
+		private final DbTableImpl table;
+		final Object key;
+
+		CacheKey(DbTableImpl table,Object key) {
+			this.table = table;
+			this.key = key;
+		}
+
+		@Override public boolean equals(Object obj) {
+			if( obj == this )
+				return true;
+			if( !(obj instanceof DbTableImpl.CacheKey) )
+				return false;
+			CacheKey ck = (CacheKey)obj;
+			return ck.table == table && ck.key.equals(key);
+		}
+
+		@Override public int hashCode() {
+			return table.hashCode() + key.hashCode();
+		}
+
+	}
+
+	private static final Map<CacheKey,DbObject> cache0 = Collections.synchronizedMap(new WeakCacheMap<CacheKey,DbObject>());
+	private final Unique<K> unique = new Unique<K>();
+	private final DbDatabaseImpl database;
+
+	DbTableImpl(DbTableExt<K,V> table,DbDatabaseImpl database) {
+		super(database,table);
+		this.database = database;
+	}
+
+	private Map<CacheKey,DbObject> transCache() {
+		Map<String,Object> transMap = database.transactionMap();
+		@SuppressWarnings("unchecked")
+		Map<CacheKey,DbObject> transCache = (Map<CacheKey,DbObject>)transMap.get("transCache");
+		if( transCache == null ) {
+			transCache = new WeakCacheMap<CacheKey,DbObject>();
+			transMap.put( "transCache", transCache );
+		}
+		return transCache;
+	}
+
+	private final boolean isStale(DbObject obj) {
+		if( obj==null )
+			return true;
+		if( obj==NULL )
+			return false;
+/*
+		if( database.isInTransaction() ) {
+			return transCache().containsKey(obj.getDbRecord().getPrimaryKey());
+		} else {
+			return obj.getDbRecord().isStale();
+		}
+*/
+		return obj.getDbRecord().isStale();
+	}
+
+	public final V findByPrimaryKey(K key) {
+		CacheKey ck = new CacheKey(this,key);
+		if( database.isInTransaction() ) {
+			Map<CacheKey,DbObject> cache = transCache();
+			@SuppressWarnings("unchecked")
+			V obj = (V)cache.get(ck);
+			if( obj==null ) {
+				obj = table.findByPrimaryKey(key);
+				if( obj==null )
+					obj = NULL;
+				cache.put(ck,obj);
+			}
+			return obj==NULL ? null : obj;
+		}
+		Map<CacheKey,DbObject> cache = cache0;
+		key = unique.get(key);
+		try {
+			synchronized(key) {
+				@SuppressWarnings("unchecked")
+				V obj = (V)cache.get(ck);
+				if( !isStale(obj) )
+					return obj==NULL ? null : obj;
+				obj = table.findByPrimaryKey(key);
+				if( !isStale( cache.put( ck, obj==null ? NULL : obj ) ) )
+					throw new RuntimeException();
+				return obj;
+			}
+		} finally {
+			unique.free(key);
+		}
+	}
+
+	public final Map<K,V> findByPrimaryKey(Collection<K> keys) {
+		Map<K,V> map = new HashMap<K,V>();
+		Set<K> set = new HashSet<K>();
+		Map<CacheKey,DbObject> cache = database.isInTransaction() ? transCache() : cache0;
+		boolean inTrans = database.isInTransaction();
+		for( K key : keys ) {
+			CacheKey ck = new CacheKey(this,key);
+			@SuppressWarnings("unchecked")
+			V obj = (V)cache.get(ck);
+			if( obj==null || !inTrans && isStale(obj) ) {
+				set.add(key);
+			} else {
+				map.put( key, obj==NULL ? null : obj );
+			}
+		}
+		if( !set.isEmpty() ) {
+			Map<K,V> objs = table.findByPrimaryKey(set);
+			for( K key : set ) {
+				CacheKey ck = new CacheKey(this,key);
+				if( inTrans ) {
+					if( cache.get(ck) != null )
+						throw new RuntimeException();
+					V obj = table.findByPrimaryKey(key);
+					if( obj==null )
+						obj = NULL;
+					cache.put(ck,obj);
+					map.put( key, obj==NULL ? null : obj );
+				} else {
+					key = unique.get(key);
+					try {
+						synchronized(key) {
+							@SuppressWarnings("unchecked")
+							V obj = (V)cache.get(ck);
+							if( isStale(obj) ) {
+								obj = objs.get(key);
+								if( obj == null )
+									obj = NULL;
+								if( !isStale( cache.put(ck,obj) ) )
+									throw new RuntimeException();
+							}
+							map.put( key, obj==NULL ? null : obj );
+						}
+					} finally {
+						unique.free(key);
+					}
+				}
+			}
+		}
+		return map;
+	}
+
+	public V getDbObject(K key,ResultSet rs,String tableName)
+		throws SQLException
+	{
+		CacheKey ck = new CacheKey(this,key);
+		if( database.isInTransaction() ) {
+			Map<CacheKey,DbObject> cache = transCache();
+			@SuppressWarnings("unchecked")
+			V obj = (V)cache.get(ck);
+			if( obj==null ) {
+				obj = table.getDbObject(key,rs,tableName);
+				if( obj==null )
+					obj = NULL;
+				cache.put(ck,obj);
+			}
+			return obj==NULL ? null : obj;
+		}
+		Map<CacheKey,DbObject> cache = cache0;
+		key = unique.get(key);
+		try {
+			synchronized(key) {
+				@SuppressWarnings("unchecked")
+				V obj = (V)cache.get(ck);
+				if( !isStale(obj) )
+					return obj==NULL ? null : obj;
+				obj = table.getDbObject(key,rs,tableName);
+				if( !isStale( cache.put( ck, obj==null ? NULL : obj ) ) )
+					throw new RuntimeException();
+				return obj;
+			}
+		} finally {
+			unique.free(key);
+		}
+	}
+
+	public void uncache(final K key) {
+		if( key == null )
+			return;
+		final CacheKey ck = new CacheKey(this,key);
+		if( database.isInTransaction() ) {
+			doUncache(ck,transCache());
+		}
+		database.runJustAfterCommit( new Runnable() {
+			public void run() {
+				doUncache(ck,cache0);
+			}
+		} );
+	}
+
+	private static void doUncache(CacheKey ck,Map<CacheKey,DbObject> cache) {
+		DbObject obj = cache.remove(ck);
+		if( obj!=null && obj!=NULL0 ) {
+			DbRecordExt rec = (DbRecordExt)obj.getDbRecord();
+			rec.makeStale();
+		}
+	}
+
+	static void clearCache() {
+		while( !cache0.isEmpty() ) {
+			CacheKey[] a = cache0.keySet().toArray(new CacheKey[0]);
+			for( CacheKey ck : a ) {
+				doUncache( ck, cache0 );
+			}
+		}
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/examples/Example.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,97 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.examples;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import fschmidt.db.DbObject;
+import fschmidt.db.DbRecord;
+import fschmidt.db.DbKey;
+import fschmidt.db.LongKey;
+import fschmidt.db.DbFinder;
+import fschmidt.db.DbDatabase;
+import fschmidt.db.DbTable;
+import fschmidt.db.DbObjectFactory;
+
+
+public class Example implements DbObject<LongKey,Example> {
+	static final String url = "jdbc:mysql://localhost/talk";
+	static final String user = "";
+	static final String password = "";
+	static DbDatabase db = DbFinder.getDatabase(url,user,password);
+
+	private final DbRecord<LongKey,Example> record;
+	private String text;
+
+	private Example(LongKey key,ResultSet rs)
+		throws SQLException
+	{
+		record = table.newRecord(this,key);
+		text = rs.getString("text");
+	}
+
+	public Example(String text) {
+		record = table.newRecord(this);
+		this.text = text;
+	}
+
+	public DbRecord<LongKey,Example> getDbRecord() {
+		return record;
+	}
+
+	public long getId() {
+		return record.getPrimaryKey().value();
+	}
+
+	public String getText() {
+		return text;
+	}
+
+	public void setText(String text) {
+		this.text = text;
+		record.fields().put("text",text);
+	}
+
+	static DbTable<LongKey,Example> table = db.newTable( "example", db.newIdentityLongKeySetter("example_id"),
+		new DbObjectFactory<LongKey,Example>() {
+			public Example makeDbObject(LongKey key,ResultSet rs,String tableName)
+				throws SQLException
+			{
+				return new Example(key,rs);
+			}
+		}
+	);
+
+	public static Example findExample(long id) {
+		return table.findByPrimaryKey(new LongKey(id));
+	}
+
+	public static void main(String[] args) throws Exception {
+		Example example = new Example("hello world");
+		example.getDbRecord().insert();
+		long id = example.getId();
+
+		example = findExample(id);
+		System.out.println(example.getText());
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/extend/DbDatabaseExt.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,63 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.extend;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.HashMap;
+import fschmidt.db.DbDatabase;
+import fschmidt.db.DbObject;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbKeySetter;
+import fschmidt.db.DbObjectFactory;
+import fschmidt.db.DbTable;
+
+
+public abstract class DbDatabaseExt implements DbDatabase {
+	public abstract <K extends DbKey,V extends DbObject<K,V>> DbRecordExt<K,V> newRecord(DbTableExt<K,V> table,V obj,K key);
+	public abstract <K extends DbKey,V extends DbObject<K,V>> DbRecordExt<K,V> newRecord(DbTableExt<K,V> table,V obj);
+	public abstract <K extends DbKey,V extends DbObject<K,V>> DbTableExt<K,V> newTable(DbDatabaseExt database,String tableName,DbKeySetter<K> keySetter,DbObjectFactory<K,V> objectFactory);
+	public abstract DbTransaction getTransaction();
+
+	public final <K extends DbKey,V extends DbObject<K,V>> DbTable<K,V> newTable(String tableName,DbKeySetter<K> keySetter,DbObjectFactory<K,V> objectFactory) {
+		return newTable(this,tableName,(DbKeySetter<K>)keySetter,objectFactory);
+	}
+
+	public final Map<String,Object> transactionMap() {
+		DbTransaction trans = getTransaction();
+		if( trans==null )
+			return null;
+		if( trans.map==null )
+			trans.map =  new HashMap<String,Object>();
+		return trans.map;
+	}
+
+
+	public void runJustAfterCommit(Runnable r) {
+		runAfterCommit(r);
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/extend/DbRecordExt.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,33 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.extend;
+
+import java.util.Map;
+import fschmidt.db.DbRecord;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbObject;
+
+
+public interface DbRecordExt<K extends DbKey,V extends DbObject> extends DbRecord<K,V> {
+	public void makeStale();
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/extend/DbTableExt.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,83 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.extend;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import fschmidt.db.DbTable;
+import fschmidt.db.DbDatabase;
+import fschmidt.db.DbObject;
+import fschmidt.db.DbKeySetter;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbRecord;
+
+
+public abstract class DbTableExt<K extends DbKey,V extends DbObject<K,V>> implements DbTable<K,V> {
+	protected final DbDatabaseExt database;
+
+	protected DbTableExt(DbDatabaseExt database) {
+		this.database = database;
+	}
+
+	public abstract DbKeySetter<K> getKeySetter();
+	public abstract V getDbObject(K key,ResultSet rs,String tableName) throws SQLException;
+
+	public final DbDatabaseExt getDbDatabaseExt() {
+		return database;
+	}
+
+	public final DbDatabase getDbDatabase() {
+		return getDbDatabaseExt();
+	}
+
+	public final DbRecord<K,V> newRecord(V obj,K key) {
+		return getDbDatabaseExt().newRecord(this,obj,key);
+	}
+
+	public final DbRecord<K,V> newRecord(V obj) {
+		return getDbDatabaseExt().newRecord(this,obj);
+	}
+
+	public final V getDbObject(K key,ResultSet rs)
+		throws SQLException
+	{
+		return getDbObject(key,rs,getTableName());
+	}
+
+	public final V getDbObject(ResultSet rs)
+		throws SQLException
+	{
+		return getDbObject(getKeySetter().getKey(rs),rs);
+	}
+
+	public final V getDbObject(ResultSet rs,String tableName)
+		throws SQLException
+	{
+		return getDbObject(getKeySetter().getKey(rs,tableName),rs,tableName);
+	}
+
+	public String toString() {
+		return getTableName();
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/extend/DbTransaction.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,31 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.extend;
+
+import java.util.Map;
+import java.util.HashMap;
+
+
+public final class DbTransaction {
+	Map<String,Object> map;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/extend/FilterDatabase.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,125 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.extend;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import fschmidt.db.DbObject;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbKeySetter;
+import fschmidt.db.DbObjectFactory;
+import fschmidt.db.DbArcana;
+import fschmidt.db.SQLRuntimeException;
+import fschmidt.db.LongKey;
+import fschmidt.db.StringKey;
+
+
+public class FilterDatabase extends DbDatabaseExt {
+	protected final DbDatabaseExt database;
+
+	public FilterDatabase(DbDatabaseExt database) {
+		this.database = database;
+	}
+
+	public void setProperty(String key,String value) {
+		database.setProperty(key,value);
+	}
+
+	public DbArcana arcana() {
+		return database.arcana();
+	}
+
+	public <K extends DbKey,V extends DbObject<K,V>> DbTableExt<K,V> newTable(DbDatabaseExt database,String tableName,DbKeySetter<K> keySetter,DbObjectFactory<K,V> objFactory) {
+		return this.database.newTable(database,tableName,keySetter,objFactory);
+	}
+
+	public <K extends DbKey,V extends DbObject<K,V>> DbRecordExt<K,V> newRecord(DbTableExt<K,V> table,V obj,K key) {
+		return database.newRecord(table,obj,key);
+	}
+
+	public <K extends DbKey,V extends DbObject<K,V>> DbRecordExt<K,V> newRecord(DbTableExt<K,V> table,V obj) {
+		return database.newRecord(table,obj);
+	}
+
+	public Connection getConnection()
+		throws SQLException
+	{
+		return database.getConnection();
+	}
+
+	public void runBeforeCommit(Runnable r) {
+		database.runBeforeCommit(r);
+	}
+
+	public void runAfterCommit(Runnable r) {
+		database.runAfterCommit(r);
+	}
+
+	public void runJustAfterCommit(Runnable r) {
+		database.runJustAfterCommit(r);
+	}
+
+	public void ignoreRunnablesInThisTransaction() {
+		database.ignoreRunnablesInThisTransaction();
+	}
+
+	public boolean isInTransaction() {
+		return database.isInTransaction();
+	}
+
+	public void beginTransaction()
+		throws SQLRuntimeException
+	{
+		database.beginTransaction();
+	}
+
+	public void commitTransaction()
+		throws SQLRuntimeException
+	{
+		database.commitTransaction();
+	}
+
+	public void endTransaction()
+		throws SQLRuntimeException
+	{
+		database.endTransaction();
+	}
+
+	public DbTransaction getTransaction() {
+		return database.getTransaction();
+	}
+
+
+	public DbKeySetter<LongKey> newIdentityLongKeySetter(String fieldName) {
+		return database.newIdentityLongKeySetter(fieldName);
+	}
+
+	public DbKeySetter<LongKey> newAssignedLongKeySetter(String fieldName) {
+		return database.newAssignedLongKeySetter(fieldName);
+	}
+
+	public DbKeySetter<StringKey> newAssignedStringKeySetter(String fieldName) {
+		return database.newAssignedStringKeySetter(fieldName);
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/extend/FilterTable.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,71 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.extend;
+
+import fschmidt.db.ListenerList;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbKeySetter;
+import fschmidt.db.DbObject;
+
+
+public abstract class FilterTable<K extends DbKey,V extends DbObject<K,V>> extends DbTableExt<K,V> {
+	protected final DbTableExt<K,V> table;
+
+	protected FilterTable(DbDatabaseExt database,DbTableExt<K,V> table) {
+		super(database);
+		this.table = table;
+	}
+
+	public String getTableName() {
+		return table.getTableName();
+	}
+
+	public DbKeySetter<K> getKeySetter() {
+		return table.getKeySetter();
+	}
+
+	public ListenerList<V> getPreInsertListeners() {
+		return table.getPreInsertListeners();
+	}
+
+	public ListenerList<V> getPreUpdateListeners() {
+		return table.getPreUpdateListeners();
+	}
+
+	public ListenerList<V> getPreDeleteListeners() {
+		return table.getPreDeleteListeners();
+	}
+
+	public ListenerList<V> getPostInsertListeners() {
+		return table.getPostInsertListeners();
+	}
+
+	public ListenerList<V> getPostUpdateListeners() {
+		return table.getPostUpdateListeners();
+	}
+
+	public ListenerList<V> getPostDeleteListeners() {
+		return table.getPostDeleteListeners();
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/extras/DbIterator.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,65 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.extras;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import fschmidt.db.DbTable;
+import fschmidt.db.SQLRuntimeException;
+
+
+public final class DbIterator implements Iterator {
+	private final DbTable table;
+	private final ResultSet rs;
+	private Object obj = null;
+
+	public DbIterator(DbTable table,ResultSet rs) {
+		this.table = table;
+		this.rs = rs;
+	}
+
+	public boolean hasNext() {
+		if( obj != null )
+			return true;
+		try {
+			if( !rs.next() )
+				return false;
+			obj = table.getDbObject(rs);
+			return true;
+		} catch(SQLException e) {
+			throw new SQLRuntimeException(e);
+		}
+	}
+
+	public Object next() {
+		if( !hasNext() )
+			throw new NoSuchElementException();
+		return obj;
+	}
+
+	public void remove() {
+		throw new UnsupportedOperationException();
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/h2/DbDatabaseImpl.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,55 @@
+/*
+Copyright (c) 2009  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.h2;
+
+import fschmidt.db.DbArcana;
+
+
+public final class DbDatabaseImpl extends fschmidt.db.base.DbDatabaseImpl implements DbArcana {
+
+	public DbDatabaseImpl(String url,String user,String password) {
+		super(url,user,password);
+		try {
+			Class.forName("org.h2.Driver");
+		} catch(ClassNotFoundException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	public DbArcana arcana() {
+		return this;
+	}
+
+	public String quoteIdentifier(String identifier) {
+		return "`" + identifier + "`";
+	}
+
+	public String getLastSeqValFn() {
+		return "IDENTITY()";
+	}
+
+	public String dateSub(String date,int n,String units) {
+		return "dateadd('" + units + "'," + (-n) + "," + date + ")";
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/mysql/DbDatabaseImpl.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,72 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.mysql;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import fschmidt.db.DbArcana;
+
+
+public final class DbDatabaseImpl extends fschmidt.db.base.DbDatabaseImpl implements DbArcana {
+
+	public DbDatabaseImpl(String url,String user,String password) {
+		super(url,user,password);
+		try {
+			Class.forName("com.mysql.jdbc.Driver");
+		} catch(ClassNotFoundException e) {
+			throw new RuntimeException(e);
+		}
+		setProperty("useUnicode","true");
+		setProperty("characterEncoding","UTF-8");
+		setProperty("jdbcCompliantTruncation","false");
+		setProperty("cacheResultSetMetadata","true");
+		setProperty("useCursorFetch","true");
+	}
+
+	public DbArcana arcana() {
+		return this;
+	}
+
+	public String quoteIdentifier(String identifier) {
+		return "`" + identifier + "`";
+	}
+
+	public String getLastSeqValFn() {
+		return "last_insert_id()";
+	}
+
+	public String dateSub(String date,int n,String units) {
+		return "date_sub(" + date + ",interval " + n + " " + units + ")";
+	}
+
+	public void setValue(PreparedStatement stmt,int idx,Object value)
+		throws SQLException
+	{
+		if( value instanceof Boolean ) {
+			stmt.setString( idx, ((Boolean)value).booleanValue() ? "t" : "f" );
+		} else {
+			super.setValue(stmt,idx,value);
+		}
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/pool/DbDatabaseImpl.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,134 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.pool;
+
+import fschmidt.db.DbDatabase;
+import fschmidt.db.SQLRuntimeException;
+import fschmidt.db.extend.DbDatabaseExt;
+import fschmidt.db.extend.DbTransaction;
+import fschmidt.db.extend.FilterDatabase;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.CallableStatement;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.NClob;
+import java.sql.PreparedStatement;
+import java.sql.SQLClientInfoException;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Savepoint;
+import java.sql.Statement;
+import java.sql.Struct;
+import java.util.Map;
+import java.util.Properties;
+
+
+public class DbDatabaseImpl extends FilterDatabase {
+	private static final Logger logger = LoggerFactory.getLogger(DbDatabaseImpl.class);
+
+	final Pool pool;
+	final String user;
+
+	public DbDatabaseImpl(DbDatabase database,Pool pool,String user) {
+		super((DbDatabaseExt)database);
+		this.pool = pool;
+		this.user = user;
+	}
+
+	public DbDatabaseImpl(DbDatabase database) {
+		this(database,new Pool(),null);
+	}
+
+	DbDatabase database() {
+		return database;
+	}
+
+	@Override public boolean isInTransaction() {
+		return pool.isInTransaction();
+	}
+
+	@Override public void beginTransaction()
+		throws SQLRuntimeException
+	{
+		if( isInTransaction() )
+			throw new IllegalStateException("beginTransaction called in nested transaction");
+		try {
+			Connection con = getConnection();
+			con.setAutoCommit(false);
+		} catch(SQLException e) {
+			throw new SQLRuntimeException(e);
+		}
+	}
+
+	@Override public void commitTransaction() {
+		pool.commitTransaction();
+	}
+
+	@Override public void endTransaction() {
+		pool.endTransaction();
+	}
+
+	@Override public void runBeforeCommit(Runnable r) {
+		if( isInTransaction() ) {
+			pool.runBeforeCommit(r);
+		} else {
+			super.runBeforeCommit(r);
+		}
+	}
+
+	@Override public void runJustAfterCommit(Runnable r) {
+		if( isInTransaction() ) {
+			pool.runJustAfterCommit(r);
+		} else {
+			super.runJustAfterCommit(r);
+		}
+	}
+
+	@Override public void runAfterCommit(Runnable r) {
+		if( isInTransaction() ) {
+			pool.runAfterCommit(r);
+		} else {
+			super.runAfterCommit(r);
+		}
+	}
+
+	@Override public void ignoreRunnablesInThisTransaction() {
+		pool.ignoreRunnablesInThisTransaction();
+	}
+
+	@Override public DbTransaction getTransaction() {
+		return pool.getTransaction();
+	}
+
+	@Override public Connection getConnection()
+		throws SQLException
+	{
+		return pool.getConnection(this);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fschmidt/db/pool/NestedConnection.java	Sun Oct 05 17:24:15 2025 -0600
@@ -0,0 +1,139 @@
+/*
+Copyright (c) 2008  Franklin Schmidt <fschmidt@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+package fschmidt.db.pool;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Set;
+import java.util.HashSet;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import fschmidt.db.DbDatabase;
+import fschmidt.db.DbObject;
+import fschmidt.db.DbKey;
+import fschmidt.db.DbObjectFactory;
+import fschmidt.db.SQLRuntimeException;
+import fschmidt.db.extend.DbDatabaseExt;
+import fschmidt.db.extend.DbTableExt;
+import fschmidt.db.extend.DbTransaction;
+import fschmidt.db.extend.DbRecordExt;
+import fschmidt.db.extend.FilterDatabase;
+import fschmidt.db.util.OverridingProxy;
+import fschmidt.util.java.Stack;
+import fschmidt.util.java.ArrayStack;
+
+
+final class NestedConnection {
+
+	private static class MyOverridingProxy extends OverridingProxy<Connection,NestedConnection> {
+
+		MyOverridingProxy() {
+			super(Connection.class,NestedConnection.class);
+		}
+
+		protected InvocationHandler newInvocationHandler(Connection obj,NestedConnection override) {
+			return new MyOverridingInvocationHandler(obj,override);
+		}
+
+		protected class MyOverridingInvocationHandler extends OverridingInvocationHandler {
+
+			MyOverridingInvocationHandler(Connection obj,NestedConnection override) {
+				super(obj,override);
+			}
+
+			public Object invoke(Object proxy,Method method, Object[] args)
+				throws Throwable
+			{
+				if( !method.getName().equals("close") )
+					override.setUser();
+				return super.invoke(proxy,method,args);
+			}
+
+		}
+
+	}
+
+	private static final MyOverridingProxy factory = new MyOverridingProxy();
+
+	private final PooledConnection pooledCon;
+	final Connection proxyCon;
+	final Exception initException = new Exception("connection constructed in "+Thread.currentThread());
+	private boolean isClosed = false;
+	private final String user;
+
+	NestedConnection(PooledConnection pooledCon,String user) {
+		this.user = user;
+		this.pooledCon = pooledCon;
+		proxyCon = factory.newInstance(pooledCon.con(),this);
+	}
+
+	void setUser() throws SQLException {
+		pooledCon.setUser(user);
+	}
+
+	protected void checkClosed()
+		throws SQLException
+	{
+		if( isClosed )
+			throw new SQLException("connection is closed");
+	}
+	
+	public void setAutoCommit(boolean autoCommit)
+		throws SQLException
+	{
+		checkClosed();
+		pooledCon.setAutoCommit(autoCommit);
+	}
+
+	public void commit()
+		throws SQLException
+	{
+		checkClosed();
+		pooledCon.commit();
+	}
+
+	public void rollback()
+		throws SQLException
+	{
+		checkClosed();
+		pooledCon.rollback();
+	}
+
+	public void close()
+		throws SQLException
+	{
+		checkClosed();
+		isClosed = true;
+		pooledCon.close(this);
+	}
+
+	public boolean isClosed() {
+		return isClosed;
+	}
+
+}