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

The following examples show how to use java.sql.PreparedStatement#setTime() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may want to check out the right sidebar which shows the related API usage.
Example 1
@Test
public void testBatch() throws SQLException, MalformedURLException {
    PreparedStatement preparedStatement = multiHostConnection.prepareStatement("UPDATE test SET a = ? WHERE b = ?");
    preparedStatement.setShort(1, (short) 12);
    preparedStatement.setTime(2, new Time(System.currentTimeMillis()));
    preparedStatement.addBatch();
    int[] resultSet = preparedStatement.executeBatch();
    preparedStatement.clearBatch();

    verify(mysqlPreparedStatement).executeBatch();
    verify(mysqlPreparedStatement).addBatch();
    verify(mysqlPreparedStatement).clearBatch();

    TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
    List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
    assertThat(spans.size(), is(1));
    assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/executeBatch", "");

}
 
Example 2
Source Project: morpheus-core   File: DbSink.java    License: Apache License 2.0 6 votes vote down vote up
@Override
void apply(PreparedStatement stmt, int stmtIndex, DataFrameRow<R, C> row) {
    final R rowKey = row.key();
    try {
        switch (rowKeyType) {
            case BIT:       stmt.setBoolean(stmtIndex, rowKeyMapper.applyAsBoolean(rowKey));             break;
            case BOOLEAN:   stmt.setBoolean(stmtIndex, rowKeyMapper.applyAsBoolean(rowKey));             break;
            case TINYINT:   stmt.setInt(stmtIndex, rowKeyMapper.applyAsInt(rowKey));                     break;
            case SMALLINT:  stmt.setInt(stmtIndex, rowKeyMapper.applyAsInt(rowKey));                     break;
            case FLOAT:     stmt.setDouble(stmtIndex, rowKeyMapper.applyAsDouble(rowKey));               break;
            case INTEGER:   stmt.setInt(stmtIndex, rowKeyMapper.applyAsInt(rowKey));                     break;
            case BIGINT:    stmt.setLong(stmtIndex, rowKeyMapper.applyAsLong(rowKey));                   break;
            case DOUBLE:    stmt.setDouble(stmtIndex, rowKeyMapper.applyAsDouble(rowKey));               break;
            case DECIMAL:   stmt.setDouble(stmtIndex, rowKeyMapper.applyAsDouble(rowKey));               break;
            case VARCHAR:   stmt.setString(stmtIndex, (String)rowKeyMapper.apply(rowKey));          break;
            case DATE:      stmt.setDate(stmtIndex, (Date)rowKeyMapper.apply(rowKey));              break;
            case TIME:      stmt.setTime(stmtIndex, (Time)rowKeyMapper.apply(rowKey));              break;
            case DATETIME:  stmt.setTimestamp(stmtIndex, (Timestamp)rowKeyMapper.apply(rowKey));    break;
            default:    throw new IllegalStateException("Unsupported column type:" + rowKeyType);
        }
    } catch (Exception ex) {
        throw new DataFrameException("Failed to apply row key to SQL statement at " + rowKey, ex);
    }
}
 
Example 3
Source Project: morpheus-core   File: SQL.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Binds arguments to prepared statement
 * @param stmt  the prepared statement reference
 * @return      the same as arg
 * @throws SQLException if binding fails
 */
private PreparedStatement bindArgs(PreparedStatement stmt) throws SQLException {
    for (int i=0; i<args.length; ++i) {
        final Object value = args[i];
        if      (value instanceof Boolean)          stmt.setBoolean(i+1, (Boolean)value);
        else if (value instanceof Short)            stmt.setShort(i+1, (Short)value);
        else if (value instanceof Integer)          stmt.setInt(i+1, (Integer)value);
        else if (value instanceof Float)            stmt.setFloat(i+1, (Float)value);
        else if (value instanceof Long)             stmt.setLong(i+1, (Long)value);
        else if (value instanceof Double)           stmt.setDouble(i+1, (Double)value);
        else if (value instanceof String)           stmt.setString(i+1, (String)value);
        else if (value instanceof java.sql.Date)    stmt.setDate(i+1, (java.sql.Date)value);
        else if (value instanceof Timestamp)        stmt.setTimestamp(i+1, (Timestamp)value);
        else if (value instanceof LocalDate)        stmt.setDate(i + 1, java.sql.Date.valueOf((LocalDate)value));
        else if (value instanceof LocalTime)        stmt.setTime(i+1, Time.valueOf((LocalTime)value));
        else if (value instanceof LocalDateTime)    stmt.setTimestamp(i+1, Timestamp.valueOf((LocalDateTime)value));
        else if (value instanceof ZonedDateTime) {
            final ZonedDateTime zonedDateTime = (ZonedDateTime)value;
            final LocalDateTime dateTime = zonedDateTime.toLocalDateTime();
            stmt.setTimestamp(i+1, Timestamp.valueOf(dateTime));
        } else {
            throw new RuntimeException("Unsupported argument, cannot be bound to SQL statement: " + value);
        }
    }
    return stmt;
}
 
Example 4
Source Project: phoenix   File: DateArithmeticIT.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void testSubtractTime() throws Exception {
  Connection conn;
  PreparedStatement stmt;
  ResultSet rs;
  String tName = generateUniqueName();
  Properties props = PropertiesUtil.deepCopy(TEST_PROPERTIES);
  conn = DriverManager.getConnection(getUrl(), props);
  conn.createStatement()
          .execute(
                  "create table " + tName + " (ts time primary key)");
  conn.close();

  conn = DriverManager.getConnection(getUrl(), props);
  stmt = conn.prepareStatement("upsert into " + tName + " values (?)");
  Time time = new Time(1995 - 1900, 4, 2);
  stmt.setTime(1, time);
  stmt.execute();
  conn.commit();
  conn = DriverManager.getConnection(getUrl(), props);
  rs = conn.createStatement().executeQuery("SELECT ts FROM " + tName + "");
  assertTrue(rs.next());
  assertEquals(time.getTime(),rs.getTimestamp(1).getTime());
  conn = DriverManager.getConnection(getUrl(), props);
  rs = conn.createStatement().executeQuery("SELECT ts - 1 FROM " + tName);
  assertTrue(rs.next());
  assertEquals(time.getTime() - MILLIS_IN_DAY,rs.getTimestamp(1).getTime());
}
 
Example 5
@Test
public void assertSetTime() throws SQLException {
    for (PreparedStatement each : preparedStatements) {
        Time now = new Time(0L);
        each.setTime(1, now);
        each.setTime(2, now, Calendar.getInstance());
        assertParameter(each, 1, now);
        assertParameter(each, 2, now);
    }
}
 
Example 6
Source Project: ignite   File: JdbcCheckpointSpi.java    License: Apache License 2.0 5 votes vote down vote up
/** {@inheritDoc} */
@Override public byte[] loadCheckpoint(String key) throws IgniteSpiException {
    Connection conn = null;

    PreparedStatement st = null;

    ResultSet rs = null;

    try {
        conn = getConnection();

        st = conn.prepareStatement(selSql);

        st.setString(1, key);
        st.setTime(2, new Time(U.currentTimeMillis()));

        rs = st.executeQuery();

        return rs.next() ? rs.getBytes(1) : null;
    }
    catch (SQLException e) {
        throw new IgniteSpiException("Failed to load checkpoint [tblName=" + tblName + ", key=" + key + ']', e);
    }
    finally {
        U.close(rs, log);
        U.close(st, log);
        U.close(conn, log);
    }
}
 
Example 7
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();
  }
}
 
Example 8
Source Project: flink   File: JdbcUtils.java    License: Apache License 2.0 4 votes vote down vote up
public static void setField(PreparedStatement upload, int type, Object field, int index) throws SQLException {
	if (field == null) {
		upload.setNull(index + 1, type);
	} else {
		try {
			// casting values as suggested by http://docs.oracle.com/javase/1.5.0/docs/guide/jdbc/getstart/mapping.html
			switch (type) {
				case java.sql.Types.NULL:
					upload.setNull(index + 1, type);
					break;
				case java.sql.Types.BOOLEAN:
				case java.sql.Types.BIT:
					upload.setBoolean(index + 1, (boolean) field);
					break;
				case java.sql.Types.CHAR:
				case java.sql.Types.NCHAR:
				case java.sql.Types.VARCHAR:
				case java.sql.Types.LONGVARCHAR:
				case java.sql.Types.LONGNVARCHAR:
					upload.setString(index + 1, (String) field);
					break;
				case java.sql.Types.TINYINT:
					upload.setByte(index + 1, (byte) field);
					break;
				case java.sql.Types.SMALLINT:
					upload.setShort(index + 1, (short) field);
					break;
				case java.sql.Types.INTEGER:
					upload.setInt(index + 1, (int) field);
					break;
				case java.sql.Types.BIGINT:
					upload.setLong(index + 1, (long) field);
					break;
				case java.sql.Types.REAL:
					upload.setFloat(index + 1, (float) field);
					break;
				case java.sql.Types.FLOAT:
				case java.sql.Types.DOUBLE:
					upload.setDouble(index + 1, (double) field);
					break;
				case java.sql.Types.DECIMAL:
				case java.sql.Types.NUMERIC:
					upload.setBigDecimal(index + 1, (java.math.BigDecimal) field);
					break;
				case java.sql.Types.DATE:
					upload.setDate(index + 1, (java.sql.Date) field);
					break;
				case java.sql.Types.TIME:
					upload.setTime(index + 1, (java.sql.Time) field);
					break;
				case java.sql.Types.TIMESTAMP:
					upload.setTimestamp(index + 1, (java.sql.Timestamp) field);
					break;
				case java.sql.Types.BINARY:
				case java.sql.Types.VARBINARY:
				case java.sql.Types.LONGVARBINARY:
					upload.setBytes(index + 1, (byte[]) field);
					break;
				default:
					upload.setObject(index + 1, field);
					LOG.warn("Unmanaged sql type ({}) for column {}. Best effort approach to set its value: {}.",
						type, index + 1, field);
					// case java.sql.Types.SQLXML
					// case java.sql.Types.ARRAY:
					// case java.sql.Types.JAVA_OBJECT:
					// case java.sql.Types.BLOB:
					// case java.sql.Types.CLOB:
					// case java.sql.Types.NCLOB:
					// case java.sql.Types.DATALINK:
					// case java.sql.Types.DISTINCT:
					// case java.sql.Types.OTHER:
					// case java.sql.Types.REF:
					// case java.sql.Types.ROWID:
					// case java.sql.Types.STRUC
			}
		} catch (ClassCastException e) {
			// enrich the exception with detailed information.
			String errorMessage = String.format(
				"%s, field index: %s, field value: %s.", e.getMessage(), index, field);
			ClassCastException enrichedException = new ClassCastException(errorMessage);
			enrichedException.setStackTrace(e.getStackTrace());
			throw enrichedException;
		}
	}
}
 
Example 9
Source Project: calcite   File: ResultSetEnumerable.java    License: Apache License 2.0 4 votes vote down vote up
/** Assigns a value to a dynamic parameter in a prepared statement, calling
 * the appropriate {@code setXxx} method based on the type of the value. */
private static void setDynamicParam(PreparedStatement preparedStatement,
    int i, Object value) throws SQLException {
  if (value == null) {
    preparedStatement.setObject(i, null, SqlType.ANY.id);
  } else if (value instanceof Timestamp) {
    preparedStatement.setTimestamp(i, (Timestamp) value);
  } else if (value instanceof Time) {
    preparedStatement.setTime(i, (Time) value);
  } else if (value instanceof String) {
    preparedStatement.setString(i, (String) value);
  } else if (value instanceof Integer) {
    preparedStatement.setInt(i, (Integer) value);
  } else if (value instanceof Double) {
    preparedStatement.setDouble(i, (Double) value);
  } else if (value instanceof java.sql.Array) {
    preparedStatement.setArray(i, (java.sql.Array) value);
  } else if (value instanceof BigDecimal) {
    preparedStatement.setBigDecimal(i, (BigDecimal) value);
  } else if (value instanceof Boolean) {
    preparedStatement.setBoolean(i, (Boolean) value);
  } else if (value instanceof Blob) {
    preparedStatement.setBlob(i, (Blob) value);
  } else if (value instanceof Byte) {
    preparedStatement.setByte(i, (Byte) value);
  } else if (value instanceof NClob) {
    preparedStatement.setNClob(i, (NClob) value);
  } else if (value instanceof Clob) {
    preparedStatement.setClob(i, (Clob) value);
  } else if (value instanceof byte[]) {
    preparedStatement.setBytes(i, (byte[]) value);
  } else if (value instanceof Date) {
    preparedStatement.setDate(i, (Date) value);
  } else if (value instanceof Float) {
    preparedStatement.setFloat(i, (Float) value);
  } else if (value instanceof Long) {
    preparedStatement.setLong(i, (Long) value);
  } else if (value instanceof Ref) {
    preparedStatement.setRef(i, (Ref) value);
  } else if (value instanceof RowId) {
    preparedStatement.setRowId(i, (RowId) value);
  } else if (value instanceof Short) {
    preparedStatement.setShort(i, (Short) value);
  } else if (value instanceof URL) {
    preparedStatement.setURL(i, (URL) value);
  } else if (value instanceof SQLXML) {
    preparedStatement.setSQLXML(i, (SQLXML) value);
  } else {
    preparedStatement.setObject(i, value);
  }
}
 
Example 10
Source Project: gemfirexd-oss   File: SQLTime.java    License: Apache License 2.0 4 votes vote down vote up
/** Adding this method to ensure that super class' setInto method doesn't get called
   * that leads to the violation of JDBC spec( untyped nulls ) when batching is turned on.
   */
 public void setInto(PreparedStatement ps, int position) throws SQLException, StandardException {

     ps.setTime(position, getTime((Calendar) null));
}
 
Example 11
/**
 * Test NULLIF with parameter as first operand
 * 
 * @throws SQLException
 */
public void testParameterForFirstOperandToNullIf() throws SQLException {
    for (int secondColumnType = 0; secondColumnType < SQLUtilities.SQLTypes.length; secondColumnType++) {

        String nullIfString = new String("SELECT NULLIF(?,"
                + SQLUtilities.allDataTypesColumnNames[secondColumnType]
                + ") from AllDataTypesTable");
        int row = 0;
        try {
            PreparedStatement ps = prepareStatement(nullIfString);
            switch (secondColumnType) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
                ps.setBoolean(1, true);
                break;
            case 8: // 'LONG VARCHAR'
            case 11: // 'LONG VARCHAR FOR BIT DATA'
            case 12: // 'CLOB'
            case 16: // 'BLOB'
                // Take specific case of LONG VARCHAR. Prepare of
                // nullif(?,long varchar)
                // fails early on because at bind time, Derby tries to set ?
                // to
                // long varchar. But comparison between 2 long varchars is
                // not
                // supported and hence bind code in
                // BinaryComparisonOperatorNode fails
                // Similar thing happens for CLOB, BLOB and LONG VARCHAR FOR
                // BIT DATA
            case 9:
            case 10:
                ps.setBinaryStream(1, (java.io.InputStream) null, 1);
                break;
            case 13:// DATE

                ps.setDate(1, Date.valueOf("2000-01-01"));
                break;
            case 14:// TIME

                ps.setTime(1, Time.valueOf("15:30:20"));
                break;
            case 15:// TIMESTAMP

                ps
                        .setTimestamp(1, Timestamp
                                .valueOf("2000-01-01 15:30:20"));
                break;
            default:
                break;
            }
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                String val = rs.getString(1);
                
                if (usingDerbyNetClient())
                    assertEquals(paramResultsClient[secondColumnType][row],
                            val);
                else
                    assertEquals(paramResults[secondColumnType][row], val);
                row++;
            }
            rs.close();
            ps.close();

        } catch (SQLException e) {
            for (int r = row; r < 4; r++) {
                if (usingDerbyNetClient())
                    assertEquals(paramResultsClient[secondColumnType][row],
                            "Exception");
                else
                    assertEquals(paramResults[secondColumnType][row],
                            "Exception");
            }
        }
    }
}
 
Example 12
/**
 * @param preparedState
 * @param param
 * @throws SQLException
 */
private void setParam(PreparedStatement preparedState, int index, PrepareSqlRequest.StateParam param)
        throws SQLException {
    boolean isNull = (null == param.getValue());

    Class<?> clazz;
    try {
        clazz = Class.forName(param.getClassName());
    } catch (ClassNotFoundException e) {
        throw new InternalErrorException(e);
    }

    Rep rep = Rep.of(clazz);

    switch (rep) {
    case PRIMITIVE_CHAR:
    case CHARACTER:
    case STRING:
        preparedState.setString(index, isNull ? null : String.valueOf(param.getValue()));
        break;
    case PRIMITIVE_INT:
    case INTEGER:
        preparedState.setInt(index, isNull ? 0 : Integer.parseInt(param.getValue()));
        break;
    case PRIMITIVE_SHORT:
    case SHORT:
        preparedState.setShort(index, isNull ? 0 : Short.parseShort(param.getValue()));
        break;
    case PRIMITIVE_LONG:
    case LONG:
        preparedState.setLong(index, isNull ? 0 : Long.parseLong(param.getValue()));
        break;
    case PRIMITIVE_FLOAT:
    case FLOAT:
        preparedState.setFloat(index, isNull ? 0 : Float.parseFloat(param.getValue()));
        break;
    case PRIMITIVE_DOUBLE:
    case DOUBLE:
        preparedState.setDouble(index, isNull ? 0 : Double.parseDouble(param.getValue()));
        break;
    case PRIMITIVE_BOOLEAN:
    case BOOLEAN:
        preparedState.setBoolean(index, !isNull && Boolean.parseBoolean(param.getValue()));
        break;
    case PRIMITIVE_BYTE:
    case BYTE:
        preparedState.setByte(index, isNull ? 0 : Byte.parseByte(param.getValue()));
        break;
    case JAVA_UTIL_DATE:
    case JAVA_SQL_DATE:
        preparedState.setDate(index, isNull ? null : java.sql.Date.valueOf(param.getValue()));
        break;
    case JAVA_SQL_TIME:
        preparedState.setTime(index, isNull ? null : Time.valueOf(param.getValue()));
        break;
    case JAVA_SQL_TIMESTAMP:
        preparedState.setTimestamp(index, isNull ? null : Timestamp.valueOf(param.getValue()));
        break;
    default:
        preparedState.setObject(index, isNull ? null : param.getValue());
    }
}
 
Example 13
/**
 * Determines how to map the given value to the appropriate JDBC data jdbcType and sets the parameter on the
 * provided PreparedStatement
 *
 * @param stmt           the PreparedStatement to set the parameter on
 * @param attrName       the name of the attribute that the parameter is coming from - for logging purposes
 * @param parameterIndex the index of the HiveQL parameter to set
 * @param parameterValue the value of the HiveQL parameter to set
 * @param jdbcType       the JDBC Type of the HiveQL parameter to set
 * @throws SQLException if the PreparedStatement throws a SQLException when calling the appropriate setter
 */
protected void setParameter(final PreparedStatement stmt, final String attrName, final int parameterIndex, final String parameterValue, final int jdbcType) throws SQLException {
    if (parameterValue == null) {
        stmt.setNull(parameterIndex, jdbcType);
    } else {
        try {
            switch (jdbcType) {
                case Types.BIT:
                case Types.BOOLEAN:
                    stmt.setBoolean(parameterIndex, Boolean.parseBoolean(parameterValue));
                    break;
                case Types.TINYINT:
                    stmt.setByte(parameterIndex, Byte.parseByte(parameterValue));
                    break;
                case Types.SMALLINT:
                    stmt.setShort(parameterIndex, Short.parseShort(parameterValue));
                    break;
                case Types.INTEGER:
                    stmt.setInt(parameterIndex, Integer.parseInt(parameterValue));
                    break;
                case Types.BIGINT:
                    stmt.setLong(parameterIndex, Long.parseLong(parameterValue));
                    break;
                case Types.REAL:
                    stmt.setFloat(parameterIndex, Float.parseFloat(parameterValue));
                    break;
                case Types.FLOAT:
                case Types.DOUBLE:
                    stmt.setDouble(parameterIndex, Double.parseDouble(parameterValue));
                    break;
                case Types.DECIMAL:
                case Types.NUMERIC:
                    stmt.setBigDecimal(parameterIndex, new BigDecimal(parameterValue));
                    break;
                case Types.DATE:
                    stmt.setDate(parameterIndex, new Date(Long.parseLong(parameterValue)));
                    break;
                case Types.TIME:
                    stmt.setTime(parameterIndex, new Time(Long.parseLong(parameterValue)));
                    break;
                case Types.TIMESTAMP:
                    stmt.setTimestamp(parameterIndex, new Timestamp(Long.parseLong(parameterValue)));
                    break;
                case Types.CHAR:
                case Types.VARCHAR:
                case Types.LONGNVARCHAR:
                case Types.LONGVARCHAR:
                    stmt.setString(parameterIndex, parameterValue);
                    break;
                default:
                    stmt.setObject(parameterIndex, parameterValue, jdbcType);
                    break;
            }
        } catch (SQLException e) {
            // Log which attribute/parameter had an error, then rethrow to be handled at the top level
            getLogger().error("Error setting parameter {} to value from {} ({})", new Object[]{parameterIndex, attrName, parameterValue}, e);
            throw e;
        }
    }
}
 
Example 14
Source Project: gemfirexd-oss   File: SQLTime.java    License: Apache License 2.0 4 votes vote down vote up
/** Adding this method to ensure that super class' setInto method doesn't get called
   * that leads to the violation of JDBC spec( untyped nulls ) when batching is turned on.
   */
 public void setInto(PreparedStatement ps, int position) throws SQLException, StandardException {

     ps.setTime(position, getTime((Calendar) null));
}
 
Example 15
Source Project: gemfirexd-oss   File: FileStreamIOTest.java    License: Apache License 2.0 4 votes vote down vote up
public void testAllDataTypesDiskWrite() throws SQLException {
    EmbedConnection conn = (EmbedConnection)TestUtil.getConnection();

    Statement st = conn.createStatement();
    try {
      st.execute("drop table test");
    } catch (Exception i) {
    }

    try {
      st
          .execute("create table test (id int primary key, "
              + "lv bigint, si smallint, fl float, dbl double, "
              + "nmr numeric(10,2), dml decimal(30,20), "
              + "dt date, tm time, ts timestamp, cr char(254), vcr varchar(8192), id2 int, id3 int )"); // rl
      // real

      PreparedStatement ps = conn
          .prepareStatement("insert into test values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )");

      String vstr = "ঙ চ ছ জ ঝ ঞ ট This is varchar max upto 8k bytes ... so I suppose this should test long " +
      		" enought string for now .... with some more bytes added for randomization ";
      for (int row = 1; row < 1000; row++) {
        ps.setInt(1, row);
        ps.setLong(2, row);
        ps.setShort(3, (short)row);
        ps.setFloat(4, row * 1.3f);
        ps.setDouble(5, row + 1.2 / 0.9);
        ps.setBigDecimal(6, BigDecimal.valueOf(row / 1.34d));
        ps.setBigDecimal(7, BigDecimal.valueOf(row / 1.43d * row));
        final int d = ((row % 20) + 1);
        ps.setDate(8, java.sql.Date
            .valueOf("2011-04-" + (d < 10 ? "0" + d : d)));
        ps.setTime(9, java.sql.Time.valueOf("12:00:01"));
        ps.setTimestamp(10, java.sql.Timestamp
            .valueOf("2011-02-28 11:59:59.99999"));
        ps.setString(11, "This is char fixed width upto 254 ...  ঋ এ ঐ ও ");
        int begin = AvailablePort.rand.nextInt(vstr.length()-1);
        ps
            .setString(
                12, vstr.substring(begin, vstr.length()));
        ps.setInt(13, row+1);
        ps.setInt(14, row+2);
        
        ps.executeUpdate();
      }

      GemFireXDQueryObserverHolder
          .setInstance(new GemFireXDQueryObserverAdapter() {
            private static final long serialVersionUID = 1L;

            public int overrideSortBufferSize(ColumnOrdering[] columnOrdering,
                int sortBufferMax) {
              return 100;
            }

            public boolean avoidMergeRuns() {
              return false;
            }
          });

//      ResultSet rs = st
//          .executeQuery("select cr, tm, vcr, dbl, lv, fl, dml, ts, nmr, dt, id from test order by ts, vcr, dt");
//      while (rs.next()) {
//        System.out.println(rs.getInt("id"));
//      }

      ResultSet rs = st
          .executeQuery("select id, id2, id3, dml, ts from test order by id2 desc, dml");
      while (rs.next()) {
        System.out.println(rs.getInt("id"));
//        TestUtil.getLogger().fine(Integer.toString(rs.getInt("id"));
      }
      
    } finally {
      GemFireXDQueryObserverHolder
          .setInstance(new GemFireXDQueryObserverAdapter());
      TestUtil.shutDown();
    }
  }
 
Example 16
@Override
public void setNonNullParameter(PreparedStatement ps, int i, Date parameter, JdbcType jdbcType) throws SQLException {
	ps.setTime(i, new Time(parameter.getTime()));
}
 
Example 17
Source Project: kylin   File: QueryService.java    License: Apache License 2.0 4 votes vote down vote up
/**
 * @param preparedState
 * @param param
 * @throws SQLException
 */
private void setParam(PreparedStatement preparedState, int index, PrepareSqlRequest.StateParam param)
        throws SQLException {
    boolean isNull = (null == param.getValue());

    Class<?> clazz;
    try {
        clazz = Class.forName(param.getClassName());
    } catch (ClassNotFoundException e) {
        throw new RuntimeException(e.getMessage(), e);
    }

    Rep rep = Rep.of(clazz);

    switch (rep) {
    case PRIMITIVE_CHAR:
    case CHARACTER:
    case STRING:
        preparedState.setString(index, isNull ? null : String.valueOf(param.getValue()));
        break;
    case PRIMITIVE_INT:
    case INTEGER:
        preparedState.setInt(index, isNull ? 0 : Integer.valueOf(param.getValue()));
        break;
    case PRIMITIVE_SHORT:
    case SHORT:
        preparedState.setShort(index, isNull ? 0 : Short.valueOf(param.getValue()));
        break;
    case PRIMITIVE_LONG:
    case LONG:
        preparedState.setLong(index, isNull ? 0 : Long.valueOf(param.getValue()));
        break;
    case PRIMITIVE_FLOAT:
    case FLOAT:
        preparedState.setFloat(index, isNull ? 0 : Float.valueOf(param.getValue()));
        break;
    case PRIMITIVE_DOUBLE:
    case DOUBLE:
        preparedState.setDouble(index, isNull ? 0 : Double.valueOf(param.getValue()));
        break;
    case PRIMITIVE_BOOLEAN:
    case BOOLEAN:
        preparedState.setBoolean(index, !isNull && Boolean.parseBoolean(param.getValue()));
        break;
    case PRIMITIVE_BYTE:
    case BYTE:
        preparedState.setByte(index, isNull ? 0 : Byte.valueOf(param.getValue()));
        break;
    case JAVA_UTIL_DATE:
    case JAVA_SQL_DATE:
        preparedState.setDate(index, isNull ? null : java.sql.Date.valueOf(param.getValue()));
        break;
    case JAVA_SQL_TIME:
        preparedState.setTime(index, isNull ? null : Time.valueOf(param.getValue()));
        break;
    case JAVA_SQL_TIMESTAMP:
        preparedState.setTimestamp(index, isNull ? null : Timestamp.valueOf(param.getValue()));
        break;
    default:
        preparedState.setObject(index, isNull ? null : param.getValue());
    }
}
 
Example 18
/** Adding this method to ensure that super class' setInto method doesn't get called
   * that leads to the violation of JDBC spec( untyped nulls ) when batching is turned on.
   */
 public void setInto(PreparedStatement ps, int position) throws SQLException, StandardException {

     ps.setTime(position, getTime((Calendar) null));
}
 
Example 19
Source Project: phoenix   File: ToNumberFunctionIT.java    License: Apache License 2.0 4 votes vote down vote up
@Before
public void initTable() throws Exception {
    long ts = nextTimestamp();
    createTestTable(getUrl(), TO_NUMBER_TABLE_DDL, null, ts-2);
    String url = getUrl() + ";" + PhoenixRuntime.CURRENT_SCN_ATTRIB + "=" + ts;
    Properties props = PropertiesUtil.deepCopy(TEST_PROPERTIES);
    Connection conn = DriverManager.getConnection(url, props);
    conn.setAutoCommit(false);
    
    PreparedStatement stmt = conn.prepareStatement(
            "upsert into " + TO_NUMBER_TABLE_NAME +
            "    (a_id, " +
            "    a_string," +
            "    b_string," +
            "    a_date," +
            "    a_time," +
            "    a_timestamp)" +
            "VALUES (?, ?, ?, ?, ?, ?)");
    
    stmt.setInt(1, 1);
    stmt.setString(2, "   1");
    stmt.setString(3, "   1");
    row1Date = new Date(System.currentTimeMillis() - 1000);
    row1Time = new Time(System.currentTimeMillis() - 1000);
    row1Timestamp = new Timestamp(System.currentTimeMillis() + 10000);
    stmt.setDate(4, row1Date);
    stmt.setTime(5, row1Time);
    stmt.setTimestamp(6, row1Timestamp);
    stmt.execute();
    
    stmt.setInt(1, 2);
    stmt.setString(2, " 2.2");
    stmt.setString(3, " 2.2");
    row2Date = new Date(System.currentTimeMillis() - 10000);
    row2Time = new Time(System.currentTimeMillis() - 1234);
    row2Timestamp = new Timestamp(System.currentTimeMillis() + 1234567);
    stmt.setDate(4, row2Date);
    stmt.setTime(5, row2Time);
    stmt.setTimestamp(6, row2Timestamp);
    stmt.execute();
    
    stmt.setInt(1, 3);
    stmt.setString(2, "$3.3");
    stmt.setString(3, "$3.3");
    row3Date = new Date(System.currentTimeMillis() - 100);
    row3Time = new Time(System.currentTimeMillis() - 789);
    row3Timestamp = new Timestamp(System.currentTimeMillis() + 78901);
    stmt.setDate(4, row3Date);
    stmt.setTime(5, row3Time);
    stmt.setTimestamp(6, row3Timestamp);
    stmt.execute();
    
    conn.commit();
    conn.close();
}
 
Example 20
@Override
@SuppressWarnings("unchecked")
protected void setStatementParameters(PreparedStatement statement, Object tuple) throws SQLException
{
  final int size = columnDataTypes.size();
  for (int i = 0; i < size; i++) {
    final int type = columnDataTypes.get(i);
    ActiveFieldInfo activeFieldInfo = columnFieldGetters.get(i);
    switch (type) {
      case (Types.CHAR):
      case (Types.VARCHAR):
        statement.setString(i + 1, ((Getter<Object, String>)activeFieldInfo.setterOrGetter).get(tuple));
        break;

      case (Types.BOOLEAN):
        statement.setBoolean(i + 1, ((GetterBoolean<Object>)activeFieldInfo.setterOrGetter).get(tuple));
        break;

      case (Types.TINYINT):
        statement.setByte(i + 1, ((PojoUtils.GetterByte<Object>)activeFieldInfo.setterOrGetter).get(tuple));
        break;

      case (Types.SMALLINT):
        statement.setShort(i + 1, ((GetterShort<Object>)activeFieldInfo.setterOrGetter).get(tuple));
        break;

      case (Types.INTEGER):
        statement.setInt(i + 1, ((GetterInt<Object>)activeFieldInfo.setterOrGetter).get(tuple));
        break;

      case (Types.BIGINT):
        statement.setLong(i + 1, ((GetterLong<Object>)activeFieldInfo.setterOrGetter).get(tuple));
        break;

      case (Types.FLOAT):
        statement.setFloat(i + 1, ((GetterFloat<Object>)activeFieldInfo.setterOrGetter).get(tuple));
        break;

      case (Types.DOUBLE):
        statement.setDouble(i + 1, ((GetterDouble<Object>)activeFieldInfo.setterOrGetter).get(tuple));
        break;

      case Types.DECIMAL:
        statement.setBigDecimal(i + 1, ((Getter<Object, BigDecimal>)activeFieldInfo.setterOrGetter).get(tuple));
        break;

      case Types.TIMESTAMP:
        statement.setTimestamp(i + 1, ((Getter<Object, Timestamp>)activeFieldInfo.setterOrGetter).get(tuple));
        break;

      case Types.TIME:
        statement.setTime(i + 1, ((Getter<Object, Time>)activeFieldInfo.setterOrGetter).get(tuple));
        break;

      case Types.DATE:
        statement.setDate(i + 1, ((Getter<Object, Date>)activeFieldInfo.setterOrGetter).get(tuple));
        break;

      default:
        handleUnknownDataType(type, tuple, activeFieldInfo);
        break;
    }
  }
}