Hard time trying do delete things

[labs20 (Labs)]

Hi. I like the way DGraph querys “just work”. You set a JSON, and bam! What you J(son) is what you G(et).

The same can not be said about delete operations. There are really common scenarios of day to day work that I just cant got to work.

Say that you have a “tags” kind of node ({__is_tags: true, tag: “MyTag”}) and you’ve been tagging so many things with it for like two or three months. Many “__is_something” nodes in your DB has the tag MyTag associated. Then I change my mind and do not like MyTag anymore. I want to delete it.

How do I do that? I was hoping that a
{ delete { <0x27> * * . } }

would do, but all I got is a “Transaction aborted error”.

Im just supposing thats because it has so many relationships with so many nodes, but do I really have to write a code to scan all my possible “__is_stuff” to check if is there a relation, and then delete that relation first?

How do I know or do I get ALL nodes related do MyTag? Remember that the relation is set from “Stuff” to “Tag”. What do I do now?

Thanks.

[tlmichael]

I was about to start a similar thread; deleting stuff feels really hard.

Right now I’m getting error with the message:

rpc error: code = Unknown desc = Please use * with delete operation for non-list type: [myNodeName]

Despite having replaced string values with *, and in case my data type is time.Time or bool or something else then I’ve tried to create a new struct with same dgraph json node names but using only strings with the * value.

Tried to delete using both:

mut := &api.Mutation{CommitNow: true}
mut.DeleteJson = myJson
dgo.Dgraph.NewTxn().Mutate(context.Background(), mut)

and

mut := &api.Mutation{CommitNow: true}
dgo.DeleteEdges(mut, uid, "uid", "someStringNode", "someBoolNode", "someSliceNode", "someTimeNode")
dgo.Dgraph.NewTxn().Mutate(context.Background(), mut)

but it’s been unsuccessful, and I can’t find any alternative methods. I’m curious why it isn’t possible to delete everything associated with an uid by simply providing the uid (assuming it is impossible).

[karan28aug (Karandeep Singh)]

Hey @tlmichael, try to delete it this way to delete an edge:

mu = &api.Mutation{}
dgo.DeleteEdges(mu, alice, "friends", "loc")

mu.CommitNow = true
_, err = dg.NewTxn().Mutate(ctx, mu)
if err != nil {
    log.Fatal(err)
}

resp, err = dg.NewTxn().QueryWithVars(ctx, q, variables)
if err != nil {
    log.Fatal(err)
}

To delete a node:

d := map[string]string{"uid": alice}
pb, err = json.Marshal(d)
if err != nil {
    log.Fatal(err)
}

mu = &api.Mutation{
    CommitNow:  true,
    DeleteJson: pb,
}

_, err = dg.NewTxn().Mutate(ctx, mu)
if err != nil {
    log.Fatal(err)
}

[karan28aug (Karandeep Singh)]

For complete example, you can check :
https://godoc.org/github.com/dgraph-io/dgo#example-DeleteEdges

[mrjn (Manish R Jain)]

If there’re mutations flowing through the system at the same time, it’s possible that transactions are conflicting and causing aborts. Retrying it should fix the issue.

We also plan to tighten up the conflict detection, so it doesn’t flag so many conflicts, which cause aborts – in a near-future release.

[tlmichael]

Thanks, I indirectly tried something similar (by having omitempty, e.g. json:"myNodeName,omitempty" on my struct while only supplying uid).

I just now realize that this does perhaps mean that it was successfully deleted, except in my case then the uid is signed to another uid via a predicate (if that makes any sense)…

In other words, I have these two structs:

type CommentNode struct {
	ThreadUid string    `json:"uid,omitempty"`
	Comments  []Comment `json:"comments,omitempty"`
}

type Comment struct {
	Uid          string    `json:"uid,omitempty"`
	NodeType     string    `json:"nodeType,omitempty"`
	Content      string    `json:"content,omitempty"`
	CreationTime time.Time `json:"creationTime,omitempty"`
	User         []User    `json:"user,omitempty"`
}

When I create a new Comment then I sign it to the CommentNode.ThreadUid via the CommentNode.Comments predicate, and save it via CommentNode marshaled (not sure if I just butchered the Dgraph terminology, rephrasing what MichelDiz wrote ).

So if I try to query the comment uid after deleting it, then the query will only return the uid itself (which I believe would indicate it was successfully deleted)… but even after deleting it, if I query the thread uid then it will still return the deleted comment uid.

[darshan]

@tlmichael

So if I try to query the comment uid after deleting it, then the query will only return the uid itself (which I believe would indicate it was successfully deleted)… but even after deleting it, if I query the thread uid then it will still return the deleted comment uid.

Well I am too having the same issue here -

Delete edge along with all values of pointing node

I did as you said, I deleted only the comment UID but I am not getting a lesser values in my count(comment) . Suppose I have 4 comments and then I delete one of them by using the UID. So when I query again, I still get count(comment) = 4. It is mentioned here in the docs https://docs.dgraph.io/mutations/#delete , that The pattern S * * deletes all edges out of a node (the node itself may remain as the target of edges), any reverse edges corresponding to the removed edges and any indexing fo…

[tlmichael]

I figured it out, our/my problem is that we only deleted the uid, but we didn’t delete the signed uid predicate.

In my case I just had to delete the comment uid, as well as delete the thread uid+comment uid association, e.g.

pb := []byte(fmt.Sprintf(`[{"uid":"%s","comments":{"uid":"%s"}},{"uid":"%s"}]`, thread.ThreadUid, comments.Uid, comments.Uid))

[darshan]

@tlmichael

figured it out, our/my problem is that we only deleted the uid, but we didn’t delete the signed uid predi

Well this is what I was doing previously.
But if you read the full post from the following link then @MichelDiz had said that it is not necessary to delete the edge to which the node is connected. Only the UID of the comment node is enough. The UID should be deleted but some how it is still returning.

Delete edge along with all values of pointing node

Delete only the UID “003” - So your application will only collect the UIDs from the comments and only delete these. You do not need to format an entire object for this process. Just know the UID of the comment. { "delete": [ { "uid": "0x3" } ] } There will no longer be any relation or predicate in the comment Node. More details: https://docs.dgraph.io/mutations/#deleting-edges Let’s say you wanna delete 6 comments in one batch: { "delete": [ { "uid": "0x3" }, …

EDIT -
BTW, there is a temporary solution to this by using filters suggested by @MichelDiz here

Delete edge along with all values of pointing node

This is weird. We are investigating this. For now use this temporary solution some(func: has(__User)) @filter( eq(isActive, true) AND (not has(__deleted))) #optional { test(func: has(Question.Title)){ uid Question.Title Answer { uid answer.body comment @filter(has(comment.body) ) { uid comment.body } } } }

[tlmichael]

Ahh great, I like the @filter(has(comment.body) solution, will definitely be using that (:

[darshan]

Just for the information sake, which version of Dgraph are you using?

[labs20 (Labs)]

I already use that approach by implementing a “remove()” function that actually flags an “__is_deleted” value on the nodes, and then my “query()” function do the correct filter. But sometimes you really want do DELETE things.

If there’re mutations flowing through the system at the same time, it’s possible that transactions are conflicting and causing aborts. Retrying it should fix the issue.

Thats mean that I should do a retry on a try catch? I’m pretty sure that no other mutation is running along side my test though.

I’m on 1.0.5

[labs20 (Labs)]

Well, all I’ve got is the same “Transaction has been aborted. Please retry” over again.

Is this a bug?

If I really have to delete the inbound relations, I would call it a bug. And I think this would bring us to the “how to find all inbound edges of a node” again.

Thanks

[darshan]

Hey @tlmichael, You were right here,

@tlmichael

I figured it out, our/my problem is that we only deleted the uid, but we didn’t delete the signed uid predicate.

In my case I just had to delete the comment uid, as well as delete the thread uid+comment uid association, e.g.

pb := byte(fmt.Sprintf([{"uid":"%s","comments":{"uid":"%s"}},{"uid":"%s"}], thread.ThreadUid, comments.Uid, comments.Uid))

We must delete the edge from parent to child node and the child node itself.
Apologies.
The answer has been updated here -

Delete edge along with all values of pointing node

Hey! Now a little more focused, I realized that I made a mistake. The right thing was to do the Delete like this: { "delete": [ { "uid": "0x2", #Answer UID "comment": { "uid": "0x3" #Comment } }, { "uid": "0x3" #Comment final delation } ] } This way you delete the UID that is in the parent’s predicate and then the comment itself. That was a mistake, have to do in order. I was wrong since I need to build the relationship in JSON/Del for deletion. The queue w…

[tlmichael]

Thanks for the update

And sorry to labs20 for hijacking your thread, it wasn’t my intention… just figured we were dealing with similar issues.

[darshan]

Yes, we are really sorry @labs20.

[labs20 (Labs)]

Nah, no worries. You may start to notice some shady men following you back home at night but youll be fine … =]

Well Glad to see that question solved but I still need help here.

[labs20 (Labs)]

Ok, did a new test round and found that if I create new tags and relationships, I can delete them with no problem, but the old ones are hard to die.

I’m starting to assume that this can be something wrong with my database, as I didnt follow the whole export / bulk load thing back when moving from 1.0.4 to 1.0.5. Could it be?

I can provide an export of it for you guys if you want look it closer.