indicating that retrieved is zero.
So, that we will know that we haven't retrieved it yet.
You'll see that we'll update that in a second.
We commit it, so that later selects we'll see this.
So, you got to do the commit.
This later select wouldn't see the one we just inserted.
We're going to ask how many rows were affected,
and if it's not equal to one, then,
we're going to complain about- we inserted it,
and we're going to do this thing.
We are going to ask, "Hey remember there was an ID up there?"
Right here, ID integer, primary key,
and we did not insert this here,
but we want to know what that ID is.
Every time I was showing you that in lectures,
I was saying it's really easy in Python to do this.
That's what we're saying.
This cursor did the insert,
but one of the things happens is after the insert,
we're going to grab the last row ID,
which is the primary key that was assigned by SQL.
Okay? So, that means, that one way or another,
coming through this code here in line 45, one way or another,
we're either going to know the ID of the user that was there before,
or we just inserted one and so we're going to know the primary key of the current user.
You'll see why we need that.
So, ID, is the primary key of the current user that we entered right here.
Okay? Now, what we're going to do is do the Twitter URL augment with OAuth,
and all the keys, and the secrets in hidden.py.
Instead, we're going go through let's count 1,000.
Let's go count, what the heck.
Let's go 200.
Up to 200 friends.
No, let's do 100. We'll keep it that way.
Then, we're going to retrieve it and we're retrieving the account.
We're not going to print the nasty URL out, we could.
Then we're going open the URL with a connection,
and then we're going to read that,
and we're going get the UTF-8 data from this,
and then we're going to decode that,
and we're going to have the unicode data.
So, the data in string is a internal Python string,
with all that data representing all the wonderful characters.
Of course, we're going to ask URL open to give us back
the headers as a dictionary, using this call.
We can see how many we have left for the remaining.
Right? What's the remaining rate limit that we have?
So, then we're going to parse the data with JSON load S. Wait,
I need to continue in here.
Continue. Okay. Save.
If we're going to parse this data,
we'll print it out, right?
So, that means that this died,
which means it's not syntactically correct, json basically.
Who knows if we're ever going to see that,
but at least, when it blows up it'll print this data out.
We'll have to catch it, and then it'll continue.
Actually, I'll make this a break,
because if that's blown up that bad, we should quit.
Now, I don't yet know what happens when this rate limit says you can't have it,
and so but I do know that I expect when it's successful,
that there will be a key of users in this outer dictionary that we're going to get.
If this outer dictionary,
that if users is not in the parsed dictionary,
then I'm going to dump out this data so that at least I can
debug what happens when I've got some broken json.
So, the difference between this code,
this code is going to fail when the json is syntactically bad,
meaning a curly brace isn't right or whatever.
This code will trigger when I get good json,
but I don't have a user's key in it, okay?
So, then, once we've retrieved it,
we will be pretty happy with it.
We're going to update for our account that we're retrieving.
We're going to set this is one of our retrieved accounts, okay?
Then, what we're going to do is write a loop that goes through
all the friends of this particular user that we're asking,
and gets their screen name,
prints it out, and then we're going to check to
see if this one is already in our people database,
because this is a spider, we're grabbing accounts.
So, we'll do a friend ID,
and do a fetch one,
grab the subzero thing.
If that works, if this person not in there,
this fetch one is going to blow up which
means we're going to drop down to the except code.
But if it does work, we have friend ID,
