Databases
StackOverflow2013
Postsdbo
 
Search
scanning

Scanning is the default search option for small tables.

Enter text here to perform a scan over supported column types.

Text columns with limited length use a substring search If the entered text is a number, integer columns will be scanned for an exact match of the value.

The scanning search option is disabled for large tables.

seeking

Seeking is the default search option for large tables.

Seeking requires indexes and can only be done using the column (or columns) the index is defined on.

In the single-column case, the database will seek to the position the entered search term would be at and return all rows greater or equal to that value.

In the multiple-column case, the above still applies to the column you supplied non-empty search text for. All previous columns, however, will be using an equality match.

Id
AcceptedAnswerId
CreationDate
FavoriteCountLastActivityDate
LastActivityDate
LastEditDate
LastEditorUserIdLastEditDate
ParentIdCreationDate
OwnerUserIdCreationDate
PostTypeIdCreationDate
ScoreLastEditDate
› search options
Title
ViewCountLastEditDate
 
 

Note that there are some explanatory texts on larger screens.

plurals
  1. PO
    primarykey
    data
    text
    <p><strong>You are a victim of <a href="//en.wikipedia.org/wiki/Branch_predictor" rel="noreferrer">branch prediction</a> fail.</strong></p> <hr> <h2>What is Branch Prediction?</h2> <p>Consider a railroad junction:</p> <p><a href="//commons.wikimedia.org/wiki/File:Entroncamento_do_Transpraia.JPG" rel="noreferrer"><img src="https://i.stack.imgur.com/muxnt.jpg" alt="Licensed Image"></a> <sub><a href="//commons.wikimedia.org/wiki/File:Entroncamento_do_Transpraia.JPG" rel="noreferrer">Image</a> by Mecanismo, via Wikimedia Commons. Used under the <a href="//creativecommons.org/licenses/by-sa/3.0/deed.en" rel="noreferrer">CC-By-SA 3.0</a> license.</sub></p> <p>Now for the sake of argument, suppose this is back in the 1800s - before long distance or radio communication.</p> <p>You are the operator of a junction and you hear a train coming. You have no idea which way it is supposed to go. You stop the train to ask the driver which direction they want. And then you set the switch appropriately.</p> <p><em>Trains are heavy and have a lot of inertia. So they take forever to start up and slow down.</em></p> <p>Is there a better way? You guess which direction the train will go!</p> <ul> <li>If you guessed right, it continues on.</li> <li>If you guessed wrong, the captain will stop, back up, and yell at you to flip the switch. Then it can restart down the other path.</li> </ul> <p><strong>If you guess right every time</strong>, the train will never have to stop.<br> <strong>If you guess wrong too often</strong>, the train will spend a lot of time stopping, backing up, and restarting.</p> <hr> <p><strong>Consider an if-statement:</strong> At the processor level, it is a branch instruction:</p> <p><img src="https://i.stack.imgur.com/pyfwC.png" alt="image2"></p> <p>You are a processor and you see a branch. You have no idea which way it will go. What do you do? You halt execution and wait until the previous instructions are complete. Then you continue down the correct path.</p> <p><em>Modern processors are complicated and have long pipelines. So they take forever to "warm up" and "slow down".</em></p> <p>Is there a better way? You guess which direction the branch will go!</p> <ul> <li>If you guessed right, you continue executing.</li> <li>If you guessed wrong, you need to flush the pipeline and roll back to the branch. Then you can restart down the other path.</li> </ul> <p><strong>If you guess right every time</strong>, the execution will never have to stop.<br> <strong>If you guess wrong too often</strong>, you spend a lot of time stalling, rolling back, and restarting.</p> <hr> <p>This is branch prediction. I admit it's not the best analogy since the train could just signal the direction with a flag. But in computers, the processor doesn't know which direction a branch will go until the last moment.</p> <p>So how would you strategically guess to minimize the number of times that the train must back up and go down the other path? You look at the past history! If the train goes left 99% of the time, then you guess left. If it alternates, then you alternate your guesses. If it goes one way every 3 times, you guess the same...</p> <p><strong><em>In other words, you try to identify a pattern and follow it.</em></strong> This is more or less how branch predictors work.</p> <p>Most applications have well-behaved branches. So modern branch predictors will typically achieve >90% hit rates. But when faced with unpredictable branches with no recognizable patterns, branch predictors are virtually useless.</p> <p>Further reading: <a href="//en.wikipedia.org/wiki/Branch_predictor" rel="noreferrer">"Branch predictor" article on Wikipedia</a>.</p> <hr> <h2>As hinted from above, the culprit is this if-statement:</h2> <pre><code>if (data[c] &gt;= 128) sum += data[c]; </code></pre> <p>Notice that the data is evenly distributed between 0 and 255. When the data is sorted, roughly the first half of the iterations will not enter the if-statement. After that, they will all enter the if-statement.</p> <p>This is very friendly to the branch predictor since the branch consecutively goes the same direction many times. Even a simple saturating counter will correctly predict the branch except for the few iterations after it switches direction.</p> <p><strong>Quick visualization:</strong></p> <pre><code>T = branch taken N = branch not taken data[] = 0, 1, 2, 3, 4, ... 126, 127, 128, 129, 130, ... 250, 251, 252, ... branch = N N N N N ... N N T T T ... T T T ... = NNNNNNNNNNNN ... NNNNNNNTTTTTTTTT ... TTTTTTTTTT (easy to predict) </code></pre> <p>However, when the data is completely random, the branch predictor is rendered useless because it can't predict random data. Thus there will probably be around 50% misprediction. (no better than random guessing)</p> <pre><code>data[] = 226, 185, 125, 158, 198, 144, 217, 79, 202, 118, 14, 150, 177, 182, 133, ... branch = T, T, N, T, T, T, T, N, T, N, N, T, T, T, N ... = TTNTTTTNTNNTTTN ... (completely random - hard to predict) </code></pre> <hr> <p><strong>So what can be done?</strong></p> <p>If the compiler isn't able to optimize the branch into a conditional move, you can try some hacks if you are willing to sacrifice readability for performance.</p> <p>Replace:</p> <pre><code>if (data[c] &gt;= 128) sum += data[c]; </code></pre> <p>with:</p> <pre><code>int t = (data[c] - 128) &gt;&gt; 31; sum += ~t &amp; data[c]; </code></pre> <p>This eliminates the branch and replaces it with some bitwise operations.</p> <p><sub>(Note that this hack is not strictly equivalent to the original if-statement. But in this case, it's valid for all the input values of <code>data[]</code>.)</sub></p> <p><strong>Benchmarks: Core i7 920 @ 3.5 GHz</strong></p> <p>C++ - Visual Studio 2010 - x64 Release</p> <pre><code>// Branch - Random seconds = 11.777 // Branch - Sorted seconds = 2.352 // Branchless - Random seconds = 2.564 // Branchless - Sorted seconds = 2.587 </code></pre> <p>Java - Netbeans 7.1.1 JDK 7 - x64</p> <pre><code>// Branch - Random seconds = 10.93293813 // Branch - Sorted seconds = 5.643797077 // Branchless - Random seconds = 3.113581453 // Branchless - Sorted seconds = 3.186068823 </code></pre> <p>Observations:</p> <ul> <li><strong>With the Branch:</strong> There is a huge difference between the sorted and unsorted data.</li> <li><strong>With the Hack:</strong> There is no difference between sorted and unsorted data.</li> <li>In the C++ case, the hack is actually a tad slower than with the branch when the data is sorted.</li> </ul> <p>A general rule of thumb is to avoid data-dependent branching in critical loops. (such as in this example)</p> <hr> <p><strong>Update:</strong></p> <ul> <li><p>GCC 4.6.1 with <code>-O3</code> or <code>-ftree-vectorize</code> on x64 is able to generate a conditional move. So there is no difference between the sorted and unsorted data - both are fast.</p></li> <li><p>VC++ 2010 is unable to generate conditional moves for this branch even under <code>/Ox</code>.</p></li> <li><p>Intel Compiler 11 does something miraculous. It <a href="//en.wikipedia.org/wiki/Loop_interchange" rel="noreferrer">interchanges the two loops</a>, thereby hoisting the unpredictable branch to the outer loop. So not only is it immune the mispredictions, it is also twice as fast as whatever VC++ and GCC can generate! In other words, ICC took advantage of the test-loop to defeat the benchmark...</p></li> <li><p>If you give the Intel Compiler the branchless code, it just out-right vectorizes it... and is just as fast as with the branch (with the loop interchange).</p></li> </ul> <p>This goes to show that even mature modern compilers can vary wildly in their ability to optimize code...</p>
    singulars
    1. This table or related slice is empty.
    1. POWhy is it faster to process a sorted array than an unsorted array?
      singulars
      1. PTQuestion
    1. PTAnswer
    1. This table or related slice is empty.
    1. USMysticial
  2. POWhy is it faster to process a sorted array than an unsorted array?
    primarykey
    data
    text
    <p>Here is a piece of C++ code that seems very peculiar. For some strange reason, sorting the data miraculously makes the code almost six times faster.</p> <pre class="lang-cpp prettyprint-override"><code>#include &lt;algorithm&gt; #include &lt;ctime&gt; #include &lt;iostream&gt; int main() { // Generate data const unsigned arraySize = 32768; int data[arraySize]; for (unsigned c = 0; c &lt; arraySize; ++c) data[c] = std::rand() % 256; // !!! With this, the next loop runs faster std::sort(data, data + arraySize); // Test clock_t start = clock(); long long sum = 0; for (unsigned i = 0; i &lt; 100000; ++i) { // Primary loop for (unsigned c = 0; c &lt; arraySize; ++c) { if (data[c] &gt;= 128) sum += data[c]; } } double elapsedTime = static_cast&lt;double&gt;(clock() - start) / CLOCKS_PER_SEC; std::cout &lt;&lt; elapsedTime &lt;&lt; std::endl; std::cout &lt;&lt; "sum = " &lt;&lt; sum &lt;&lt; std::endl; } </code></pre> <ul> <li>Without <code>std::sort(data, data + arraySize);</code>, the code runs in 11.54 seconds.</li> <li>With the sorted data, the code runs in 1.93 seconds.</li> </ul> <p>Initially, I thought this might be just a language or compiler anomaly. So I tried it in Java.</p> <pre class="lang-java prettyprint-override"><code>import java.util.Arrays; import java.util.Random; public class Main { public static void main(String[] args) { // Generate data int arraySize = 32768; int data[] = new int[arraySize]; Random rnd = new Random(0); for (int c = 0; c &lt; arraySize; ++c) data[c] = rnd.nextInt() % 256; // !!! With this, the next loop runs faster Arrays.sort(data); // Test long start = System.nanoTime(); long sum = 0; for (int i = 0; i &lt; 100000; ++i) { // Primary loop for (int c = 0; c &lt; arraySize; ++c) { if (data[c] &gt;= 128) sum += data[c]; } } System.out.println((System.nanoTime() - start) / 1000000000.0); System.out.println("sum = " + sum); } } </code></pre> <p>With a somewhat similar but less extreme result.</p> <hr> <p>My first thought was that sorting brings the data into the cache, but then I thought how silly that is because the array was just generated.</p> <ul> <li>What is going on?</li> <li>Why is it faster to process a sorted array than an unsorted array?</li> <li>The code is summing up some independent terms, and the order should not matter.</li> </ul>
    singulars
    1. PO
      singulars
      1. PTAnswer
    1. This table or related slice is empty.
    1. PTQuestion
    1. USGManNickG
    1. USGManNickG
  3. PO
    primarykey
    data
    text
    <h3>Undo a commit and redo</h3> <pre class="lang-sh prettyprint-override"><code>$ git commit -m "Something terribly misguided" # (1) $ git reset HEAD~ # (2) &lt;&lt; edit files as necessary &gt;&gt; # (3) $ git add ... # (4) $ git commit -c ORIG_HEAD # (5) </code></pre> <ol> <li>This is what you want to undo</li> <li>This leaves your working tree (the state of your files on disk) unchanged but undoes the commit and leaves the changes you committed unstaged (so they'll appear as "Changes not staged for commit" in <code>git status</code>, and you'll need to add them again before committing). If you <em>only</em> want to <em>add</em> more changes to the previous commit, or change the commit message<sup>1</sup>, you could use <code>git reset --soft HEAD~</code> instead, which is like <code>git reset HEAD~</code> (where <code>HEAD~</code> is the same as <code>HEAD~1</code>) but leaves your existing changes staged.</li> <li>Make corrections to working tree files.</li> <li><code>git add</code> anything that you want to include in your new commit.</li> <li>Commit the changes, reusing the old commit message. <code>reset</code> copied the old head to <code>.git/ORIG_HEAD</code>; <code>commit</code> with <code>-c ORIG_HEAD</code> will open an editor, which initially contains the log message from the old commit and allows you to edit it. If you do not need to edit the message, you could use the <code>-C</code> option.</li> </ol> <p>Beware however that if you have added any new changes to the index, using <code>commit --amend</code> will add them to your previous commit.</p> <p>If the code is already pushed to your server and you have permissions to overwrite history (rebase) then:</p> <pre><code>git push origin master --force </code></pre> <p>You can also look at this answer: </p> <p><a href="https://stackoverflow.com/questions/34519665/how-to-move-head-back-to-a-previous-location-detached-head/34519716#34519716">How to move HEAD back to a previous location? (Detached head)</a></p> <p>The above answer will show you <code>git reflog</code> which is used to find out what is the SHA-1 which you wish to revert to. Once you found the point to which you wish to undo to use the sequence of commands as explained above.</p> <hr> <p><sup>1</sup> Note, however, that you don't need to reset to an earlier commit if you just made a mistake in your <em>commit message</em>. The easier option is to <code>git reset</code> (to upstage any changes you've made since) and then <a href="https://stackoverflow.com/q/179123/1146608"><code>git commit --amend</code></a>, which will open your default commit message editor pre-populated with the last commit message. </p>
    singulars
    1. This table or related slice is empty.
    1. POHow to undo the most recent commits in Git?
      singulars
      1. PTQuestion
    1. PTAnswer
    1. This table or related slice is empty.
    1. USEsko Luontola
  4. POHow to undo the most recent commits in Git?
    primarykey
    data
    text
    singulars
    1. PO
      singulars
      1. PTAnswer
    1. This table or related slice is empty.
    1. PTQuestion
    1. USTon van den Heuvel
    1. USHamza Yerlikaya
  5. PO
    primarykey
    data
    text
    <h1>Executive Summary</h1> <pre><code>$ git push --delete &lt;remote_name&gt; &lt;branch_name&gt; $ git branch -d &lt;branch_name&gt; </code></pre> <p>Note that in most cases the remote name is <code>origin</code>.</p> <h1>Delete Local Branch</h1> <p>To delete the <em>local</em> branch use one of the following:</p> <pre><code>$ git branch -d branch_name $ git branch -D branch_name </code></pre> <p><strong>Note:</strong> The <code>-d</code> option is an alias for <code>--delete</code>, which only deletes the branch if it has already been fully merged in its upstream branch. You could also use <code>-D</code>, which is an alias for <code>--delete --force</code>, which deletes the branch "irrespective of its merged status." [Source: <code>man git-branch</code>] </p> <h1>Delete Remote Branch [Updated on 8-Sep-2017]</h1> <p>As of <a href="https://github.com/gitster/git/blob/master/Documentation/RelNotes/1.7.0.txt" rel="noreferrer">Git v1.7.0</a>, you can delete a <strong><em>remote</em></strong> branch using</p> <pre><code>$ git push &lt;remote_name&gt; --delete &lt;branch_name&gt; </code></pre> <p>which might be easier to remember than</p> <pre><code>$ git push &lt;remote_name&gt; :&lt;branch_name&gt; </code></pre> <p>which was added in <a href="https://github.com/gitster/git/blob/master/Documentation/RelNotes/1.5.0.txt" rel="noreferrer">Git v1.5.0</a> "to delete a remote branch or a tag."</p> <p>Starting on <a href="https://github.com/git/git/blob/master/Documentation/RelNotes/2.8.0.txt" rel="noreferrer">Git v2.8.0</a> you can also use <code>git push</code> with the <code>-d</code> option as an alias for <code>--delete</code>.</p> <p>Therefore, the version of Git you have installed will dictate whether you need to use the easier or harder syntax.</p> <h2>Delete Remote Branch [Original Answer from 5-Jan-2010]</h2> <p>From Chapter 3 of <a href="http://git-scm.com/book/en/Git-Branching-Remote-Branches" rel="noreferrer"><em>Pro Git</em></a> by Scott Chacon:</p> <blockquote> <h3>Deleting Remote Branches</h3> <p>Suppose you’re done with a remote branch — say, you and your collaborators are finished with a feature and have merged it into your remote’s master branch (or whatever branch your stable codeline is in). You can delete a remote branch using the rather obtuse syntax <code>git push [remotename] :[branch]</code>. If you want to delete your serverfix branch from the server, you run the following:</p> <pre><code>$ git push origin :serverfix To git@github.com:schacon/simplegit.git - [deleted] serverfix </code></pre> <p>Boom. No more branch on your server. You may want to dog-ear this page, because you’ll need that command, and you’ll likely forget the syntax. A way to remember this command is by recalling the <code>git push [remotename] [localbranch]:[remotebranch]</code> syntax that we went over a bit earlier. If you leave off the <code>[localbranch]</code> portion, then you’re basically saying, “Take nothing on my side and make it be <code>[remotebranch]</code>.”</p> </blockquote> <p>I issued <code>git push origin :bugfix</code> and it worked beautifully. Scott Chacon was right—I will want to <a href="http://en.wiktionary.org/wiki/dogear#Verb" rel="noreferrer">dog ear</a> that page (or virtually dog ear by answering this on Stack&nbsp;Overflow).</p> <p>Then you should execute this on other machines</p> <pre><code>git fetch --all --prune </code></pre> <p>to propagate changes.</p>
    singulars
    1. This table or related slice is empty.
    1. POHow do I delete a Git branch both locally and remotely?
      singulars
      1. PTQuestion
    1. PTAnswer
    1. This table or related slice is empty.
    1. USMatthew Rankin
  6. PO
    primarykey
    data
    text
    <h1>Amending the most recent commit message</h1> <pre class="lang-sh prettyprint-override"><code>git commit --amend </code></pre> <p>will open your editor, allowing you to change the commit message of the most recent commit. Additionally, you can set the commit message directly in the command line with:</p> <pre class="lang-sh prettyprint-override"><code>git commit --amend -m "New commit message" </code></pre> <p>…however, this can make multi-line commit messages or small corrections more cumbersome to enter.</p> <p>Make sure you don't have any working copy changes <em>staged</em> before doing this or they will get committed too. (<em>Unstaged</em> changes will not get committed.)</p> <h2>Changing the message of a commit that you've already pushed to your remote branch</h2> <p>If you've already pushed your commit up to your remote branch, then you'll <a href="https://stackoverflow.com/questions/41003071/why-must-i-force-push-after-changing-a-commit-message">need to force push the commit</a> with: </p> <pre class="lang-bash prettyprint-override"><code>git push &lt;remote&gt; &lt;branch&gt; --force # Or git push &lt;remote&gt; &lt;branch&gt; -f </code></pre> <p><strong>Warning: force-pushing will overwrite the remote branch with the state of your local one</strong>. If there are commits on the remote branch that you don't have in your local branch, you <em>will</em> lose those commits.</p> <p><strong>Warning: be cautious about amending commits that you have already shared with other people.</strong> Amending commits essentially <em>rewrites</em> them to have different <a href="http://en.wikipedia.org/wiki/SHA-1" rel="noreferrer">SHA</a> IDs, which poses a problem if other people have copies of the old commit that you've rewritten. Anyone who has a copy of the old commit will need to synchronize their work with your newly re-written commit, which can sometimes be difficult, so make sure you coordinate with others when attempting to rewrite shared commit history, or just avoid rewriting shared commits altogether.</p> <hr> <h3>Use interactive rebase</h3> <p>Another option is to use interactive rebase.<br> This allows you to edit any message you want to update even if it's not the latest message.</p> <p>In order to do a git squash, follow these steps:</p> <pre><code>// X is the number of commits to the last commit you want to be able to edit git rebase -i HEAD~X </code></pre> <p>Once you squash your commits - choose the <code>e/r</code> for editing the message</p> <p><a href="https://i.stack.imgur.com/LVcm9.png" rel="noreferrer"><img src="https://i.stack.imgur.com/LVcm9.png" alt="enter image description here"></a></p> <h3>Important note about Interactive rebase</h3> <p>When you use the <code>git rebase -i HEAD~X</code> there can be <strong>more</strong> than <code>X</code> commits. Git will "collect" all the commits in the last <code>X</code> commits and if there was a merge somewhere in between that range you will see all the commits as well so the outcome will be X+.</p> <h3>Good tip:</h3> <p>If you have to do it for more than a single branch and you might face conflicts when amending the content, set up <a href="https://stackoverflow.com/questions/35415925/is-it-possible-to-setup-git-merge-for-automatic-resolving-git-rerere/35417944#35417944"><code>git rerere</code></a> and let git resolve those conflicts automatically for you.</p> <hr> <h2>Documentation</h2> <ul> <li><p><a href="https://www.kernel.org/pub/software/scm/git/docs/git-commit.html" rel="noreferrer">git-commit(1) Manual Page</a></p></li> <li><p><a href="https://www.kernel.org/pub/software/scm/git/docs/git-rebase.html" rel="noreferrer">git-rebase(1) Manual Page</a></p></li> <li><p><a href="https://www.kernel.org/pub/software/scm/git/docs/git-push.html" rel="noreferrer">git-push(1) Manual Page</a></p></li> </ul>
    singulars
    1. This table or related slice is empty.
    1. POHow to modify existing, unpushed commits?
      singulars
      1. PTQuestion
    1. PTAnswer
    1. This table or related slice is empty.
    1. USEfForEffort
  7. POHow do I delete a Git branch both locally and remotely?
    primarykey
    data
    text
    singulars
    1. PO
      singulars
      1. PTAnswer
    1. This table or related slice is empty.
    1. PTQuestion
    1. This table or related slice is empty.
    1. USMatthew Rankin
  8. PO
    primarykey
    data
    text
    <h2>One does not simply redirect using jQuery</h2> <p>jQuery is not necessary, and <a href="https://developer.mozilla.org/en-US/docs/Web/API/Location/replace" rel="noreferrer"><strong><code>window.location.replace(...)</code></strong></a> will best simulate an HTTP redirect. </p> <p><code>window.location.replace(...)</code> is better than using <code>window.location.href</code>, because <code>replace()</code> does not keep the originating page in the session history, meaning the user won't get stuck in a never-ending back-button fiasco.</p> <blockquote> <p>If you want to simulate someone clicking on a link, use <strong><code>location.href</code></strong></p> <p>If you want to simulate an HTTP redirect, use <strong><code>location.replace</code></strong></p> </blockquote> <p><strong>For example:</strong></p> <pre><code>// similar behavior as an HTTP redirect window.location.replace("http://stackoverflow.com"); // similar behavior as clicking on a link window.location.href = "http://stackoverflow.com"; </code></pre>
    singulars
    1. This table or related slice is empty.
    1. POHow do I redirect to another webpage?
      singulars
      1. PTQuestion
    1. PTAnswer
    1. USRyan McGeary
    1. USRyan McGeary
  9. PO
    primarykey
    data
    text
    <p>To understand what <code>yield</code> does, you must understand what <em>generators</em> are. And before generators come <em>iterables</em>.</p> <h2>Iterables</h2> <p>When you create a list, you can read its items one by one. Reading its items one by one is called iteration:</p> <pre><code>&gt;&gt;&gt; mylist = [1, 2, 3] &gt;&gt;&gt; for i in mylist: ... print(i) 1 2 3 </code></pre> <p><code>mylist</code> is an <em>iterable</em>. When you use a list comprehension, you create a list, and so an iterable:</p> <pre><code>&gt;&gt;&gt; mylist = [x*x for x in range(3)] &gt;&gt;&gt; for i in mylist: ... print(i) 0 1 4 </code></pre> <p>Everything you can use "<code>for... in...</code>" on is an iterable; <code>lists</code>, <code>strings</code>, files...</p> <p>These iterables are handy because you can read them as much as you wish, but you store all the values in memory and this is not always what you want when you have a lot of values.</p> <h2>Generators</h2> <p>Generators are iterators, a kind of iterable <strong>you can only iterate over once</strong>. Generators do not store all the values in memory, <strong>they generate the values on the fly</strong>:</p> <pre><code>&gt;&gt;&gt; mygenerator = (x*x for x in range(3)) &gt;&gt;&gt; for i in mygenerator: ... print(i) 0 1 4 </code></pre> <p>It is just the same except you used <code>()</code> instead of <code>[]</code>. BUT, you <strong>cannot</strong> perform <code>for i in mygenerator</code> a second time since generators can only be used once: they calculate 0, then forget about it and calculate 1, and end calculating 4, one by one.</p> <h2>Yield</h2> <p><code>yield</code> is a keyword that is used like <code>return</code>, except the function will return a generator.</p> <pre><code>&gt;&gt;&gt; def createGenerator(): ... mylist = range(3) ... for i in mylist: ... yield i*i ... &gt;&gt;&gt; mygenerator = createGenerator() # create a generator &gt;&gt;&gt; print(mygenerator) # mygenerator is an object! &lt;generator object createGenerator at 0xb7555c34&gt; &gt;&gt;&gt; for i in mygenerator: ... print(i) 0 1 4 </code></pre> <p>Here it's a useless example, but it's handy when you know your function will return a huge set of values that you will only need to read once.</p> <p>To master <code>yield</code>, you must understand that <strong>when you call the function, the code you have written in the function body does not run.</strong> The function only returns the generator object, this is a bit tricky :-)</p> <p>Then, your code will be run each time the <code>for</code> uses the generator.</p> <p>Now the hard part:</p> <p>The first time the <code>for</code> calls the generator object created from your function, it will run the code in your function from the beginning until it hits <code>yield</code>, then it'll return the first value of the loop. Then, each other call will run the loop you have written in the function one more time, and return the next value, until there is no value to return.</p> <p>The generator is considered empty once the function runs, but does not hit <code>yield</code> anymore. It can be because the loop had come to an end, or because you do not satisfy an <code>"if/else"</code> anymore.</p> <hr> <h2>Your code explained</h2> <p>Generator:</p> <pre><code># Here you create the method of the node object that will return the generator def _get_child_candidates(self, distance, min_dist, max_dist): # Here is the code that will be called each time you use the generator object: # If there is still a child of the node object on its left # AND if distance is ok, return the next child if self._leftchild and distance - max_dist &lt; self._median: yield self._leftchild # If there is still a child of the node object on its right # AND if distance is ok, return the next child if self._rightchild and distance + max_dist &gt;= self._median: yield self._rightchild # If the function arrives here, the generator will be considered empty # there is no more than two values: the left and the right children </code></pre> <p>Caller:</p> <pre><code># Create an empty list and a list with the current object reference result, candidates = list(), [self] # Loop on candidates (they contain only one element at the beginning) while candidates: # Get the last candidate and remove it from the list node = candidates.pop() # Get the distance between obj and the candidate distance = node._get_dist(obj) # If distance is ok, then you can fill the result if distance &lt;= max_dist and distance &gt;= min_dist: result.extend(node._values) # Add the children of the candidate in the candidates list # so the loop will keep running until it will have looked # at all the children of the children of the children, etc. of the candidate candidates.extend(node._get_child_candidates(distance, min_dist, max_dist)) return result </code></pre> <p>This code contains several smart parts:</p> <ul> <li><p>The loop iterates on a list, but the list expands while the loop is being iterated :-) It's a concise way to go through all these nested data even if it's a bit dangerous since you can end up with an infinite loop. In this case, <code>candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))</code> exhausts all the values of the generator, but <code>while</code> keeps creating new generator objects which will produce different values from the previous ones since it's not applied on the same node.</p></li> <li><p>The <code>extend()</code> method is a list object method that expects an iterable and adds its values to the list.</p></li> </ul> <p>Usually we pass a list to it:</p> <pre><code>&gt;&gt;&gt; a = [1, 2] &gt;&gt;&gt; b = [3, 4] &gt;&gt;&gt; a.extend(b) &gt;&gt;&gt; print(a) [1, 2, 3, 4] </code></pre> <p>But in your code it gets a generator, which is good because:</p> <ol> <li>You don't need to read the values twice.</li> <li>You may have a lot of children and you don't want them all stored in memory.</li> </ol> <p>And it works because Python does not care if the argument of a method is a list or not. Python expects iterables so it will work with strings, lists, tuples and generators! This is called duck typing and is one of the reason why Python is so cool. But this is another story, for another question...</p> <p>You can stop here, or read a little bit to see an advanced use of a generator:</p> <h2>Controlling a generator exhaustion</h2> <pre><code>&gt;&gt;&gt; class Bank(): # Let's create a bank, building ATMs ... crisis = False ... def create_atm(self): ... while not self.crisis: ... yield "$100" &gt;&gt;&gt; hsbc = Bank() # When everything's ok the ATM gives you as much as you want &gt;&gt;&gt; corner_street_atm = hsbc.create_atm() &gt;&gt;&gt; print(corner_street_atm.next()) $100 &gt;&gt;&gt; print(corner_street_atm.next()) $100 &gt;&gt;&gt; print([corner_street_atm.next() for cash in range(5)]) ['$100', '$100', '$100', '$100', '$100'] &gt;&gt;&gt; hsbc.crisis = True # Crisis is coming, no more money! &gt;&gt;&gt; print(corner_street_atm.next()) &lt;type 'exceptions.StopIteration'&gt; &gt;&gt;&gt; wall_street_atm = hsbc.create_atm() # It's even true for new ATMs &gt;&gt;&gt; print(wall_street_atm.next()) &lt;type 'exceptions.StopIteration'&gt; &gt;&gt;&gt; hsbc.crisis = False # The trouble is, even post-crisis the ATM remains empty &gt;&gt;&gt; print(corner_street_atm.next()) &lt;type 'exceptions.StopIteration'&gt; &gt;&gt;&gt; brand_new_atm = hsbc.create_atm() # Build a new one to get back in business &gt;&gt;&gt; for cash in brand_new_atm: ... print cash $100 $100 $100 $100 $100 $100 $100 $100 $100 ... </code></pre> <p><strong>Note:</strong> For Python 3, use<code>print(corner_street_atm.__next__())</code> or <code>print(next(corner_street_atm))</code></p> <p>It can be useful for various things like controlling access to a resource.</p> <h2>Itertools, your best friend</h2> <p>The itertools module contains special functions to manipulate iterables. Ever wish to duplicate a generator? Chain two generators? Group values in a nested list with a one-liner? <code>Map / Zip</code> without creating another list?</p> <p>Then just <code>import itertools</code>.</p> <p>An example? Let's see the possible orders of arrival for a four-horse race:</p> <pre><code>&gt;&gt;&gt; horses = [1, 2, 3, 4] &gt;&gt;&gt; races = itertools.permutations(horses) &gt;&gt;&gt; print(races) &lt;itertools.permutations object at 0xb754f1dc&gt; &gt;&gt;&gt; print(list(itertools.permutations(horses))) [(1, 2, 3, 4), (1, 2, 4, 3), (1, 3, 2, 4), (1, 3, 4, 2), (1, 4, 2, 3), (1, 4, 3, 2), (2, 1, 3, 4), (2, 1, 4, 3), (2, 3, 1, 4), (2, 3, 4, 1), (2, 4, 1, 3), (2, 4, 3, 1), (3, 1, 2, 4), (3, 1, 4, 2), (3, 2, 1, 4), (3, 2, 4, 1), (3, 4, 1, 2), (3, 4, 2, 1), (4, 1, 2, 3), (4, 1, 3, 2), (4, 2, 1, 3), (4, 2, 3, 1), (4, 3, 1, 2), (4, 3, 2, 1)] </code></pre> <h2>Understanding the inner mechanisms of iteration</h2> <p>Iteration is a process implying iterables (implementing the <code>__iter__()</code> method) and iterators (implementing the <code>__next__()</code> method). Iterables are any objects you can get an iterator from. Iterators are objects that let you iterate on iterables.</p> <p>There is more about it in this article about <a href="http://effbot.org/zone/python-for-statement.htm" rel="noreferrer">how <code>for</code> loops work</a>.</p>
    singulars
    1. This table or related slice is empty.
    1. POWhat does the "yield" keyword do?
      singulars
      1. PTQuestion
    1. PTAnswer
    1. USPeter Mortensen
    1. USe-satis
...and more
 

Querying!

 
Guidance
A table list

Lists show table rows with slightly less information than detail views, therefore not requiring section labels.

This list shows the beginning of an entire table.

Search

Searching on lists works via indexes when the table is large. On the left you see input fields generated from viable indexes and an expandable report for all indexes that are unavailable for searching with the respective reasons.

Searching along indexes is called seeking and this is one of the main values that databases offer. The trivial alternative is scanning, which is potentially inefficient as it works by walking the entirety of the candidate rows to find the matches.

The offer to scan is given for small tables. Currently, this only works on text and integer columns and they are searched all at once.

Loading more

Loading more rows than the initial 10 results is also currently restricted to a single reloading of 100 entries.

A future version will keep auto-loading on scroll for tables that have suitable indexes.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload