org.mule.modules.cassandradb

Class CassandraDBConnector

java.lang.Object

org.mule.modules.cassandradb.CassandraDBConnector

@Connector(name="cassandradb",
           schemaVersion="3.2",
           friendlyName="CassandraDB",
           minMuleVersion="3.6")
 @RequiresEnterpriseLicense(allowEval=true)
public class CassandraDBConnector
extends Object

The Apache Cassandra database is the right choice when you need scalability and high availability without compromising performance. Cassandra's ColumnFamily data model offers the convenience of column indexes with the performance of log-structured updates, strong support for materialized views, and powerful built-in caching.

Author:

MuleSoft, Inc.

Constructor Summary

Constructors

Constructor and Description
CassandraDBConnector()

Method Summary

Modifier and Type	Method and Description
boolean	addNewColumn(String table, String keyspaceName, AlterColumnInput input) Adds a new column
boolean	changeColumnType(String table, String keyspaceName, AlterColumnInput input) Changes the type of a column - check compatibility here: CQL type compatibility
boolean	createKeyspace(CreateKeyspaceInput input) Creates a new keyspace
boolean	createTable(CreateTableInput input) Creates a table(column family) in a specific keyspace; If no keyspace is specified the keyspace used for login will be used
void	deleteColumnsValue(String table, String keyspaceName, Map<String,Object> payload) Deletes values from an object specified by the where clause
void	deleteRows(String table, String keyspaceName, Map<String,Object> payload) Deletes an entire record
boolean	dropColumn(String table, String keyspaceName, String columnName) Removes a column
boolean	dropKeyspace(String keyspaceName) Drops the entire keyspace
boolean	dropTable(String tableName, String keyspaceName) Drops an entire table form the specified keyspace or from the keyspace used for login if none is specified as an operation parameter
List<Map<String,Object>>	executeCQLQuery(CQLQueryInput input) Executes the raw input query provided
BasicAuthConnectionStrategy	getBasicAuthConnectionStrategy()
List<String>	getTableNamesFromKeyspace(String keyspaceName) Returns all the table names from the specified keyspace
void	insert(String table, String keyspaceName, Map<String,Object> entity) Executes the insert entity operation
boolean	renameColumn(String table, String keyspaceName, String oldColumnName, String newColumnName) Renames a column
List<Map<String,Object>>	select(String query, List<Object> parameters) Executes a select query
void	setBasicAuthConnectionStrategy(BasicAuthConnectionStrategy basicAuthConnectionStrategy)
String	toNativeQuery(org.mule.common.query.DsqlQuery query)
void	update(String table, String keyspaceName, Map<String,Object> entity) Executes the update entity operation

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

CassandraDBConnector

public CassandraDBConnector()

Method Detail

createKeyspace

@Processor
public boolean createKeyspace(@RefOnly @Default(value="#[payload]")
                                         CreateKeyspaceInput input)
                                  throws CassandraDBException

Creates a new keyspace

Parameters:

input - operation input containing the keyspace name and the replication details

Returns:

true if the operation succeeded, false otherwise

Throws:

CassandraDBException - if any error occurs when executing the create keyspace operation

dropKeyspace

@Processor
public boolean dropKeyspace(String keyspaceName)
                                throws CassandraDBException

Drops the entire keyspace

Parameters:

keyspaceName - the name of the keyspace to be dropped

Returns:

true if the operation succeeded, false otherwise

Throws:

CassandraDBException - if any error occurs when executing the drop keyspace operation

createTable

@Processor
public boolean createTable(@RefOnly @Default(value="#[payload]")
                                      CreateTableInput input)
                               throws CassandraDBException

Creates a table(column family) in a specific keyspace; If no keyspace is specified the keyspace used for login will be used

Parameters:

input - operation input describing the table name, the keyspace name and the list of columns

Returns:

true if the operation succeeded, false otherwise

Throws:

CassandraDBException - if any error occurs when executing the create table operation

dropTable

@Processor
public boolean dropTable(String tableName,
                                    @Optional
                                    String keyspaceName)
                             throws CassandraDBException

Drops an entire table form the specified keyspace or from the keyspace used for login if none is specified as an operation parameter

Parameters:

tableName - the name of the table to be dropped

keyspaceName - (optional) the keyspace which contains the table to be dropped

Returns:

true if the operation succeeded, false otherwise

Throws:

CassandraDBException - if any error occurs when executing the drop table operation

executeCQLQuery

@Processor(friendlyName="Execute CQL Query")
public List<Map<String,Object>> executeCQLQuery(@Placement(group="Query") @RefOnly @Default(value="#[payload]")
                                                                                             CQLQueryInput input)
                                                                                      throws CassandraDBException

Executes the raw input query provided

Parameters:

input - CQLQueryInput describing the parametrized query to be executed along with the parameters

Returns:

the result of the query execution

Throws:

CassandraDBException - if any error occurs when executing the custom query

insert

@Processor
 @MetaDataScope(value=CassandraMetadataCategory.class)
public void insert(@MetaDataKeyParam(affects=INPUT)
                                                                                     String table,
                                                                                     @Optional
                                                                                     String keyspaceName,
                                                                                     @RefOnly @Default(value="#[payload]")
                                                                                     Map<String,Object> entity)
                                                                              throws CassandraDBException

Executes the insert entity operation

Parameters:

table - the table name in which the entity will be inserted

keyspaceName - (optional) the keyspace which contains the table to be used

entity - the entity to be inserted

Throws:

CassandraDBException - if any error occurs when executing the insert query

update

@Processor
 @MetaDataScope(value=CassandraWithFiltersMetadataCategory.class)
public void update(@MetaDataKeyParam(affects=INPUT)
                                                                                                String table,
                                                                                                @Optional
                                                                                                String keyspaceName,
                                                                                                @RefOnly @Default(value="#[payload]")
                                                                                                Map<String,Object> entity)
                                                                                         throws CassandraDBException

Executes the update entity operation

Parameters:

table - the table name in which the entity will be updated

keyspaceName - (optional) the keyspace which contains the table to be dropped

entity - the entity to be updated

Throws:

CassandraDBException - if any error occurs when executing the update query

deleteColumnsValue

@Processor
 @MetaDataScope(value=CassandraWithFiltersMetadataCategory.class)
public void deleteColumnsValue(@MetaDataKeyParam(affects=INPUT)
                                                                                                            String table,
                                                                                                            @Optional
                                                                                                            String keyspaceName,
                                                                                                            @RefOnly @Default(value="#[payload]")
                                                                                                            Map<String,Object> payload)
                                                                                                     throws CassandraDBException

Deletes values from an object specified by the where clause

Parameters:

table - the name of the table

keyspaceName - (optional) the keyspace which contains the table to be used

payload - operation input: columns to be deleted and where clause for the delete operation

Throws:

CassandraDBException - if any error occurs when executing the delete query

deleteRows

@Processor
 @MetaDataScope(value=CassandraOnlyWithFiltersMetadataCategory.class)
public void deleteRows(@MetaDataKeyParam(affects=INPUT)
                                                                                                        String table,
                                                                                                        @Optional
                                                                                                        String keyspaceName,
                                                                                                        @RefOnly @Default(value="#[payload]")
                                                                                                        Map<String,Object> payload)
                                                                                                 throws CassandraDBException

Deletes an entire record

Parameters:

table - the name of the table

keyspaceName - (optional) the keyspace which contains the table to be used

payload - operation input: where clause for the delete operation

Throws:

CassandraDBException - if any error occurs when executing the delete query

select

@Processor
 @MetaDataScope(value=CassandraMetadataCategory.class)
public List<Map<String,Object>> select(@Default(value="#[payload]") @Query
                                                                                                         String query,
                                                                                                         @Optional @RefOnly
                                                                                                         List<Object> parameters)
                                                                                                  throws CassandraDBException

Executes a select query

Parameters:

query - the query to be executed

parameters - the query parameters

Returns:

list of entities returned by the select query

Throws:

CassandraDBException - if any error occurs when executing the select query

getTableNamesFromKeyspace

@Processor
public List<String> getTableNamesFromKeyspace(@Optional
                                                         String keyspaceName)
                                                  throws CassandraDBException

Returns all the table names from the specified keyspace

Parameters:

keyspaceName - the name of the keyspace to be used on the operation

Returns:

a list of table names

Throws:

CassandraDBException - if any error occurs when executing the operation

changeColumnType

@Processor(friendlyName="Change the type of a column")
public boolean changeColumnType(String table,
                                                                                       @Optional
                                                                                       String keyspaceName,
                                                                                       @RefOnly @Default(value="#[payload]")
                                                                                       AlterColumnInput input)

Changes the type of a column - check compatibility here: CQL type compatibility

Parameters:

table - the name of the table to be used for the operation

keyspaceName - (optional) the keyspace which contains the table to be used

input - POJO defining the name of the column to be changed and the new DataType

Returns:

true if the operation succeeded or false if not

addNewColumn

@Processor(friendlyName="Add new column")
public boolean addNewColumn(String table,
                                                                      @Optional
                                                                      String keyspaceName,
                                                                      @RefOnly @Default(value="#[payload]")
                                                                      AlterColumnInput input)
                                                               throws CassandraDBException

Adds a new column

Parameters:

table - the name of the table to be used for the operation

keyspaceName - (optional) the keyspace which contains the table to be used

input - POJO defining the name of the new column and its DataType

Returns:

true if the operation succeeded or false if not

Throws:

CassandraDBException - if any error occurs when executing the operation

dropColumn

@Processor(friendlyName="Remove column")
public boolean dropColumn(String table,
                                                                   @Optional
                                                                   String keyspaceName,
                                                                   @RefOnly @Default(value="#[payload]")
                                                                   String columnName)

Removes a column

Parameters:

table - the name of the table to be used for the operation

keyspaceName - (optional) the keyspace which contains the table to be used

columnName - the name of the column to be removed

Returns:

true if the operation succeeded or false if not

renameColumn

@Processor(friendlyName="Rename column")
public boolean renameColumn(String table,
                                                                     @Optional
                                                                     String keyspaceName,
                                                                     @Default(value="#[payload]")
                                                                     String oldColumnName,
                                                                     String newColumnName)

Renames a column

Parameters:

table - the name of the table to be used for the operation

keyspaceName - (optional) the keyspace which contains the table to be used

oldColumnName - the name of the column to be changed

newColumnName - the new value for the name of the column

Returns:

true if the operation succeeded or false if not

toNativeQuery

@QueryTranslator
public String toNativeQuery(org.mule.common.query.DsqlQuery query)

getBasicAuthConnectionStrategy

public BasicAuthConnectionStrategy getBasicAuthConnectionStrategy()

setBasicAuthConnectionStrategy

public void setBasicAuthConnectionStrategy(BasicAuthConnectionStrategy basicAuthConnectionStrategy)