id int64 0 25.6k | text stringlengths 0 4.59k |
|---|---|
23,000 | abefore split bafter split -node -node cbefore color flip dafter color flip -node -node figure two red children one red child -node split and color flip thuswe see that splitting -node during the insertion process in tree is equivalent to performing color flips during the insertion process in red-black tree -node split... |
23,001 | trees and external storage atree bleft slant color change color change rotation cright slant black node red node figure -node and rotation although these arrangements are equally validyou can see that the tree in bis not balancedwhile that in cis given the red-black tree in )we would want to rotate it to the right (and... |
23,002 | efficiency of trees it' harder to analyze the efficiency of tree than red-black treebut the equivalence of red-black trees and trees gives us starting point speed as we saw in in red-black tree one node on each level must be visited during searchwhether to find an existing node or insert new one the number of levels in... |
23,003 | trees and external storage if we take two data items per node as the average utilizationabout / of the available storage is wasted you might imagine using linked lists instead of arrays to hold the child and data referencesbut the overhead of the linked list compared with an arrayfor only three or four itemswould proba... |
23,004 | nodeand one to move up to the parent node full node in tree has three data itemswhich are moved to these three destinations howevera full node in tree has only two data items where can we get third itemwe must use the new itemthe one being inserted in the tree in tree the new item is inserted after all the splits have ... |
23,005 | trees and external storage ab figure splitting the root figure shows node split that ripples up through tree until it reaches the root figure splits rippling up tree implementation we'll leave complete java implementation of - tree as an exercise howeverwe'll finish with some hints on how to handle splits this is only ... |
23,006 | method can be the full leaf node and the new item it will be the responsibility of split(to make the split and insert the new node in the new leaf if split(finds that the leaf' parent is fullit calls itself recursively to split the parent it keeps calling itself until non-full leaf or the root is found the return value... |
23,007 | trees and external storage in this figure the new nodes created as the result of split are shadedand new connections are shown as wiggly lines external storage trees are examples of multiway treeswhich have more than two children and more than one data item another kind of multiway treethe -treeis useful when data resi... |
23,008 | used internally by the phone company let' say an entry is stored as record requiring bytes the result is file size of , which is , , bytes or megabytes we'll assume that on the target machine this is too large to fit in main memory but small enough to fit on your disk drive thusyou have large amount of data on your dis... |
23,009 | trees and external storage assume block size of , bytes ( thusour phone book database will require , , bytes divided by , bytes per blockwhich is , blocks your software is most efficient when it specifies read or write operation that' multiple of the block size if you ask to read bytesthe system will read one block , b... |
23,010 | once the read-write head is positioned as described earlierreading block is fairly fastrequiring only few milliseconds thusa disk access to read or write block is not very dependent on the size of the block it follows that the larger the blockthe more efficiently you can read or write single record (assuming you use al... |
23,011 | trees and external storage in practice this number is reduced somewhat because we read records at once in the beginning stages of binary searchit doesn' help to have multiple records in memory because the next access will be in distant part of the file howeverwhen we get close to the desired recordthe next record we wa... |
23,012 | they willbut different kind of tree must be used for external data than for inmemory data the appropriate tree is multiway tree somewhat like treebut with many more data items per nodeit' called -tree -trees were first conceived as appropriate structures for external storage by bayer and mccreight in (strictly speaking... |
23,013 | trees and external storage as many as the node actually holds)starting at when it finds record with greater keyit knows to go to the child whose link lies between this record and the preceding one smith smyth smoot snell (other data (other data figure (other data , , , (other data , block numbers , node in -tree of ord... |
23,014 | againas in - treeit' not the middle item in node that' promoted upwardbut the middle item in the sequence formed from the items in the node plus the new item we'll demonstrate these features of the insertion process by building small -treeas shown in figure there isn' room to show realistic number of records per nodeso... |
23,015 | trees and external storage figure building -tree |
23,016 | howeverthe next item to be inserted does cause splitin fact it causes two of them the second node child is fullso it' splitas shown in figure howeverthe promoted from this splithas no place to go because the root is full thereforethe root must be split as wellresulting in the arrangement of figure notice that throughou... |
23,017 | trees and external storage thususing -treeonly six disk accesses are necessary to find any record in file of , records at milliseconds per accessthis takes about millisecondsor / of second this is dramatically faster than the binary search of sequentially ordered file the more records there are in nodethe fewer levels ... |
23,018 | let' say we use string bytes long for the key (big enough for most last namesand bytes for the block number ( type int in javaeach entry in our index thus requires bytes this is only / the amount necessary for each record the entries in the index are arranged sequentially by last name the original records on the disk c... |
23,019 | trees and external storage time to read the actual record from the fileonce its block number has been found in the index howeverthis is only one disk access of (say milliseconds insertion to insert new item in an indexed filetwo steps are necessary we first insert the item' full record into the main filethen we insert ... |
23,020 | note that when an index is arranged as -treeeach node contains child pointers and - data items the child pointers are the block numbers of other nodes in the index the data items consist of key value and pointer to block in the main file don' confuse these two kinds of block pointers complex search criteria in complex ... |
23,021 | trees and external storage internal memory (of courseall these sizes would be much larger in real situation figure shows the file before sortingthe number in each record is its key value ablock sort block sort block sort merge file sort file merge block file file merge figure mergesort on an external file internal sort... |
23,022 | and - are merged into -- - also- and - are merged into -- - the result is shown in figure third file is necessary to hold the result of this merge step in the second passthe two -record sequences are merged into -record sequencewhich can be written back to file as shown in figure now the sort is complete of coursemore ... |
23,023 | trees and external storage merge into arr (arr is now empty read - into arr merge into arr write to disk merge into arr (arr is now empty read - into arr merge into arr write to disk merge into arr write to disk this last sequence of steps is rather lengthyso it may be helpful to examine the details of the array conten... |
23,024 | summary multiway tree has more keys and children than binary tree tree is multiway tree with up to three keys and four children per node in multiway treethe keys in node are arranged in ascending order in treeall insertions are made in leaf nodesand all leaf nodes are on the same level three kinds of nodes are possible... |
23,025 | trees and external storage - tree is similar to treeexcept that it can have only one or two data items and onetwoor three children insertion in - tree involves finding the appropriate leaf and then performing splits from the leaf upwarduntil non-full node is found external storage means storing data outside of main mem... |
23,026 | which of the following is not true each time node is splita exactly one new node is created exactly one new data item is added to the tree one data item moves from the split node to its parent one data item moves from the split node to its new sibling tree increases its number of levels when searching tree does not inv... |
23,027 | trees and external storage true or falsenode splits in -tree have similarities to node splits in - tree in external storageindexing means keeping file of keys and their corresponding blocks records and their corresponding blocks keys and their corresponding records last names and their corresponding keys experiments ca... |
23,028 | being splitdoes not also need to be split this implies that the split(routine need not be recursive in writing insert()remember that no splits happen until the appropriate leaf has been located then the leaf will be split if it' full you'll need to be able to split the root toobut only when it' leaf with this limited r... |
23,029 | hash tables in this introduction to hashing open addressing separate chaining hash table is data structure that offers very fast insertion and searching when you first hear about themhash tables sound almost too good to be true no matter how many data items there areinsertion and searching (and sometimes deletioncan ta... |
23,030 | hash tables introduction to hashing in this section we'll introduce hash tables and hashing one important concept is how range of key values is transformed into range of array index values in hash table this is accomplished with hash function howeverfor certain kinds of keysno hash function is necessarythe key values c... |
23,031 | as you knowaccessing specified array element is very fast if you know its index number the clerk looking up herman alcazar knows that he is employee number so he enters that numberand the program goes instantly to index number in the array single program statement is all that' necessaryemprecord rec databasearray[ ]add... |
23,032 | hash tables converting words to numbers what we need is system for turning word into an appropriate index number to beginwe know that computers use various schemes for representing individual characters as numbers one such scheme is the ascii codein which is is and so onup to for howeverthe ascii code runs from to to a... |
23,033 | thusthe total range of word codes is from to unfortunatelythere are , words in the dictionaryso there aren' enough index numbers to go around each array element will need to hold about words ( , divided by clearlythis presents problems if we're thinking in terms of our one word-per-array element scheme maybe we could p... |
23,034 | hash tables say we want to convert the word cats to number we convert the digits to numbers as shown earlier then we multiply each number by the appropriate power of and add the results * * * * calculating the powers gives * , * * * and multiplying the letter codes times the powers yields , which sums to , this process... |
23,035 | hashing what we need is way to compress the huge range of numbers we obtain from the numbers-multiplied-by-powers system into range that matches reasonably sized array how big an array are we talking about for our english dictionaryif we have only , wordsyou might assume our array should have approximately this many el... |
23,036 | hash tables small range large range figure range conversion thenusing the modulo operator (%)we squeeze the resulting huge range of numbers into range about twice as big as the number of items we want to store this is an example of hash functionarraysize numberwords arrayindex hugenumber arraysizein the huge rangeeach ... |
23,037 | collisions we pay price for squeezing large range into small one there' no longer guarantee that two words won' hash to the same array index this is similar to what happened when we added the letter codesbut the situation is nowhere near as bad when we added the lettersthere were only possible results (for words up to ... |
23,038 | hash tables remember that we've specified an array with twice as many cells as data items thusperhaps half the cells are empty one approachwhen collision occursis to search the array in some systematic way for an empty cell and insert the new item thereinstead of at the index specified by the hash function this approac... |
23,039 | figure the hash workshop applet at startup for the initial array size of this is arrayindex key this hash function is simple enough that you can solve it mentally for given keykeep subtracting until you get number less than for exampleto hash subtract giving and then againgiving this is the index number where the algor... |
23,040 | hash tables the fill button initiallythe hash table contains itemsso it' half full howeveryou can also fill it with specified number of data items using the fill button keep clicking filland when promptedtype the number of items to fill hash tables work best when they are not more than half or at the most two-thirds fu... |
23,041 | alsonote that if the hash table becomes completely fullthe algorithms all stop workingin this applet they assume that the table has at least one empty cell the find button the find button starts by applying the hash function to the key value you type into the number box this results in an array index the cell at this i... |
23,042 | hash tables try inserting some new data items type in three-digit number and watch what happens most items will go into the first cell they trybut some will suffer collisions and need to step along to find an empty cell the number of steps they take is the probe length most probe lengths are only few cells long sometim... |
23,043 | clustering try inserting more items into the hash table in the hash workshop applet as it gets more fullthe clusters grow larger clustering can result in very long probe lengths this means that accessing cells at the end of the sequence is very slow the more full the array isthe worse clustering becomes it' not usually... |
23,044 | hash tables as hashval steps through the arrayit eventually reaches the end when this happenswe want it to wrap around to the beginning we could check for this with an if statementsetting hashval to whenever it equaled the array size howeverwe can accomplish the same thing by applying the operator to hashval and the ar... |
23,045 | dataitem temp hasharray[hashval]/save item hasharray[hashvalnonitem/delete item return temp/return item ++hashval/go to next cell hashval %arraysize/wrap around if necessary return null/can' find item /end delete(the hash java program listing shows the complete hash java program in this program dataitem object contains... |
23,046 | listing hash tables continued private dataitem nonitem/for deleted items /public hashtable(int size/constructor arraysize sizehasharray new dataitem[arraysize]nonitem new dataitem(- )/deleted item key is - /public void displaytable(system out print("table")for(int = <arraysizej++if(hasharray[ !nullsystem out print(hash... |
23,047 | listing continued /public dataitem delete(int key/delete dataitem int hashval hashfunc(key)/hash the key while(hasharray[hashval!null/until empty cell/found the keyif(hasharray[hashvalgetkey(=keydataitem temp hasharray[hashval]/save item hasharray[hashvalnonitem/delete item return temp/return item ++hashval/go to next ... |
23,048 | listing hash tables continued /get sizes system out print("enter size of hash table")size getint()system out print("enter initial number of items") getint()keyspercell /make table hashtable thehashtable new hashtable(size)for(int = <nj++/insert data akey (int)(java lang math random(keyspercell size)adataitem new datait... |
23,049 | listing continued adataitem thehashtable find(akey)if(adataitem !nullsystem out println("found akey)else system out println("could not find akey)breakdefaultsystem out print("invalid entry\ ")/end switch /end while /end main(//public static string getstring(throws ioexception inputstreamreader isr new inputstreamreader... |
23,050 | hash tables initiallythe program asks the user to input the size of the hash table and the number of items in it you can make it almost any sizefrom few items to , (building larger tables than this may take little time don' use the (for showoption on tables of more than few hundred itemsthey scroll off the screen and d... |
23,051 | remember that the hash function calculates the location of given data item based on the array sizeso items won' be located in the same place in the large array as they were in the small array you can' therefore simply copy the items from one array to the other you'll need to go through the old array in sequencecell by ... |
23,052 | hash tables quadratic probing we've seen that clusters can occur in the linear probe approach to open addressing once cluster formsit tends to grow larger items that hash to any value in the range of the cluster will step along and insert themselves at the end of the clusterthus making it even bigger the bigger the clu... |
23,053 | figure initial probe initial probe asuccessful search for bunsuccessful search for quadratic probes to see how quadratic probes lookstart up this applet and create new hash table of items using the new button when you're asked to select double or quadratic probeclick the quad button after the new table is createdfill i... |
23,054 | hash tables tip importantalways make the array size prime number use instead of for example (other primes less than are and if the array size is not primean endless sequence of steps may occur during probe if this happens during fill operationthe applet will be paralyzed the problem with quadratic probes quadratic prob... |
23,055 | where constant is prime and smaller than the array size for examplestepsize (key )this is the secondary hash function used in the hashdouble workshop applet different keys may hash to the same indexbut they will (most likelygenerate different step sizes with this hash function the step sizes are all in the range to thi... |
23,056 | hash tables java code for double hashing listing shows the complete listing for hashdouble javawhich uses double hashing it' similar to the hash java program (listing )but uses two hash functionsone for finding the initial index and the second for generating the step size as beforethe user can show the table contentsin... |
23,057 | listing continued if(hasharray[ !nullsystem out print(hasharray[jgetkey()")else system out print("*")system out println("")/public int hashfunc (int keyreturn key arraysize/public int hashfunc (int key/non-zeroless than array sizedifferent from hf /array size must be relatively prime to and return key //insert dataitem... |
23,058 | listing hash tables continued while(hasharray[hashval!null/until empty cell/is correct hashvalif(hasharray[hashvalgetkey(=keydataitem temp hasharray[hashval]/save item hasharray[hashvalnonitem/delete item return temp/return item hashval +stepsize/add the step hashval %arraysize/for wraparound return null/can' find item... |
23,059 | listing continued size getint()system out print("enter initial number of items") getint()/make table hashtable thehashtable new hashtable(size)for(int = <nj++/insert data akey (int)(java lang math random( size)adataitem new dataitem(akey)thehashtable insert(akeyadataitem)while(true/interact with user system out print("... |
23,060 | listing hash tables continued system out println("could not find akey)breakdefaultsystem out print("invalid entry\ ")/end switch /end while /end main(//public static string getstring(throws ioexception inputstreamreader isr new inputstreamreader(system in)bufferedreader br new bufferedreader(isr)string br readline()ret... |
23,061 | table continued item number key hash value step size cells in probe sequence the first keys mostly hash to vacant cell (the th one is an anomalyafter thatas the array gets more fullthe probe sequences become quite long here' the resulting array of keys* * table size prime number double hashing requires that the size of... |
23,062 | hash tables similar effect occurs using the quadratic probe in that casehoweverthe step size gets larger with each step and will eventually overflow the variable holding itthus preventing an endless loop in generaldouble hashing is the probe sequence of choice when open addressing is used separate chaining in open addr... |
23,063 | figure separate chaining in the hashchain workshop applet each element of the array occupies one line of the displayand the linked lists extend from left to right initiallythere are cells in the array ( liststhis is more than fits on the screenyou can move the display up and down with the scrollbar to see the entire ar... |
23,064 | hash tables of courseif there are many items on the listsaccess time is reduced because access to specified item requires searching through an average of half the items on the list finding the initial cell takes fast ( timebut searching through list takes time proportional to mthe average number of items on the list th... |
23,065 | problem of choosing the size of the buckets if they're too smallthey may overflowand if they're too largethey waste memory linked listswhich allocate memory dynamicallydon' have this problem java code for separate chaining the hashchain java program includes sortedlist class and an associated link class sorted lists do... |
23,066 | listing hash tables continued /end class link ///////////////////////////////////////////////////////////////class sortedlist private link first/ref to first list item /public void sortedlist(/constructor first null/public void insert(link thelink/insert linkin order int key thelink getkey()link previous null/start at ... |
23,067 | listing continued previous next current next/delete current link /end delete(/public link find(int key/find link link current first/start at first /until end of listwhile(current !null ¤t getkey(<key/or key too smallif(current getkey(=key/is this the linkreturn current/found itreturn link current current next/go ... |
23,068 | listing hash tables continued /public void displaytable(for(int = <arraysizej++/for each cellsystem out print( ")/display cell number hasharray[jdisplaylist()/display list /public int hashfunc(int key/hash function return key arraysize/public void insert(link thelink/insert link int key thelink getkey()int hashval hash... |
23,069 | listing continued int akeylink adataitemint sizenkeyspercell /get sizes system out print("enter size of hash table")size getint()system out print("enter initial number of items") getint()/make table hashtable thehashtable new hashtable(size)for(int = <nj++/insert data akey (int)(java lang math random(keyspercell size)a... |
23,070 | listing hash tables continued akey getint()adataitem thehashtable find(akey)if(adataitem !nullsystem out println("found akey)else system out println("could not find akey)breakdefaultsystem out print("invalid entry\ ")/end switch /end while /end main(//public static string getstring(throws ioexception inputstreamreader ... |
23,071 | list (first-->last) list (first-->last) list (first-->last) list (first-->last) list (first-->last) list (first-->last) list (first-->last) list (first-->last) list (first-->last) list (first-->last) list (first-->last) list (first-->last) list (first-->last) list (first-->last) list (first-->last) list (first-->last) ... |
23,072 | hash tables random keys so-called perfect hash function maps every key into different table location this is only possible for keys that are unusually well behaved and whose range is small enough to be used directly as array indices (as in the employee-number example at the beginning of this in most cases neither of th... |
23,073 | don' use non-data the key fields should be squeezed down until every bit counts for examplethe category codes should be changed to run from to alsothe checksum should be removed because it doesn' add any additional informationit' deliberately redundant various bit-twiddling techniques are appropriate for compressing th... |
23,074 | hash tables this approach has the desirable attribute of involving all the characters in the input string the calculated key value can then be hashed into an array index in the usual wayindex (keyarraysizehere' java method that finds the key value of stringpublic static int hashfunc (string keyint hashval int pow / * e... |
23,075 | for(int = <key length() ++int letter key charat( hashval hashval letterreturn hashval arraysize/end hashfunc (/left to right /get char code /multiply and add /mod here we start with the leftmost letter of the word (which is somewhat more natural than starting on the right)and we have only one multiplication and one add... |
23,076 | hash tables folding another reasonable hash function involves breaking the key into groups of digits and adding the groups this ensures that all the digits influence the hash value the number of digits in group should correspond to the size of the array that isfor an array of , itemsuse groups of three digits each for ... |
23,077 | in open addressingunsuccessful searches generally take longer than successful searches during probe sequencethe algorithm can stop as soon as it finds the desired itemwhich ison the averagehalfway through the probe sequence on the other handit must go all the way to the end of the sequence before it' sure it can' find ... |
23,078 | hash tables at load factor of / successful search takes comparisons and an unsuccessful search takes at load factor of / the numbers are and at higher load factors the numbers become very large the moralas you can seeis that the load factor must be kept under / and preferably under / on the other handthe lower the load... |
23,079 | average probe length unsuccessful successful figure load factor quadratic-probe and double-hashing performance this is the same as the definition of the load factorloadfactor arraysize so the average list length equals the load factor searching in successful searchthe algorithm hashes to the appropriate list and then s... |
23,080 | hash tables these formulas are graphed in figure average probe length unsuccessful successful load factor figure separate-chaining performance for an ordered listonly half the items must be examined in an unsuccessful searchso the time is the same as for successful search in separate chaining it' typical to use load fa... |
23,081 | if the number of items that will be inserted in hash table isn' known when the table is createdseparate chaining is preferable to open addressing increasing the load factor causes major performance penalties in open addressingbut performance degrades only linearly in separate chaining when in doubtuse separate chaining... |
23,082 | hash tables dewitt white bercerra chong appleby decosta milano freeman keys hash to array indices block lang milano danzig full figure block chong leblanc empty smith full external hashing all records with keys that hash to the same value are located in the same block to find record with particular keythe search algori... |
23,083 | in open addressingifduring insertionone block is found to be fullthe algorithm inserts the new record in neighboring block in linear probing this is the next blockbut it could also be selected using quadratic probe or double hashing in separate chainingspecial overflow blocks are made availablewhen primary block is fou... |
23,084 | hash tables quadratic probing eliminates primary clustering but suffers from the less severe secondary clustering secondary clustering occurs because all the keys that hash to the same value follow the same sequence of steps during probe all keys that hash to the same value follow the same probe sequence because the st... |
23,085 | using big notationsay how long it takes (ideallyto find an item in hash table transforms range of key values into range of index values open addressing refers to keeping many of the cells in the array unoccupied keeping an open mind about which address to use probing at cell + + and so on until an empty cell is found l... |
23,086 | hash tables in separate chaining the time to insert new item increases linearly with the load factor is proportional to the number of items in the table is proportional to the number of lists is proportional to the percentage of full cells in the array true or falsein external hashingit' important that the records don'... |
23,087 | programming projects writing programs to solve the programming projects helps to solidify your understanding of the material and demonstrates how the concepts are applied (as noted in the introductionqualified instructors may obtain completed solutions to the programming projects on the publisher' web site modify the h... |
23,088 | heaps in this introduction to heaps java code for heaps tree-based heap we saw in "stacks and queues,that priority queue is data structure that offers convenient access to the data item with the smallest (or largestkey priority queues may be used for task scheduling in computerswhere some programs and activities should... |
23,089 | heaps in this we'll describe another structure that can be used to implement priority queuethe heap heap is kind of tree it offers both insertion and deletion in (logntime thusit' not quite as fast for deletionbut much faster for insertion it' the method of choice for implementing priority queues where speed is importa... |
23,090 | heap array figure heap root last node heap and its underlying array the fact that heap is complete binary tree implies that there are no "holesin the array used to represent it every cell is filledfrom to - ( is in figure we'll assume in this that the maximum key (rather than the minimumis in the root priority queue ba... |
23,091 | heaps class priorityqueue private heap theheappublic void insert(node ndtheheap insert(nd)public node remove(return theheap remove(the methods for the priorityqueue class are simply wrapped around the methods for the underlying heap classthey have the same functionality this example makes it conceptually clear that pri... |
23,092 | heap as priority queue we'll discuss briefly how these operations are carried out and then see them in action in workshop applet removal removal means removing the node with the maximum key this node is always the rootso removing it is easy the root is always at index of the heap arraymaxnode heaparray[ ]the problem is... |
23,093 | heaps removed ab last node swap cd swap swap figure removing the maximum node at each position of the target node the trickle-down algorithm checks which child is larger it then swaps the target node with the larger child if it tried to swap with the smaller childthat child would become the parent of larger childwhich ... |
23,094 | insertion inserting node is also easy insertion uses trickle uprather than trickle down initiallythe node to be inserted is placed in the first open position at the end of the arrayincreasing the array size by oneheaparray[nnewnoden++the problem is that it' likely that this will destroy the heap condition this happens ... |
23,095 | heaps the trickle-up algorithm is somewhat simpler than trickling down because two children don' need to be compared node has only one parentand the target node is simply swapped with its parent in the figure the final correct position for the new node happens to be the rootbut new node can also end up at an intermedia... |
23,096 | storage account for less of the total for large number of levels the savings in the number of copies approach factor of three another way to visualize trickle-up and trickle-down processes being carried out with copies is to think of "hole"--the absence of node--moving down in trickle up and up in trickle down for exam... |
23,097 | heaps the change button it' possible to change the priority of an existing node this procedure is useful in many situations for examplein our cruiser examplea threat such as an approaching airplane may reverse course away from the carrierits priority should be lowered to reflect this new developmentalthough the aircraf... |
23,098 | insertion we place the trickle-up algorithm in its own method the insert(methodwhich includes call to this trickleup(methodis straightforwardpublic boolean insert(int keyif(currentsize==maxsizereturn falsenode newnode new node(key)heaparray[currentsizenewnodetrickleup(currentsize++)return true/end insert(/if array is f... |
23,099 | heaps finallywhen the loop has exitedthe newly inserted nodewhich has been temporarily stored in bottomis inserted into the cell pointed to by index this is the first location where it' not larger than its parentso inserting it here satisfies the heap condition removal the removal algorithm is also not complicated if w... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.