cassandro 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0120288029f77b9b0c1f5decbf83dd3aa28ee3f6
-  data.tar.gz: 3f50c226fb664ccbd79eb2e95b6c638b0a0caaf0
+  metadata.gz: 3ca78baede197271950dd4171393ec32c9f3698f
+  data.tar.gz: 59a76cb0577d8b8293a1925d5ca071c889d61cbb
 SHA512:
-  metadata.gz: 734ad77b4020a932713e66d2618815798c14b850a0243fd3f36c2d621dcaaec4b4d937f7c4a66c624dc13c653618039c55534bb2d904c7c28569bd6587aac153
-  data.tar.gz: 97d3d021c5808aa343988e8781beaee4327756fe52a7a68304caed7e1b8657dc0446b2981a42de502a9b8b8e8a6329bf0f398ab487b26857cf303c529d4a7b8b
+  metadata.gz: 7b0810673c9631f7e60e0e9b7e4796b579c4c1b8b943f76f7dc0890a631f2b5fd0fbd08ca507d0abfaad198697206167ef6fcd84451123b759ca52d96abd6c2e
+  data.tar.gz: a5f4d40a976c593e3e6b149cf28573955b5e60381c24d2c4b8a04a92afcba110e3787784db5c127600bac5e9da7335a72c6ba0be7db021d8a8792509139f84b5

data/.gems

@@ -1 +1 @@
-cassandra-driver -v 1.2
+cassandra-driver -v 2.1.3

data/README.md

@@ -1,329 +1,56 @@
 # Cassandro [![Gem Version](https://badge.fury.io/rb/cassandro.svg)](http://badge.fury.io/rb/cassandro)
 
-Cassandro is a small Ruby ORM for Apache Cassandra 2.0 and CQL 3.0. Cassandro uses the new Datastax Ruby Driver (official driver).
+Cassandro is a small Ruby ORM for Apache Cassandra 2.0 and CQL 3.0. Cassandro uses the new [Datastax Ruby Driver](https://github.com/datastax/ruby-driver)
 
 ## Install
  
 `gem install cassandro`
 
-## Basic Cassandro
+## Changelog
 
-Connecting to Cassandra DB: `Cassandro.connect(Hash options)`. For full list of options visit [Ruby Driver Documentation](http://datastax.github.io/ruby-driver/api/#cluster-class_method)
+### v2.0
+* Support `cassandra-driver` >= 2.0
+* Allow registering indexes in model's definition
+* Add `Model#ttl` method
 
-```ruby
-Cassandro.connect(
-                  hosts: ['127.0.0.1'],
-                  keyspace: 'some_keyspace'
-                 )
-```
-
-Creating a new keyspace. For full details of keyspace creation visit [CLI keyspace](http://www.datastax.com/documentation/cassandra/2.0/cassandra/reference/referenceStorage_r.html)
-
-```ruby
-# < 1.0.0
-Cassandro.create_keyspace('new_keyspace', 'SimpleStrategy', 1)
-
-# >= 1.0.0, allow more options
-Cassandro.create_keyspace('new_keyspace', {
-  replication: {
-    class: 'NetworkTopologyStrategy',
-    dc_1: 2,
-    dc_2: 2
-  },
-  durable_writes: true
-})
-```
-
-Select keyspace outside `#connect`
-
-```ruby
-Cassandro.use('keyspace_name')
-```
-
-Create table.
-```ruby
-table = <<-TABLEDEF                                                              
-  CREATE TABLE IF NOT EXISTS users (                                              
-    email VARCHAR,                                                                       
-    first_name VARCHAR,                                                                 
-    age INT,
-    created_at TIMESTAMP,                                                          
-    PRIMARY KEY(email,created_at)                                                          
-  )                                                                                
-TABLEDEF
-
-Cassandro.execute(table)
-```
-
-Execute queries.
-```ruby
-result = Cassandro.execute("SELECT * FROM table_name;")
-```
-
-Using Driver directly.
-```ruby
-statement = Cassandro.client.prepare("SELECT * FROM table_name WHERE colname = ?;")
-result = Cassandro.client.execute(statement, id)
-```
-
-## Cassandro::Model
-
-### Creating model
-Creating new model: make you class inherits form `Cassandro::Model`
-
-```ruby
-class User < Cassandro::Model
-end
-```
-
-Specifying table name using the method `table(table_name)`:
-
-```ruby
-class User < Cassandro::Model
-
-  table 'users'
-end
-```
+### v1.2
+* TTL
+ * Model-wide TTL
+ * Single record TTL
+* Support `:set` datatype
+* Ignore columns not definied on model
 
-Adding attributes using the method `attribute(name, type, options)`:
+## Example
 
 ```ruby
-class User < Cassandro::Model
-
-  attribute :email, :text
-  attribute :first_name, :text
-  attribute :age, :integer
-  attribute :created_at, :datetime
-end
-```
-
-types: :uuid, :text, :integer, :float, :timestamp, :datetime
-
-Setting the primary key using the method `primary_key(pk_name | Array)`:
-
-```ruby
-class User < Cassandro::Model
-
-  primary_key [:email, :created_at]
-
-end
-
-```
-
-Setting unique field using the method `unique(field | Array)`:
-
-```ruby
-class  User < Cassandro::Model
-
-  unique :email
-end
-```
-
-
-### Setting TTL to a model
-
-```Ruby
-class Person < Cassandro::Model
-  table :people
-  ttl 60
-end
-```
-This will make all the instances of the People class will have a Time To Live of `60` seconds in the database.
-
-Creating a single record with a given TTL:
-
-```Ruby
-class Person < Cassandro::Model
-  table :people
-  attribute :first_name, :text
-  attribute :last_name, :text
-end
-
-Person.create_with_ttl(20, :first_name => "Eddie", :last_name => "Vedder")
-```
-
-This will create a record in the `people` table with a TTL of `20` seconds. It doesn't matter if the model has a different TTL set, this will override that TTL for _this record only_
-
-
-__A complete example__
-
-```ruby
-class User < Cassandro::Model
-
-  table 'users'
-
+class Developer < Cassandro::Model
+  table :developers
+  
   attribute :email, :text
-  attribute :first_name, :text
-  attribute :age, :integer
-  attribute :created_at, :datetime
+  attribute :repos, :integer
+  attribute :nickname, :text
   
-  primary_key [:email, :created_at]
-
-  unique :email
-end
-```
-
-### Interacting
-
-Creating a new row:
-
-```ruby
-user = User.create(email: 'test1@example.com', first_name: 'Test', age: 30, created_at: DateTime.now)
-=> #<User:0x00000001b9dc40
- @attributes=
-  {:email=>"test1@example.com",
-   :first_name=>"Test",
-   :age=>30,
-   :created_at=>
-    #<DateTime: 2014-11-03T11:34:47-03:00 ((2456965j,52487s,201385585n),-10800s,2299161j)>},
- @errors={},
- @insert_statement=
-  #<Cassandra::Statements::Prepared:0xdcd4f8 @cql="          INSERT INTO users(email,first_name,age,created_at)\n          VALUES(?,?,?,?)\n          IF NOT EXISTS\n">,
- @persisted=true>
-
-```
-
-Find:
-
-```ruby
-User[email: 'test1@example.com']
-=> #<User:0x00000001cc59d8
- @attributes=
-  {:email=>"test1@example.com",
-   :created_at=>2014-11-03 11:34:47 -0300,
-   :age=>30,
-   :first_name=>"Test"},
- @errors={},
- @persisted=true>
-
-User.where('email','test1@example.com')
-=> #<User:0x00000001cc59d8
- @attributes=
-  {:email=>"test1@example.com",
-   :created_at=>2014-11-03 11:34:47 -0300,
-   :age=>30,
-   :first_name=>"Test"},
- @errors={},
- @persisted=true>
-
-```
-
-```ruby
-User.all
-=> [#<User:0x00000002bc75f8
-  @attributes=
-   {:email=>"test@example.com",
-    :created_at=>2014-11-03 11:30:52 -0300,
-    :age=>30,
-    :first_name=>"Test"},
-  @errors={},
-  @persisted=true>,
- #<User:0x00000002bc6b30
-  @attributes=
-   {:email=>"test1@example.com",
-    :created_at=>2014-11-03 11:34:47 -0300,
-    :age=>30,
-    :first_name=>"Test"},
-  @errors={},
-  @persisted=true>]
-```
-
-```ruby
-User.query('created_at > ?', Time.now.to_i)
-=> #<Cassandra::Result:0x1fcb254 @rows=[{"email"=>"test@example.com", "created_at"=>2014-11-03 11:30:52 -0300, "age"=>30, "first_name"=>"Test"}, {"email"=>"test1@example.com", "created_at"=>2014-11-03 11:34:47 -0300, "age"=>30, "first_name"=>"Test"}] @last_page=true>
-```
-
-Count:
-
-```ruby
-User.count('email', 'test@example.com')
-=> 1
-```
-
-Checking errors:
-```ruby
-user = User.create(email: 'test1@example.com', first_name: 'Test', age: 30, created_at: DateTime.now)
-=> #<User:0x00000001dc7a48
- @attributes=
-  {:email=>"test1@example.com",
-   :first_name=>"Test",
-   :age=>30,
-   :created_at=>
-    #<DateTime: 2014-11-03T11:36:40-03:00 ((2456965j,52600s,972972939n),-10800s,2299161j)>},
- @errors={:unique=>"user_not_unique"},
- @persisted=false>
-
-user.persisted?
-=> false
-user.errors
-=> {:unique=>"user_not_unique"}
-
-```
-
-## Migrations
-
-Define your migrations by extending from `Cassandro::Migration`
-
-```ruby
-class UserMigration < Cassandro::Migration
-  version 1
-
-  def up
-    execute <<-TABLEDEF
-      CREATE TABLE users (
-        id UUID,
-        first_name VARCHAR,
-        last_name VARCHAR,
-        email VARCHAR,
-        PRIMARY KEY(id, email)
-      )
-    TABLEDEF
-  end
-
-  def down
-    execute <<-QUERY
-      DROP TABLE users;
-    QUERY
-  end
+  primary_key [:id, :repos]
+  
+  index :nickname
 end
 
-class UserGenderMigration < Cassandro::Migration
-
-  version 2
+Cassandro.connect(hosts: ['127.0.0.1'], keyspace: 'little_cassandro')
 
-  def up
-    execute <<-TABLEUPDATE
-      ALTER TABLE users ADD gender VARCHAR
-    TABLEUPDATE
-  end
-
-  def down
-    execute <<-QUERY
-      ALTER TABLE users DROP gender
-    QUERY
-  end
-end
+Developer.create(email: 'developer@dev.com', repos: 10, nickname: 'cassandro')
 ```
 
-Then use `Cassandro::Migrator` to run your migrations
-
-```ruby
-Cassandro.connect(hosts: ['127.0.0.1'], keyspace: 'some_keyspace')
+## Documentation
 
-migrator = Cassandro::Migrator.new('./path/to/migrations', Logger.new(STDOUT))
-
-migrator.migrate!(:up) #migrates to last version
-migrator.migrate!(:down) #apply all downgrades
-
-migrator.migrate!(:up, 2) #migrates up to version 2
-migrator.migrate!(:down, 1) #migrates down to version 1
-```
+* [Getting Started](docs/getting_started.md)
+* [Migrations](docs/migrations.md)
+* [Modeling](docs/modeling.md)
+* [Querying](docs/querying.md)
+* [Advanced Features](docs/advanced_features.md)
 
 ## TODO
 
-* Support Index
-* Better queries
-* Better documentation
+* Improve querying
 
 ## How to collaborate
 

data/cassandro.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = "cassandro"
-  s.version = "1.2.0"
+  s.version = "2.0.0"
   s.summary = "Ruby ORM for Apache Cassandra"
   s.license = "MIT"
   s.description = "Lightweight Apache Cassandra ORM for Ruby"
@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.email = ["orazile@gmail.com", "leonardomateo@gmail.com"]
   s.homepage = "https://github.com/tarolandia/cassandro"
   s.require_paths = ["lib"]
-  s.add_dependency "cassandra-driver", '~> 1.2', '>= 1.0.0'
+  s.add_dependency "cassandra-driver", '~> 2.1.3', '>= 2.0.0'
   s.add_development_dependency "protest", '~> 0.5', '>= 0.5.3'
   s.add_development_dependency "rack-test", '~> 0.6', '>= 0.6.3'
 

data/docs/advanced_features.md

@@ -0,0 +1,59 @@
+## TTL
+
+### Setting TTL to a model
+
+```Ruby
+class Person < Cassandro::Model
+  table :people
+  ttl 60
+end
+```
+This will make all the instances of the People class will have a Time To Live of `60` seconds in the database.
+
+### Creating a single record with a given TTL:
+
+```Ruby
+class Person < Cassandro::Model
+  table :people
+  attribute :first_name, :text
+  attribute :last_name, :text
+end
+
+Person.create_with_ttl(20, :first_name => "Eddie", :last_name => "Vedder")
+```
+
+This will create a record in the `people` table with a TTL of `20` seconds. It doesn't matter if the model has a different TTL set, this will override that TTL for _this record only_
+
+### Getting TTL
+
+After creating a record with a TTL you can use method `Model#ttl` to get the value.
+
+```Ruby
+person = Person.create_with_ttl(20, :first_name => "John", :last_name => "Lennon")
+
+person.ttl # => 20
+
+# ...
+
+person.ttl # => 18
+```
+
+### Enabling Soft Delete
+
+
+```Ruby
+class Person < Cassandro::Model
+  include Cassandro::SoftDelete
+  
+  table :people
+end
+```
+
+This will add an attribute `:delete` to your model. Next time you use `Model#destroy` your data will not be deleted from database but marked as deleted. You can then use `Model#restore` to unmark it.
+
+Data marked as deleted is not included within `Model#all` method by default. In order to include deleted records you have to send a boolean parameter to `all`.
+
+```ruby
+Person.all # => list all but deleted
+Person.all(true) # => list all, deleted included
+```

data/docs/getting_started.md

@@ -0,0 +1,70 @@
+# Getting Started with Cassandro ORM
+
+## Connection
+
+Connecting to Cassandra DB: `Cassandro.connect(Hash options)`.
+
+```ruby
+# Connect
+Cassandro.connect(hosts: ['192.168.2.100', '192.168.2.101'])
+
+# Connect specifying keyspace
+Cassandro.connect(hosts: ['192.168.2.100', '192.168.2.101'], keyspace: 'some_keyspace')
+```
+
+_For full list of options visit [Ruby Driver Documentation](http://datastax.github.io/ruby-driver/api/#cluster-class_method)_
+
+## Keyspace
+
+### Create Keyspace
+
+```ruby
+Cassandro.create_keyspace('new_keyspace', {
+  replication: {
+    class: 'NetworkTopologyStrategy',
+    dc_1: 2,
+    dc_2: 2
+  },
+  durable_writes: true
+})
+```
+
+_For full details of keyspace creation visit [CLI keyspace](http://www.datastax.com/documentation/cassandra/2.0/cassandra/reference/referenceStorage_r.html)_
+
+
+### Select keyspace
+
+```ruby
+Cassandro.use('keyspace_name')
+```
+
+## Execute
+
+### Execute queries
+```ruby
+result = Cassandro.execute("SELECT * FROM table_name;")
+```
+### Create table
+```ruby
+table = <<-TABLEDEF                                                              
+  CREATE TABLE IF NOT EXISTS users (                                              
+    email VARCHAR,                                                                       
+    first_name VARCHAR,                                                                 
+    age INT,
+    created_at TIMESTAMP,                                                          
+    PRIMARY KEY(email,created_at)                                                          
+  )                                                                                
+TABLEDEF
+
+Cassandro.execute(table)
+```
+
+## Cassandra Client
+
+Cassandro provides access to `cassandra-driver` instance through `Cassandro.client`
+
+### Using Driver directly
+```ruby
+statement = Cassandro.client.prepare("SELECT * FROM table_name WHERE colname = ?;")
+result = Cassandro.client.execute(statement, id)
+```

data/docs/migrations.md

@@ -0,0 +1,60 @@
+## Migrations
+
+Define your migrations by extending from `Cassandro::Migration`
+
+```ruby
+class UserMigration < Cassandro::Migration
+  version 1
+
+  def up
+    execute <<-TABLEDEF
+      CREATE TABLE users (
+        id UUID,
+        first_name VARCHAR,
+        last_name VARCHAR,
+        email VARCHAR,
+        PRIMARY KEY(id, email)
+      )
+    TABLEDEF
+  end
+
+  def down
+    execute <<-QUERY
+      DROP TABLE users;
+    QUERY
+  end
+end
+
+class UserGenderMigration < Cassandro::Migration
+
+  version 2
+
+  def up
+    execute <<-TABLEUPDATE
+      ALTER TABLE users ADD gender VARCHAR
+    TABLEUPDATE
+  end
+
+  def down
+    execute <<-QUERY
+      ALTER TABLE users DROP gender
+    QUERY
+  end
+end
+```
+
+Then use `Cassandro::Migrator` to run your migrations
+
+```ruby
+Cassandro.connect(hosts: ['127.0.0.1'], keyspace: 'some_keyspace')
+
+migrator = Cassandro::Migrator.new('./path/to/migrations', Logger.new(STDOUT))
+
+migrator.migrate!(:up) #migrates to last version
+migrator.migrate!(:down) #apply all downgrades
+
+migrator.migrate!(:up, 2) #migrates up to version 2
+migrator.migrate!(:down, 1) #migrates down to version 1
+```
+
+

data/docs/modeling.md

@@ -0,0 +1,93 @@
+## Cassandro::Model
+
+### Creating model
+
+#### Creating new model
+
+Make you class inherits form `Cassandro::Model`
+
+```ruby
+class User < Cassandro::Model
+end
+```
+#### Table name
+
+Specify table name using the method `table(table_name)`:
+
+```ruby
+class User < Cassandro::Model
+
+  table 'users'
+end
+```
+
+#### Attributes
+
+Add attributes using the method `attribute(name, type, options)`:
+
+```ruby
+class User < Cassandro::Model
+
+  attribute :email, :text
+  attribute :first_name, :text
+  attribute :age, :integer
+  attribute :created_at, :datetime
+end
+```
+
+Types: `:uuid`, `:text`, `:integer`, `:float`, `:timestamp`, `:datetime`, `:set`
+
+#### Primary Key
+
+Set the primary key using the method `primary_key(pk_name | Array)`:
+
+```ruby
+class User < Cassandro::Model
+
+  primary_key [:email, :created_at]
+
+end
+
+```
+
+#### Unique
+
+Set unique fields using the method `unique(field | Array)`:
+
+```ruby
+class  User < Cassandro::Model
+
+  unique :email
+end
+```
+
+#### Index
+
+Set indexes using the method `index(field | Array)`. Note registering indexes in your model is only a refence.
+
+```ruby
+class  User < Cassandro::Model
+
+  index :age
+end
+```
+
+#### A complete example
+
+```ruby
+class User < Cassandro::Model
+
+  table 'users'
+
+  attribute :email, :text
+  attribute :first_name, :text
+  attribute :age, :integer
+  attribute :created_at, :datetime
+  
+  primary_key [:email, :created_at]
+
+  unique :email
+  
+  index :age
+end
+```

data/docs/querying.md

@@ -0,0 +1,120 @@
+## Querying
+
+```ruby
+class User < Cassandro::Model
+  table :users
+  
+  attribute :email, :text
+  attribute :first_name, :text
+  attribute :age, :integer
+  attribute :created_at, :datetime
+  
+  primary_key :email
+  
+  index :first_name
+end
+```
+
+### Creating a new row:
+
+```ruby
+user = User.create(email: 'test1@example.com', first_name: 'Test', age: 30, created_at: DateTime.now)
+=> #<User:0x00000001b9dc40 ... @persisted=true>
+
+```
+
+### Updating attributes
+
+#### Using `#save`
+
+```ruby
+user.age = 31
+user.save
+=> true
+```
+
+#### Using `#update_attributes`
+
+```ruby
+user.update_attributes(first_name: 'Test 1', age: 31)
+=> true
+```
+
+### Selecting records
+
+#### Find
+
+```ruby
+User[email: 'test1@example.com']
+=> #<User:0x00000001cc59d8 ... @persisted=true>
+```
+```ruby
+User[email: 'test1@example.com', first_name: 'No Test']
+=> nil
+```
+
+#### Find all
+
+```ruby
+User.all
+=> [#<User:0x00000001cc59d8 ... @persisted=true>, #<User:0x00000001cc59d9 ... @persisted=true>, ...]
+```
+#### Where / Query
+
+```ruby
+User.where('first_name','Test 1')
+=> [#<User:0x00000001cc59d8 ... @persisted=true>]
+```
+
+```ruby
+User.query('first_name = ?', 'Test')
+=> [#<User:0x00000001cc59d8 ... @persisted=true>, ...]
+```
+
+#### Count:
+
+```ruby
+User.count('email', 'test@example.com')
+=> 1
+
+User.count
+=> 2
+```
+
+### Deleting
+
+#### Destroy
+
+```ruby
+user = User[email: 'test1@example.com']
+user.destroy
+```
+
+#### Destroy All (truncate table)
+
+```ruby
+User.destroy_all
+```
+
+### Checking errors:
+
+```ruby
+user = User.create(email: 'test1@example.com', first_name: 'Test', age: 30, created_at: DateTime.now)
+=> #<User:0x00000001dc7a48
+ @attributes=
+  {:email=>"test1@example.com",
+   :first_name=>"Test",
+   :age=>30,
+   :created_at=>
+    #<DateTime: 2014-11-03T11:36:40-03:00 ((2456965j,52600s,972972939n),-10800s,2299161j)>},
+ @errors={:unique=>"user_not_unique"},
+ @persisted=false>
+
+user.persisted?
+=> false
+user.errors
+=> {:unique=>"user_not_unique"}
+
+```
+
+

data/lib/cassandro/core.rb

@@ -71,3 +71,12 @@ module Cassandro
     end
   end
 end
+
+# Patch: Make params_metadata public for Prepared Statements
+module Cassandra
+  module Statements
+    class Prepared
+      attr_reader :params_metadata
+    end
+  end
+end

data/lib/cassandro/model.rb

@@ -70,7 +70,7 @@ module Cassandro
 
       begin
         st = Cassandro.client.prepare(query)
-        Cassandro.client.execute(st, *native_attributes(attrs))
+        Cassandro.client.execute(st, arguments: native_attributes(attrs))
         @attributes.merge!(attrs)
         true
       rescue Exception => e
@@ -101,7 +101,7 @@ module Cassandro
       st = self.statement_for(:insert, :insert_check => insert_check)
 
       begin
-        r = Cassandro.client.execute(st, *self.native_attributes)
+        r = Cassandro.client.execute(st, arguments: self.native_attributes)
         raise ModelException.new('not_applied') unless !insert_check || (insert_check && r.first["[applied]"])
         @persisted = true
       rescue => e
@@ -119,11 +119,21 @@ module Cassandro
       Cassandro.execute(query)
     end
 
+    def ttl
+      query = <<-QUERY
+        SELECT TTL(#{@attributes.keys.last}) FROM #{self.class.table_name}
+        WHERE #{self.class.pk.flatten.map { |k| "#{k.to_s} = #{self.class.cast_as(k, @attributes[k])}" }.join(' AND ')}
+      QUERY
+      result = Cassandro.execute(query)
+      result.any? ? result.first.values.first : nil
+    end
+
     def self.table(name)
       self.table_name = name.to_s
     end
 
     def self.attribute(name, type = String, options = {})
+      return if attributes.include?(name)
       attributes << name
       casts[name] = type
 
@@ -138,17 +148,25 @@ module Cassandro
 
     def self.primary_key(keys)
       if keys.is_a?(Array)
-        pk.push(*keys)
+        pk.merge(keys)
       else
-        pk << keys
+        pk.add(keys)
       end
     end
 
     def self.unique(keys)
       if keys.is_a?(Array)
-        uniques.push(*keys)
+        uniques.merge(keys)
       else
-        uniques << keys
+        uniques.add(keys)
+      end
+    end
+
+    def self.index(keys)
+      if keys.is_a?(Array)
+        indexes.merge(keys)
+      else
+        indexes.add(keys)
       end
     end
 
@@ -170,7 +188,7 @@ module Cassandro
       QUERY
 
       st = Cassandro.client.prepare(query)
-      result = Cassandro.client.execute(st, *values)
+      result = Cassandro.client.execute(st, arguments: values)
 
       return nil unless result.any?
 
@@ -184,6 +202,16 @@ module Cassandro
       model
     end
 
+    def self.create_with_ttl(seconds, attrs = {})
+      old_ttl = self.options[:ttl]
+      self.options[:ttl] = seconds.to_i
+
+      result = self.create(attrs)
+
+      old_ttl ? self.options[:ttl] = old_ttl : self.options.delete(:ttl)
+      result
+    end
+
     def self.all
       query = "SELECT * FROM #{self.table_name}"
 
@@ -202,7 +230,7 @@ module Cassandro
       query = "SELECT * FROM #{table_name} WHERE #{key} = ? ALLOW FILTERING"
 
       st = Cassandro.client.prepare(query)
-      rows = Cassandro.client.execute(st, value)
+      rows = Cassandro.client.execute(st, arguments: [value])
 
       rows.each do |result|
         results << new(result, true)
@@ -218,7 +246,7 @@ module Cassandro
         key = key.to_sym
         query << " WHERE #{key} = ? ALLOW FILTERING"
         st = Cassandro.client.prepare(query)
-        results = Cassandro.client.execute(st, value)
+        results = Cassandro.client.execute(st, arguments: [value])
       else
         results = Cassandro.client.execute(query)
       end
@@ -237,9 +265,18 @@ module Cassandro
     end
 
     def self.query(where, *values)
+      results = []
+
       query = "SELECT * FROM #{table_name} WHERE #{where} ALLOW FILTERING"
       st = Cassandro.client.prepare(query)
-      Cassandro.client.execute(st, *values)
+      rows = Cassandro.client.execute(st, arguments: values)
+
+
+      rows.each do |result|
+        results << new(result, true)
+      end
+
+      results
     end
 
     protected
@@ -248,7 +285,7 @@ module Cassandro
     end
 
     def self.pk
-      @pk ||= []
+      @pk ||= Set.new
     end
 
     def self.table_name
@@ -264,7 +301,11 @@ module Cassandro
     end
 
     def self.uniques
-      @unique ||= []
+      @unique ||= Set.new
+    end
+
+    def self.indexes
+      @indexes ||= Set.new
     end
 
     def self.uniqueness_defined?
@@ -298,16 +339,6 @@ module Cassandro
       self.options[:ttl] = seconds.to_i
     end
 
-    def self.create_with_ttl(seconds, attrs = {})
-      old_ttl = self.options[:ttl]
-      self.options[:ttl] = seconds.to_i
-
-      result = self.create(attrs)
-
-      old_ttl ? self.options[:ttl] = old_ttl : self.options.delete(:ttl)
-      result
-    end
-
     def statement_for(operation, options = {})
       case operation
       when :insert

data/test/cassandro_model_test.rb

@@ -44,6 +44,28 @@ Protest.describe "Cassandro Model" do
       assert Test.uniqueness_defined?
     end
 
+    test "adds index" do
+      class Test < Cassandro::Model
+        index :test_col_2
+      end
+
+      assert Test.indexes.include?(:test_col_2)
+    end
+
+    test "adds multiple indexes" do
+      class Test < Cassandro::Model
+        attribute :test_col_3, :text
+        attribute :test_col_4, :text
+        attribute :test_col_5, :text
+
+        index :test_col_3
+        index [:test_col_4, :test_col_5]
+      end
+      assert Test.indexes.include?(:test_col_3)
+      assert Test.indexes.include?(:test_col_4)
+      assert Test.indexes.include?(:test_col_5)
+    end
+
     test "allows setting and getting attributes" do
       uuid = SecureRandom.uuid
       test = Test.new(test_col_1: uuid, test_col_2: 'test_value_2')
@@ -159,7 +181,7 @@ Protest.describe "Cassandro Model" do
       Test.create(test_col_1: uuid, test_col_2: 'test_value_2')
 
       tests = Test[uuid]
-      assert_equal false, tests.respond_to?("test_col_3")
+      assert_equal false, tests.respond_to?("test_col_ignored")
     end
   end
 
@@ -247,5 +269,11 @@ Protest.describe "Cassandro Model" do
       assert results.first["ttl(address)"] > 0
       assert results.first["ttl(address)"] <= 30
     end
+
+    test "should get TTL" do
+      patient = Patient.create_with_ttl(20, :name => "Cassandro Get", :address => "cassandstreet", :age => 1)
+      assert patient.ttl > 0
+      assert patient.ttl <= 20
+    end
   end
 end

data/test/support/tables.rb

@@ -4,6 +4,9 @@ table = <<-TABLEDEF
     test_col_1 UUID,
     test_col_2 VARCHAR,
     test_col_3 VARCHAR,
+    test_col_4 VARCHAR,
+    test_col_5 VARCHAR,
+    test_col_ignored VARCHAR,
     PRIMARY KEY(test_col_1)
   )
 TABLEDEF

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cassandro
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Lautaro Orazi
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-30 00:00:00.000000000 Z
+date: 2015-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cassandra-driver
@@ -17,20 +17,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: 2.1.3
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: 2.1.3
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: protest
   requirement: !ruby/object:Gem::Requirement
@@ -82,9 +82,14 @@ files:
 - ".gems"
 - ".gems-test"
 - ".gitignore"
-- LICENSE
+- LICENSE.md
 - README.md
 - cassandro.gemspec
+- docs/advanced_features.md
+- docs/getting_started.md
+- docs/migrations.md
+- docs/modeling.md
+- docs/querying.md
 - lib/cassandro.rb
 - lib/cassandro/core.rb
 - lib/cassandro/ext/migration.rb