Examples with ParameterMetaData java.sql.ParameterMetaData used on opensource projects

Example 6 with ParameterMetaData

use of java.sql.ParameterMetaData in project cubrid-manager by CUBRID.

the class PstmtDataDialog method analyzeSql.

protected void analyzeSql() {
    if (!validSql()) {
        return;
    }
    String sql = sqlTxt.getText();
    int count = SqlParser.getStrCount(sql, "?");
    parameterTable.removeAll();
    ParameterMetaData metaData = TableUtil.getParameterMetaData(database, sqlTxt.getText());
    for (int i = 0; i < count; i++) {
        TableItem item = new TableItem(parameterTable, SWT.NONE);
        item.setText(0, String.valueOf(i + 1));
        if (metaData != null) {
            try {
                String type = metaData.getParameterTypeName(i + 1);
                if (type == null || type.trim().length() == 0) {
                    continue;
                }
                int precision = metaData.getPrecision(i + 1);
                int scale = metaData.getScale(i + 1);
                type = FieldHandlerUtils.getComleteType(type, null, precision, scale);
                item.setText(1, type);
            } catch (SQLException e) {
                continue;
            }
        }
    }
    validate();
    packTable();
}

Example 7 with ParameterMetaData

use of java.sql.ParameterMetaData in project calcite-avatica by apache.

the class JdbcMetaTest method testPrepareSetsMaxRows.

@Test
public void testPrepareSetsMaxRows() throws Exception {
    final String id = UUID.randomUUID().toString();
    final String sql = "SELECT * FROM FOO";
    final int maxRows = 500;
    final ConnectionHandle ch = new ConnectionHandle(id);
    final AtomicInteger statementIdGenerator = new AtomicInteger(0);
    JdbcMeta meta = Mockito.mock(JdbcMeta.class);
    Connection connection = Mockito.mock(Connection.class);
    PreparedStatement statement = Mockito.mock(PreparedStatement.class);
    ResultSetMetaData resultSetMetaData = Mockito.mock(ResultSetMetaData.class);
    ParameterMetaData parameterMetaData = Mockito.mock(ParameterMetaData.class);
    @SuppressWarnings("unchecked") Cache<Integer, StatementInfo> statementCache = (Cache<Integer, StatementInfo>) Mockito.mock(Cache.class);
    Mockito.when(meta.getStatementIdGenerator()).thenReturn(statementIdGenerator);
    Mockito.when(meta.getStatementCache()).thenReturn(statementCache);
    Mockito.when(meta.getConnection(id)).thenReturn(connection);
    Mockito.when(connection.prepareStatement(sql)).thenReturn(statement);
    Mockito.when(statement.isWrapperFor(AvaticaPreparedStatement.class)).thenReturn(false);
    Mockito.when(statement.getMetaData()).thenReturn(resultSetMetaData);
    Mockito.when(statement.getParameterMetaData()).thenReturn(parameterMetaData);
    // Call the real methods
    Mockito.doCallRealMethod().when(meta).setMaxRows(statement, maxRows);
    Mockito.doCallRealMethod().when(meta).prepare(ch, sql, maxRows);
    meta.prepare(ch, sql, maxRows);
    Mockito.verify(statement).setMaxRows(maxRows);
}

Example 8 with ParameterMetaData

use of java.sql.ParameterMetaData in project calcite-avatica by apache.

the class RemoteDriverTest method checkPrepareBindExecuteFetchDate.

private void checkPrepareBindExecuteFetchDate(Connection connection) throws Exception {
    final String sql0 = "select cast(? as varchar(20)) as c\n" + "from (values (1, 'a'))";
    final String sql1 = "select ? + interval '2' day as c from (values (1, 'a'))";
    final Date date = Date.valueOf("2015-04-08");
    final long time = date.getTime();
    PreparedStatement ps;
    ParameterMetaData parameterMetaData;
    ResultSet resultSet;
    ps = connection.prepareStatement(sql0);
    parameterMetaData = ps.getParameterMetaData();
    assertThat(parameterMetaData.getParameterCount(), equalTo(1));
    ps.setDate(1, date);
    resultSet = ps.executeQuery();
    assertThat(resultSet.next(), is(true));
    assertThat(resultSet.getString(1), is("2015-04-08"));
    ps.setTimestamp(1, new Timestamp(time));
    resultSet = ps.executeQuery();
    assertThat(resultSet.next(), is(true));
    assertThat(resultSet.getString(1), is("2015-04-08 00:00:00.0"));
    ps.setTime(1, new Time(time));
    resultSet = ps.executeQuery();
    assertThat(resultSet.next(), is(true));
    assertThat(resultSet.getString(1), is("00:00:00"));
    ps.close();
    ps = connection.prepareStatement(sql1);
    parameterMetaData = ps.getParameterMetaData();
    assertThat(parameterMetaData.getParameterCount(), equalTo(1));
    ps.setDate(1, date);
    resultSet = ps.executeQuery();
    assertTrue(resultSet.next());
    assertThat(resultSet.getDate(1), equalTo(new Date(time + TimeUnit.DAYS.toMillis(2))));
    assertThat(resultSet.getTimestamp(1), equalTo(new Timestamp(time + TimeUnit.DAYS.toMillis(2))));
    ps.setTimestamp(1, new Timestamp(time));
    resultSet = ps.executeQuery();
    assertTrue(resultSet.next());
    assertThat(resultSet.getTimestamp(1), equalTo(new Timestamp(time + TimeUnit.DAYS.toMillis(2))));
    assertThat(resultSet.getTimestamp(1), equalTo(new Timestamp(time + TimeUnit.DAYS.toMillis(2))));
    ps.setObject(1, new java.util.Date(time));
    resultSet = ps.executeQuery();
    assertTrue(resultSet.next());
    assertThat(resultSet.getDate(1), equalTo(new Date(time + TimeUnit.DAYS.toMillis(2))));
    assertThat(resultSet.getTimestamp(1), equalTo(new Timestamp(time + TimeUnit.DAYS.toMillis(2))));
    resultSet.close();
    ps.close();
    connection.close();
}

Example 9 with ParameterMetaData

use of java.sql.ParameterMetaData in project calcite-avatica by apache.

the class RemoteDriverTest method checkPrepareBindExecuteFetch.

private void checkPrepareBindExecuteFetch(Connection connection) throws SQLException {
    final String sql = "select cast(? as integer) * 3 as c, 'x' as x\n" + "from (values (1, 'a'))";
    final PreparedStatement ps = connection.prepareStatement(sql);
    final ResultSetMetaData metaData = ps.getMetaData();
    assertEquals(2, metaData.getColumnCount());
    assertEquals("C", metaData.getColumnName(1));
    assertEquals("X", metaData.getColumnName(2));
    try {
        final ResultSet resultSet = ps.executeQuery();
        fail("expected error, got " + resultSet);
    } catch (SQLException e) {
        LOG.info("Caught expected error", e);
        assertThat(e.getMessage(), containsString("exception while executing query: unbound parameter"));
    }
    final ParameterMetaData parameterMetaData = ps.getParameterMetaData();
    assertThat(parameterMetaData.getParameterCount(), equalTo(1));
    ps.setInt(1, 10);
    final ResultSet resultSet = ps.executeQuery();
    assertTrue(resultSet.next());
    assertThat(resultSet.getInt(1), equalTo(30));
    assertFalse(resultSet.next());
    resultSet.close();
    ps.setInt(1, 20);
    final ResultSet resultSet2 = ps.executeQuery();
    assertFalse(resultSet2.isClosed());
    assertTrue(resultSet2.next());
    assertThat(resultSet2.getInt(1), equalTo(60));
    assertThat(resultSet2.wasNull(), is(false));
    assertFalse(resultSet2.next());
    resultSet2.close();
    ps.setObject(1, null);
    final ResultSet resultSet3 = ps.executeQuery();
    assertTrue(resultSet3.next());
    assertThat(resultSet3.getInt(1), equalTo(0));
    assertThat(resultSet3.wasNull(), is(true));
    assertFalse(resultSet3.next());
    resultSet3.close();
    ps.close();
    connection.close();
}

Example 10 with ParameterMetaData

use of java.sql.ParameterMetaData in project calcite-avatica by apache.

the class MetadataTest method parameterMetadata.

@Test
public void parameterMetadata() throws Exception {
    final String tableName = getTableName();
    try (Statement stmt = getConnection().createStatement()) {
        assertFalse(stmt.execute("DROP TABLE IF EXISTS " + tableName));
        String sql = "CREATE TABLE " + tableName + " (pk integer not null primary key, " + "col1 DECIMAL(10, 5), col2 boolean not null)";
        assertFalse(stmt.execute(sql));
        String insertSql = "INSERT INTO " + tableName + " values(?, ?, ?)";
        try (PreparedStatement pstmt = getConnection().prepareStatement(insertSql)) {
            ParameterMetaData params = pstmt.getParameterMetaData();
            assertEquals(3, params.getParameterCount());
            assertEquals(Types.INTEGER, params.getParameterType(1));
            assertTrue(params.isSigned(1));
            assertTrue(ParameterMetaData.parameterNoNulls == params.isNullable(1) || ParameterMetaData.parameterNullableUnknown == params.isNullable(1));
            assertEquals(Types.DECIMAL, params.getParameterType(2));
            assertTrue(params.isSigned(2));
            assertTrue(ParameterMetaData.parameterNullable == params.isNullable(2) || ParameterMetaData.parameterNullableUnknown == params.isNullable(2));
            assertEquals(10, params.getPrecision(2));
            assertEquals(5, params.getScale(2));
            assertEquals(Types.BOOLEAN, params.getParameterType(3));
            assertFalse(params.isSigned(3));
            assertTrue(ParameterMetaData.parameterNoNulls == params.isNullable(3) || ParameterMetaData.parameterNullableUnknown == params.isNullable(3));
            // CALCITE-1103 <1.8.0 server mishandled the protobuf translation from BIG_DECIMAL to NUMBER
            pstmt.setInt(1, Integer.MAX_VALUE);
            pstmt.setBigDecimal(2, new BigDecimal("12345.12345"));
            pstmt.setBoolean(3, true);
            assertEquals(1, pstmt.executeUpdate());
            pstmt.setInt(1, Integer.MIN_VALUE);
            pstmt.setBigDecimal(2, new BigDecimal("54321.54321"));
            pstmt.setBoolean(3, false);
            assertEquals(1, pstmt.executeUpdate());
        }
        ResultSet results = stmt.executeQuery("SELECT * FROM " + tableName + " ORDER BY pk");
        assertNotNull(results);
        ResultSetMetaData resultMetadata = results.getMetaData();
        // Verify result metadata
        assertEquals(3, resultMetadata.getColumnCount());
        assertTrue(ParameterMetaData.parameterNoNulls == resultMetadata.isNullable(1) || ParameterMetaData.parameterNullableUnknown == resultMetadata.isNullable(1));
        assertEquals(Types.INTEGER, resultMetadata.getColumnType(1));
        assertTrue(resultMetadata.isSigned(1));
        assertTrue(ParameterMetaData.parameterNullable == resultMetadata.isNullable(2) || ParameterMetaData.parameterNullableUnknown == resultMetadata.isNullable(2));
        assertEquals(Types.DECIMAL, resultMetadata.getColumnType(2));
        assertTrue(resultMetadata.isSigned(2));
        assertEquals(10, resultMetadata.getPrecision(2));
        assertEquals(5, resultMetadata.getScale(2));
        assertTrue(ParameterMetaData.parameterNoNulls == resultMetadata.isNullable(3) || ParameterMetaData.parameterNullableUnknown == resultMetadata.isNullable(3));
        assertEquals(Types.BOOLEAN, resultMetadata.getColumnType(3));
        assertFalse(resultMetadata.isSigned(3));
        // Verify the results
        assertTrue(results.next());
        assertEquals(Integer.MIN_VALUE, results.getInt(1));
        // CALCITE-1103 protobuf truncated decimal value
        BigDecimal buggyDecimalValue = new BigDecimal("54321.00000");
        BigDecimal expectedDecimalValue = new BigDecimal("54321.54321");
        BigDecimal actualDecimalValue = results.getBigDecimal(2);
        assertTrue("Unexpected decimal value of " + actualDecimalValue, expectedDecimalValue.equals(actualDecimalValue) || buggyDecimalValue.equals(actualDecimalValue));
        assertEquals(false, results.getBoolean(3));
        assertTrue(results.next());
        assertEquals(Integer.MAX_VALUE, results.getInt(1));
        // CALCITE-1103 protobuf truncated decimal value
        buggyDecimalValue = new BigDecimal("12345.00000");
        expectedDecimalValue = new BigDecimal("12345.12345");
        actualDecimalValue = results.getBigDecimal(2);
        assertTrue("Unexpected decimal value of " + actualDecimalValue, expectedDecimalValue.equals(actualDecimalValue) || buggyDecimalValue.equals(actualDecimalValue));
        assertEquals(true, results.getBoolean(3));
        assertFalse(results.next());
    }
}