orm support complete m2m operation api / auto load related api

orm/orm.go

@@ -18,7 +18,7 @@ var (
 	Debug            = false
 	DebugLog         = NewLog(os.Stderr)
 	DefaultRowsLimit = 1000
-	DefaultRelsDepth = 5
+	DefaultRelsDepth = 2
 	DefaultTimeLoc   = time.Local
 	ErrTxHasBegan    = errors.New("<Ormer.Begin> transaction already begin")
 	ErrTxDone        = errors.New("<Ormer.Commit/Rollback> transaction not begin")
@@ -53,6 +53,14 @@ func (o *orm) getMiInd(md interface{}) (mi *modelInfo, ind reflect.Value) {
 	panic(fmt.Errorf("<Ormer> table: `%s` not found, maybe not RegisterModel", name))
 }
 
+func (o *orm) getFieldInfo(mi *modelInfo, name string) *fieldInfo {
+	fi, ok := mi.fields.GetByAny(name)
+	if !ok {
+		panic(fmt.Errorf("<Ormer> cannot find field `%s` for model `%s`", name, mi.fullName))
+	}
+	return fi
+}
+
 func (o *orm) Read(md interface{}, cols ...string) error {
 	mi, ind := o.getMiInd(md)
 	err := o.alias.DbBaser.Read(o.db, mi, ind, o.alias.TZ, cols)
@@ -107,22 +115,152 @@ func (o *orm) Delete(md interface{}) (int64, error) {
 	return num, nil
 }
 
-func (o *orm) M2mAdd(md interface{}, name string, mds ...interface{}) (int64, error) {
-	// TODO
-	panic(ErrNotImplement)
-	return 0, nil
+func (o *orm) QueryM2M(md interface{}, name string) QueryM2Mer {
+	mi, ind := o.getMiInd(md)
+	fi := o.getFieldInfo(mi, name)
+
+	if fi.fieldType != RelManyToMany {
+		panic(fmt.Errorf("<Ormer.QueryM2M> name `%s` for model `%s` is not a m2m field", fi.name, mi.fullName))
+	}
+
+	return newQueryM2M(md, o, mi, fi, ind)
 }
 
-func (o *orm) M2mDel(md interface{}, name string, mds ...interface{}) (int64, error) {
-	// TODO
-	panic(ErrNotImplement)
-	return 0, nil
+func (o *orm) LoadRelated(md interface{}, name string, args ...interface{}) (int64, error) {
+	_, fi, ind, qseter := o.queryRelated(md, name)
+
+	qs := qseter.(*querySet)
+
+	var relDepth int
+	var limit, offset int64
+	var order string
+	for i, arg := range args {
+		switch i {
+		case 0:
+			if v, ok := arg.(bool); ok {
+				if v {
+					relDepth = DefaultRelsDepth
+				}
+			} else if v, ok := arg.(int); ok {
+				relDepth = v
+			}
+		case 1:
+			limit = ToInt64(arg)
+		case 2:
+			offset = ToInt64(arg)
+		case 3:
+			order, _ = arg.(string)
+		}
+	}
+
+	switch fi.fieldType {
+	case RelOneToOne, RelForeignKey, RelReverseOne:
+		limit = 1
+		offset = 0
+	}
+
+	qs.limit = limit
+	qs.offset = offset
+	qs.relDepth = relDepth
+
+	if len(order) > 0 {
+		qs.orders = []string{order}
+	}
+
+	find := ind.Field(fi.fieldIndex)
+
+	var nums int64
+	var err error
+	switch fi.fieldType {
+	case RelOneToOne, RelForeignKey, RelReverseOne:
+		val := reflect.New(find.Type().Elem())
+		container := val.Interface()
+		err = qs.One(container)
+		if err == nil {
+			find.Set(val)
+			nums = 1
+		}
+	default:
+		nums, err = qs.All(find.Addr().Interface())
+	}
+
+	return nums, err
 }
 
-func (o *orm) LoadRel(md interface{}, name string) (int64, error) {
-	// TODO
-	panic(ErrNotImplement)
-	return 0, nil
+func (o *orm) QueryRelated(md interface{}, name string) QuerySeter {
+	// is this api needed ?
+	_, _, _, qs := o.queryRelated(md, name)
+	return qs
+}
+
+func (o *orm) queryRelated(md interface{}, name string) (*modelInfo, *fieldInfo, reflect.Value, QuerySeter) {
+	mi, ind := o.getMiInd(md)
+	fi := o.getFieldInfo(mi, name)
+
+	_, _, exist := getExistPk(mi, ind)
+	if exist == false {
+		panic(ErrMissPK)
+	}
+
+	var qs *querySet
+
+	switch fi.fieldType {
+	case RelOneToOne, RelForeignKey, RelManyToMany:
+		if !fi.inModel {
+			break
+		}
+		qs = o.getRelQs(md, mi, fi)
+	case RelReverseOne, RelReverseMany:
+		if !fi.inModel {
+			break
+		}
+		qs = o.getReverseQs(md, mi, fi)
+	}
+
+	if qs == nil {
+		panic(fmt.Errorf("<Ormer> name `%s` for model `%s` is not an available rel/reverse field"))
+	}
+
+	return mi, fi, ind, qs
+}
+
+func (o *orm) getReverseQs(md interface{}, mi *modelInfo, fi *fieldInfo) *querySet {
+	switch fi.fieldType {
+	case RelReverseOne, RelReverseMany:
+	default:
+		panic(fmt.Errorf("<Ormer> name `%s` for model `%s` is not an available reverse field", fi.name, mi.fullName))
+	}
+
+	var q *querySet
+
+	if fi.fieldType == RelReverseMany && fi.reverseFieldInfo.mi.isThrough {
+		q = newQuerySet(o, fi.relModelInfo).(*querySet)
+		q.cond = NewCondition().And(fi.reverseFieldInfoM2M.column+ExprSep+fi.reverseFieldInfo.column, md)
+	} else {
+		q = newQuerySet(o, fi.reverseFieldInfo.mi).(*querySet)
+		q.cond = NewCondition().And(fi.reverseFieldInfo.column, md)
+	}
+
+	return q
+}
+
+func (o *orm) getRelQs(md interface{}, mi *modelInfo, fi *fieldInfo) *querySet {
+	switch fi.fieldType {
+	case RelOneToOne, RelForeignKey, RelManyToMany:
+	default:
+		panic(fmt.Errorf("<Ormer> name `%s` for model `%s` is not an available rel field", fi.name, mi.fullName))
+	}
+
+	q := newQuerySet(o, fi.relModelInfo).(*querySet)
+	q.cond = NewCondition()
+
+	if fi.fieldType == RelManyToMany {
+		q.cond = q.cond.And(fi.reverseFieldInfoM2M.column+ExprSep+fi.reverseFieldInfo.column, md)
+	} else {
+		q.cond = q.cond.And(fi.reverseFieldInfo.column, md)
+	}
+
+	return q
 }
 
 func (o *orm) QueryTable(ptrStructOrTableName interface{}) (qs QuerySeter) {