Driver for MongoDB

.travis.yml

@@ -4,6 +4,8 @@ sudo: required
 go:
   - 1.4
   - 1.5
+  - 1.6
+  - 1.7
 
 services:
   - docker

Makefile

@@ -1,15 +1,23 @@
+TESTFLAGS?=
 IMAGE=mattes/migrate
 DCR=docker-compose run --rm
-.PHONY: clean test build release docker-build docker-push run
+GOTEST=go test $(TESTFLAGS) `go list  ./... | grep -v "/vendor/"`
 
+.PHONY: clean test build release docker-build docker-push run
 all: release
 
 clean:
 	rm -f migrate
 
-test:
+fmt:
+	@gofmt -s -w `go list -f {{.Dir}} ./... | grep -v "/vendor/"`
+
+test: fmt
 	$(DCR) go-test
 
+go-test: fmt
+	@$(GOTEST)
+
 build:
 	$(DCR) go-build
 

README.md

@@ -25,6 +25,7 @@ __Features__
  * [Cassandra](https://github.com/mattes/migrate/tree/master/driver/cassandra)
  * [SQLite](https://github.com/mattes/migrate/tree/master/driver/sqlite3)
  * [MySQL](https://github.com/mattes/migrate/tree/master/driver/mysql) ([experimental](https://github.com/mattes/migrate/issues/1#issuecomment-58728186))
+ * [Ql](https://github.com/mattes/migrate/tree/master/driver/ql)
  * Bash (planned)
 
 Need another driver? Just implement the [Driver interface](http://godoc.org/github.com/mattes/migrate/driver#Driver) and open a PR.
@@ -100,15 +101,15 @@ go migrate.Up(pipe, "driver://url", "./path")
 The format of migration files looks like this:
 
 ```
-001_initial_plan_to_do_sth.up.sql     # up migration instructions
-001_initial_plan_to_do_sth.down.sql   # down migration instructions
-002_xxx.up.sql
-002_xxx.down.sql
+1481574547_initial_plan_to_do_sth.up.sql     # up migration instructions
+1481574547_initial_plan_to_do_sth.down.sql   # down migration instructions
+1482438365_xxx.up.sql
+1482438365_xxx.down.sql
 ...
 ```
 
 Why two files? This way you could still do sth like 
-``psql -f ./db/migrations/001_initial_plan_to_do_sth.up.sql`` and there is no
+``psql -f ./db/migrations/1481574547_initial_plan_to_do_sth.up.sql`` and there is no
 need for any custom markup language to divide up and down migrations. Please note
 that the filename extension depends on the driver.
 

docker-compose.yml

@@ -10,6 +10,8 @@ go-test:
     - postgres
     - mysql
     - cassandra
+    - crate
+    - mongo
 go-build:
   <<: *go
   command: sh -c 'go get -v && go build -ldflags ''-s'' -o migrater'
@@ -21,6 +23,12 @@ mysql:
   image: mysql
   environment:
     MYSQL_DATABASE: migratetest
-    MYSQL_ALLOW_EMPTY_PASSWORD: yes
+    MYSQL_ALLOW_EMPTY_PASSWORD: "yes"
 cassandra:
   image: cassandra:2.2
+crate:
+  image: crate
+mongo:
+  image: mongo:3.2.6
+
+

driver/cassandra/README.md

@@ -8,8 +8,13 @@ migrate -url cassandra://host:port/keyspace -path ./db/migrations up
 migrate help # for more info
 ```
 
+Url format
+- Authentication: `cassandra://username:password@host:port/keyspace`
+- Cassandra v3.x: `cassandra://host:port/keyspace?protocol=4`
+
+
 ## Authors
 
 * Paul Bergeron, https://github.com/dinedal
 * Johnny Bergström, https://github.com/balboah
-* pateld982, http://github.com/pateld982
+* pateld982, http://github.com/pateld982

driver/cassandra/cassandra.go

@@ -41,18 +41,36 @@ const (
 )
 
 // Cassandra Driver URL format:
-// cassandra://host:port/keyspace?protocol=version
+// cassandra://host:port/keyspace?protocol=version&consistency=level
 //
-// Example:
+// Examples:
 // cassandra://localhost/SpaceOfKeys?protocol=4
+// cassandra://localhost/SpaceOfKeys?protocol=4&consistency=all
+// cassandra://localhost/SpaceOfKeys?consistency=quorum
 func (driver *Driver) Initialize(rawurl string) error {
 	u, err := url.Parse(rawurl)
+	if err != nil {
+		return fmt.Errorf("failed to parse connectil url: %v", err)
+	}
+
+	if u.Path == "" {
+		return fmt.Errorf("no keyspace provided in connection url")
+	}
 
 	cluster := gocql.NewCluster(u.Host)
 	cluster.Keyspace = u.Path[1:len(u.Path)]
 	cluster.Consistency = gocql.All
 	cluster.Timeout = 1 * time.Minute
 
+	if len(u.Query().Get("consistency")) > 0 {
+		consistency, err := parseConsistency(u.Query().Get("consistency"))
+		if err != nil {
+			return err
+		}
+
+		cluster.Consistency = consistency
+	}
+
 	if len(u.Query().Get("protocol")) > 0 {
 		protoversion, err := strconv.Atoi(u.Query().Get("protocol"))
 		if err != nil {
@@ -169,3 +187,20 @@ func (driver *Driver) Version() (uint64, error) {
 func init() {
 	driver.RegisterDriver("cassandra", &Driver{})
 }
+
+// ParseConsistency wraps gocql.ParseConsistency to return an error
+// instead of a panicing.
+func parseConsistency(consistencyStr string) (consistency gocql.Consistency, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			var ok bool
+			err, ok = r.(error)
+			if !ok {
+				err = fmt.Errorf("Failed to parse consistency \"%s\": %v", consistencyStr, r)
+			}
+		}
+	}()
+	consistency = gocql.ParseConsistency(consistencyStr)
+
+	return consistency, nil
+}

driver/cassandra/cassandra_test.go

@@ -13,6 +13,10 @@ import (
 )
 
 func TestMigrate(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+
 	var session *gocql.Session
 
 	host := os.Getenv("CASSANDRA_PORT_9042_TCP_ADDR")
@@ -112,5 +116,35 @@ func TestMigrate(t *testing.T) {
 	if err := d.Close(); err != nil {
 		t.Fatal(err)
 	}
+}
+
+func TestInitializeReturnsErrorsForBadUrls(t *testing.T) {
+	var session *gocql.Session
+
+	host := os.Getenv("CASSANDRA_PORT_9042_TCP_ADDR")
+	port := os.Getenv("CASSANDRA_PORT_9042_TCP_PORT")
+
+	cluster := gocql.NewCluster(host)
+	cluster.Consistency = gocql.All
+	cluster.Timeout = 1 * time.Minute
+
+	session, err := cluster.CreateSession()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer session.Close()
+	if err := session.Query(`CREATE KEYSPACE IF NOT EXISTS migrate WITH REPLICATION = {'class': 'SimpleStrategy', 'replication_factor': 1};`).Exec(); err != nil {
+		t.Fatal(err)
+	}
 
+	d := &Driver{}
+	invalidURL := "sdf://asdf://as?df?a"
+	if err := d.Initialize(invalidURL); err == nil {
+		t.Errorf("expected an error to be returned if url could not be parsed")
+	}
+
+	noKeyspace := "cassandra://" + host + ":" + port
+	if err := d.Initialize(noKeyspace); err == nil {
+		t.Errorf("expected an error to be returned if no keyspace provided")
+	}
 }

driver/crate/README.md

@@ -0,0 +1,15 @@
+# Crate driver
+
+This is a driver for the [Crate](https://crate.io) database. It is based on the Crate
+sql driver by [herenow](https://github.com/herenow/go-crate).
+
+This driver does not use transactions! This is not a limitation of the driver, but a 
+limitation of Crate. So handle situations with failed migrations with care!
+
+## Usage
+
+```bash
+migrate -url http://host:port -path ./db/migrations create add_field_to_table
+migrate -url http://host:port -path ./db/migrations up
+migrate help # for more info
+```

driver/crate/crate.go

@@ -0,0 +1,115 @@
+// Package crate implements a driver for the Crate.io database
+package crate
+
+import (
+	"database/sql"
+	"fmt"
+	"strings"
+
+	_ "github.com/herenow/go-crate"
+	"github.com/mattes/migrate/driver"
+	"github.com/mattes/migrate/file"
+	"github.com/mattes/migrate/migrate/direction"
+)
+
+func init() {
+	driver.RegisterDriver("crate", &Driver{})
+}
+
+type Driver struct {
+	db *sql.DB
+}
+
+const tableName = "schema_migrations"
+
+func (driver *Driver) Initialize(url string) error {
+	url = strings.Replace(url, "crate", "http", 1)
+	db, err := sql.Open("crate", url)
+	if err != nil {
+		return err
+	}
+	if err := db.Ping(); err != nil {
+		return err
+	}
+	driver.db = db
+
+	if err := driver.ensureVersionTableExists(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (driver *Driver) Close() error {
+	if err := driver.db.Close(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (driver *Driver) FilenameExtension() string {
+	return "sql"
+}
+
+func (driver *Driver) Version() (uint64, error) {
+	var version uint64
+	err := driver.db.QueryRow("SELECT version FROM " + tableName + " ORDER BY version DESC LIMIT 1").Scan(&version)
+	switch {
+	case err == sql.ErrNoRows:
+		return 0, nil
+	case err != nil:
+		return 0, err
+	default:
+		return version, nil
+	}
+}
+
+func (driver *Driver) Migrate(f file.File, pipe chan interface{}) {
+	defer close(pipe)
+	pipe <- f
+
+	if err := f.ReadContent(); err != nil {
+		pipe <- err
+		return
+	}
+
+	lines := splitContent(string(f.Content))
+	for _, line := range lines {
+		_, err := driver.db.Exec(line)
+		if err != nil {
+			pipe <- err
+			return
+		}
+	}
+
+	if f.Direction == direction.Up {
+		if _, err := driver.db.Exec("INSERT INTO "+tableName+" (version) VALUES (?)", f.Version); err != nil {
+			pipe <- err
+			return
+		}
+	} else if f.Direction == direction.Down {
+		if _, err := driver.db.Exec("DELETE FROM "+tableName+" WHERE version=?", f.Version); err != nil {
+			pipe <- err
+			return
+		}
+	}
+}
+
+func splitContent(content string) []string {
+	lines := strings.Split(content, ";")
+	resultLines := make([]string, 0, len(lines))
+	for i, line := range lines {
+		line = strings.Replace(lines[i], ";", "", -1)
+		line = strings.TrimSpace(line)
+		if line != "" {
+			resultLines = append(resultLines, line)
+		}
+	}
+	return resultLines
+}
+
+func (driver *Driver) ensureVersionTableExists() error {
+	if _, err := driver.db.Exec(fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s (version INTEGER PRIMARY KEY)", tableName)); err != nil {
+		return err
+	}
+	return nil
+}