final DataType dataType = columnDefinitions.getType(i); final String colName = columnDefinitions.getName(i); if (i != 0) {
final DataType dataType = columnDefinitions.getType(i);
@Override protected DataType getType(int i) { return metadata.getType(i); }
for (int i = 0; i < nrOfColumns; i++) { DataType dataType = columnDefinitions.getType(i); if (dataType == null) { throw new IllegalArgumentException("No data type for column[" + i + "] with name " + columnDefinitions.getName(i));
protected DataType getType(int i) { return wrapped.statement.getVariables().getType(i); }
/** * Returns the type of the first occurrence of {@code name} in this metadata. * * <p>Note that this method does not set the {@link DataType#isFrozen()} flag on the returned * object, it will always default to {@code false}. Use {@link Cluster#getMetadata()} to determine * if a column is frozen. * * @param name the name of the column. * @return the type of (the first occurrence of) {@code name} in this metadata. * @throws IllegalArgumentException if {@code name} is not in this metadata. */ public DataType getType(String name) { return getType(getFirstIdx(name)); }
@Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("Row["); for (int i = 0; i < metadata.size(); i++) { if (i != 0) sb.append(", "); ByteBuffer bb = data.get(i); if (bb == null) sb.append("NULL"); else sb.append( getCodecRegistry() .codecFor(metadata.getType(i)) .deserialize(bb, protocolVersion) .toString()); } sb.append(']'); return sb.toString(); } }
sb.append(" | "); if (metadata.columns != null) { DataType dataType = metadata.columns.getType(i); sb.append(dataType); sb.append(" ");
private static boolean checkWasApplied( List<ByteBuffer> firstRow, ColumnDefinitions metadata, ProtocolVersion protocolVersion) { // If the column is not present or not a boolean, we assume the query // was not a conditional statement, and therefore return true. if (firstRow == null) return true; int[] is = metadata.findAllIdx("[applied]"); if (is == null) return true; int i = is[0]; if (!DataType.cboolean().equals(metadata.getType(i))) return true; // Otherwise return the value of the column ByteBuffer value = firstRow.get(i); if (value == null || value.remaining() == 0) return false; return TypeCodec.cboolean().deserializeNoBoxing(value, protocolVersion); } }
@Override public <E> List<E> getColumnsById(String schemaName, String tableName, String pKeyColumnName, String columnName, Object pKeyColumnValue, Class columnJavaType) { // select columnName from tableName where pKeyColumnName = // pKeyColumnValue List results = new ArrayList(); CQLTranslator translator = new CQLTranslator(); String selectQuery = translator.SELECT_QUERY; selectQuery = StringUtils.replace(selectQuery, CQLTranslator.COLUMN_FAMILY, translator.ensureCase(new StringBuilder(), tableName, false).toString()); selectQuery = StringUtils.replace(selectQuery, CQLTranslator.COLUMNS, translator.ensureCase(new StringBuilder(), columnName, false).toString()); StringBuilder selectQueryBuilder = new StringBuilder(selectQuery); selectQueryBuilder.append(CQLTranslator.ADD_WHERE_CLAUSE); translator.buildWhereClause(selectQueryBuilder, columnJavaType, pKeyColumnName, pKeyColumnValue, CQLTranslator.EQ_CLAUSE, false); selectQueryBuilder.delete(selectQueryBuilder.lastIndexOf(CQLTranslator.AND_CLAUSE), selectQueryBuilder.length()); ResultSet rSet = execute(selectQueryBuilder.toString(), null); Iterator<Row> rowIter = rSet.iterator(); while (rowIter.hasNext()) { Row row = rowIter.next(); DataType dataType = row.getColumnDefinitions().getType(columnName); Object columnValue = DSClientUtilities.assign(row, null, null, dataType.getName(), null, columnName, null, null); results.add(columnValue); } return results; }
public ColumnDefinitionsAssert containsVariable(String name, DataType type) { try { assertThat(actual.getType(name)).isEqualTo(type); } catch (Exception e) { fail( String.format( "Expected actual to contain variable %s of type %s, but it did not", name, type), e); } return this; }
@Test(groups = "unit") public void multiDefinitionTest() { ColumnDefinitions defs = new ColumnDefinitions( new ColumnDefinitions.Definition[] { new ColumnDefinitions.Definition("ks", "cf1", "column", DataType.text()), new ColumnDefinitions.Definition("ks", "cf2", "column", DataType.cint()), new ColumnDefinitions.Definition("ks", "cf3", "column", DataType.cfloat()) }, CodecRegistry.DEFAULT_INSTANCE); assertTrue(defs.getType("column").equals(DataType.text())); } }
CodecRegistry.DEFAULT_INSTANCE); assertTrue(defs.getType("foo").equals(DataType.text())); assertTrue(defs.getType("Foo").equals(DataType.text())); assertTrue(defs.getType("FOO").equals(DataType.text())); assertTrue(defs.getType("\"FOO\"").equals(DataType.cint())); assertTrue(defs.getType("in quote").equals(DataType.cint())); assertTrue(defs.getType("\"in quote\"").equals(DataType.cint())); assertTrue(defs.getType("\"\"in quote\"\"").equals(DataType.text()));
@Test(groups = "short") @CassandraVersion(value = "3.6", description = "Non-frozen UDTs were introduced in C* 3.6") public void should_indicate_user_type_is_not_frozen() { session().execute("CREATE TABLE not_frozen_table(k int primary key, v type_for_frozen_test)"); KeyspaceMetadata keyspaceMetadata = cluster().getMetadata().getKeyspace(this.keyspace); assertThat(keyspaceMetadata.getUserType("type_for_frozen_test")).isNotFrozen(); DataType userType = keyspaceMetadata.getTable("not_frozen_table").getColumn("v").getType(); assertThat(userType).isNotFrozen(); assertThat(userType.toString()).isEqualTo(keyspace + ".type_for_frozen_test"); ResultSet rs = session().execute("SELECT v FROM not_frozen_table WHERE k = 1"); assertThat(rs.getColumnDefinitions().getType(0)).isNotFrozen(); PreparedStatement pst = session().prepare("SELECT v FROM not_frozen_table WHERE k = ?"); assertThat(pst.getVariables().getType(0)).isNotFrozen(); } }
@Test(groups = "short") public void should_indicate_user_type_is_frozen() { session() .execute("CREATE TABLE frozen_table(k int primary key, v frozen<type_for_frozen_test>)"); KeyspaceMetadata keyspaceMetadata = cluster().getMetadata().getKeyspace(this.keyspace); assertThat(keyspaceMetadata.getUserType("type_for_frozen_test")).isNotFrozen(); DataType userType = keyspaceMetadata.getTable("frozen_table").getColumn("v").getType(); assertThat(userType).isFrozen(); assertThat(userType.toString()).isEqualTo("frozen<" + keyspace + ".type_for_frozen_test>"); // The frozen flag is not set for result set definitions (the protocol does not provide // that information and it's not really useful in that situation). We always return false. ResultSet rs = session().execute("SELECT v FROM frozen_table WHERE k = 1"); assertThat(rs.getColumnDefinitions().getType(0)).isNotFrozen(); // Same thing for prepared statements PreparedStatement pst = session().prepare("SELECT v FROM frozen_table WHERE k = ?"); assertThat(pst.getVariables().getType(0)).isNotFrozen(); }
/** * Validates that columns using collections of custom types are properly handled by the driver. * * @jira_ticket JAVA-1034 * @test_category metadata */ @Test(groups = "short") public void should_serialize_and_deserialize_collections_of_custom_types() { TestUtils.compactStorageSupportCheck(ccm()); TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable("test_collection"); assertThat(table.getColumn("c1")).hasType(DataType.list(CUSTOM_DYNAMIC_COMPOSITE)); assertThat(table.getColumn("c2")) .hasType(DataType.map(CUSTOM_DYNAMIC_COMPOSITE, CUSTOM_DYNAMIC_COMPOSITE)); session() .execute( "INSERT INTO test_collection(k, c1, c2) VALUES (0, [ 's@foo:i@32' ], { 's@foo:i@32': 's@bar:i@42' })"); Row r = session().execute("SELECT * FROM test_collection").one(); assertThat(r.getColumnDefinitions().getType("c1")) .isEqualTo(DataType.list(CUSTOM_DYNAMIC_COMPOSITE)); List<ByteBuffer> c1 = r.getList("c1", ByteBuffer.class); assertThat(c1.get(0)).isEqualTo(serializeForDynamicCompositeType("foo", 32)); assertThat(r.getColumnDefinitions().getType("c2")) .isEqualTo(DataType.map(CUSTOM_DYNAMIC_COMPOSITE, CUSTOM_DYNAMIC_COMPOSITE)); Map<ByteBuffer, ByteBuffer> c2 = r.getMap("c2", ByteBuffer.class, ByteBuffer.class); Map.Entry<ByteBuffer, ByteBuffer> entry = c2.entrySet().iterator().next(); assertThat(entry.getKey()).isEqualTo(serializeForDynamicCompositeType("foo", 32)); assertThat(entry.getValue()).isEqualTo(serializeForDynamicCompositeType("bar", 42)); }
for (Row row : r) { Integer i = row.getInt("i"); assertThat(row.getColumnDefinitions().getType("fint")).isEqualTo(DataType.cint()); Integer f = row.getInt("fint"); switch (i) {
assertThat(row.getColumnDefinitions().getType("iavg")).isEqualTo(DataType.cfloat()); Float f = row.getFloat("iavg");