/** * Add a static column definition to this CREATE TABLE statement, when its type contains a UDT. * * @param columnName the name of the column to be added. * @param udtType the UDT type of the column to be added. Use {@link SchemaBuilder#frozen(String)} * or {@link SchemaBuilder#udtLiteral(String)}. * @return this CREATE statement. */ public Create addUDTStaticColumn(String columnName, UDTType udtType) { validateNotEmpty(tableName, "Column name"); validateNotNull(udtType, "Column UDT type"); validateNotKeyWord( columnName, String.format( "The static column name '%s' is not allowed because it is a reserved keyword", columnName)); staticColumns.put(columnName, udtType); return this; }
/** * Add a partition key column definition to this CREATE TABLE statement, when its type contains a * UDT. * * <p>This includes the column declaration (you don't need an additional {@code addColumn} call). * * <p>Partition key columns are added in the order of their declaration. * * @param columnName the name of the partition key column to be added. * @param udtType the UDT type of the partition key column to be added. Use {@link * SchemaBuilder#frozen(String)} or {@link SchemaBuilder#udtLiteral(String)}. * @return this CREATE statement. */ public Create addUDTPartitionKey(String columnName, UDTType udtType) { validateNotEmpty(columnName, "Clustering key name"); validateNotNull(udtType, "UDT partition key type"); validateNotKeyWord( columnName, String.format( "The partition key name '%s' is not allowed because it is a reserved keyword", columnName)); partitionColumns.put(columnName, udtType); return this; }
/** * Add a clustering column definition to this CREATE TABLE statement, when its type contains a * UDT. * * <p>This includes the column declaration (you don't need an additional {@code addColumn} call). * * <p>Clustering columns are added in the order of their declaration. * * @param columnName the name of the clustering column to be added. * @param udtType the UDT type of the clustering column to be added. Use {@link * SchemaBuilder#frozen(String)} or {@link SchemaBuilder#udtLiteral(String)}. * @return this CREATE statement. */ public Create addUDTClusteringColumn(String columnName, UDTType udtType) { validateNotEmpty(columnName, "Clustering column name"); validateNotNull(udtType, "UDT clustering column type"); validateNotKeyWord( columnName, String.format( "The clustering column name '%s' is not allowed because it is a reserved keyword", columnName)); clusteringColumns.put(columnName, udtType); return this; }
/** * Add a static column definition to this CREATE TABLE statement. * * @param columnName the name of the column to be added. * @param dataType the data type of the column to be added. * @return this CREATE statement. */ public Create addStaticColumn(String columnName, DataType dataType) { validateNotEmpty(columnName, "Column name"); validateNotNull(dataType, "Column type"); validateNotKeyWord( columnName, String.format( "The static column name '%s' is not allowed because it is a reserved keyword", columnName)); staticColumns.put(columnName, new NativeColumnType(dataType)); return this; }
/** * Add a partition key column definition to this CREATE TABLE statement. * * <p>This includes the column declaration (you don't need an additional {@code addColumn} call). * * <p>Partition key columns are added in the order of their declaration. * * @param columnName the name of the partition key column to be added. * @param dataType the data type of the partition key column to be added. * @return this CREATE statement. */ public Create addPartitionKey(String columnName, DataType dataType) { validateNotEmpty(columnName, "Partition key name"); validateNotNull(dataType, "Partition key type"); validateNotKeyWord( columnName, String.format( "The partition key name '%s' is not allowed because it is a reserved keyword", columnName)); partitionColumns.put(columnName, new NativeColumnType(dataType)); return this; }
/** * Add a clustering column definition to this CREATE TABLE statement. * * <p>This includes the column declaration (you don't need an additional {@code addColumn} call). * * <p>Clustering columns are added in the order of their declaration. * * @param columnName the name of the clustering column to be added. * @param dataType the data type of the clustering column to be added. * @return this CREATE statement. */ public Create addClusteringColumn(String columnName, DataType dataType) { validateNotEmpty(columnName, "Clustering column name"); validateNotNull(dataType, "Clustering column type"); validateNotKeyWord( columnName, String.format( "The clustering column name '%s' is not allowed because it is a reserved keyword", columnName)); clusteringColumns.put(columnName, new NativeColumnType(dataType)); return this; }
/** * Add a static column definition to this CREATE TABLE statement, when its type contains a UDT. * * @param columnName the name of the column to be added. * @param udtType the UDT type of the column to be added. Use {@link SchemaBuilder#frozen(String)} or {@link SchemaBuilder#udtLiteral(String)}. * @return this CREATE statement. */ public Create addUDTStaticColumn(String columnName, UDTType udtType) { validateNotEmpty(tableName, "Column name"); validateNotNull(udtType, "Column UDT type"); validateNotKeyWord(columnName, String.format("The static column name '%s' is not allowed because it is a reserved keyword", columnName)); staticColumns.put(columnName, udtType); return this; }
/** * Add a static column definition to this CREATE TABLE statement, when its type contains a UDT. * * @param columnName the name of the column to be added. * @param udtType the UDT type of the column to be added. Use {@link SchemaBuilder#frozen(String)} or {@link SchemaBuilder#udtLiteral(String)}. * @return this CREATE statement. */ public Create addUDTStaticColumn(String columnName, UDTType udtType) { validateNotEmpty(tableName, "Column name"); validateNotNull(udtType, "Column UDT type"); validateNotKeyWord(columnName, String.format("The static column name '%s' is not allowed because it is a reserved keyword", columnName)); staticColumns.put(columnName, udtType); return this; }
/** * Add a static column definition to this CREATE TABLE statement, when its type contains a UDT. * * @param columnName the name of the column to be added. * @param udtType the UDT type of the column to be added. Use {@link SchemaBuilder#frozen(String)} or {@link SchemaBuilder#udtLiteral(String)}. * @return this CREATE statement. */ public Create addUDTStaticColumn(String columnName, UDTType udtType) { validateNotEmpty(tableName, "Column name"); validateNotNull(udtType, "Column UDT type"); validateNotKeyWord(columnName, String.format("The static column name '%s' is not allowed because it is a reserved keyword", columnName)); staticColumns.put(columnName, udtType); return this; }
/** * Add a clustering column definition to this CREATE TABLE statement, when its type contains a UDT. * <p/> * This includes the column declaration (you don't need an additional {@code addColumn} call). * <p/> * Clustering columns are added in the order of their declaration. * * @param columnName the name of the clustering column to be added. * @param udtType the UDT type of the clustering column to be added. Use {@link SchemaBuilder#frozen(String)} or {@link SchemaBuilder#udtLiteral(String)}. * @return this CREATE statement. */ public Create addUDTClusteringColumn(String columnName, UDTType udtType) { validateNotEmpty(columnName, "Clustering column name"); validateNotNull(udtType, "UDT clustering column type"); validateNotKeyWord(columnName, String.format("The clustering column name '%s' is not allowed because it is a reserved keyword", columnName)); clusteringColumns.put(columnName, udtType); return this; }
/** * Add a partition key column definition to this CREATE TABLE statement, when its type contains a UDT. * <p/> * This includes the column declaration (you don't need an additional {@code addColumn} call). * <p/> * Partition key columns are added in the order of their declaration. * * @param columnName the name of the partition key column to be added. * @param udtType the UDT type of the partition key column to be added. Use {@link SchemaBuilder#frozen(String)} or {@link SchemaBuilder#udtLiteral(String)}. * @return this CREATE statement. */ public Create addUDTPartitionKey(String columnName, UDTType udtType) { validateNotEmpty(columnName, "Clustering key name"); validateNotNull(udtType, "UDT partition key type"); validateNotKeyWord(columnName, String.format("The partition key name '%s' is not allowed because it is a reserved keyword", columnName)); partitionColumns.put(columnName, udtType); return this; }
/** * Add a clustering column definition to this CREATE TABLE statement, when its type contains a UDT. * <p/> * This includes the column declaration (you don't need an additional {@code addColumn} call). * <p/> * Clustering columns are added in the order of their declaration. * * @param columnName the name of the clustering column to be added. * @param udtType the UDT type of the clustering column to be added. Use {@link SchemaBuilder#frozen(String)} or {@link SchemaBuilder#udtLiteral(String)}. * @return this CREATE statement. */ public Create addUDTClusteringColumn(String columnName, UDTType udtType) { validateNotEmpty(columnName, "Clustering column name"); validateNotNull(udtType, "UDT clustering column type"); validateNotKeyWord(columnName, String.format("The clustering column name '%s' is not allowed because it is a reserved keyword", columnName)); clusteringColumns.put(columnName, udtType); return this; }
/** * Add a partition key column definition to this CREATE TABLE statement, when its type contains a UDT. * <p/> * This includes the column declaration (you don't need an additional {@code addColumn} call). * <p/> * Partition key columns are added in the order of their declaration. * * @param columnName the name of the partition key column to be added. * @param udtType the UDT type of the partition key column to be added. Use {@link SchemaBuilder#frozen(String)} or {@link SchemaBuilder#udtLiteral(String)}. * @return this CREATE statement. */ public Create addUDTPartitionKey(String columnName, UDTType udtType) { validateNotEmpty(columnName, "Clustering key name"); validateNotNull(udtType, "UDT partition key type"); validateNotKeyWord(columnName, String.format("The partition key name '%s' is not allowed because it is a reserved keyword", columnName)); partitionColumns.put(columnName, udtType); return this; }
/** * Add a clustering column definition to this CREATE TABLE statement, when its type contains a UDT. * <p/> * This includes the column declaration (you don't need an additional {@code addColumn} call). * <p/> * Clustering columns are added in the order of their declaration. * * @param columnName the name of the clustering column to be added. * @param udtType the UDT type of the clustering column to be added. Use {@link SchemaBuilder#frozen(String)} or {@link SchemaBuilder#udtLiteral(String)}. * @return this CREATE statement. */ public Create addUDTClusteringColumn(String columnName, UDTType udtType) { validateNotEmpty(columnName, "Clustering column name"); validateNotNull(udtType, "UDT clustering column type"); validateNotKeyWord(columnName, String.format("The clustering column name '%s' is not allowed because it is a reserved keyword", columnName)); clusteringColumns.put(columnName, udtType); return this; }
/** * Add a static column definition to this CREATE TABLE statement. * * @param columnName the name of the column to be added. * @param dataType the data type of the column to be added. * @return this CREATE statement. */ public Create addStaticColumn(String columnName, DataType dataType) { validateNotEmpty(columnName, "Column name"); validateNotNull(dataType, "Column type"); validateNotKeyWord(columnName, String.format("The static column name '%s' is not allowed because it is a reserved keyword", columnName)); staticColumns.put(columnName, new NativeColumnType(dataType)); return this; }
/** * Add a static column definition to this CREATE TABLE statement. * * @param columnName the name of the column to be added. * @param dataType the data type of the column to be added. * @return this CREATE statement. */ public Create addStaticColumn(String columnName, DataType dataType) { validateNotEmpty(columnName, "Column name"); validateNotNull(dataType, "Column type"); validateNotKeyWord(columnName, String.format("The static column name '%s' is not allowed because it is a reserved keyword", columnName)); staticColumns.put(columnName, new NativeColumnType(dataType)); return this; }
/** * Add a static column definition to this CREATE TABLE statement. * * @param columnName the name of the column to be added. * @param dataType the data type of the column to be added. * @return this CREATE statement. */ public Create addStaticColumn(String columnName, DataType dataType) { validateNotEmpty(columnName, "Column name"); validateNotNull(dataType, "Column type"); validateNotKeyWord(columnName, String.format("The static column name '%s' is not allowed because it is a reserved keyword", columnName)); staticColumns.put(columnName, new NativeColumnType(dataType)); return this; }
/** * Add a partition key column definition to this CREATE TABLE statement. * <p/> * This includes the column declaration (you don't need an additional {@code addColumn} call). * <p/> * Partition key columns are added in the order of their declaration. * * @param columnName the name of the partition key column to be added. * @param dataType the data type of the partition key column to be added. * @return this CREATE statement. */ public Create addPartitionKey(String columnName, DataType dataType) { validateNotEmpty(columnName, "Partition key name"); validateNotNull(dataType, "Partition key type"); validateNotKeyWord(columnName, String.format("The partition key name '%s' is not allowed because it is a reserved keyword", columnName)); partitionColumns.put(columnName, new NativeColumnType(dataType)); return this; }
/** * Add a clustering column definition to this CREATE TABLE statement. * <p/> * This includes the column declaration (you don't need an additional {@code addColumn} call). * <p/> * Clustering columns are added in the order of their declaration. * * @param columnName the name of the clustering column to be added. * @param dataType the data type of the clustering column to be added. * @return this CREATE statement. */ public Create addClusteringColumn(String columnName, DataType dataType) { validateNotEmpty(columnName, "Clustering column name"); validateNotNull(dataType, "Clustering column type"); validateNotKeyWord(columnName, String.format("The clustering column name '%s' is not allowed because it is a reserved keyword", columnName)); clusteringColumns.put(columnName, new NativeColumnType(dataType)); return this; }
/** * Add a clustering column definition to this CREATE TABLE statement. * <p/> * This includes the column declaration (you don't need an additional {@code addColumn} call). * <p/> * Clustering columns are added in the order of their declaration. * * @param columnName the name of the clustering column to be added. * @param dataType the data type of the clustering column to be added. * @return this CREATE statement. */ public Create addClusteringColumn(String columnName, DataType dataType) { validateNotEmpty(columnName, "Clustering column name"); validateNotNull(dataType, "Clustering column type"); validateNotKeyWord(columnName, String.format("The clustering column name '%s' is not allowed because it is a reserved keyword", columnName)); clusteringColumns.put(columnName, new NativeColumnType(dataType)); return this; }