Listing 15.4 defines the sequence shown in Figure 15.4. You can use a sequence generator in a few ways. The SQL standard provides the built-in function NEXT VALUE FOR to increment a sequence value, as in: INSERT INTO shipment( part_num, desc, quantity) VALUES( NEXT VALUE FOR part_seq, ‘motherboard’, 5); If you’re creating a column of unique values, you can use the keyword IDENTITY to define a sequence right in the CREATE TABLE statement: CREATE TABLE parts ( part_num INTEGER AS IDENTITY(INCREMENT BY 1 MINVALUE 1 MAXVALUE 10000 START WITH 1 NO CYCLE), desc AS VARCHAR(100), quantity INTEGER; This table definition lets you omit NEXT VALUE FOR when you insert a row: INSERT INTO shipment( desc, quantity) VALUES( ‘motherboard’, 5); SQL also provides ALTER SEQUENCE and DROP SEQUENCE to change and remove sequence generators. 410 Chapter 15 Generating Sequences Listing 15.4 Create a sequence generator for the consecutive integers 1 to 10,000. See Figure 15.4 for the result. CREATE SEQUENCE part_seq INCREMENT BY 1 MINVALUE 1 MAXVALUE 10000 START WITH 1 NO CYCLE; Listing 1 2 3 9998 9999 10000 Figure 15.4 The sequence that Listing 15.4 generates. ✔ Tip ■ Oracle, DB2, and PostgreSQL support CREATE SEQUENCE , ALTER SEQUENCE , and DROP SEQUENCE . In Oracle, use NOCYCLE instead of NO CYCLE . See your DBMS documentation to see how sequences are used in your system. Most DBMSs don’t support IDENTITY columns because they have other (pre- SQL:2003) ways that define columns with unique values. See Table 3.18 in “Unique Identifiers” in Chapter 3. PostgreSQL’s generate_series() function offers a quick way to generate numbered rows. A one-column table containing a sequence of consecutive integers makes it easy to solve problems that would otherwise be difficult with SQL’s limited computational power. Sequence tables aren’t really part of the data model—they’re auxiliary tables that are adjuncts to queries and other “real” tables. You can create a sequence table by using one of the methods just described. Alternatively, you can create one by using Listing 15.5, which creates the sequence table seq by cross-joining the intermediate table temp09 with itself. The CAST expression concatenates digit characters into sequential numbers and then casts them as integers. You can drop temp09 after seq is created. Figure 15.5 shows the result. The table seq contains the integer sequence 0, 1, 2, …, 9999. You can shrink or grow this sequence by changing the SELECT and FROM expressions in the INSERT INTO seq statement. 411 SQL Tricks Generating Sequences Listing 15.5 Create a one-column table that contains consecutive integers. See Figure 15.5 for the result. CREATE TABLE temp09 ( i CHAR(1) NOT NULL PRIMARY KEY ); INSERT INTO temp09 VALUES('0'); INSERT INTO temp09 VALUES('1'); INSERT INTO temp09 VALUES('2'); INSERT INTO temp09 VALUES('3'); INSERT INTO temp09 VALUES('4'); INSERT INTO temp09 VALUES('5'); INSERT INTO temp09 VALUES('6'); INSERT INTO temp09 VALUES('7'); INSERT INTO temp09 VALUES('8'); INSERT INTO temp09 VALUES('9'); CREATE TABLE seq ( i INTEGER NOT NULL PRIMARY KEY ); INSERT INTO seq SELECT CAST(t1.i || t2.i || t3.i || t4.i AS INTEGER) FROM temp09 t1, temp09 t2, temp09 t3, temp09 t4; DROP TABLE temp09; Listing i 0 1 2 3 4 9996 9997 9998 9999 Figure 15.5 Result of Listing 15.5. A sequence table is especially useful for enumerative and datetime functions. Listing 15.6 lists the 95 printable charac- ters in the ASCII character set (if that’s the character set in use). See Figure 15.6 for the result. Listing 15.7 adds monthly intervals to today’s date (7-March-2005) for the next six months. See Figure 15.7 for the result. This example works on Microsoft SQL Server; the other DBMSs have similar functions that increment dates. Sequence tables are handy for normalizing data that you’ve imported from a non- relational environment such as a spreadsheet. Suppose that you have the following non- normalized table, named au_orders , showing the order of the authors’ names on each book’s cover: title_id author1 author2 author3 ———————— ——————— ——————— ——————— T01 A01 NULL NULL T02 A01 NULL NULL T03 A05 NULL NULL T04 A03 A04 NULL T05 A04 NULL NULL T06 A02 NULL NULL T07 A02 A04 NULL T08 A06 NULL NULL T09 A06 NULL NULL T10 A02 NULL NULL T11 A06 A03 A04 T12 A02 NULL NULL T13 A01 NULL NULL Listing 15.8 cross-joins au_orders with seq to produce Figure 15.8. You can DELETE the result rows with nulls in the column au_id , leaving the result set looking like the table title_authors in the sample database. Note that Listing 15.8 does the reverse of Listing 8.18 in Chapter 8. 412 Chapter 15 Generating Sequences Listing 15.6 List the characters associated with a set of character codes. See Figure 15.6 for the result. SELECT i AS CharCode, CHR(i) AS Ch FROM seq WHERE i BETWEEN 32 AND 126; Listing CharCode Ch 32 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / 48 0 49 1 50 2 51 3 52 4 Figure 15.6 Result of Listing 15.6. 413 SQL Tricks Generating Sequences Listing 15.7 Increment today’s date to six months hence, in one-month intervals. See Figure 15.7 for the result. SELECT i AS MonthsAhead, DATEADD("m", i, CURRENT_TIMESTAMP) AS FutureDate FROM seq WHERE i BETWEEN 1 AND 6; Listing MonthsAhead FutureDate 1 2005-04-07 2 2005-05-07 3 2005-06-07 4 2005-07-07 5 2005-08-07 6 2005-09-07 Figure 15.7 Result of Listing 15.7. Listing 15.8 Normalize the table au_orders . See Figure 15.8 for the result. SELECT title_id, (CASE WHEN i=1 THEN '1' WHEN i=2 THEN '2' WHEN i=3 THEN '3' END) AS au_order, (CASE WHEN i=1 THEN author1 WHEN i=2 THEN author2 WHEN i=3 THEN author3 END) AS au_id FROM au_orders, seq WHERE i BETWEEN 1 AND 3 ORDER BY title_id, i; Listing title_id au_order au_id T01 1 A01 T01 2 NULL T01 3 NULL T02 1 A01 T02 2 NULL T02 3 NULL T03 1 A05 T03 2 NULL T03 3 NULL T04 1 A03 T04 2 A04 T04 3 NULL T05 1 A04 T05 2 NULL T05 3 NULL T06 1 A02 T06 2 NULL T06 3 NULL T07 1 A02 T07 2 A04 T07 3 NULL T08 1 A06 T08 2 NULL T08 3 NULL T09 1 A06 T09 2 NULL T09 3 NULL T10 1 A02 T10 2 NULL T10 3 NULL T11 1 A06 T11 2 A03 T11 3 A04 T12 1 A02 T12 2 NULL T12 3 NULL T13 1 A01 T13 2 NULL T13 3 NULL Figure 15.8 Result of Listing 15.8. ✔ Tips ■ If you have a column of sequential inte- gers that’s missing some numbers, you can fill in the gaps by EXCEPT ing the column with a sequence column. See “Finding Different Rows with EXCEPT ” earlier in this chapter. ■ To run Listing 15.5 in Microsoft Access and Microsoft SQL Server, change the CAST expression to: t1.i + t2.i + t3.i + t4.i To run Listing 15.5 in MySQL, change the CAST expression to: CONCAT(t1.i, t2.i, t3.i, t4.i) To run Listing 15.6 in Microsoft SQL Server and MySQL, change CHR(i) to CHAR(i) . To run Listing 15.8 in Microsoft Access, change the CASE expressions to Switch() function calls (see the DBMS Tip in “Evaluating Conditional Values with CASE ” in Chapter 5): (Switch(i=1, ‘1’, i=2, ‘2’, i=3, ‘3’)) AS au_order, (Switch(i=1, author1, i=2, author2, i=3, author3)) AS au_id 414 Chapter 15 Generating Sequences Calendar Tables Another useful auxiliary table is a calendar table. One type of calendar table has a primary-key column that contains a row for each calendar date (past and future) and other columns that indicate the date’s attributes: business day, holiday, international holiday, fiscal-month end, fiscal-year end, Julian date, business- day offsets, and so on. Another type of calendar table stores the starting and ending dates of events (in the columns event_id , start_date , and end_date , for example). Spreadsheets have more date- arithmetic functions than DBMSs, so it might be easier to build a calendar table in a spreadsheet and then import it as a database table. Even if your DBMS has plenty of date- arithmetic functions, it might be faster to look up data in a calendar table than to call these functions in a query. Finding Sequences, Runs, and Regions A sequence is a series of consecutive values without gaps. A run is like a sequence, but the values don’t have to be consecutive, just increasing (that is, gaps are allowed). A region is an unbroken series of values that all are equal. Finding these series requires a table that has at least two columns: a primary-key column that holds a sequence of consecutive inte- gers and a column that holds the values of interest. The table temps (Listing 15.9 and Figure 15.9) shows a series of high temper- atures over 15 days. As a set-oriented language, SQL isn’t a good choice for finding series of values. The fol- lowing queries won’t run very fast, so if you have a lot of data to analyze, you might con- sider exporting it to a statistical package or using a procedural host language. ✔ Tip ■ These queries are based on the ideas in David Rozenshtein, Anatoly Abramovich, and Eugene Birger’s Optimizing Transact- SQL: Advanced Programming Techniques (SQL Forum Press). You can use the queries’ common framework to create similar queries that find other series of values. 415 SQL Tricks Finding Sequences, Runs, and Regions Listing 15.9 List all the column in the table temps . See Figure 15.9 for the result. SELECT * FROM temps; Listing id hi_temp 1 49 2 46 3 48 4 50 5 50 6 50 7 51 8 52 9 53 10 50 11 50 12 47 13 50 14 51 15 52 Figure 15.9 Result of Listing 15.9. Listing 15.10 finds all the sequences in temps and lists each sequence’s start position, end position, and length. See Figure 15.10 for the result. This query is a lot to take in at first glance, but it’s easier to understand it if you look at it piecemeal. Then you’ll be able to under- stand the rest of the queries in this section. The subquery’s WHERE clause subtracts id from hi_temp , yielding (internally): id hi_temp diff —— ——————— ———— 1 49 48 2 46 44 3 48 45 4 50 46 5 50 45 6 50 44 7 51 44 8 52 44 9 53 44 10 50 40 11 50 39 12 47 35 13 50 37 14 51 37 15 52 37 In the column diff , note that successive differences are constant for sequences (50 – 6 = 44, 51 – 7 = 44, and so on). To find neighboring rows, the outer query cross-joins two instances of the same table ( t1 and t2 ), as described in “Calculating Running Statistics” earlier in this chapter. The condition WHERE (t1.id < t2.id) guarantees that any t1 row represents an element with an index ( id ) lower than the corresponding t2 row. 416 Chapter 15 Finding Sequences, Runs, and Regions Listing 15.10 List the starting point, ending point, and length of each sequence in the table temps . See Figure 15.10 for the result. SELECT t1.id AS StartSeq, t2.id AS EndSeq, t2.id - t1.id + 1 AS SeqLen FROM temps t1, temps t2 WHERE (t1.id < t2.id) AND NOT EXISTS( SELECT * FROM temps t3 WHERE (t3.hi_temp - t3.id <> t1.hi_temp - t1.id AND t3.id BETWEEN t1.id AND t2.id) OR (t3.id = t1.id - 1 AND t3.hi_temp - t3.id = t1.hi_temp - t1.id) OR (t3.id = t2.id + 1 AND t3.hi_temp - t3.id = t1.hi_temp - t1.id) ); Listing StartSeq EndSeq SeqSize 6 9 4 13 15 3 Figure 15.10 Result of Listing 15.10. The subquery detects sequence breaks with the condition t3.hi_temp - t3.id <> t1.hi_temp - t1.id The third instance of temps ( t3 ) in the sub- query is used to determine whether any row in a candidate sequence ( t3 ) has the same difference as the sequence’s first row ( t1 ). If so, it’s a sequence member. If not, the can- didate pair ( t1 and t2 ) is rejected. The last two OR conditions determine whether the candidate sequence’s borders can expand. A row that satisfies these conditions means the current candidate sequence can be extended and is rejected in favor of a longer one. ✔ Tip ■ To find only sequences larger than n rows, add the WHERE condition AND (t2.id - t1.id) >= n - 1 To change Listing 15.10 to find all sequences of four or more rows, for example, replace WHERE (t1.id < t2.id) with WHERE (t1.id < t2.id) AND (t2.id - t1.id) >= 3 The result is: StartSeq EndSeq SeqSize ———————— —————— ——————— 6 9 4 417 SQL Tricks Finding Sequences, Runs, and Regions Listing 15.11 finds all the runs in temps and lists each run’s start position, end position, and length. See Figure 15.11 for the result. The logic of this query is similar to that of the preceding one but accounts for run values needing only to increase, not (neces- sarily) be consecutive. The fourth instance of temps ( t4 ) is needed because there doesn’t have to be a constant difference between id and hi_temp values. The subquery cross- joins t3 and t4 to check rows in the middle of a candidate run, whose borders are t1 and t2 . For every element between t1 and t2 (limited by BETWEEN ), t3 and its predecessor t4 are compared to see whether their values are increasing. 418 Chapter 15 Finding Sequences, Runs, and Regions Listing 15.11 List the starting point, ending point, and length of each run in the table temps . See Figure 15.11 for the result. SELECT t1.id AS StartRun, t2.id AS EndRun, t2.id - t1.id + 1 AS RunLen FROM temps t1, temps t2 WHERE (t1.id < t2.id) AND NOT EXISTS( SELECT * FROM temps t3, temps t4 WHERE (t3.hi_temp <= t4.hi_temp AND t4.id = t3.id - 1 AND t3.id BETWEEN t1.id + 1 AND t2.id) OR (t3.id = t1.id - 1 AND t3.hi_temp < t1.hi_temp) OR (t3.id = t2.id + 1 AND t3.hi_temp > t2.hi_temp) ); Listing StartRun EndRun RunLen 2 4 3 6 9 4 12 15 4 Figure 15.11 Result of Listing 15.11. Listing 15.12 finds all regions in temps with a high temperature of 50 and lists each region’s start position, end position, and length. See Figure 15.12 for the result. ✔ Tips ■ To rank regions by length, add an ORDER BY clause to the outer query: ORDER BY t2.id - t1.id DESC ■ To list the individual id s that fall in a region (with value 50), type: SELECT DISTINCT t1.id FROM temps t1, temps t2 WHERE t1.hi_temp = 50 AND t2.hi_temp = 50 AND ABS(t1.id - t2.id) = 1; The standard function ABS() , which all DBMSs support, returns the absolute value of its argument. The result is: id –– 4 5 6 10 11 419 SQL Tricks Finding Sequences, Runs, and Regions Listing 15.12 List the starting point, ending point, and length of each region (with value 50) in the table temps . See Figure 15.12 for the result. SELECT t1.id AS StartReg, t2.id AS EndReg, t2.id - t1.id + 1 AS RegLen FROM temps t1, temps t2 WHERE (t1.id < t2.id) AND NOT EXISTS( SELECT * FROM temps t3 WHERE (t3.hi_temp <> 50 AND t3.id BETWEEN t1.id AND t2.id) OR (t3.id = t1.id - 1 AND t3.hi_temp = 50) OR (t3.id = t2.id + 1 AND t3.hi_temp = 50) ); Listing StartReg EndReg RegLen 4 6 3 10 11 2 Figure 15.12 Result of Listing 15.12. . Optimizing Transact- SQL: Advanced Programming Techniques (SQL Forum Press). You can use the queries’ common framework to create similar queries that find other series of values. 415 SQL Tricks Finding. run Listing 15.5 in Microsoft Access and Microsoft SQL Server, change the CAST expression to: t1.i + t2.i + t3.i + t4.i To run Listing 15.5 in MySQL, change the CAST expression to: CONCAT(t1.i,. change the CAST expression to: CONCAT(t1.i, t2.i, t3.i, t4.i) To run Listing 15.6 in Microsoft SQL Server and MySQL, change CHR(i) to CHAR(i) . To run Listing 15.8 in Microsoft Access, change the CASE expressions