I want to the set null values on runtime depending on the type I get
Here is my code
@SuppressWarnings("rawtypes")
// input can be Intger,Date, BigInt etc which Mysql supports
String input = "."+st.getType();
// param :- java.sql.Types.Integer or java.sql.Types.BigInt
Class clazz = Class.forName("java.sql.Types");
Field field = clazz.getField(input);
int val = field.getInt(null);
pstmt.setNull(1,val);
I'm going to slightly challenge your question in this answer. I do not believe that you need to do what you are doing, but as it's somewhat unclear, I'll do what I can to help you out.
First, based on the variable name pstmt I'm going to guess that this is a PreparedStatement that looks something like this:
INSERT INTO my_table (my_int, my_date, my_varchar, my_bool) VALUES (?, ?, ?, ?);
If this is the case, then you don't need to do any reflection at all, because Parameter 1 will always be an INTEGER, Parameter 2 will always be a DATE and so on. So you know what type to use in setNull because you know the position already (because you have to, because it's the first argument to setNull), and you know the statement. It's generally going to be much easier to follow your code if you just do the obvious thing and set the values.
if (myInt != null) {
pstmt.setInt(1, myInt);
} else {
pstmt.setNull(1, Types.INTEGER);
}
pstmt.setDate(2, myDate); // already handles null
// and so on
Now, this might get a tad trickier if you're trying to set the columns in a loop for some reason. I suggest to you that this is a bad idea because it'll be less obvious to future developers what you're up to.
However, the JDBC API has setObject for just such an occasion. setObject will allow null values, so you don't have to handle the null and not-null cases separately. There's even a version of setObject that will allow you to do this without specifying the type. In that case, it's just:
for (int i = 0; i < myObjects.size(); ++i) {
Object obj = myObjects.get(i);
pstmt.setObject(i, obj);
}
No casting, no remembering the type, no reflection needed. The documentation says it's not supported by every database, but I'd give this a shot before you do reflection.
If, for some reason, you need to do this with reflection (because you're one of the unlucky few whose database doesn't support un-typed nulls), you were actually pretty close.
public void apply(PreparedStatement pstmt, int param, String typeName, Object value) {
try {
Class<?> types = Types.class;
Field field = types.getField(typeName);
int typeValue = field.getInt(null);
pstmt.setObject(param, obj, typeValue);
} catch (Exception e) {
// handle exceptions
}
}
So what's different here from what you were trying? First, the field name doesn't have a . in front of it. That's not part of the field name. Secondly, the typeName parameter here must exactly match the java.sql.Types field name. This is a case-sensitive String. So, for example it's "INTEGER" not "int". In your comment, you indicated that your st.getType() method had an ArrayList. I've assumed that this method returns a single string, based on its knowledge of the query. Just make sure that your type names are the same as the names used by java.sql.Types and that the object in question can actually be used as (cast / converted to) that type.
Integerinstead of int. int can only be 0 while Integer can also be nullst? Where is it declared and how is it initialized?st, why the reflection magic?