示例#1
0
func (this *AlterIndex) UnmarshalJSON(body []byte) error {
	var _unmarshalled struct {
		_      string              `json:"#operator"`
		Index  string              `json:"index"`
		Keys   string              `json:"keyspace"`
		Names  string              `json:"namespace"`
		Rename string              `json:"rename"`
		Using  datastore.IndexType `json:"using"`
	}

	err := json.Unmarshal(body, &_unmarshalled)
	if err != nil {
		return err
	}

	ksref := algebra.NewKeyspaceRef(_unmarshalled.Names, _unmarshalled.Keys, "")
	this.node = algebra.NewAlterIndex(ksref, _unmarshalled.Index, _unmarshalled.Using, _unmarshalled.Rename)

	this.keyspace, err = datastore.GetKeyspace(_unmarshalled.Names, _unmarshalled.Keys)
	if err != nil {
		return err
	}

	indexer, err := this.keyspace.Indexer(_unmarshalled.Using)
	if err != nil {
		return err
	}

	this.index, err = indexer.IndexByName(_unmarshalled.Index)
	return err
}
示例#2
0
func (this *InferKeyspace) UnmarshalJSON(body []byte) error {
	var _unmarshalled struct {
		_      string                  `json:"#operator"`
		Keysp  string                  `json:"keyspace"`
		Namesp string                  `json:"namespace"`
		Using  datastore.InferenceType `json:"using"`
		With   json.RawMessage         `json:"with"`
	}

	err := json.Unmarshal(body, &_unmarshalled)
	if err != nil {
		return err
	}

	this.keyspace, err = datastore.GetKeyspace(_unmarshalled.Namesp, _unmarshalled.Keysp)
	if err != nil {
		return err
	}

	ksref := algebra.NewKeyspaceRef(_unmarshalled.Namesp, _unmarshalled.Keysp, "")

	var with value.Value
	if len(_unmarshalled.With) > 0 {
		with = value.NewValue(_unmarshalled.With)
	}

	this.node = algebra.NewInferKeyspace(ksref, _unmarshalled.Using, with)
	return nil
}
示例#3
0
func (this *BuildIndexes) UnmarshalJSON(body []byte) error {
	var _unmarshalled struct {
		_       string              `json:"#operator"`
		Keys    string              `json:"keyspace"`
		Names   string              `json:"namespace"`
		Using   datastore.IndexType `json:"using"`
		Indexes []string            `json:"indexes"`
	}

	err := json.Unmarshal(body, &_unmarshalled)
	if err != nil {
		return err
	}

	ksref := algebra.NewKeyspaceRef(_unmarshalled.Names, _unmarshalled.Keys, "")
	this.node = algebra.NewBuildIndexes(ksref, _unmarshalled.Using, _unmarshalled.Indexes...)

	this.keyspace, err = datastore.GetKeyspace(_unmarshalled.Names, _unmarshalled.Keys)
	return err
}
示例#4
0
文件: merge.go 项目: pkdevboxy/query
func (this *Merge) UnmarshalJSON(body []byte) error {
	var _unmarshalled struct {
		_      string          `json:"#operator"`
		Keys   string          `json:"keyspace"`
		Names  string          `json:"namespace"`
		As     string          `json:"as"`
		Key    string          `json:"key"`
		Update json.RawMessage `json:"update"`
		Delete json.RawMessage `json:"delete"`
		Insert json.RawMessage `json:"insert"`
	}

	err := json.Unmarshal(body, &_unmarshalled)
	if err != nil {
		return err
	}

	this.keyspace, err = datastore.GetKeyspace(_unmarshalled.Names, _unmarshalled.Keys)
	if err != nil {
		return err
	}

	this.ref = algebra.NewKeyspaceRef(_unmarshalled.Names, _unmarshalled.Keys, _unmarshalled.As)

	if _unmarshalled.Key != "" {
		this.key, err = parser.Parse(_unmarshalled.Key)
		if err != nil {
			return err
		}
	}

	ops := []json.RawMessage{
		_unmarshalled.Update,
		_unmarshalled.Delete,
		_unmarshalled.Insert,
	}

	for i, child := range ops {
		if len(child) == 0 {
			continue
		}

		var op_type struct {
			Operator string `json:"#operator"`
		}

		err = json.Unmarshal(child, &op_type)
		if err != nil {
			return err
		}

		switch i {
		case 0:
			this.update, err = MakeOperator(op_type.Operator, child)
		case 1:
			this.delete, err = MakeOperator(op_type.Operator, child)
		case 2:
			this.insert, err = MakeOperator(op_type.Operator, child)
		}

		if err != nil {
			return err
		}
	}

	return err
}
示例#5
0
func (this *CreateIndex) UnmarshalJSON(body []byte) error {
	var _unmarshalled struct {
		_         string              `json:"#operator"`
		Keysp     string              `json:"keyspace"`
		Namesp    string              `json:"namespace"`
		Index     string              `json:"index"`
		Keys      []string            `json:"keys"`
		Using     datastore.IndexType `json:"using"`
		Partition []string            `json:"partition"`
		Where     string              `json:"where"`
		With      json.RawMessage     `json:"with"`
	}

	err := json.Unmarshal(body, &_unmarshalled)
	if err != nil {
		return err
	}

	this.keyspace, err = datastore.GetKeyspace(_unmarshalled.Namesp, _unmarshalled.Keysp)
	if err != nil {
		return err
	}

	ksref := algebra.NewKeyspaceRef(_unmarshalled.Namesp, _unmarshalled.Keysp, "")

	keys := make(expression.Expressions, len(_unmarshalled.Keys))
	for i, k := range _unmarshalled.Keys {
		keys[i], err = parser.Parse(k)
		if err != nil {
			return err
		}
	}

	var partition expression.Expressions
	if len(_unmarshalled.Partition) > 0 {
		partition = make(expression.Expressions, len(_unmarshalled.Partition))
		for i, p := range _unmarshalled.Partition {
			partition[i], err = parser.Parse(p)
			if err != nil {
				return err
			}
		}
	}

	var where expression.Expression
	if _unmarshalled.Where != "" {
		where, err = parser.Parse(_unmarshalled.Where)
		if err != nil {
			return err
		}
	}

	var with value.Value
	if len(_unmarshalled.With) > 0 {
		with = value.NewValue(_unmarshalled.With)
	}

	this.node = algebra.NewCreateIndex(_unmarshalled.Index, ksref,
		keys, partition, where, _unmarshalled.Using, with)
	return nil
}