diff --git a/db/mongo/mongo.go b/db/mongo/mongo.go
index 7b2240ea6ba0c558ae321a66c892b0353db96eb8..40d448f544ea9bdabaefd07c586047cdddc7bdf6 100644
--- a/db/mongo/mongo.go
+++ b/db/mongo/mongo.go
@@ -106,43 +106,35 @@ func (c *MongoDataSourceCollection) Append(items ...interface{}) bool {
 func (c *MongoDataSourceCollection) compileConditions(term interface{}) interface{} {
 	switch term.(type) {
 	case []interface{}:
-		{
-			values := []interface{}{}
-			itop := len(term.([]interface{}))
-			for i := 0; i < itop; i++ {
-				value := c.compileConditions(term.([]interface{})[i])
-				if value != nil {
-					values = append(values, value)
-				}
-			}
-			if len(values) > 0 {
-				return values
+		values := []interface{}{}
+		itop := len(term.([]interface{}))
+		for i := 0; i < itop; i++ {
+			value := c.compileConditions(term.([]interface{})[i])
+			if value != nil {
+				values = append(values, value)
 			}
 		}
+		if len(values) > 0 {
+			return values
+		}
 	case db.Or:
-		{
-			values := []interface{}{}
-			itop := len(term.(db.Or))
-			for i := 0; i < itop; i++ {
-				values = append(values, c.compileConditions(term.(db.Or)[i]))
-			}
-			condition := map[string]interface{}{"$or": values}
-			return condition
+		values := []interface{}{}
+		itop := len(term.(db.Or))
+		for i := 0; i < itop; i++ {
+			values = append(values, c.compileConditions(term.(db.Or)[i]))
 		}
+		condition := map[string]interface{}{"$or": values}
+		return condition
 	case db.And:
-		{
-			values := []interface{}{}
-			itop := len(term.(db.And))
-			for i := 0; i < itop; i++ {
-				values = append(values, c.compileConditions(term.(db.And)[i]))
-			}
-			condition := map[string]interface{}{"$and": values}
-			return condition
+		values := []interface{}{}
+		itop := len(term.(db.And))
+		for i := 0; i < itop; i++ {
+			values = append(values, c.compileConditions(term.(db.And)[i]))
 		}
+		condition := map[string]interface{}{"$and": values}
+		return condition
 	case db.Cond:
-		{
-			return c.marshal(term.(db.Cond))
-		}
+		return c.marshal(term.(db.Cond))
 	}
 	return nil
 }
@@ -197,17 +189,11 @@ func (c *MongoDataSourceCollection) Update(terms ...interface{}) bool {
 
 		switch term.(type) {
 		case db.Set:
-			{
-				set = term.(db.Set)
-			}
+			set = term.(db.Set)
 		case db.Upsert:
-			{
-				upsert = term.(db.Upsert)
-			}
+			upsert = term.(db.Upsert)
 		case db.Modify:
-			{
-				modify = term.(db.Modify)
-			}
+			modify = term.(db.Modify)
 		}
 	}
 
@@ -302,17 +288,11 @@ func (c *MongoDataSourceCollection) BuildQuery(terms ...interface{}) *mgo.Query
 
 		switch term.(type) {
 		case db.Limit:
-			{
-				limit = int(term.(db.Limit))
-			}
+			limit = int(term.(db.Limit))
 		case db.Offset:
-			{
-				offset = int(term.(db.Offset))
-			}
+			offset = int(term.(db.Offset))
 		case db.Sort:
-			{
-				sort = term.(db.Sort)
-			}
+			sort = term.(db.Sort)
 		}
 	}
 
@@ -354,13 +334,9 @@ func (c *MongoDataSourceCollection) FindAll(terms ...interface{}) []db.Item {
 
 		switch term.(type) {
 		case db.Relate:
-			{
-				relate = term.(db.Relate)
-			}
+			relate = term.(db.Relate)
 		case db.RelateAll:
-			{
-				relateAll = term.(db.RelateAll)
-			}
+			relateAll = term.(db.RelateAll)
 		}
 	}
 
@@ -383,9 +359,7 @@ func (c *MongoDataSourceCollection) FindAll(terms ...interface{}) []db.Item {
 				rterm := rterms[t]
 				switch rterm.(type) {
 				case db.Collection:
-					{
-						rcollection = rterm.(db.Collection)
-					}
+					rcollection = rterm.(db.Collection)
 				}
 			}
 
@@ -402,9 +376,7 @@ func (c *MongoDataSourceCollection) FindAll(terms ...interface{}) []db.Item {
 				rterm := rterms[t]
 				switch rterm.(type) {
 				case db.Collection:
-					{
-						rcollection = rterm.(db.Collection)
-					}
+					rcollection = rterm.(db.Collection)
 				}
 			}
 
@@ -445,17 +417,15 @@ func (c *MongoDataSourceCollection) FindAll(terms ...interface{}) []db.Item {
 				switch term.(type) {
 				// Just waiting for db.Cond statements.
 				case db.Cond:
-					{
-						for wkey, wval := range term.(db.Cond) {
-							//if reflect.TypeOf(wval).Kind() == reflect.String { // does not always work.
-							if reflect.TypeOf(wval).Name() == "string" {
-								// Matching dynamic values.
-								matched, _ := regexp.MatchString("\\{.+\\}", wval.(string))
-								if matched {
-									// Replacing dynamic values.
-									kname := strings.Trim(wval.(string), "{}")
-									term = db.Cond{wkey: item[kname]}
-								}
+					for wkey, wval := range term.(db.Cond) {
+						//if reflect.TypeOf(wval).Kind() == reflect.String { // does not always work.
+						if reflect.TypeOf(wval).Name() == "string" {
+							// Matching dynamic values.
+							matched, _ := regexp.MatchString("\\{.+\\}", wval.(string))
+							if matched {
+								// Replacing dynamic values.
+								kname := strings.Trim(wval.(string), "{}")
+								term = db.Cond{wkey: item[kname]}
 							}
 						}
 					}
diff --git a/db/mysql/mysql.go b/db/mysql/mysql.go
index ee3ea3fe16d8205bc82186cf65fa6f08d808ae91..869a4f66e1201a1eac3d2cebf39f54f5ab2b3bcf 100644
--- a/db/mysql/mysql.go
+++ b/db/mysql/mysql.go
@@ -48,24 +48,18 @@ func myCompile(terms []interface{}) *myQuery {
 	for _, term := range terms {
 		switch term.(type) {
 		case string:
-			{
-				q.Query = append(q.Query, term.(string))
-			}
+			q.Query = append(q.Query, term.(string))
 		case db.SqlArgs:
-			{
-				for _, arg := range term.(db.SqlArgs) {
-					q.SqlArgs = append(q.SqlArgs, arg)
-				}
+			for _, arg := range term.(db.SqlArgs) {
+				q.SqlArgs = append(q.SqlArgs, arg)
 			}
 		case db.SqlValues:
-			{
-				args := make([]string, len(term.(db.SqlValues)))
-				for i, arg := range term.(db.SqlValues) {
-					args[i] = "?"
-					q.SqlArgs = append(q.SqlArgs, arg)
-				}
-				q.Query = append(q.Query, "("+strings.Join(args, ", ")+")")
+			args := make([]string, len(term.(db.SqlValues)))
+			for i, arg := range term.(db.SqlValues) {
+				args[i] = "?"
+				q.SqlArgs = append(q.SqlArgs, arg)
 			}
+			q.Query = append(q.Query, "("+strings.Join(args, ", ")+")")
 		}
 	}
 
@@ -132,24 +126,16 @@ func (t *MysqlTable) myFetchAll(rows sql.Rows) []db.Item {
 
 			switch t.types[name] {
 			case reflect.Uint64:
-				{
-					intval, _ := strconv.Atoi(strval)
-					item[name] = uint64(intval)
-				}
+				intval, _ := strconv.Atoi(strval)
+				item[name] = uint64(intval)
 			case reflect.Int64:
-				{
-					intval, _ := strconv.Atoi(strval)
-					item[name] = intval
-				}
+				intval, _ := strconv.Atoi(strval)
+				item[name] = intval
 			case reflect.Float64:
-				{
-					floatval, _ := strconv.ParseFloat(strval, 10)
-					item[name] = floatval
-				}
+				floatval, _ := strconv.ParseFloat(strval, 10)
+				item[name] = floatval
 			default:
-				{
-					item[name] = strval
-				}
+				item[name] = strval
 			}
 		}
 
@@ -309,67 +295,55 @@ func (t *MysqlTable) compileConditions(term interface{}) (string, db.SqlArgs) {
 
 	switch term.(type) {
 	case []interface{}:
-		{
-
-			itop := len(term.([]interface{}))
-
-			for i := 0; i < itop; i++ {
-				rsql, rargs := t.compileConditions(term.([]interface{})[i])
-				if rsql != "" {
-					sql = append(sql, rsql)
-					for j := 0; j < len(rargs); j++ {
-						args = append(args, rargs[j])
-					}
+		itop := len(term.([]interface{}))
+
+		for i := 0; i < itop; i++ {
+			rsql, rargs := t.compileConditions(term.([]interface{})[i])
+			if rsql != "" {
+				sql = append(sql, rsql)
+				for j := 0; j < len(rargs); j++ {
+					args = append(args, rargs[j])
 				}
 			}
+		}
 
-			if len(sql) > 0 {
-				return "(" + strings.Join(sql, " AND ") + ")", args
-			}
+		if len(sql) > 0 {
+			return "(" + strings.Join(sql, " AND ") + ")", args
 		}
 	case db.Or:
-		{
-
-			itop := len(term.(db.Or))
-
-			for i := 0; i < itop; i++ {
-				rsql, rargs := t.compileConditions(term.(db.Or)[i])
-				if rsql != "" {
-					sql = append(sql, rsql)
-					for j := 0; j < len(rargs); j++ {
-						args = append(args, rargs[j])
-					}
+		itop := len(term.(db.Or))
+
+		for i := 0; i < itop; i++ {
+			rsql, rargs := t.compileConditions(term.(db.Or)[i])
+			if rsql != "" {
+				sql = append(sql, rsql)
+				for j := 0; j < len(rargs); j++ {
+					args = append(args, rargs[j])
 				}
 			}
+		}
 
-			if len(sql) > 0 {
-				return "(" + strings.Join(sql, " OR ") + ")", args
-			}
+		if len(sql) > 0 {
+			return "(" + strings.Join(sql, " OR ") + ")", args
 		}
 	case db.And:
-		{
-
-			itop := len(term.(db.Or))
-
-			for i := 0; i < itop; i++ {
-				rsql, rargs := t.compileConditions(term.(db.Or)[i])
-				if rsql != "" {
-					sql = append(sql, rsql)
-					for j := 0; j < len(rargs); j++ {
-						args = append(args, rargs[j])
-					}
+		itop := len(term.(db.Or))
+
+		for i := 0; i < itop; i++ {
+			rsql, rargs := t.compileConditions(term.(db.Or)[i])
+			if rsql != "" {
+				sql = append(sql, rsql)
+				for j := 0; j < len(rargs); j++ {
+					args = append(args, rargs[j])
 				}
 			}
-
-			if len(sql) > 0 {
-				return "(" + strings.Join(sql, " AND ") + ")", args
-			}
 		}
-	case db.Cond:
-		{
-			return t.marshal(term.(db.Cond))
 
+		if len(sql) > 0 {
+			return "(" + strings.Join(sql, " AND ") + ")", args
 		}
+	case db.Cond:
+		return t.marshal(term.(db.Cond))
 	}
 
 	return "", args
@@ -473,25 +447,15 @@ func (t *MysqlTable) FindAll(terms ...interface{}) []db.Item {
 
 		switch term.(type) {
 		case db.Limit:
-			{
-				limit = fmt.Sprintf("LIMIT %v", term.(db.Limit))
-			}
+			limit = fmt.Sprintf("LIMIT %v", term.(db.Limit))
 		case db.Offset:
-			{
-				offset = fmt.Sprintf("OFFSET %v", term.(db.Offset))
-			}
+			offset = fmt.Sprintf("OFFSET %v", term.(db.Offset))
 		case db.Fields:
-			{
-				fields = strings.Join(term.(db.Fields), ", ")
-			}
+			fields = strings.Join(term.(db.Fields), ", ")
 		case db.Relate:
-			{
-				relate = term.(db.Relate)
-			}
+			relate = term.(db.Relate)
 		case db.RelateAll:
-			{
-				relateAll = term.(db.RelateAll)
-			}
+			relateAll = term.(db.RelateAll)
 		}
 	}
 
@@ -742,17 +706,14 @@ func (my *MysqlDataSource) Collection(name string) db.Collection {
 		// Guessing datatypes.
 		switch dtype {
 		case "tinyint", "smallint", "mediumint", "int", "bigint":
-			{
-				if dextra == "unsigned" {
-					vtype = reflect.Uint64
-				} else {
-					vtype = reflect.Int64
-				}
+			if dextra == "unsigned" {
+				vtype = reflect.Uint64
+			} else {
+				vtype = reflect.Int64
 			}
 		case "decimal", "float", "double":
-			{
-				vtype = reflect.Float64
-			}
+			vtype = reflect.Float64
+
 		}
 
 		/*
diff --git a/db/postgresql/postgresql.go b/db/postgresql/postgresql.go
index 3bc0f5afe81b0e8fe767195a61e22dbd220b1dab..ca8572a5ee8b8ab8f82da5983130fbb2de73cc6c 100644
--- a/db/postgresql/postgresql.go
+++ b/db/postgresql/postgresql.go
@@ -48,24 +48,18 @@ func pgCompile(terms []interface{}) *pgQuery {
 	for _, term := range terms {
 		switch term.(type) {
 		case string:
-			{
-				q.Query = append(q.Query, term.(string))
-			}
+			q.Query = append(q.Query, term.(string))
 		case db.SqlArgs:
-			{
-				for _, arg := range term.(db.SqlArgs) {
-					q.SqlArgs = append(q.SqlArgs, arg)
-				}
+			for _, arg := range term.(db.SqlArgs) {
+				q.SqlArgs = append(q.SqlArgs, arg)
 			}
 		case db.SqlValues:
-			{
-				args := make([]string, len(term.(db.SqlValues)))
-				for i, arg := range term.(db.SqlValues) {
-					args[i] = "?"
-					q.SqlArgs = append(q.SqlArgs, arg)
-				}
-				q.Query = append(q.Query, "("+strings.Join(args, ", ")+")")
+			args := make([]string, len(term.(db.SqlValues)))
+			for i, arg := range term.(db.SqlValues) {
+				args[i] = "?"
+				q.SqlArgs = append(q.SqlArgs, arg)
 			}
+			q.Query = append(q.Query, "("+strings.Join(args, ", ")+")")
 		}
 	}
 
@@ -131,24 +125,16 @@ func (t *PostgresqlTable) pgFetchAll(rows sql.Rows) []db.Item {
 
 			switch t.types[name] {
 			case reflect.Uint64:
-				{
-					intval, _ := strconv.Atoi(strval)
-					item[name] = uint64(intval)
-				}
+				intval, _ := strconv.Atoi(strval)
+				item[name] = uint64(intval)
 			case reflect.Int64:
-				{
-					intval, _ := strconv.Atoi(strval)
-					item[name] = intval
-				}
+				intval, _ := strconv.Atoi(strval)
+				item[name] = intval
 			case reflect.Float64:
-				{
-					floatval, _ := strconv.ParseFloat(strval, 10)
-					item[name] = floatval
-				}
+				floatval, _ := strconv.ParseFloat(strval, 10)
+				item[name] = floatval
 			default:
-				{
-					item[name] = strval
-				}
+				item[name] = strval
 			}
 		}
 
@@ -304,67 +290,55 @@ func (t *PostgresqlTable) compileConditions(term interface{}) (string, db.SqlArg
 
 	switch term.(type) {
 	case []interface{}:
-		{
-
-			itop := len(term.([]interface{}))
-
-			for i := 0; i < itop; i++ {
-				rsql, rargs := t.compileConditions(term.([]interface{})[i])
-				if rsql != "" {
-					sql = append(sql, rsql)
-					for j := 0; j < len(rargs); j++ {
-						args = append(args, rargs[j])
-					}
+		itop := len(term.([]interface{}))
+
+		for i := 0; i < itop; i++ {
+			rsql, rargs := t.compileConditions(term.([]interface{})[i])
+			if rsql != "" {
+				sql = append(sql, rsql)
+				for j := 0; j < len(rargs); j++ {
+					args = append(args, rargs[j])
 				}
 			}
+		}
 
-			if len(sql) > 0 {
-				return "(" + strings.Join(sql, " AND ") + ")", args
-			}
+		if len(sql) > 0 {
+			return "(" + strings.Join(sql, " AND ") + ")", args
 		}
 	case db.Or:
-		{
-
-			itop := len(term.(db.Or))
-
-			for i := 0; i < itop; i++ {
-				rsql, rargs := t.compileConditions(term.(db.Or)[i])
-				if rsql != "" {
-					sql = append(sql, rsql)
-					for j := 0; j < len(rargs); j++ {
-						args = append(args, rargs[j])
-					}
+		itop := len(term.(db.Or))
+
+		for i := 0; i < itop; i++ {
+			rsql, rargs := t.compileConditions(term.(db.Or)[i])
+			if rsql != "" {
+				sql = append(sql, rsql)
+				for j := 0; j < len(rargs); j++ {
+					args = append(args, rargs[j])
 				}
 			}
+		}
 
-			if len(sql) > 0 {
-				return "(" + strings.Join(sql, " OR ") + ")", args
-			}
+		if len(sql) > 0 {
+			return "(" + strings.Join(sql, " OR ") + ")", args
 		}
 	case db.And:
-		{
-
-			itop := len(term.(db.Or))
-
-			for i := 0; i < itop; i++ {
-				rsql, rargs := t.compileConditions(term.(db.Or)[i])
-				if rsql != "" {
-					sql = append(sql, rsql)
-					for j := 0; j < len(rargs); j++ {
-						args = append(args, rargs[j])
-					}
+		itop := len(term.(db.Or))
+
+		for i := 0; i < itop; i++ {
+			rsql, rargs := t.compileConditions(term.(db.Or)[i])
+			if rsql != "" {
+				sql = append(sql, rsql)
+				for j := 0; j < len(rargs); j++ {
+					args = append(args, rargs[j])
 				}
 			}
-
-			if len(sql) > 0 {
-				return "(" + strings.Join(sql, " AND ") + ")", args
-			}
 		}
-	case db.Cond:
-		{
-			return t.marshal(term.(db.Cond))
 
+		if len(sql) > 0 {
+			return "(" + strings.Join(sql, " AND ") + ")", args
 		}
+	case db.Cond:
+		return t.marshal(term.(db.Cond))
 	}
 
 	return "", args
@@ -428,9 +402,7 @@ func (t *PostgresqlTable) Update(terms ...interface{}) bool {
 	for _, term := range terms {
 		switch term.(type) {
 		case db.Set:
-			{
-				fields, fargs = t.compileSet(term.(db.Set))
-			}
+			fields, fargs = t.compileSet(term.(db.Set))
 		}
 	}
 
@@ -467,25 +439,15 @@ func (t *PostgresqlTable) FindAll(terms ...interface{}) []db.Item {
 
 		switch term.(type) {
 		case db.Limit:
-			{
-				limit = fmt.Sprintf("LIMIT %v", term.(db.Limit))
-			}
+			limit = fmt.Sprintf("LIMIT %v", term.(db.Limit))
 		case db.Offset:
-			{
-				offset = fmt.Sprintf("OFFSET %v", term.(db.Offset))
-			}
+			offset = fmt.Sprintf("OFFSET %v", term.(db.Offset))
 		case db.Fields:
-			{
-				fields = strings.Join(term.(db.Fields), ", ")
-			}
+			fields = strings.Join(term.(db.Fields), ", ")
 		case db.Relate:
-			{
-				relate = term.(db.Relate)
-			}
+			relate = term.(db.Relate)
 		case db.RelateAll:
-			{
-				relateAll = term.(db.RelateAll)
-			}
+			relateAll = term.(db.RelateAll)
 		}
 	}
 
@@ -518,9 +480,7 @@ func (t *PostgresqlTable) FindAll(terms ...interface{}) []db.Item {
 				rterm := rterms[t]
 				switch rterm.(type) {
 				case db.Collection:
-					{
-						rcollection = rterm.(db.Collection)
-					}
+					rcollection = rterm.(db.Collection)
 				}
 			}
 
@@ -541,9 +501,7 @@ func (t *PostgresqlTable) FindAll(terms ...interface{}) []db.Item {
 				rterm := rterms[t]
 				switch rterm.(type) {
 				case db.Collection:
-					{
-						rcollection = rterm.(db.Collection)
-					}
+					rcollection = rterm.(db.Collection)
 				}
 			}
 
@@ -588,17 +546,15 @@ func (t *PostgresqlTable) FindAll(terms ...interface{}) []db.Item {
 				switch term.(type) {
 				// Just waiting for db.Cond statements.
 				case db.Cond:
-					{
-						for wkey, wval := range term.(db.Cond) {
-							//if reflect.TypeOf(wval).Kind() == reflect.String { // does not always work.
-							if reflect.TypeOf(wval).Name() == "string" {
-								// Matching dynamic values.
-								matched, _ := regexp.MatchString("\\{.+\\}", wval.(string))
-								if matched {
-									// Replacing dynamic values.
-									kname := strings.Trim(wval.(string), "{}")
-									term = db.Cond{wkey: item[kname]}
-								}
+					for wkey, wval := range term.(db.Cond) {
+						//if reflect.TypeOf(wval).Kind() == reflect.String { // does not always work.
+						if reflect.TypeOf(wval).Name() == "string" {
+							// Matching dynamic values.
+							matched, _ := regexp.MatchString("\\{.+\\}", wval.(string))
+							if matched {
+								// Replacing dynamic values.
+								kname := strings.Trim(wval.(string), "{}")
+								term = db.Cond{wkey: item[kname]}
 							}
 						}
 					}
@@ -737,17 +693,13 @@ func (pg *PostgresqlDataSource) Collection(name string) db.Collection {
 		// Guessing datatypes.
 		switch dtype {
 		case "smallint", "integer", "bigint", "serial", "bigserial":
-			{
-				if dextra == "unsigned" {
-					vtype = reflect.Uint64
-				} else {
-					vtype = reflect.Int64
-				}
+			if dextra == "unsigned" {
+				vtype = reflect.Uint64
+			} else {
+				vtype = reflect.Int64
 			}
 		case "real", "double":
-			{
-				vtype = reflect.Float64
-			}
+			vtype = reflect.Float64
 		}
 
 		//fmt.Printf("Imported %v (from %v)\n", vtype, dtype)
diff --git a/db/sqlite/sqlite.go b/db/sqlite/sqlite.go
index da457b97c8f08fd33fc860b3a3657c17e4b5c5ef..abcbb96e39e0ba52db814df28d45a8c3a19f3f8e 100644
--- a/db/sqlite/sqlite.go
+++ b/db/sqlite/sqlite.go
@@ -48,24 +48,18 @@ func slCompile(terms []interface{}) *slQuery {
 	for _, term := range terms {
 		switch term.(type) {
 		case string:
-			{
-				q.Query = append(q.Query, term.(string))
-			}
+			q.Query = append(q.Query, term.(string))
 		case db.SqlArgs:
-			{
-				for _, arg := range term.(db.SqlArgs) {
-					q.SqlArgs = append(q.SqlArgs, arg)
-				}
+			for _, arg := range term.(db.SqlArgs) {
+				q.SqlArgs = append(q.SqlArgs, arg)
 			}
 		case db.SqlValues:
-			{
-				args := make([]string, len(term.(db.SqlValues)))
-				for i, arg := range term.(db.SqlValues) {
-					args[i] = "?"
-					q.SqlArgs = append(q.SqlArgs, arg)
-				}
-				q.Query = append(q.Query, "("+strings.Join(args, ", ")+")")
+			args := make([]string, len(term.(db.SqlValues)))
+			for i, arg := range term.(db.SqlValues) {
+				args[i] = "?"
+				q.SqlArgs = append(q.SqlArgs, arg)
 			}
+			q.Query = append(q.Query, "("+strings.Join(args, ", ")+")")
 		}
 	}
 
@@ -131,24 +125,16 @@ func (t *SqliteTable) slFetchAll(rows sql.Rows) []db.Item {
 
 			switch t.types[name] {
 			case reflect.Uint64:
-				{
-					intval, _ := strconv.Atoi(strval)
-					item[name] = uint64(intval)
-				}
+				intval, _ := strconv.Atoi(strval)
+				item[name] = uint64(intval)
 			case reflect.Int64:
-				{
-					intval, _ := strconv.Atoi(strval)
-					item[name] = intval
-				}
+				intval, _ := strconv.Atoi(strval)
+				item[name] = intval
 			case reflect.Float64:
-				{
-					floatval, _ := strconv.ParseFloat(strval, 10)
-					item[name] = floatval
-				}
+				floatval, _ := strconv.ParseFloat(strval, 10)
+				item[name] = floatval
 			default:
-				{
-					item[name] = strval
-				}
+				item[name] = strval
 			}
 		}
 
@@ -188,9 +174,7 @@ func (sl *SqliteDataSource) slExec(method string, terms ...interface{}) sql.Rows
 
 	switch res[0].Elem().Interface().(type) {
 	case sql.Rows:
-		{
-			rows = res[0].Elem().Interface().(sql.Rows)
-		}
+		rows = res[0].Elem().Interface().(sql.Rows)
 	}
 
 	return rows
@@ -309,67 +293,54 @@ func (t *SqliteTable) compileConditions(term interface{}) (string, db.SqlArgs) {
 
 	switch term.(type) {
 	case []interface{}:
-		{
-
-			itop := len(term.([]interface{}))
-
-			for i := 0; i < itop; i++ {
-				rsql, rargs := t.compileConditions(term.([]interface{})[i])
-				if rsql != "" {
-					sql = append(sql, rsql)
-					for j := 0; j < len(rargs); j++ {
-						args = append(args, rargs[j])
-					}
+		itop := len(term.([]interface{}))
+
+		for i := 0; i < itop; i++ {
+			rsql, rargs := t.compileConditions(term.([]interface{})[i])
+			if rsql != "" {
+				sql = append(sql, rsql)
+				for j := 0; j < len(rargs); j++ {
+					args = append(args, rargs[j])
 				}
 			}
-
-			if len(sql) > 0 {
-				return "(" + strings.Join(sql, " AND ") + ")", args
-			}
+		}
+		if len(sql) > 0 {
+			return "(" + strings.Join(sql, " AND ") + ")", args
 		}
 	case db.Or:
-		{
-
-			itop := len(term.(db.Or))
-
-			for i := 0; i < itop; i++ {
-				rsql, rargs := t.compileConditions(term.(db.Or)[i])
-				if rsql != "" {
-					sql = append(sql, rsql)
-					for j := 0; j < len(rargs); j++ {
-						args = append(args, rargs[j])
-					}
+		itop := len(term.(db.Or))
+
+		for i := 0; i < itop; i++ {
+			rsql, rargs := t.compileConditions(term.(db.Or)[i])
+			if rsql != "" {
+				sql = append(sql, rsql)
+				for j := 0; j < len(rargs); j++ {
+					args = append(args, rargs[j])
 				}
 			}
+		}
 
-			if len(sql) > 0 {
-				return "(" + strings.Join(sql, " OR ") + ")", args
-			}
+		if len(sql) > 0 {
+			return "(" + strings.Join(sql, " OR ") + ")", args
 		}
 	case db.And:
-		{
-
-			itop := len(term.(db.Or))
-
-			for i := 0; i < itop; i++ {
-				rsql, rargs := t.compileConditions(term.(db.Or)[i])
-				if rsql != "" {
-					sql = append(sql, rsql)
-					for j := 0; j < len(rargs); j++ {
-						args = append(args, rargs[j])
-					}
+		itop := len(term.(db.Or))
+
+		for i := 0; i < itop; i++ {
+			rsql, rargs := t.compileConditions(term.(db.Or)[i])
+			if rsql != "" {
+				sql = append(sql, rsql)
+				for j := 0; j < len(rargs); j++ {
+					args = append(args, rargs[j])
 				}
 			}
-
-			if len(sql) > 0 {
-				return "(" + strings.Join(sql, " AND ") + ")", args
-			}
 		}
-	case db.Cond:
-		{
-			return t.marshal(term.(db.Cond))
 
+		if len(sql) > 0 {
+			return "(" + strings.Join(sql, " AND ") + ")", args
 		}
+	case db.Cond:
+		return t.marshal(term.(db.Cond))
 	}
 
 	return "", args
@@ -433,9 +404,7 @@ func (t *SqliteTable) Update(terms ...interface{}) bool {
 	for _, term := range terms {
 		switch term.(type) {
 		case db.Set:
-			{
-				fields, fargs = t.compileSet(term.(db.Set))
-			}
+			fields, fargs = t.compileSet(term.(db.Set))
 		}
 	}
 
@@ -472,25 +441,15 @@ func (t *SqliteTable) FindAll(terms ...interface{}) []db.Item {
 
 		switch term.(type) {
 		case db.Limit:
-			{
-				limit = fmt.Sprintf("LIMIT %v", term.(db.Limit))
-			}
+			limit = fmt.Sprintf("LIMIT %v", term.(db.Limit))
 		case db.Offset:
-			{
-				offset = fmt.Sprintf("OFFSET %v", term.(db.Offset))
-			}
+			offset = fmt.Sprintf("OFFSET %v", term.(db.Offset))
 		case db.Fields:
-			{
-				fields = strings.Join(term.(db.Fields), ", ")
-			}
+			fields = strings.Join(term.(db.Fields), ", ")
 		case db.Relate:
-			{
-				relate = term.(db.Relate)
-			}
+			relate = term.(db.Relate)
 		case db.RelateAll:
-			{
-				relateAll = term.(db.RelateAll)
-			}
+			relateAll = term.(db.RelateAll)
 		}
 	}
 
@@ -523,9 +482,7 @@ func (t *SqliteTable) FindAll(terms ...interface{}) []db.Item {
 				rterm := rterms[t]
 				switch rterm.(type) {
 				case db.Collection:
-					{
-						rcollection = rterm.(db.Collection)
-					}
+					rcollection = rterm.(db.Collection)
 				}
 			}
 
@@ -546,9 +503,7 @@ func (t *SqliteTable) FindAll(terms ...interface{}) []db.Item {
 				rterm := rterms[t]
 				switch rterm.(type) {
 				case db.Collection:
-					{
-						rcollection = rterm.(db.Collection)
-					}
+					rcollection = rterm.(db.Collection)
 				}
 			}
 
@@ -593,17 +548,15 @@ func (t *SqliteTable) FindAll(terms ...interface{}) []db.Item {
 				switch term.(type) {
 				// Just waiting for db.Cond statements.
 				case db.Cond:
-					{
-						for wkey, wval := range term.(db.Cond) {
-							//if reflect.TypeOf(wval).Kind() == reflect.String { // does not always work.
-							if reflect.TypeOf(wval).Name() == "string" {
-								// Matching dynamic values.
-								matched, _ := regexp.MatchString("\\{.+\\}", wval.(string))
-								if matched {
-									// Replacing dynamic values.
-									kname := strings.Trim(wval.(string), "{}")
-									term = db.Cond{wkey: item[kname]}
-								}
+					for wkey, wval := range term.(db.Cond) {
+						//if reflect.TypeOf(wval).Kind() == reflect.String { // does not always work.
+						if reflect.TypeOf(wval).Name() == "string" {
+							// Matching dynamic values.
+							matched, _ := regexp.MatchString("\\{.+\\}", wval.(string))
+							if matched {
+								// Replacing dynamic values.
+								kname := strings.Trim(wval.(string), "{}")
+								term = db.Cond{wkey: item[kname]}
 							}
 						}
 					}
@@ -745,21 +698,15 @@ func (sl *SqliteDataSource) Collection(name string) db.Collection {
 		// Guessing datatypes.
 		switch dtype {
 		case "integer":
-			{
-				if dextra == "unsigned" {
-					vtype = reflect.Uint64
-				} else {
-					vtype = reflect.Int64
-				}
+			if dextra == "unsigned" {
+				vtype = reflect.Uint64
+			} else {
+				vtype = reflect.Int64
 			}
 		case "real", "numeric":
-			{
-				vtype = reflect.Float64
-			}
+			vtype = reflect.Float64
 		default:
-			{
-				vtype = reflect.String
-			}
+			vtype = reflect.String
 		}
 
 		/*