Java Code Examples for java.sql.PreparedStatement#setDouble()

private static void bindField(ValueBuffer valueBuffer, PreparedStatement preparedStatement, int parameterIndex, boolean isUuid)
        throws SQLException
{
    Type type = valueBuffer.getType();
    if (valueBuffer.isNull()) {
        preparedStatement.setNull(parameterIndex, typeToSqlType(type));
    }
    else if (type.getJavaType() == long.class) {
        preparedStatement.setLong(parameterIndex, valueBuffer.getLong());
    }
    else if (type.getJavaType() == double.class) {
        preparedStatement.setDouble(parameterIndex, valueBuffer.getDouble());
    }
    else if (type.getJavaType() == boolean.class) {
        preparedStatement.setBoolean(parameterIndex, valueBuffer.getBoolean());
    }
    else if (type.getJavaType() == Slice.class && isUuid) {
        preparedStatement.setBytes(parameterIndex, valueBuffer.getSlice().getBytes());
    }
    else if (type.getJavaType() == Slice.class) {
        preparedStatement.setString(parameterIndex, new String(valueBuffer.getSlice().getBytes(), UTF_8));
    }
    else {
        throw new IllegalArgumentException("Unknown Java type: " + type.getJavaType());
    }
}
 

/**
 * 通过参数构建SQL
 * @param psmt
 * @param paramIndex
 * @param param
 *            ;
 */
private void setParameter(PreparedStatement psmt, int paramIndex, Object param) {
	try {
		if (param instanceof String) {
			psmt.setString(paramIndex, (String) param);
		} else if (param instanceof Integer) {
			psmt.setInt(paramIndex, (Integer) param);
		} else if (param instanceof Long) {
			psmt.setLong(paramIndex, (Long) param);
		} else if (param instanceof Float) {
			psmt.setFloat(paramIndex, (Float) param);
		} else if (param instanceof Double) {
			psmt.setDouble(paramIndex, (Double) param);
		} else if (param instanceof Date) {
			psmt.setTimestamp(paramIndex, new Timestamp(((Date) param).getTime()));
		}
	} catch (SQLException e) {
		LOGGER.error("", e);
	}
}
 

private HoldingDataBean createHolding(Connection conn, int accountID, String symbol, double quantity, BigDecimal purchasePrice) throws Exception {

        Timestamp purchaseDate = new Timestamp(System.currentTimeMillis());
        PreparedStatement stmt = getStatement(conn, createHoldingSQL);

        Integer holdingID = KeySequenceDirect.getNextID(conn, "holding", inSession, getInGlobalTxn());
        stmt.setInt(1, holdingID.intValue());
        stmt.setTimestamp(2, purchaseDate);
        stmt.setBigDecimal(3, purchasePrice);
        stmt.setDouble(4, quantity);
        stmt.setString(5, symbol);
        stmt.setInt(6, accountID);
        stmt.executeUpdate();

        stmt.close();

        return getHoldingData(conn, holdingID.intValue());
    }
 

@Override
public void apply(Connection connection) throws Exception {
    wideColumnPrepare(connection, "Float64");

    String params = Strings.repeat("?, ", columnNum);
    PreparedStatement pstmt = connection.prepareStatement("INSERT INTO "  + getTableName() +" values("   + params.substring(0, params.length()-2) + ")");


    for (int i = 0; i < batchSize; i++) {
        for (int j = 0; j < columnNum; j++ ) {
            pstmt.setDouble(j + 1, j + 1.2);
        }
        pstmt.addBatch();
    }
    int []res = pstmt.executeBatch();
    Assert.assertEquals(res.length, batchSize);

    wideColumnAfter(connection);
}
 

private void setDoubleValue(int queryType, String value, String paramType,
        PreparedStatement sqlQuery, int i) throws SQLException {
    Double val = null;
    if (value != null) {
        val = Double.parseDouble(value);
    }
    if (QueryTypes.IN.equals(paramType)) {
        if (queryType == SQLQuery.DS_QUERY_TYPE_NORMAL) {
            if (value == null) {
                sqlQuery.setNull(i + 1, Types.DOUBLE);
            } else {
                sqlQuery.setDouble(i + 1, val);
            }
        } else {
            if (value == null) {
                ((CallableStatement) sqlQuery).setNull(i + 1, Types.DOUBLE);
            } else {
                ((CallableStatement) sqlQuery).setDouble(i + 1, val);
            }
        }
    } else if (QueryTypes.INOUT.equals(paramType)) {
        if (value == null) {
            ((CallableStatement) sqlQuery).setNull(i + 1, Types.DOUBLE);
        } else {
            ((CallableStatement) sqlQuery).setDouble(i + 1, val);
        }
        ((CallableStatement) sqlQuery).registerOutParameter(i + 1, Types.DOUBLE);
    } else {
        ((CallableStatement) sqlQuery).registerOutParameter(i + 1, Types.DOUBLE);
    }
}
 

public static void setSelectActivityIndexSQLParameters(PreparedStatement statement, int index, long playtimeThreshold, long date) throws SQLException {
    statement.setDouble(index, Math.PI);
    statement.setLong(index + 1, playtimeThreshold);

    statement.setLong(index + 2, date - TimeUnit.DAYS.toMillis(7L));
    statement.setLong(index + 3, date);
    statement.setLong(index + 4, date - TimeUnit.DAYS.toMillis(14L));
    statement.setLong(index + 5, date - TimeUnit.DAYS.toMillis(7L));
    statement.setLong(index + 6, date - TimeUnit.DAYS.toMillis(21L));
    statement.setLong(index + 7, date - TimeUnit.DAYS.toMillis(14L));
}
 

private void insertData(String tableName, int startIndex, int endIndex) throws SQLException{
  Connection connection = TestUtil.getConnection();
  PreparedStatement ps = connection.prepareStatement("INSERT INTO " + tableName + "(bigIntegerField, blobField, charField," +
      "charForBitData, clobField, dateField, decimalField, doubleField, floatField, longVarcharForBitDataField, numericField," +
      "realField, smallIntField, timeField, timestampField, varcharField, varcharForBitData, xmlField) values( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, xmlparse(document cast (? as clob) PRESERVE WHITESPACE))");
 
  for (int i = startIndex; i < endIndex; i++) {
    int lessThan10 = i % 10;

    ps.setLong(1, i); //BIG INT
    ps.setBlob(2,new ByteArrayInputStream(new byte[]{(byte)i,(byte)i,(byte)i,(byte)i}));
    ps.setString(3, ""+lessThan10);
    ps.setBytes(4, ("" + lessThan10).getBytes());
    ps.setClob(5, new StringReader("SOME CLOB " + i));
    ps.setDate(6, new Date(System.currentTimeMillis()));
    ps.setBigDecimal(7, new BigDecimal(lessThan10 + .8));
    ps.setDouble(8, i + .88);
    ps.setFloat(9, i + .9f);
    ps.setBytes(10, ("A" + lessThan10).getBytes());
    ps.setBigDecimal(11, new BigDecimal(i));
    ps.setFloat(12, lessThan10 * 1111);
    ps.setShort(13, (short)i);
    ps.setTime(14, new Time(System.currentTimeMillis()));
    ps.setTimestamp(15, new Timestamp(System.currentTimeMillis()));
    ps.setString(16, "HI" + lessThan10);
    ps.setBytes(17, ("" + lessThan10).getBytes());
    ps.setClob(18, new StringReader("<xml><sometag>SOME XML CLOB " + i + "</sometag></xml>"));
    ps.execute();
  }
}
 

static void addParameters(final PreparedStatement preparedStatement, final Object... parameters)
        throws SQLException {
    if (parameters == null) {
        return;
    }
    int index = 0;
    for (final Object param : parameters) {
        index++;
        if (param instanceof Integer) {
            preparedStatement.setInt(index, (Integer) param);
        } else if (param instanceof Long) {
            preparedStatement.setLong(index, (Long) param);
        } else if (param instanceof Boolean) {
            preparedStatement.setBoolean(index, (Boolean) param);
        } else if (param instanceof String) {
            preparedStatement.setString(index, (String) param);
        } else if (param instanceof Double) {
            preparedStatement.setDouble(index, (Double) param);
        } else if (param instanceof Float) {
            preparedStatement.setFloat(index, (Float) param);
        } else if (param instanceof byte[]) {
            preparedStatement.setBytes(index, (byte[]) param);
        } else {
            throw new IllegalStateException("invalid parameter type: " + param);
        }
    }
}
 

private void updateUnsignedTable(Connection conn, double data) throws Exception {
    PreparedStatement stmt = conn.prepareStatement("UPSERT INTO " + unsignedTableName + " VALUES (?, ?, ?, ?, ?, ?, ?)");
    stmt.setString(1, KEY);
    Double d = Double.valueOf(data);
    stmt.setDouble(2, d.doubleValue());
    stmt.setFloat(3, d.floatValue());
    stmt.setInt(4, d.intValue());
    stmt.setLong(5, d.longValue());
    stmt.setShort(6, d.shortValue());
    stmt.setByte(7, d.byteValue());
    stmt.executeUpdate();
    conn.commit();
}
 

@Override
public void excluir(Compra compra) throws Exception {
    Conexao c = new Conexao();
    String sql = "UPDATE TBCOMPRA SET CODIGOFORNECEDOR=?, DATACOMPRA=?, VALORTOTAL=?, SITUACAO=? WHERE CODIGO=?";
    PreparedStatement ps = c.getConexao().prepareStatement(sql);
    ps.setInt(1, compra.getFornecedor().getCodigo());
    ps.setDate(2, new Date(compra.getDataCompra().getTime()));
    ps.setDouble(3, compra.getValorTotal());
    ps.setInt(4, Situacao.CANCELADA.getId());
    ps.setInt(5, compra.getCodigo());
    ps.execute();
    c.confirmar();
}
 

/**
 * Execute a prepared statement with a single double argument
 * and return the double value from the single row returned.
 */
private double getValue(PreparedStatement ps, double value)
        throws SQLException {
    ps.setDouble(1, value);
    ResultSet rs = ps.executeQuery();
    rs.next(); // we know a single value will be returned.
    double rValue = rs.getDouble(1);
    rs.close();
    return rValue;
}
 

/**
 * Flush the instance of this clause into database.
 * Here "instance" means all the constant ID in instance with
 * its weight as a row in DB.
 * @param db the database object used to store clause instances.
 */
protected void sealClauseInstances(RDB db) {
	if(!isTemplate){
		Clause.mappingFromID2Desc.put(this.id+ ".0", this.toString(-1));
		return;
	}
	// cosntruct SQL of adding instances
	ArrayList<String> atts = new ArrayList<String>();
	ArrayList<String> pholders = new ArrayList<String>();
	atts.add("weight FLOAT8");
	pholders.add("?");
	for(String v : metaVars) {
		if (Config.constants_as_raw_string) {
			atts.add(v + " TEXT");
		} else {
			atts.add(v + " INT");
		}
		pholders.add("?");
	}
	atts.add("myisfixed TEXT");
	pholders.add("?");
	
	
	db.dropTable(relIntanceClauses);
	String sql = "CREATE TABLE " + relIntanceClauses +
	StringMan.commaListParen(atts);
	db.update(sql);
	
	//TODO:
	db.dropSequence(relIntanceClauses+"_seq");
	sql = "CREATE SEQUENCE " + relIntanceClauses + "_seq;";
	db.update(sql);
	sql = "ALTER TABLE " + relIntanceClauses + " ADD myid INT;";
	db.update(sql);
	sql = "ALTER TABLE " + relIntanceClauses + " ALTER COLUMN myid SET " +
			"DEFAULT NEXTVAL('" + relIntanceClauses + "_seq');";
	db.update(sql);
	
	int instanceCount = 0;
	
	sql = "INSERT INTO " + relIntanceClauses + " VALUES" + 
	StringMan.commaListParen(pholders);
	PreparedStatement psAddMeta = db.getPrepareStatement(sql);
	
	int ni = 0;
	try {
		for(ClauseInstance ins : instances){
			double weight = ins.weight;
			ArrayList<Term> meta = ins.conList;
			psAddMeta.setDouble(1, weight);
			for(int k=0; k<meta.size(); k++) {
				if (Config.constants_as_raw_string) {
					psAddMeta.setString(k+2, meta.get(k).constantString());
				} else {
					psAddMeta.setInt(k+2, meta.get(k).constant());
				}
			}
			psAddMeta.setString(meta.size()+2, ins.isFixedWeight == true? "fixed" : "");
			instanceCount ++;
			Clause.mappingFromID2Desc.put(this.id+ "." + instanceCount, this.toString(ni++));
			psAddMeta.addBatch();
		}
		psAddMeta.executeBatch();
		psAddMeta.close();
	} catch (SQLException e) {
		ExceptionMan.handle(e);
	}
	psAddMeta = null;
}
 

/**
 * Test index scan on multivm queries on tables with redundancy.
 * @throws Exception
 */
public void testIndexScans () throws Exception {
  startVMs(2, 2);
  Connection conn = TestUtil.jdbcConn;
  Statement s = conn.createStatement();
  PreparedStatement psInsertBrokerTickets = null;
  
  s.execute("Create table broker_tickets (id int not null, ticketPrice int not null ," +
      " firmId int not null ,  price double, quantity int, ticker varchar(20)) " +
      " redundancy 1");
  
  psInsertBrokerTickets = conn.prepareStatement("insert into broker_tickets " +
      "(id, ticketPrice, firmId,  price, quantity, ticker ) " +
      "values (?, ?, ?, ?, ?, ?)");
  
  int numInserts = 1000;
  int key = 0;
  double price = 1.0;
  int quantity = 10;
  for (int i = 0; i < numInserts; i++) {
    psInsertBrokerTickets.setInt(1, key + 10);
    if ((i % 2) == 0) {
      psInsertBrokerTickets.setInt(2, 10);
    } else {
      psInsertBrokerTickets.setInt(2, 20);
    }
    psInsertBrokerTickets.setInt(3, key + 10);
    psInsertBrokerTickets.setDouble(4, price);
    psInsertBrokerTickets.setInt(5, quantity);
    psInsertBrokerTickets.setString(6, "YYYY" + key);
    int rt = psInsertBrokerTickets.executeUpdate();
    assertEquals("Insert should return 1.", 1, rt) ; 
    key += 10;
    price += 0.01;

  }
  s.execute("create index index_ticketPrice on broker_tickets (ticketPrice)");
  ResultSet rs = s.executeQuery("select avg(distinct ticketPrice) from " +
      "broker_tickets");
  while (rs.next()) {
    assertEquals("Result should match ", 15, rs.getInt(1));
  }
     
}
 

static void assignParameter(@NotNull final PreparedStatement stmt,
                            final int index,
                            @Nullable final Object object)
        throws SQLException
{
  if (object == null) {
    assignNull(stmt, index);
    return;
  }

  String setter = null;
  try {
    if (object instanceof Boolean) {
      setter = "setBoolean";
      stmt.setBoolean(index, (Boolean) object);
    }
    else if (object instanceof Byte) {
      setter = "setByte";
      stmt.setByte(index, (Byte) object);
    }
    else if (object instanceof Short) {
      setter = "setShort";
      stmt.setShort(index, (Short) object);
    }
    else if (object instanceof Integer) {
      setter = "setInt";
      stmt.setInt(index, (Integer) object);
    }
    else if (object instanceof Float) {
      setter = "setFloat";
      stmt.setFloat(index, (Float) object);
    }
    else if (object instanceof Double) {
      setter = "setDouble";
      stmt.setDouble(index, (Double) object);
    }
    else if (object instanceof BigInteger) {
      setter = "setBigDecimal";
      BigDecimal bigDecimal = new BigDecimal(object.toString());
      stmt.setBigDecimal(index, bigDecimal);
    }
    else if (object instanceof BigDecimal) {
      setter = "setBigDecimal";
      stmt.setBigDecimal(index, (BigDecimal) object);
    }
    else if (object instanceof Long) {
      setter = "setLong";
      stmt.setLong(index, (Long) object);
    }
    else if (object instanceof Character) {
      setter = "setString";
      stmt.setString(index, object.toString());
    }
    else if (object instanceof String) {
      setter = "setString";
      stmt.setString(index, (String) object);
    }
    else if (object instanceof java.sql.Date) {
      setter = "setDate";
      stmt.setDate(index, (java.sql.Date) object);
    }
    else if (object instanceof Timestamp) {
      setter = "setTimestamp";
      stmt.setTimestamp(index, (Timestamp) object);
    }
    else if (object instanceof java.sql.Time) {
      setter = "setTime";
      stmt.setTime(index, (java.sql.Time) object);
    }
    else if (object instanceof java.util.Date) {
      setter = "setTimestamp";
      stmt.setTimestamp(index, new Timestamp(((java.util.Date) object).getTime()));
    }
    else if (object instanceof byte[]) {
      setter = "setBytes";
      stmt.setBytes(index, (byte[]) object);
    }
    else {
      setter = "setObject";
      stmt.setObject(index, object);
    }
  }
  catch (Exception e) {
    //noinspection ConstantConditions
    String message = setter != null
        ? format("A problem with setting parameter %d using %s(). The original value class is %s. Exception %s: %s",
                 index, setter, object.getClass().getCanonicalName(), e.getClass().getSimpleName(), e.getMessage())
        : format("An unexpected problem with setting parameter %d. Exception %s: %s",
                 index, e.getClass().getSimpleName(), e.getMessage());
    throw new DBParameterSettingException(message, e, null);
  }
}
 

@Override
public void setNonNullParameter(PreparedStatement ps, int i, Double parameter, JdbcType jdbcType) throws SQLException {
	ps.setDouble(i, parameter);
}
 

/**
 * 设置PreparedStatement的参数
 * 
 * @param stmt
 * @param parameters
 * @throws SQLException
 * @throws NumberFormatException
 */
default void setPreparedStatmentParameters(PreparedStatement stmt, List<Parameter> parameters)
        throws NumberFormatException, SQLException {
    if (parameters != null) {
        for (int i = 0; i < parameters.size(); i++) {
            switch (parameters.get(i).getDataType()) {
            case SHORT:
                stmt.setShort(i + 1, Short.parseShort(parameters.get(i).getValue().toString()));
                break;
            case INT:
                stmt.setInt(i + 1, Integer.parseInt(parameters.get(i).getValue().toString()));
                break;
            case LONG:
                stmt.setLong(i + 1, Long.parseLong(parameters.get(i).getValue().toString()));
                break;
            case FLOAT:
                stmt.setFloat(i + 1, Float.parseFloat(parameters.get(i).getValue().toString()));
                break;
            case DOUBLE:
                stmt.setDouble(i + 1, Double.parseDouble(parameters.get(i).getValue().toString()));
                break;
            case STRING:
                stmt.setString(i + 1, parameters.get(i).getValue().toString());
                break;
            case DATE:
                SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd");
                try {
                    Date formattedDate = dateFormatter.parse(parameters.get(i).getValue().toString());
                    stmt.setDate(i + 1, new java.sql.Date(formattedDate.getTime()));
                } catch (ParseException e) {
                    throw new DAOException(e);
                }
                break;
            case DATETIME:
                Date date = (Date) parameters.get(i).getValue();
                stmt.setDate(i + 1, new java.sql.Date(date.getTime()));
                break;
            case TIMESTAMP:
                Date dt = (Date) parameters.get(i).getValue();
                SimpleDateFormat timestampFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
                stmt.setTimestamp(i + 1, java.sql.Timestamp.valueOf(timestampFormatter.format(dt)));
                break;
            case BOOLEAN:
                stmt.setBoolean(i + 1, Boolean.parseBoolean(parameters.get(i).getValue().toString()));
                break;
            case OBJECT:
                stmt.setObject(i + 1, parameters.get(i));
                break;
            default:
                stmt.setObject(i + 1, parameters.get(i));
            }
        }
    }
}
 

@Override
public void setParameter(PreparedStatement statement, int parameterIndex, Double arg) throws SQLException {
    statement.setDouble(parameterIndex, arg);
}
 

public void testNonKeyBasedTransactionalUpdatesAndConflict() throws Exception {
  startVMs(1, 1);
  Connection conn = TestUtil.jdbcConn;
  Statement st = conn.createStatement();
  st.execute("create schema trade");

  st.execute("create table trade.securities (sec_id int not null, "
      + "symbol varchar(10) not null, price decimal (30, 20), "
      + "exchange varchar(10) not null, tid int, "
      + "constraint sec_pk primary key (sec_id) ) "
      + " partition by primary key"+ getSuffix());// column (tid) ");

  conn.setTransactionIsolation(getIsolationLevel());
  conn.setAutoCommit(false);
  
  final int numRows = 5;
  PreparedStatement ps = conn
      .prepareStatement("insert into trade.securities values "
          + "(?, ?, ?, ?, ?)");
  for (int i = 0; i < numRows; i++) {
    ps.setInt(1, i);
    ps.setString(2, "XXXX" + i);
    ps.setDouble(3, i);
    ps.setString(4, "nasdaq");
    ps.setInt(5, i);
    ps.executeUpdate();
  }
  conn.commit();

  PreparedStatement psUpdate = conn
      .prepareStatement("update trade.securities "
          + "set symbol = ? where sec_id = ? and tid = ?");
  for (int i = 0; i < numRows; i++) {
    psUpdate.setString(1, "YYY" + i);
    psUpdate.setInt(2, i);
    psUpdate.setInt(3, i);
    psUpdate.executeUpdate();
  }

  this.gotConflict = false;
  Thread otherTx = new Thread(new Runnable() {
    @Override
    public void run() {
      final Region<Object, Object> r = Misc
          .getRegionForTable("TRADE.SECURITIES", true);
      final CacheTransactionManager txManager = Misc.getGemFireCache()
          .getCacheTransactionManager();
      txManager.begin();
      try {
        Object key = TestUtil.getGemFireKey(0, r);
        Object row = r.get(key);
        r.put(key, row);
      } catch (ConflictException ce) {
        gotConflict = true;
        txManager.rollback();
      } catch (StandardException se) {
        gotConflict = false;
        fail("failing put with exception", se);
      }
    }
  });
  otherTx.start();
  otherTx.join();

  assertTrue("expected conflict", this.gotConflict);
  this.gotConflict = false;

  conn.commit();
  // rs.close();
  st.close();
  psUpdate.close();
  ps.close();
  conn.close();
}
 

@Override
public void saveUsageRecords(List<UsageVO> usageRecords) {
    TransactionLegacy txn = TransactionLegacy.currentTxn();
    try {
        txn.start();
        String sql = INSERT_USAGE_RECORDS;
        PreparedStatement pstmt = null;
        pstmt = txn.prepareAutoCloseStatement(sql); // in reality I just want CLOUD_USAGE dataSource connection
        for (UsageVO usageRecord : usageRecords) {
            pstmt.setLong(1, usageRecord.getZoneId());
            pstmt.setLong(2, usageRecord.getAccountId());
            pstmt.setLong(3, usageRecord.getDomainId());
            pstmt.setString(4, usageRecord.getDescription());
            pstmt.setString(5, usageRecord.getUsageDisplay());
            pstmt.setInt(6, usageRecord.getUsageType());
            pstmt.setDouble(7, usageRecord.getRawUsage());
            if (usageRecord.getVmInstanceId() != null) {
                pstmt.setLong(8, usageRecord.getVmInstanceId());
            } else {
                pstmt.setNull(8, Types.BIGINT);
            }
            pstmt.setString(9, usageRecord.getVmName());
            if (usageRecord.getOfferingId() != null) {
                pstmt.setLong(10, usageRecord.getOfferingId());
            } else {
                pstmt.setNull(10, Types.BIGINT);
            }
            if (usageRecord.getTemplateId() != null) {
                pstmt.setLong(11, usageRecord.getTemplateId());
            } else {
                pstmt.setNull(11, Types.BIGINT);
            }
            if (usageRecord.getUsageId() != null) {
                pstmt.setLong(12, usageRecord.getUsageId());
            } else {
                pstmt.setNull(12, Types.BIGINT);
            }
            pstmt.setString(13, usageRecord.getType());
            if (usageRecord.getSize() != null) {
                pstmt.setLong(14, usageRecord.getSize());
            } else {
                pstmt.setNull(14, Types.BIGINT);
            }
            if (usageRecord.getNetworkId() != null) {
                pstmt.setLong(15, usageRecord.getNetworkId());
            } else {
                pstmt.setNull(15, Types.BIGINT);
            }
            pstmt.setString(16, DateUtil.getDateDisplayString(s_gmtTimeZone, usageRecord.getStartDate()));
            pstmt.setString(17, DateUtil.getDateDisplayString(s_gmtTimeZone, usageRecord.getEndDate()));
            if (usageRecord.getVirtualSize() != null) {
                pstmt.setLong(18, usageRecord.getVirtualSize());
            } else {
                pstmt.setNull(18, Types.BIGINT);
            }
            pstmt.addBatch();
        }
        pstmt.executeBatch();
        txn.commit();
    } catch (Exception ex) {
        txn.rollback();
        s_logger.error("error saving usage records to cloud_usage db", ex);
        throw new CloudRuntimeException(ex.getMessage());
    }
}
 

@Override
public void setNonNullParameter(PreparedStatement ps, int index, Double parameter, JdbcType jdbcType)
    throws SQLException {
  ps.setDouble(index, parameter);
}