Muchas gracias y ante cualquier duda, ya sabes que tienes que elegir ElHacker

Respecto a tu pregunta, yo haría lo siguiente:

• Asociar las fechas a un ID_USUARIO que será la PK.

Así sería muy fácil. Primero obtenemos los registros por el ID_USUARIO. Una vez que tengamos los registros (las fechas) podremos trabajar fácilmente.

Sería algo así, aclaro que no lo he probado y quizás debe tener algunos errores, de eso ya te encargas tú. Espero hayas aprendido a cómo realizarlo.

public boolean validarLicencia(long id) throws SQLException {
      try {
	String sentencia = "SELECT ID1, ID2 FROM TUTABLA WHERE ID_USUARIO = ?";
	Map mapaUsuario = obtenerMapaPorUserID(sentencia, id);
 
	Long id2 = (Long) mapaUsuario.get(0).get("id2"); // obtiene el valor asociado a la llave 'id2' del Map 'mapaUsuario'
 
	if(mapaUsuario = null && mapaUsuario.size() == 0) { return false; }
 
	if (id2 == null)  { // si el campo id2 es null en la tabla
		Calendar calendario = Calendar.getInstance();
		calendario.add(5,15) // la fecha de vencimiento es en 15 dias
		Long fechaHoyMiliseg = cal.getTime().getTime(); // obtiene fecha en milisegunos
		String sentencia = "UPDATE TUTABLA SET ID2 = ?";
		ejecutarSentenciaPorUserId(sentencia, fechaHoyMiliseg);
		return true; // informa que la licencia es valida
	}
 
	// Si existe el campo ID2
	Calendar calendario = Calendar.getInstance();
	Long fechaLimiteMiliseg = id2; // le asigna el valor de id2 recuperado del usuario
	Long fechaHoyMiliseg = calendario.getTime().getTime();
	if (fechaHoyMiliseg > fechaMiliteMiliseg) { // YA SE VENCIO LICENCIA!
		String sentencia = "DELE FROM TUTABLA WHERE ID_USUARIO = ?";
		ejecutarSentenciaPorUserId(sentencia, id);
		return false; // informa que la licencia ya vencio
	}
       } catch (SQLException ex) { throw ex; }
     finally { /* cierras flujos*/ }
 
     return true; // solo para que no de error ya que se debe de colocar el retorno
}

Método que obtiene un Map por id de usuario:

public Map obtenerMapaPorUserID(String sql, id) throws SQLException {
       try {
	// obtienes tu conexion y declaras previamente un preparedStatement
	estatuto = conexion.preparedStatement(sql);
	estatuto.setLong(1,user); // asigna el id a la consulta
	ResultSet rs = estatuto.executeQuery();
	Map<String llave, Long valor) mapaUsuario = new HashMap<>();
	while(rs.next()) {
		mapaUsuario.put("id1",rs.getLong("ID1"));
		mapaUsuario.put("id2",rs.getLong("ID2"));
	}
      } catch (SQLException ex) { throw ex; }
      finally { /* cierras flujos*/ }
	return mapaUsuario; // en caso no haya coincidencias devolvera una lista vacia (mapaUsuario.size() == 0)
}

Método que ejecuta una sentencia por id de usuario:

public void ejecutarSentenciaPorUserId(String sentencia, long id) throws SQLException {
        try {
	       // obtienes tu conexion y haces un executeUpdate();
        } catch (SQLException ex) { throw ex; }
        finally { /* cierras flujos*/ }
}

Hola, vamos a hacer un análisis de este algoritmo que a simple vista no entiendo nada xD

Esta línea obtiene los campos ID1, ID2 de la tabla TB_CIV_TEMP cuando el ID1 es desconocido, es decir luego se seteará el parámetro de condición.

String sql = "SELECT ID1, ID2 FROM TB_CIV_TMP WHERE ID1 = ?";
 

Luego hace uso de un método del cual no podemos ver nada pero al parecer devuelve fechas en milisegundos (para poder compararse luego). Este método recibe 3 parámetros: La query, un array String y un array Object.

Dado que no puedo ver el código de éste método, creo que no hace falta decirte que no entiendo ni un carajo para qué sirve xD

List<Map> obj = findMapBySQLParam(sql, new String[] { "id1", "id2" }, new Object[] { "202cb962ac59075b964b07152d234b70" });
 

Ahora, podemos deducir que el método findMapBySQLParam() concatenerá algún valor (alguna fecha en milisegundos quizás) con la query y hará la consulta. Por otro lado, si no se puede realizar la consulta o no hay coincidencias con la consulta, la lista puede ser nula (si no se ha podido realizar la consulta) o vacía (si no hay coincidencias). Si ésto llegara a pasar, devuelve false y termina el método.

Crea un objeto Object y le asigna el valor de la llave "id2" del primer Map de la lista recibida.

// obj.get(0) -> obtiene el primer elemento de la lista. En este caso el primer Map
// .get("id2") -> obtiene el valor asociado a la llave "id2"
Object id2 = (Map) obj.get(0).get("id2");
 

Si el valor es nulo, es decir no hay una llave con ese identificador lo crea:

Calendar cal = Calendar.getInstance(); // obtiene una instancia Calendar
// el primer parametro debe ser una constante. 5 equivale a Calendar.DAY
// el segundo parametro le suma 80 al tipo de dato de la constante. Ej.,
// si es Calendar.DAY y hoy estamos 20, adelanta la fecha en 80 dias.
call.add(5,80);
// Obtiene la fecha avanzada en milisegundos
Long var1 = Long.valueOf(cal.getTime().getTime());
// actualiza el campo ID2 con la fecha avanzada en milisegundos (al parecer)
sql = "UPDATE TB_CIV_TMP SET ID2 = ?";
executeUpdateSQLParam(sql, new Object[] { var1 });
return true; // devuelve true y termina el metodo

En caso el valor no sea nulo, es decir, si el primer Map de la lista si tiene un valor asociado a la llave "id2", obtiene el "id2" en milisegundos (al parecer es una fecha) y la fecha actual también en milisegundos. Luego los compara: Si la fecha en milisegundos de hoy es mayor que id2 en milisegundos, se elimina el usuario de la tabla.

Calendar cal = Calendar.getInstance();
// Fecha ID2 (avanzada) en milisegundos en la base de datos
Long var1 = Long.valueOf(Long.parseLong("" + id2));
// Fecha actual en milisegundos
Long var2 = Long.valueOf(cal.getTime().getTime());
	// si la actual es mayor que la avanzada: FIN DE LICENCIA!
	if (var2.longValue() > var1.longValue()) {
		sql = "DELETE FROM TB_CIV_TMP"; // elimina al user de la DB
		executeUpdateSQL(sql); // ejecuta la sentencia sql
		return false; // fin del metodo y devuelve false
}
 

De lo anterior podemos resumir que:

Hace una consulta a la base de datos para obtener los campos ID1 e ID2 que al parecer son un fechas, de acuerdo a un valor para ID1.

Calculamos la fecha en milisegundos que está en la base de datos (id2) con la fecha en milisegundos actual. Si la actual es mayor, se elimina el usuario de la base de datos.

Si ID2 no tiene un campo establecido en la base de datos, se obtiene la fecha 80 días en adelante en milisegundos y se guarda en la base de datos.


Conclusión:

Al parecer éste algoritmo trata sobre verificación de licencias de usuario de algún software.


PD: Creo que no es necesario que te diga dónde tienes que manejar las fechas (ya lo he explicado en el análisis). Salu2.

Por si te interesa usar Gtkmm3, tienes la guía oficial en español: Guía Gtkmm3

Gracias por la aclaración jefe. Una pregunta, ¿ésto sería para una mejor administración del staff, es decir saber si un mod no está cumpliendo su labor? Salu2.

Gracias Elektro, no lo había leído

Saludos.

Lo de Topic Solved creo que yo, mi estimado el-brujo, que vendría muy bien, sobre todo por el orden, así los que entran a la sección, saben qué temas han sido solucionados, encontrando una posible solución a su problema también, y si no, crean un tema nuevo. También en la búsqueda, se podría agregar un filtro: Solucionados.

Salu2.

PD: Lo de las votaciones me parece bien. Esto podría motivar a más gente a ayudar ^^

Hola, hoy entré y vi esto (A no ser que haya estado desde siempre y yo de animal no lo vi xD), un sistema de puntuación. ¿Cómo funciona? ¿Es como agradecimiento?



Salu2.

Listo, me alegra que se haya solucionado tu problema. Por eso te decía, que primero siempre se agrega el modelo a la JTable y recién se empieza a agregar datos. Cualquier duda, puedes postearla en ElHacker.net que seguro te apoyaremos.

Como última recomendación, te invito a que investigues sobre buenas prácticas de programación, cómo trabajar con bases de datos y patrones de diseño. Con ésto, tendrás un código muy limpio y entendible. Recuerda además, comentar siempre tus códigos, así cuando otro lo vean, sepan qué hace el código y no se pierda intentando decifrarlo.

Un saludo amigo.

PD: Edita el tema y coloca [Solucionado] antes del tema.

Saca esa línea, tiene que quedarte así:

while(rs.next()) {
	// asignas los datos al array data con sus castings respectivos
	modelo.addRow(data);
}
 
for(Object e : data) {
	System.out.println("Valor: "+e+"\tTipo de dato: "+e.getClass().getName());
}

NOTA: Los flujos se cierran siempre en un finally, ya que así ocurra una excepción nos aseguramos que la conexión se haya cerrado.

try {
	// conexion a db y demas
} catch(SQLException ex) { throw ex; }
finally { if(conexion != null) conexion.close(); }

Pega lo que imprime, para saber si se está guardando la información de la tabla en el array con su correspondiente tipo de dato. Salu2.

PD: Si le pasas por parámetro el modelo de la tabla, ¿para qué la devuelves nuevamente? ¿Estás haciendo algo así no?

JTable tblDatos = new JTable();
DefaultTableModel modelo = new DefaultTableModel();
modelo = agregarFila(modelo);
tblDatos.setModel(modelo);

Pero no sería necesario. Acuérdate que en Java el paso es por referencia (tipo punteros en C++), por lo que solamente bastaría con un agregarFila(modelo); y el cambio se reflejaría en el modelo. Ej.:

DefaultTableModel modelo = new DefaultTableModel();
JTable tblDatos = new JTable(modelo);
// aqui el paso es por referencia por lo que solo basta hacer esto
this.agregarFila(modelo); // y se agrega la fila al modelo.

Ayer la instalé y noté unity un poco más fluido. Han actualizado un poco la deroación de ventanas con GTK3 y ahora tiene un aspecto más 'fino'. En general, para ser beta está estable, solo un crasheo de firefox en el primer inicio, pero nada grave. Ningún problema con drivers (intel). Lo que me ha gustado es que ahora puedes redimensionar el dash hasta unos minúsculos 16px y creo que se va apoder minimizar las ventanas 'on click' en el dash.

Consumo de ram: 25-25% de 1.8 GB. Hasta Gnome consume la mitad xD. Salu2.