cqlsh:userkeyspace> CREATE TABLE playlists (

               id      uuid,

               type    text,

              name    text,

              size    int,

              artist text,

              PRIMARY KEY (id, type, name, size)

             );

echo 'use userkeyspace; describe table playlists; select count(*) from playlists;' | ./cqlsh -f /dev/stdin

CREATE TABLE playlists (

  id uuid,

  type text,

  name text,

  size int,

  artist text,

  PRIMARY KEY (id, type, name, size)

) WITH

  bloom_filter_fp_chance=0.010000 AND

  caching='KEYS_ONLY' AND

  comment='' AND

  dclocal_read_repair_chance=0.000000 AND

  gc_grace_seconds=864000 AND

  index_interval=128 AND

  read_repair_chance=0.100000 AND

  replicate_on_write='true' AND

  populate_io_cache_on_flush='false' AND

  default_time_to_live=0 AND

  speculative_retry='NONE' AND

  memtable_flush_period_in_ms=0 AND

  compaction={'class': 'SizeTieredCompactionStrategy'} AND

  compression={'sstable_compression': 'LZ4Compressor'};

 count

-------

     0

(1 rows)

cqlsh:userkeyspace> describe table cf21;

CREATE TABLE cf21 (

  key text,

  number text,

  name text,

  PRIMARY KEY (key, number)

) WITH COMPACT STORAGE AND

  bloom_filter_fp_chance=0.010000 AND

  caching='KEYS_ONLY' AND

  comment='' AND

  dclocal_read_repair_chance=0.000000 AND

  gc_grace_seconds=864000 AND

  index_interval=128 AND

  read_repair_chance=0.100000 AND

  replicate_on_write='true' AND

  populate_io_cache_on_flush='false' AND

  default_time_to_live=0 AND

  speculative_retry='NONE' AND

  memtable_flush_period_in_ms=0 AND

  compaction={'class': 'SizeTieredCompactionStrategy'} AND

  compression={'sstable_compression': 'LZ4Compressor'};

cqlsh:userkeyspace> select * from cf21 where key in ('row1') and number in ('1') ;

 key  | number | name

------+--------+------

 row1 |      1 |  Kim

(1 rows)

cqlsh:userkeyspace> select * from cf21 where key in ('row1')  ;

 key  | number | name

------+--------+------

 row1 |      1 |  Kim

 row1 |      2 |  Yun

 row1 |      3 | Park

cqlsh:userkeyspace> select * from cf21 where number in ('1');

Bad Request: Cannot execute this query as it might involve data filtering and thus may have unpredictable performance. If you want to execute this query despite the performance unpredictability, use ALLOW FILTERING

cqlsh:userkeyspace> select * from cf21 where number in ('1', '2') ALLOW FILTERING;

 key  | number | name

------+--------+------

 row1 |      1 |  Kim

 row1 |      2 |  Yun

 row2 |      1 | Choi

(3 rows)

cqlsh:userkeyspace> describe table cf33;

CREATE TABLE cf33 (

  key text,

  name text,

  number text,

  PRIMARY KEY (key)

) WITH

  bloom_filter_fp_chance=0.010000 AND

  caching='KEYS_ONLY' AND

  comment='' AND

  dclocal_read_repair_chance=0.000000 AND

  gc_grace_seconds=864000 AND

  index_interval=128 AND

  read_repair_chance=0.100000 AND

  replicate_on_write='true' AND

  populate_io_cache_on_flush='false' AND

  default_time_to_live=0 AND

  speculative_retry='NONE' AND

  memtable_flush_period_in_ms=0 AND

  compaction={'class': 'SizeTieredCompactionStrategy'} AND

  compression={'sstable_compression': 'LZ4Compressor'};

CREATE INDEX name ON cf33 (name);

cqlsh:userkeyspace> select * from cf33 where name in ('John') ALLOW FILTERING;

Bad Request: No indexed columns present in by-columns clause with Equal operator

cqlsh:userkeyspace> select * from cf33 where key in ('John') ALLOW FILTERING;

(0 rows)

<dependency>

<groupId>org.apache.cassandra</groupId>

<artifactId>cassandra-thrift</artifactId>

<version>2.0.1</version>

</dependency>

                <dependency>

<groupId>com.datastax.cassandra</groupId>

<artifactId>cassandra-driver-core</artifactId>

<version>2.0.0-beta2</version> 

</dependency>

package com.google.cassandra.client;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import org.apache.cassandra.cql.jdbc.CassandraStatementExtras;

import org.apache.cassandra.thrift.ConsistencyLevel;

public class CQLTest {

/*

* 

CREATE TABLE cf10 (

  key text,

  number text,

  name text,

  PRIMARY KEY (key, number)

) WITH COMPACT STORAGE AND

  bloom_filter_fp_chance=0.010000 AND

  caching='KEYS_ONLY' AND

  comment='' AND

  dclocal_read_repair_chance=0.000000 AND

  gc_grace_seconds=864000 AND

  index_interval=128 AND

  read_repair_chance=0.100000 AND

  replicate_on_write='true' AND

  populate_io_cache_on_flush='false' AND

  default_time_to_live=0 AND

  speculative_retry='NONE' AND

  memtable_flush_period_in_ms=0 AND

  compaction={'class': 'SizeTieredCompactionStrategy'} AND

  compression={'sstable_compression': 'LZ4Compressor'};

  cqlsh:userkeyspace> select * from cf10;

 key  | number | name

------+--------+------

 row1 |      1 |  Kim

 row1 |      2 |   Yu

 row2 |      1 | Park

 row2 |      2 | Choi

(4 rows)

*/

private static java.sql.Connection con = null;

public static void main(String[] args) throws Exception {

Class.forName("org.apache.cassandra.cql.jdbc.CassandraDriver");

con = DriverManager.getConnection("jdbc:cassandra://localhost:9160/userkeyspace?consistency=ONE");

CQLTest sample = new CQLTest();

try {

sample.checkConsistency();

sample.create();

sample.insert();

sample.list();

sample.update();

sample.listUpdated();

sample.delete();

} catch (SQLException e) {

throw e;

}

}

public static final String KEY_SPACE_NAME = "userkeyspace";

public static final String COLUMN_FAMILY_NAME = "cf10";

public void checkConsistency() throws Exception {

Statement stmt = con.createStatement();

    ConsistencyLevel cl = statementExtras(stmt).getConsistencyLevel();

    System.out.println("consistency level : " + cl );

}

    private CassandraStatementExtras statementExtras(Statement statement) throws Exception {

        Class<?> cse = Class.forName("org.apache.cassandra.cql.jdbc.CassandraStatementExtras");

        return (CassandraStatementExtras) statement.unwrap(cse);

    }

public void create() throws SQLException {

drop();

String data = "create table IF NOT EXISTS " + COLUMN_FAMILY_NAME

+ " (key text, number text, name text, PRIMARY KEY (key, number)) WITH COMPACT STORAGE;";

Statement st = con.createStatement();

st.execute(data);

}

public void drop() throws SQLException {

String data = "drop table  IF EXISTS " + COLUMN_FAMILY_NAME + ";";

Statement st = con.createStatement();

st.execute(data);

}

public void insert() throws SQLException {

String cql = "BEGIN BATCH \n"

+ "insert into " + COLUMN_FAMILY_NAME + " (key, number, name) values ('row1','1','Kim') \n"

+ "insert into " + COLUMN_FAMILY_NAME + " (key, number, name) values ('row1','2','Yu') \n"

+ "insert into " + COLUMN_FAMILY_NAME + " (key, number, name) values ('row2','1','Park') \n"

+ "insert into " + COLUMN_FAMILY_NAME + " (key, number, name) values ('row2','2','Choi') \n"

+ "APPLY BATCH;";

//String cql = "insert into " + COLUMN_FAMILY_NAME + " (key, number, name) values ('row1','1','Kim') ";

Statement st = con.createStatement();

st.executeUpdate(cql);

st.close();

/*

prepared statement code is not working in 1.2.5 cassandra -jdbc.. Caused by: InvalidRequestException(why:Invalid amount of bind variables)

https://code.google.com/a/apache-extras.org/p/cassandra-jdbc/issues/detail?id=93&thanks=93&ts=1383294323

String cql2 = "insert into " + COLUMN_FAMILY_NAME + " (key, number, name) values (?, ?, ?)";

PreparedStatement ps = con.prepareStatement(cql2);

ps.setString(1, "row1");

ps.setString(2, "1");

ps.setString(3, "Kim");

ps.executeUpdate(cql2);

ps.close();

*/

}

public void delete() throws SQLException {

String data = "truncate  " + COLUMN_FAMILY_NAME ;

Statement st = con.createStatement();

st.executeUpdate(data);

}

public void update() throws SQLException {

String t = "update " + COLUMN_FAMILY_NAME + " set name='AAAA' where key='row1' and number = '1'";

Statement st = con.createStatement();

st.executeUpdate(t);

}

public void listUpdated() throws SQLException {

String t = "select * from " + COLUMN_FAMILY_NAME + "  where key = 'row1' and number = '1'";

Statement st = con.createStatement();

ResultSet rs = st.executeQuery(t);

System.out.println("---------------");

while (rs.next()) {

System.out.println(" " + rs.getString("key"));

for (int j = 1; j < rs.getMetaData().getColumnCount() + 1; j++) {

System.out.println("   " + rs.getMetaData().getColumnName(j) + " : "

+ rs.getString(rs.getMetaData().getColumnName(j)));

}

}

}

public void list() throws SQLException {

String t = "select * from " + COLUMN_FAMILY_NAME;

Statement st = con.createStatement();

ResultSet rs = st.executeQuery(t);

System.out.println("---------------");

while (rs.next()) {

System.out.println(" " + rs.getString("key"));

for (int j = 1; j < rs.getMetaData().getColumnCount() + 1; j++) {

System.out.println("   " + rs.getMetaData().getColumnName(j) + " : "

+ rs.getString(rs.getMetaData().getColumnName(j)));

}

}

}

}

package com.google.cassandra.client;

import java.nio.ByteBuffer;

import java.util.List;

import org.apache.cassandra.thrift.Cassandra;

import org.apache.cassandra.thrift.Column;

import org.apache.cassandra.thrift.ColumnOrSuperColumn;

import org.apache.cassandra.thrift.ColumnParent;

import org.apache.cassandra.thrift.Compression;

import org.apache.cassandra.thrift.ConsistencyLevel;

import org.apache.cassandra.thrift.KeyRange;

import org.apache.cassandra.thrift.KeySlice;

import org.apache.cassandra.thrift.SlicePredicate;

import org.apache.cassandra.thrift.SliceRange;

import org.apache.thrift.protocol.TBinaryProtocol;

import org.apache.thrift.protocol.TProtocol;

import org.apache.thrift.transport.TFramedTransport;

import org.apache.thrift.transport.TSocket;

import org.apache.thrift.transport.TTransport;

public class ThriftTest {

/*

cqlsh:userkeyspace> describe columnfamily cf11;

CREATE TABLE cf11 (

  key text,

  name text,

  number text,

  PRIMARY KEY (key)

) WITH COMPACT STORAGE AND

  bloom_filter_fp_chance=0.010000 AND

  caching='KEYS_ONLY' AND

  comment='' AND

  dclocal_read_repair_chance=0.000000 AND

  gc_grace_seconds=864000 AND

  index_interval=128 AND

  read_repair_chance=0.100000 AND

  replicate_on_write='true' AND

  populate_io_cache_on_flush='false' AND

  default_time_to_live=0 AND

  speculative_retry='NONE' AND

  memtable_flush_period_in_ms=0 AND

  compaction={'class': 'SizeTieredCompactionStrategy'} AND

  compression={'sstable_compression': 'LZ4Compressor'};

cqlsh:userkeyspace> select * from cf11;

 key  | name | number

------+------+--------

 row1 |    1 |      2

(1 rows)

*/

    public static void main(String[] args) throws Exception {

    ThriftTest sample = new ThriftTest();

    sample.getConfig();

    sample.create();

    sample.insert();

    sample.list();

    }

    public static final String KEYSPACE_NAME = "userkeyspace";

    public static final String ROW_KEY_NAME = "row1";

    public static final String COLUMN_FAMILY_NAME = "cf11";

Cassandra.Client client;

TTransport tr;

public void getConfig() {

  tr = new TFramedTransport(new TSocket("localhost", 9160));

           TProtocol proto = new TBinaryProtocol(tr);

           client = new Cassandra.Client(proto);

}

public void create() throws Exception {

tr.open();

String cql = "use " + KEYSPACE_NAME + ";";

client.execute_cql_query(ByteBuffer.wrap(cql.getBytes()), Compression.NONE);

cql = "drop table " + COLUMN_FAMILY_NAME + ";";

client.execute_cql_query(ByteBuffer.wrap(cql.getBytes()), Compression.NONE);

    cql = "create columnfamily " + COLUMN_FAMILY_NAME + "  (key text primary key, name text, number text);";

    client.execute_cql_query(ByteBuffer.wrap(cql.getBytes()), Compression.NONE);

tr.close();

}

public void insert() throws Exception {

        tr.open();

        client.set_keyspace(KEYSPACE_NAME);

        // insert data

        long timestamp = System.currentTimeMillis();

        Column nameColumn = new Column(ByteBuffer.wrap("name".getBytes()));

        nameColumn.setValue(Long.toHexString(1).getBytes());

        nameColumn.setTimestamp(timestamp);

        Column numberColumn = new Column(ByteBuffer.wrap("number".getBytes()));

        numberColumn.setValue(Long.toHexString(2).getBytes());

        numberColumn.setTimestamp(timestamp);

        ColumnParent columnParent = new ColumnParent(COLUMN_FAMILY_NAME);

        client.insert(ByteBuffer.wrap(ROW_KEY_NAME.getBytes()), columnParent,nameColumn,ConsistencyLevel.ALL) ;

        client.insert(ByteBuffer.wrap(ROW_KEY_NAME.getBytes()), columnParent,numberColumn,ConsistencyLevel.ALL);

        tr.close();

}

public void list() throws Exception {

tr.open();

client.set_keyspace(KEYSPACE_NAME);

ColumnParent columnParent = new ColumnParent(COLUMN_FAMILY_NAME);

//  make predicate

        SlicePredicate predicate = new SlicePredicate();

        predicate.setSlice_range(new SliceRange(ByteBuffer.wrap(new byte[0]), ByteBuffer.wrap(new byte[0]), false, 100));

        List<ColumnOrSuperColumn> columnsByKey = client.get_slice(ByteBuffer.wrap(ROW_KEY_NAME.getBytes()), columnParent, predicate, ConsistencyLevel.ALL);

        System.out.println(columnsByKey);

        // list 

        KeyRange keyRange = new KeyRange(100);

        keyRange.setStart_key(new byte[0]);

        keyRange.setEnd_key(new byte[0]);

        List<KeySlice> keySlices = client.get_range_slices(columnParent, predicate, keyRange, ConsistencyLevel.ONE);

        System.out.println("size : " + keySlices.size());

        for (KeySlice ks : keySlices) {

                System.out.println("key : " + new String(ks.getKey()));

                for (ColumnOrSuperColumn columns : ks.columns) {

                System.out.println(" column name : " + new String(columns.getColumn().getName()) + 

                ", value : " + new String(columns.getColumn().getValue()));

                }

        }

        tr.close();

}

}

<dependency>

<groupId>me.prettyprint</groupId>

<artifactId>hector-core</artifactId>

<version>1.0-2</version>

</dependency>

package com.google.cassandra.client;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import me.prettyprint.cassandra.model.BasicColumnDefinition;

import me.prettyprint.cassandra.model.BasicColumnFamilyDefinition;

import me.prettyprint.cassandra.model.ConfigurableConsistencyLevel;

import me.prettyprint.cassandra.model.CqlQuery;

import me.prettyprint.cassandra.model.CqlRows;

import me.prettyprint.cassandra.model.RowImpl;

import me.prettyprint.cassandra.serializers.StringSerializer;

import me.prettyprint.cassandra.service.CassandraHostConfigurator;

import me.prettyprint.hector.api.Cluster;

import me.prettyprint.hector.api.HConsistencyLevel;

import me.prettyprint.hector.api.Keyspace;

import me.prettyprint.hector.api.beans.ColumnSlice;

import me.prettyprint.hector.api.beans.HColumn;

import me.prettyprint.hector.api.beans.OrderedRows;

import me.prettyprint.hector.api.beans.Row;

import me.prettyprint.hector.api.ddl.ColumnIndexType;

import me.prettyprint.hector.api.ddl.ComparatorType;

import me.prettyprint.hector.api.factory.HFactory;

import me.prettyprint.hector.api.mutation.Mutator;

import me.prettyprint.hector.api.query.QueryResult;

import me.prettyprint.hector.api.query.RangeSlicesQuery;

public class HectorTest {

public static void main(String[] args) {

HectorTest sample = new HectorTest();

sample.getConfig();

sample.create();

sample.insert();

sample.read1();

sample.read2();

/*

CREATE TABLE cf6 (

  key text,

  name text,

  number text,

  PRIMARY KEY (key)

) WITH COMPACT STORAGE AND

  bloom_filter_fp_chance=0.010000 AND

  caching='KEYS_ONLY' AND

  comment='' AND

  dclocal_read_repair_chance=0.000000 AND

  gc_grace_seconds=0 AND

  index_interval=128 AND

  read_repair_chance=0.000000 AND

  replicate_on_write='false' AND

  populate_io_cache_on_flush='false' AND

  default_time_to_live=0 AND

  speculative_retry='NONE' AND

  memtable_flush_period_in_ms=0 AND

  compaction={'class': 'SizeTieredCompactionStrategy'} AND

  compression={'sstable_compression': 'LZ4Compressor'};

  CREATE INDEX name_idx ON cf6 (name);

CREATE INDEX number_idx ON cf6 (number);

  cqlsh:userkeyspace> select * from cf6;

(0 rows)

why? bug?

 */

}

Cluster cluster = null;

Keyspace keySpace = null;

BasicColumnFamilyDefinition columnFamilyDefinition = null;

public static final String KEY_SPACE_NAME = "userkeyspace";

public static final String COLUMN_FAMILY_NAME = "cf6";

public void getConfig() {

String hosts = "localhost:9160"; 

// connection pool : https://github.com/hector-client/hector/wiki/User-Guide 

        CassandraHostConfigurator cassandraHostConfigurator = new CassandraHostConfigurator(hosts); 

        cassandraHostConfigurator.setMaxActive(1); 

        cassandraHostConfigurator.setCassandraThriftSocketTimeout(3000); 

        cassandraHostConfigurator.setMaxWaitTimeWhenExhausted(4000); 

        cluster = HFactory.getOrCreateCluster("Test Cluster", cassandraHostConfigurator);

        // basic case : not connection pool 

//cluster = HFactory.getOrCreateCluster("Test Cluster", "localHost:9160");

// consistency level

ConfigurableConsistencyLevel configurableConsistencyLevel = new ConfigurableConsistencyLevel();

Map<String, HConsistencyLevel> clmap = new HashMap<String, HConsistencyLevel>();

clmap.put("MyColumnFamily", HConsistencyLevel.ONE);

configurableConsistencyLevel.setReadCfConsistencyLevels(clmap);

configurableConsistencyLevel.setWriteCfConsistencyLevels(clmap);

HFactory.createKeyspace(KEY_SPACE_NAME, cluster, configurableConsistencyLevel);

keySpace = HFactory.createKeyspace(KEY_SPACE_NAME, cluster);

}

public void create() {

cluster.dropColumnFamily(KEY_SPACE_NAME, COLUMN_FAMILY_NAME, true);

StringSerializer stringSerializer = StringSerializer.get();

// column definition

BasicColumnDefinition numberColumnDefinition = new BasicColumnDefinition();

numberColumnDefinition.setName(stringSerializer.toByteBuffer("number"));   

numberColumnDefinition.setIndexName("number_idx");

numberColumnDefinition.setIndexType(ColumnIndexType.KEYS);

numberColumnDefinition.setValidationClass(ComparatorType.UTF8TYPE.getClassName());

BasicColumnDefinition nameColumnDefinition = new BasicColumnDefinition();

nameColumnDefinition.setName(stringSerializer.toByteBuffer("name"));

nameColumnDefinition.setIndexName("name_idx");

nameColumnDefinition.setIndexType(ColumnIndexType.KEYS);

nameColumnDefinition.setValidationClass(ComparatorType.UTF8TYPE.getClassName());

// column family (table) definition

columnFamilyDefinition = new BasicColumnFamilyDefinition();

        columnFamilyDefinition.setKeyspaceName(KEY_SPACE_NAME);

        columnFamilyDefinition.setName(COLUMN_FAMILY_NAME);

        columnFamilyDefinition.setKeyValidationClass(ComparatorType.UTF8TYPE.getClassName());

        columnFamilyDefinition.setComparatorType(ComparatorType.UTF8TYPE);

// adding column family to column.

        columnFamilyDefinition.addColumnDefinition(numberColumnDefinition);

        columnFamilyDefinition.addColumnDefinition(nameColumnDefinition);

cluster.addColumnFamily(columnFamilyDefinition);

assert columnFamilyDefinition != null;

    }

public void insert() {

StringSerializer stringSerializer = StringSerializer.get();

        Mutator<String> mutator = HFactory.createMutator(keySpace, stringSerializer);

        // mutator insert 

        mutator.insert("row1", columnFamilyDefinition.getName(), HFactory.createStringColumn("1", "Kim"));

        mutator.insert("row1", columnFamilyDefinition.getName(), HFactory.createStringColumn("2", "Park"));

        mutator.insert("row1", columnFamilyDefinition.getName(), HFactory.createStringColumn("3", "Yun"));

        // mutator batch

        mutator.addInsertion("row2", columnFamilyDefinition.getName(), HFactory.createStringColumn("1", "A"))

        .addInsertion("row2", columnFamilyDefinition.getName(), HFactory.createStringColumn("2", "B"))

        .addInsertion("row2", columnFamilyDefinition.getName(), HFactory.createStringColumn("3", "C"));

        mutator.execute();

}

// RangeSliceQuery

public void read1() {

if (null == cluster || null == keySpace) {

// throw exception

return;

}

int row_count = 100;

RangeSlicesQuery<String, String, String> rangeSlicesQuery = HFactory

            .createRangeSlicesQuery(keySpace, StringSerializer.get(), StringSerializer.get(), StringSerializer.get())

            .setColumnFamily(COLUMN_FAMILY_NAME)

            .setRange(null, null, false, 10)

            .setRowCount(row_count);

String last_key = null;

while (true) {

rangeSlicesQuery.setKeys(last_key, null);

            QueryResult<OrderedRows<String, String, String>> result1 = rangeSlicesQuery.execute();

            System.out.println(  result1);

            OrderedRows<String, String, String> rows1 = result1.get();

            Iterator<Row<String, String, String>> rowsIterator = rows1.iterator();

            // we'll skip this first one, since it is the same as the last one from previous time we executed

            if (last_key != null && rowsIterator != null) {

            rowsIterator.next();   

            }

while (rowsIterator.hasNext()) {

Row<String, String, String> row = rowsIterator.next();

last_key = row.getKey();

if (row.getColumnSlice().getColumns().isEmpty()) {

continue;

}

  System.out.println(row);

  ColumnSlice<String, String> columnSlice = row.getColumnSlice();

  Iterator<HColumn<String, String>> columnSliceIterator = columnSlice.getColumns().listIterator();

  while (columnSliceIterator.hasNext()) {

  HColumn<String, String> hColumn = columnSliceIterator.next();

  System.out.println("  name : " + hColumn.getName() + ", value : " + hColumn.getValue());

  }

}

if (rows1.getCount() < row_count) {

    break;

}

}

}

// Cqlquery

public void read2() {

if (null == cluster || null == keySpace) {

// throw exception

return;

}

// CqlQuery

CqlQuery<String, String, String> cqlQuery = new CqlQuery<String, String, String>(

keySpace, StringSerializer.get(), StringSerializer.get(),

StringSerializer.get());

cqlQuery.setQuery("select * from " + COLUMN_FAMILY_NAME);

QueryResult<CqlRows<String, String, String>> result = cqlQuery.execute();

CqlRows<String, String, String> rows = result.get();

if (null != rows) {

System.out.println();

for (int i = 0; i < rows.getCount(); i++) {

RowImpl<String, String, String> row = (RowImpl<String, String, String>) rows.getList().get(i);

System.out.println("Row key = " + row.getKey());

for (HColumn<String, String> column : row.getColumnSlice().getColumns()) {

System.out.println("  Column name = " + column.getName().toString() + ", value = " + column.getValue().toString());

}

}

}

}

}

<dependency>

<groupId>com.netflix.astyanax</groupId>

<artifactId>astyanax-cassandra</artifactId>

<version>1.56.37</version>

</dependency>

<dependency>

<groupId>com.netflix.astyanax</groupId>

<artifactId>astyanax-thrift</artifactId>

<version>1.56.37</version>

</dependency>

package com.google.cassandra.client;

import com.netflix.astyanax.AstyanaxContext;

import com.netflix.astyanax.ColumnListMutation;

import com.netflix.astyanax.Keyspace;

import com.netflix.astyanax.MutationBatch;

import com.netflix.astyanax.connectionpool.NodeDiscoveryType;

import com.netflix.astyanax.connectionpool.OperationResult;

import com.netflix.astyanax.connectionpool.exceptions.ConnectionException;

import com.netflix.astyanax.connectionpool.impl.ConnectionPoolConfigurationImpl;

import com.netflix.astyanax.connectionpool.impl.CountingConnectionPoolMonitor;

import com.netflix.astyanax.impl.AstyanaxConfigurationImpl;

import com.netflix.astyanax.model.ColumnFamily;

import com.netflix.astyanax.model.ColumnList;

import com.netflix.astyanax.model.CqlResult;

import com.netflix.astyanax.model.Row;

import com.netflix.astyanax.serializers.StringSerializer;

import com.netflix.astyanax.thrift.ThriftFamilyFactory;

public class AstyanaxTest {

public static void main(String[] args) {

AstyanaxTest sample = new AstyanaxTest();

sample.getConfig();

sample.create();

sample.insert();

sample.list();

}

/*

cqlsh:userkeyspace> describe columnfamily cf21

CREATE TABLE cf21 (

  key text,

  number text,

  name text,

  PRIMARY KEY (key, number)

) WITH COMPACT STORAGE AND

  bloom_filter_fp_chance=0.010000 AND

  caching='KEYS_ONLY' AND

  comment='' AND

  dclocal_read_repair_chance=0.000000 AND

  gc_grace_seconds=864000 AND

  index_interval=128 AND

  read_repair_chance=0.100000 AND

  replicate_on_write='true' AND

  populate_io_cache_on_flush='false' AND

  default_time_to_live=0 AND

  speculative_retry='NONE' AND

  memtable_flush_period_in_ms=0 AND

  compaction={'class': 'SizeTieredCompactionStrategy'} AND

  compression={'sstable_compression': 'LZ4Compressor'};

  cqlsh:userkeyspace> select * from cf21;

 key  | number | name

------+--------+------

 row1 |      1 |  Kim

 row1 |      2 |  Yun

 row1 |      3 | Park

 row2 |      1 | Choi

*/

public static final String CLUSTER_NAME = "Test Cluster";

public static final String KEY_SPACE_NAME = "userkeyspace";

public static final String COLUMN_FAMILY_NAME = "cf21";

private AstyanaxContext<Keyspace> context;

private Keyspace keyspace;

private ColumnFamily<String, String> COLUMN_FAMILY;

public void getConfig() {

context = new AstyanaxContext.Builder()

.forCluster(CLUSTER_NAME)

.forKeyspace(KEY_SPACE_NAME)

.withAstyanaxConfiguration(new AstyanaxConfigurationImpl()

.setDiscoveryType(NodeDiscoveryType.RING_DESCRIBE))

// connection pool support

.withConnectionPoolConfiguration(new ConnectionPoolConfigurationImpl("MyConnectionPool")

.setPort(9160).setMaxConnsPerHost(1)

.setSeeds("127.0.0.1:9160"))

.withAstyanaxConfiguration(new AstyanaxConfigurationImpl().setCqlVersion("3.0.0")

.setTargetCassandraVersion("2.0.1"))

.withConnectionPoolMonitor(new CountingConnectionPoolMonitor())

.buildKeyspace(ThriftFamilyFactory.getInstance());

context.start();

keyspace = context.getClient();

COLUMN_FAMILY = ColumnFamily.newColumnFamily(COLUMN_FAMILY_NAME,

StringSerializer.get(), StringSerializer.get());

}

public void insert() {

try {

String statement = String.format("insert into " + COLUMN_FAMILY_NAME + " (key, number, name) values (?, ?, ?) \n");

keyspace.prepareQuery(COLUMN_FAMILY)

.withCql(statement)

.asPreparedStatement()

.withStringValue("row1")

.withStringValue("1")

.withStringValue("Kim")

.execute();

keyspace.prepareQuery(COLUMN_FAMILY)

.withCql(statement)

.asPreparedStatement()

.withStringValue("row1")

.withStringValue("2")

.withStringValue("Yun")

.execute();

keyspace.prepareQuery(COLUMN_FAMILY)

.withCql(statement)

.asPreparedStatement()

.withStringValue("row1")

.withStringValue("3")

.withStringValue("Park")

.execute();

keyspace.prepareQuery(COLUMN_FAMILY)

.withCql(statement)

.asPreparedStatement()

.withStringValue("row2")

.withStringValue("1")

.withStringValue("Choi")

.execute();

} catch (ConnectionException e) {

throw new RuntimeException("failed to write data to cql", e);

}

}

public void insertBatch(String key, String[]... entries) {

MutationBatch m = keyspace.prepareMutationBatch();

ColumnListMutation<String> clm = m.withRow(COLUMN_FAMILY, key);

for (String[] kv : entries) {

clm.putColumn(kv[0], kv[1], null);

}

try {

m.execute();

} catch (ConnectionException e) {

throw new RuntimeException("failed to write data to batch insert", e);

}

}

public void create() {

drop();

String statement = "create table IF NOT EXISTS " + COLUMN_FAMILY_NAME

+ " (KEY text, number text, name text, PRIMARY KEY (KEY, number)) WITH COMPACT STORAGE;";

try {

keyspace.prepareQuery(COLUMN_FAMILY)

.withCql(statement)

.execute();

} catch (ConnectionException e) {

throw new RuntimeException("failed to create table", e);

}

}

public void list() {

String statement = "SELECT * FROM " + COLUMN_FAMILY_NAME + " WHERE key = ?";

try {

OperationResult<CqlResult<String, String>> result = keyspace.prepareQuery(COLUMN_FAMILY)

.withCql(statement)

.asPreparedStatement()

.withStringValue("row1")

.execute();

for (Row<String, String> row : result.getResult().getRows()) {

ColumnList<String> cols = row.getColumns();

System.out.println("- key : " + cols.getStringValue("key", null) + ", name : " + 

cols.getStringValue("name", null) + ", number : " + 

cols.getStringValue("number", null));

}

} catch (ConnectionException e) {

throw new RuntimeException("failed to read from cql", e);

}

}

public void drop() {

try {

keyspace.prepareQuery(COLUMN_FAMILY)

.withCql("drop table IF EXISTS " + COLUMN_FAMILY_NAME)

.execute();

} catch (ConnectionException e) {

throw new RuntimeException("failed to create table", e);

}

}

}

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<version>3.2.2.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>3.2.2.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework.data</groupId>

<artifactId>spring-data-commons-core</artifactId>

<version>1.4.1.RELEASE</version>

</dependency>

<dependency>

<groupId>org.easycassandra</groupId>

<artifactId>EasyCassandra</artifactId>

<version>2.0.0-RC3</version>

</dependency>

<dependency>

<groupId>com.datastax.cassandra</groupId>

<artifactId>cassandra-driver-core</artifactId>

<version>1.0.3</version> 

</dependency>

package com.google.cassandra.client;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.GenericXmlApplicationContext;

import com.google.cassandra.client.spring.Person;

import com.google.cassandra.client.spring.PersonRepository;

public class EasyCassandraTest {

/*

 CREATE TABLE cf33 (

  key text,

  number text,

  name text,

  PRIMARY KEY (key, number)

) 

 */

public static void main(String[] args) {

@SuppressWarnings("resource")

ApplicationContext ctx = new GenericXmlApplicationContext("SpringConfig.xml");

PersonRepository personService = ctx.getBean(PersonRepository.class);

Person person = new Person();

person.setKey("row1");

person.setName("Kim");

person.setNumber("1");

personService.save(person);

person = new Person();

person.setKey("row1");

person.setName("John");

person.setNumber("2");

personService.save(person);

Iterable<Person> iter = personService.findAll();

for (Person p : iter) {

System.out.println("key : " + p.getKey() + ", number : " + p.getNumber() + " , name : " + p.getName());

}

Person xman = personService.findOne("row1");

System.out.println("xman : " +xman.getName());

}

}

package com.google.cassandra.client.spring;

import java.io.Serializable;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.Id;

import org.easycassandra.Index;

// easy

@Entity(name = "cf33")

public class Person implements Serializable {

private static final long serialVersionUID = 3L;

@Id

private String key;

@Index

@Column(name = "name")

private String name;

@Column(name = "number")

private String number;

public String getKey() {

return key;

}

public void setKey(String key) {

this.key = key;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public void setNumber(String number) {

this.number = number;

}

public String getNumber() {

return number;

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + ((key == null) ? 0 : key.hashCode());

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Person other = (Person) obj;

if (key == null) {

if (other.key != null)

return false;

} else if (!key.equals(other.key))

return false;

return true;

}

}

package com.google.cassandra.client.spring;

import org.easycassandra.persistence.cassandra.spring.CassandraRepository;

import org.easycassandra.persistence.cassandra.spring.CassandraTemplate;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Repository;

@Repository("personRepository")

public class PersonRepository extends CassandraRepository<Person, String> {

@Autowired

private CassandraTemplate cassandraTemplate;

@Override

protected CassandraTemplate getCassandraTemplate() {

return cassandraTemplate;

}

}

cqlsh:userkeyspace> consistency one;

Consistency level set to ONE.

package org.apache.cassandra.cql.jdbc;

import java.sql.Statement;

import org.apache.cassandra.thrift.ConsistencyLevel;

public interface CassandraStatementExtras extends Statement

{

    public void setConsistencyLevel(ConsistencyLevel consistencyLevel);

    public ConsistencyLevel getConsistencyLevel();

}

{

Class.forName("org.apache.cassandra.cql.jdbc.CassandraDriver");

con = DriverManager.getConnection("jdbc:cassandra://localhost:9160/userkeyspace?consistency=ONE");

Statement stmt = con.createStatement();

ConsistencyLevel cl = statementExtras(stmt).getConsistencyLevel();

System.out.println("consistency level : " + cl );

}

...

    private CassandraStatementExtras statementExtras(Statement statement) throws Exception {

        Class cse = Class.forName("org.apache.cassandra.cql.jdbc.CassandraStatementExtras");

        return (CassandraStatementExtras) statement.unwrap(cse);

    }

Exception in thread "main" java.sql.SQLSyntaxErrorException: line 0:-1 mismatched input '<EOF>' expecting K_WHERE