import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
@Override
public boolean checkIfRowExists(int n, double gamma, double C,int total_rows,int training_rows,int run){
    try{
        String sql = "SELECT id FROM "+this.tablename+" WHERE gamma = ? AND C = ? AND total_rows = ? AND training_rows = ? AND run = ?";
        PreparedStatement preparedStatement = (PreparedStatement) conn.prepareStatement(sql);
        preparedStatement.setDouble(1, gamma);
        preparedStatement.setDouble(2, C);
        preparedStatement.setInt(3, total_rows);
        preparedStatement.setInt(4, training_rows);
        preparedStatement.setInt(5, run);
        ResultSet rs = (ResultSet) preparedStatement.executeQuery();
        return rs.next();
    }catch(SQLException ex){
        // handle any errors
        System.out.println("SQLException: " + ex.getMessage());
        System.out.println("SQLState: " + ex.getSQLState());
        System.out.println("VendorError: " + ex.getErrorCode());  
        System.exit(1);
    }
    return false;
}
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
/**
 * Checks if the required database is available
 * @return True, if the database is available
 */
private boolean dbIsAvailable() {

	boolean isDbAvailable = true;
	String sql = "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '" + dbName + "'";
	ResultSet res = this.getSqlResult4ExecuteQuery(sql);
	if (res==null) {
		return false;
	} else {
		try {
			res.last();
			if ( res.getRow()==0 ) {
				isDbAvailable = false;
			} else {
				isDbAvailable = true;
			}		
			
		} catch (SQLException e) {
			e.printStackTrace();
			this.dbError.setErrNumber( e.getErrorCode() );
			this.dbError.setHead( "Fehler beim Auslesen der Datensätze!" );
			this.dbError.setText( e.getLocalizedMessage() );
			this.dbError.setErr(true);
			this.dbError.show();
			isDbAvailable = false;
		}
	}
	
	try {
		res.close();
	} catch (SQLException sqle) {
		sqle.printStackTrace();
	}
	return isDbAvailable;
}
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
/**
 * This method returns the number of rows from a ResultSet-Object
 * @param rs
 * @return Number of rows from a result set, after SQL execution 
 */
public int getRowCount(ResultSet rs){
       int numResults = 0;
       try{
           rs.last();
           numResults = rs.getRow();
           rs.beforeFirst();
       } catch(SQLException e){
           e.printStackTrace();
       }
       return numResults;
   }
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
/**
 * This method is automatically called when you use a factory or the
 * constructor <ObjectRelational(ResultSet resultSet)>
 * 
 * @param resultSet
 * @throws IllegalArgumentException
 * @throws IllegalAccessException
 * @throws SQLException
 * @throws NoSuchMethodException
 * @throws SecurityException
 * @throws InvocationTargetException
 */
public void initialize(ResultSet resultSet)
		throws IllegalArgumentException, IllegalAccessException,
		SQLException, NoSuchMethodException, SecurityException,
		InvocationTargetException {
	fields = this.getClass().getDeclaredFields();
	for (Field field : fields) {
		if (!Modifier.isStatic(field.getModifiers())) {
			String columnName = getColumnName(field.getName());
			setFieldValue(field, resultSet.getObject(columnName));
		}
	}
}
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public List<T> getList(ResultSet resultSet) throws SQLException,
		IllegalArgumentException, IllegalAccessException,
		InstantiationException, NoSuchMethodException, SecurityException,
		InvocationTargetException {
	List<T> list = new ArrayList<T>();
	while (resultSet.next()) {
		objectRelational = t.newInstance();
		objectRelational.initialize(resultSet);
		list.add((T) objectRelational);
	}
	return list;
}
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
public List<String> getTableNames() {
	List<String> tables = new ArrayList<String>();
	try {
		ResultSet resultSet = (ResultSet) databaseMetaData.getTables(null,
				schema, "%", null);
		while (resultSet.next()) {
			tables.add(resultSet.getString(3));
		}
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return tables;
}
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
public List<String> getColumnNames(String table) {
	List<String> columns = new ArrayList<String>();
	try {
		ResultSet resultSet = (ResultSet) databaseMetaData.getColumns(null,
				schema, table, null);
		while (resultSet.next()) {
			columns.add(resultSet.getString("COLUMN_NAME"));
		}
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return columns;
}
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
public List<String> getSQLDataTypeNames(String table) {
	List<String> columns = new ArrayList<String>();
	try {
		ResultSet resultSet = (ResultSet) databaseMetaData.getColumns(null,
				schema, table, null);
		while (resultSet.next()) {
			columns.add(resultSet.getString("TYPE_NAME"));
		}
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return columns;
}
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
public String getPrimaryKey(String table) {
	String pk = null;
	try {
		ResultSet resultSet = (ResultSet) databaseMetaData.getPrimaryKeys(
				null, schema, table);
		if (resultSet.next()) {
			pk = resultSet.getString("COLUMN_NAME");
		}
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return pk;
}
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
public Map<String, String> getForeignKeys(String table) {
	Map<String, String> fks = new HashMap<String, String>();
	try {
		ResultSet resultSet = (ResultSet) databaseMetaData.getExportedKeys(
				null, schema, table);
		while (resultSet.next()) {
			fks.put(resultSet.getString("FKTABLE_NAME"),
					resultSet.getString("FKCOLUMN_NAME"));
		}
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return fks;
}
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
public ResultSet innerJoin(String tableA, String tableB, String columnA,
		String columnB) {
	return join(tableA, tableB, columnA, columnB, "INNER");
}
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
public ResultSet leftJoin(String tableA, String tableB, String columnA,
		String columnB) {
	return join(tableA, tableB, columnA, columnB, "LEFT");
}
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
public ResultSet rightJoin(String tableA, String tableB, String columnA,
		String columnB) {
	return join(tableA, tableB, columnA, columnB, "RIGHT");
}
 

import com.mysql.jdbc.ResultSet; //导入依赖的package包/类
/**
 * Returns a ResultSet - Object for a SQL-Statement
 * @param sqlStmt the SQL statement
 * @return com.mysql.jdbc.ResultSet
 */
public ResultSet getSqlResult4ExecuteQuery(String sqlStmt) {
	return this.getSqlResult4ExecuteQuery(sqlStmt, true);
}