diff --git a/engine.go b/engine.go
index 60fc9d74..9eca5b97 100644
--- a/engine.go
+++ b/engine.go
@@ -98,63 +98,58 @@ func (engine *Engine) Test() error {
 
 func (engine *Engine) Sql(querystring string, args ...interface{}) *Session {
 	session := engine.NewSession()
-	session.Sql(querystring, args...)
-	return session
+	return session.Sql(querystring, args...)
+}
+
+func (engine *Engine) Cascade(trueOrFalse ...bool) *Session {
+	session := engine.NewSession()
+	return session.Cascade(trueOrFalse...)
 }
 
 func (engine *Engine) Where(querystring string, args ...interface{}) *Session {
 	session := engine.NewSession()
-	session.Where(querystring, args...)
-	return session
+	return session.Where(querystring, args...)
 }
 
 func (engine *Engine) Id(id int64) *Session {
 	session := engine.NewSession()
-	session.Id(id)
-	return session
+	return session.Id(id)
 }
 
 func (engine *Engine) In(column string, args ...interface{}) *Session {
 	session := engine.NewSession()
-	session.In(column, args...)
-	return session
+	return session.In(column, args...)
 }
 
 func (engine *Engine) Table(tableName string) *Session {
 	session := engine.NewSession()
-	session.Table(tableName)
-	return session
+	return session.Table(tableName)
 }
 
 func (engine *Engine) Limit(limit int, start ...int) *Session {
 	session := engine.NewSession()
-	session.Limit(limit, start...)
-	return session
+	return session.Limit(limit, start...)
 }
 
 func (engine *Engine) OrderBy(order string) *Session {
 	session := engine.NewSession()
-	session.OrderBy(order)
-	return session
+	return session.OrderBy(order)
 }
 
 //The join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN
 func (engine *Engine) Join(join_operator, tablename, condition string) *Session {
 	session := engine.NewSession()
-	session.Join(join_operator, tablename, condition)
-	return session
+	return session.Join(join_operator, tablename, condition)
 }
 
 func (engine *Engine) GroupBy(keys string) *Session {
 	session := engine.NewSession()
-	session.GroupBy(keys)
-	return session
+	return session.GroupBy(keys)
 }
 
 func (engine *Engine) Having(conditions string) *Session {
 	session := engine.NewSession()
-	session.Having(conditions)
-	return session
+	return session.Having(conditions)
 }
 
 // some lock needed
diff --git a/session.go b/session.go
index fa95d50b..1b6d93d8 100644
--- a/session.go
+++ b/session.go
@@ -487,6 +487,7 @@ func (session *Session) Query(sql string, paramStr ...interface{}) (resultsSlice
 		defer session.Close()
 	}
 
+	// TODO: this statement should be invoke before Query
 	if session.Statement.RefTable != nil && session.Statement.RefTable.PrimaryKey != "" {
 		sql = strings.Replace(sql, "(id)", session.Statement.RefTable.PrimaryKey, -1)
 	}
@@ -552,6 +553,8 @@ func (session *Session) Query(sql string, paramStr ...interface{}) (resultsSlice
 				if aa.String() == "time.Time" {
 					str = rawValue.Interface().(time.Time).Format("2006-01-02 15:04:05.000 -0700")
 					result[key] = []byte(str)
+				} else {
+					fmt.Print("Unsupported struct type")
 				}
 			}
 			//default:
@@ -729,24 +732,32 @@ func (session *Session) InsertOne(bean interface{}) (int64, error) {
 		if col.MapType == ONLYFROMDB {
 			continue
 		}
-		if fieldTable, ok := session.Engine.Tables[fieldValue.Type()]; ok {
-			if fieldTable.PrimaryKey != "" {
-				pkField := reflect.Indirect(fieldValue).FieldByName(fieldTable.PKColumn().FieldName)
-				args = append(args, pkField.Interface())
-			} else {
-				continue
-			}
-		} else if fieldValue.Type().Kind() == reflect.Struct &&
-			fieldValue.CanAddr() {
-			if fieldConvert, ok := fieldValue.Addr().Interface().(Conversion); ok {
-				data, err := fieldConvert.ToDB()
-				if err != nil {
-					return 0, err
+		if fieldValue.Type().String() == "time.Time" {
+			args = append(args, val)
+		} else if fieldValue.Type().Kind() == reflect.Struct {
+			if fieldValue.CanAddr() {
+				if fieldConvert, ok := fieldValue.Addr().Interface().(Conversion); ok {
+					data, err := fieldConvert.ToDB()
+					if err != nil {
+						return 0, err
+					} else {
+						args = append(args, string(data))
+					}
 				} else {
-					args = append(args, string(data))
+					if fieldTable, ok := session.Engine.Tables[fieldValue.Type()]; ok {
+						if fieldTable.PrimaryKey != "" {
+							pkField := reflect.Indirect(fieldValue).FieldByName(fieldTable.PKColumn().FieldName)
+							args = append(args, pkField.Interface())
+						} else {
+							continue
+						}
+					} else {
+						//args = append(args, val)
+						continue
+					}
 				}
 			} else {
-				args = append(args, val)
+				continue
 			}
 		} else {
 			args = append(args, val)
diff --git a/statement.go b/statement.go
index 0ecc6cab..4edbcc38 100644
--- a/statement.go
+++ b/statement.go
@@ -96,13 +96,15 @@ func BuildConditions(engine *Engine, table *Table, bean interface{}) ([]string,
 				if t.IsZero() {
 					continue
 				}
+			} else {
+				engine.AutoMapType(fieldValue.Type())
 			}
 		default:
 			continue
 		}
+
 		if table, ok := engine.Tables[fieldValue.Type()]; ok {
 			pkField := reflect.Indirect(fieldValue).FieldByName(table.PKColumn().FieldName)
-			fmt.Println(pkField.Interface())
 			if pkField.Int() != 0 {
 				args = append(args, pkField.Interface())
 			} else {