asp.net pdf viewer user control : Create thumbnails from pdf files Library SDK component asp.net wpf web page mvc guide14-part73

Data Access and Change
128
WITH costs(i_d, s) AS (SELECT item_date, SUM(cost) AS s FROM expenses WHERE item_date >=
CURRENT_DATE - 7 DAY GROUP BY item_date),
dates(d, i) AS (SELECT * FROM UNNEST(SEQUENCE_ARRAY(CURRENT_DATE - 7 DAY, CURRENT_DATE - 1 DAY,
1 DAY)) WITH ORDINALITY)   
SELECT i, d, s FROM dates LEFT OUTER JOIN costs ON dates.d = costs.i_d
I D          S      
- ---------- ------ 
1 2010-07-25 (null) 
2 2010-07-26 (null) 
3 2010-07-27 100.12 
4 2010-07-28 (null) 
5 2010-07-29 50.45  
6 2010-07-30 (null) 
7 2010-07-31 (null) 
Table Function Derived Table
Table Function Derived Table
When TABLE is used in this context, the <collection value expression> must be the result of a function call to a
built-in function or user-defined function that returns an array or a table. When the function returns an array, this
array is converted into a table, similar to the way UNNEST operates. When the function returns a table, the result is
a MULTISET and is used as is.
<table  function  derived  table>  ::=  TABLE  <left  paren>  <collection  value
expression> <right paren>
Parenthesized Joined Table
A parenthesized joined table is simply a joined table contained in parentheses. Joined tables are discussed below.
<parenthesized  joined  table>  ::=  <left  paren>  <parenthesized  joined  table>
<right paren> | <left paren> <joined table> <right paren>
Column Name List
column name list
The column list that is specified for the table reference must contain names that are unique within the list
<derived column list> ::= <column name list>
<column name list> ::= <column name> [ { <comma> <column name> }... ]
Joined Table
Joins are operators with two table as the operands, resulting in a third table, called joined table. All join operators are
evaluated left to right, therefore, with multiple joins, the table resulting from the first join operator becomes an operand
of the next join operator. Parentheses can be used to group sequences of joined tables and change the evaluation order.
So if more than two tables are joined together with join operators, the end result is also a joined table. There are
different types of join, each producing the result table in a different way.
<joined table> ::= <cross join> | <qualified join> | <natural join>
<cross join> ::= <table reference> CROSS JOIN <table factor>
Create thumbnails from pdf files - Library SDK component:C# PDF Thumbnail Create SDK: Draw thumbnail images for PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
www.rasteredge.com
Create thumbnails from pdf files - Library SDK component:VB.NET PDF Thumbnail Create SDK: Draw thumbnail images for PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
www.rasteredge.com
Data Access and Change
129
<qualified join> ::= <table reference> | [ <join type> ] JOIN <table reference>
<join specification>
<natural join> ::= <table reference> NATURAL [ <join type> ] JOIN <table factor>
<join specification> ::= <join condition> | <named columns join>
<join condition> ::= ON <search condition>
<named columns join> ::= USING <left paren> <join column list> <right paren>
<join type> ::= INNER | <outer join type> [ OUTER ]
<outer join type> ::= LEFT | RIGHT | FULL
<join column list> ::= <column name list>
CROSS JOIN
The simplest form of join is CROSS JOIN. The CROSS JOIN of two tables is a table that has all the columns of the
first table, followed by all the columns of the second table, in the original order. Each row of the first table is combined
with each row of the second table to fill the rows of the new table. If the rows of each table form a set, then the rows
of the CROSS JOIN table form the Cartesian product of the rows of the two table operands.
Conditions are not allowed as part of a cross join, which is simply A CROSS JOIN B. Any conditions in a WHERE
clause are later applied to the table resulting from the cross join.
Tables in the FROM CLAUSE separated with commas, are equivalent to cross joins between the tables. Two joined
tables separated with a comma, such as A, B, is equivalent to (A) CROSS JOIN (B), which means the joined tables
A and B are populated separately before they are joined.
CROSS JOIN is not is not generally very useful, as it returns large result tables unless WHERE conditions are used.
UNION JOIN
The UNION JOIN has limited use in queries. The result table has the same columns as that of CROSS JOIN. Each
row of the first table is extended to the right with nulls and added to the new table. Each row of the second table is
extended to the left with nulls and added to the new table. The UNION JOIN is expressed as A UNION JOIN B.
This should not be confused with A UNION B, which is a set operation. Union join is for special applications and
is not commonly used.
JOIN ... ON
The condition join is similar to CROSS JOIN, but a condition is tested for each row of the new table and the row is
created only if the condition is true. This form of join is expressed as A JOIN B ON (<search condition>).
Equijoin is a condition join in which the search condition is an equality condition between on or more pairs of columns
from the two table. Equijoin is the most commonly used type of join.
SELECT a.*, b.* FROM a INNER JOIN b ON a.col_one = b.col_two
JOIN ... USING
NATURAL JOIN
Joins with USING or NATURAL keywords joins are similar to an equijoin but they cannot be replaced simply with
an equijoin. The new table is formed with the specified or implied shared columns of the two tables, followed by the
Library SDK component:C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Images. File and Page Process. File: Merge, Append PDF Files. File: Split PDF Document. File: Compress PDF. Page: Create Thumbnails. Page: Insert PDF Pages. Page
www.rasteredge.com
Library SDK component:C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
Turn multiple pages PDF into single jpg files respectively online. Support of converting from any single one PDF page and multiple pages. Thumbnails can be
www.rasteredge.com
Data Access and Change
130
rest of the columns from each table. In NATURAL JOIN, the shared columns are all the column pairs that have the
same name in the first and second table. In JOIN USING, only columns names that are specified by the USING clause
are shared. The joins are expressed as A NATURAL JOIN B, and A JOIN B USING (<comma separated
column name list>).
The columns of the joined table are formed by the following procedures: In JOIN ... USING the shared columns are
added to the joined table in the same order as they appear in the column name list. In NATURAL JOIN the shared
columns are added to the joined table in the same order as they appear in the first table. In both forms of join, the non-
shared columns of the first table are added in the order they appear in the first table, finally the non-shared columns
of the second table are added in the order they appear in the second table.
The type of each shared column of the joined table is based on the type of the columns in the original tables. If the
original types are not exactly the same, the type of the shared column is formed by type aggregation. Type aggregations
selects a type that can represent values of both aggregated types. Simple type aggregation picks one of the types.
For example SMALLINT and INTEGER, results in INTEGER, or VARCHAR(10) and VARCHAR(20) results in
VARCHAR(20). More complex type aggregation inherits properties from both types. For example DECIMAL(8) and
DECIMAL (6,2) results in DECIMAL (8,2).
In the examples below, the rows are joined exactly the same way, but the first query contains a.col_two and b.col_two
together with all the rest of the columns of both tables, while the second query returns only one copy of col_two.
SELECT * FROM a INNER JOIN b ON a.col_two = b.col_two
SELECT * FROM a INNER JOIN b USING (col_two)
OUTER JOIN
LEFT, RIGHT and FULL OUTER JOIN
The three qualifiers can be added to all types of JOIN except CROSS JOIN and UNION JOIN. First the new table is
populated with the rows from the original join. If LEFT is specified, all the rows from the first table that did not make
it into the new table are extended to the right with nulls and added to the table. If RIGHT is specified, all the rows
from the second table that did not make it into the new table are extended to the left with nulls and added to the table.
If FULL is specified, the addition of leftover rows is performed from both the first and the second table. These forms
are expressed by prefixing the join specification with the given keyword. For example A LEFT OUTER JOIN B
ON (<search condition>) or A NATURAL FULL OUTER JOIN B or A FULL OUTER JOIN B USING
(<comma separated column name list>).
SELECT a.*, b.* FROM a LEFT OUTER JOIN b ON a.col_one = b.col_two
Selection
Despite the name, selection has nothing to do with the list of columns in a SELECT statement. In fact, it refers to
the search condition used to limit the rows that from a result table (selection of rows, not columns). In SQL, simple
selection is expressed with a WHERE condition appended to a single table or a joined table. In some cases, this method
of selection is the only method available. For example in DELETE and UPDATE statements. But when it is possible
to perform the selection with join conditions, this is the better method, as it results in a clearer expression of the query.
Projection
Projection is selection of the columns from a simple or joined table to form a result table. Explicit projection is
performed in the SELECT statement by specifying the select column list. Some form of projection is also performed
in JOIN ... USING and NATURAL JOIN.
The joined table has columns that are formed according to the rules mentioned above. But in many cases, not all the
columns are necessary for the intended operation. If the statement is in the form, SELECT * FROM <joined table>,
Library SDK component:C# PDF Convert to Images SDK: Convert PDF to png, gif images in C#
Turn multipage PDF file into single image files respectively in .NET framework. Converter control easy to create thumbnails from PDF pages.
www.rasteredge.com
Library SDK component:C# PDF File Compress Library: Compress reduce PDF size in C#.net
and decompression method and Image files compression and Embedded page thumbnails. Program.RootPath + "\\" 3_optimized.pdf"; // create optimizing options
www.rasteredge.com
Data Access and Change
131
then all the columns of <joined table> are returned. But normally, the columns to be returned are specified after the
SELECT keyword, separated from each other with commas.
Computed Columns
In the select list, it is possible to use expressions that reference any columns of <joined table>. Each of these expressions
forms a computed column. It is computed for each row of the result table, using the values of the columns of the
<joined table> for that row.
Naming
Naming is used to hide the original names of tables or table columns and to replace them with new names in the scope
of the query. Naming is also used for defining names for computed columns.
Without explicit naming, the name of a column is a predefined name. If the column is a column of a table, or is a named
parameter, the name is of the table column or parameter is used. Otherwise it is generated by the database engine.
HyperSQL generates column names such as C1, C2, etc. As generated naming is implementation defined according
to the SQL Standard, it is better to explicitly name the computed and derived columns in your applications.
Naming in Joined Table
Naming is performed by adding a new name after a table's real name and by adding a list of column names after the
new table name. Both table naming and column naming are optional, but table naming is required for column naming.
The expression A [AS] X (<comma separated column name list>) means table A is used in the
query expression as table X and its columns are named as in the given list. The original name A, or its original column
names, are not visible in the scope of the query. The BNF is given below. The <correlation name> can be the
same or different from the name of the table. The <derived column list> is a comma separated list of column
names. The degree of this list must be equal to the degree of the table. The column names in the list must be distinct.
They can be the same or different from the names of the table's columns.
<table or query name> [ [ AS ] <correlation name> [ <left paren> <derived column
list> <right paren> ] ]
In the examples below, the columns of the original tables are named (a, b, c, d, e, f). The two queries are equivalent.
In the second query, the table and its columns are renamed and the new names are used in the WHERE clauses:
CREATE TABLE atable (a INT, b INT, c INT, d INT, e INT, f INT);
SELECT d, e, f FROM atable WHERE a + b = c
SELECT x, y, z FROM atable AS t (u, v, w, x, y, z)  WHERE u + v = w
Naming in Select List
Naming in the SELECT list logically takes place after naming in the joined table. The new names for columns are
not visible in the immediate query expression or query expression. They become visible in the ORDER BY clause
and in the result table that is returned to the user. Or if the query expression is used as a derived table in an enclosing
query expression.
In the example below, the query is on the same table but with column renaming in the Select list. The new names are
used in the ORDER BY clause:
SELECT x + y AS xysum, y + z AS yzsum FROM atable AS t (u, v, w, x, y, z)  WHERE u + v = w ORDER
BY xysum, yzsum
If the names xysum or yzsum are not used, the computed columns cannot be referenced in the ORDER BY list.
Name Resolution
Library SDK component:VB.NET Create PDF from Word Library to convert docx, doc to PDF in
Images. File & Page Process. File: Merge, Append PDF Files. File: Split PDF Document. File: Compress PDF. Page: Create Thumbnails. Page: Insert PDF Pages. Page
www.rasteredge.com
Library SDK component:VB.NET PDF File Merge Library: Merge, append PDF files in vb.net
File: Merge, Append PDF Files. |. Home ›› XDoc.PDF ›› VB.NET PDF: Merge and Append PDF. VB.NET Demo code to Combine and Merge Multiple PDF Files into One.
www.rasteredge.com
Data Access and Change
132
In a joined table, if a column name appears in tables on both sides then any reference to the name must use the table
name in order to specify which table is being referred to.
Grouping Operations
Grouping Operations
Grouping results in the elimination of duplicate rows. A grouping operation is performed after the operations discussed
above. A simple form of grouping is performed by the use of DISTINCT after SELECT. This eliminates all the
duplicate rows (rows that have the same value in each of their columns when compared to another row). The other
form of grouping is performed with the GROUP BY clause. This form is usually used together with aggregation.
GROUP BY
<group  by  clause>  ::=  GROUP  BY  <grouping  element>  [  {  <comma>  <grouping
element> }... ]
<grouping element> ::= <column reference> [ <collate clause> ]
The <group by clause> is a comma separated list of columns of the table in the <from clause> or expressions
based on the columns.
When a <group by clause> is used, only the columns used in the <group by clause> or expressions
used there, can be used in the <select list>, together with any <aggregate function> on other columns.
In other words, the column names or expressions listed in the GROUP BY cluase dictate what can be used in the
<select list>. After the rows of the table formed by the <from clause> and the <where clause> are
finalised, the grouping operation groups together the rows that have the same values in the columns of the <group
by clause>. Then any <aggregate function> in the <select list> is performed on each group, and
for each group, a row is formed that contains the values of the columns of the <group by clause> and the values
returned from each <aggregate function>.
When the type of <column reference> is character string, the <collate clause> can be used to specify
the collation used for grouping the rows. For example, a collation that is not case sensitive can be used, or a collation
for a different language than the original collation of the column.
In the first example below, a simple column reference is used in GROUP BY, while in the second example, an
expression is used.
CREATE TABLE atable (a INT, b INT, c INT, d INT, e INT, f INT);
SELECT d, e, f FROM atable WHERE a + b = c GROUP BY d, e, f
SELECT d + e, SUM(f) FROM atable WHERE a + b = c GROUP BY d + e HAVING SUM(f) > 2 AND d + e > 4
A <having clause> filters the rows of the table that is formed after applying the <group by clause> using
its search condition. The search condition must be an expression based on the expressions in the GROUP BY list or
the aggregate functions used.
DISTINCT
SELECT DISTINCT
When the keyword DISTINCT is used after SELECT, it works as a shortcut replacement for a simple GROUP BY
clause. The expressions in the SELECT list are used directly as the <group by clause>. The following examples
of SELECT DISTINCT and SELECT with GROUP BY are equivalent.
SELECT DISTINCT d, e + f FROM atable WHERE a + b = c
SELECT d, e + f FROM atable WHERE a + b = c GROUP BY d, e + f
Library SDK component:VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
Images. File & Page Process. File: Merge, Append PDF Files. File: Split PDF Document. File: Compress PDF. Page: Create Thumbnails. Page: Insert PDF Pages. Page
www.rasteredge.com
Library SDK component:VB.NET Create PDF from CSV to convert csv files to PDF in vb.net
Images. File & Page Process. File: Merge, Append PDF Files. File: Split PDF Document. File: Compress PDF. Page: Create Thumbnails. Page: Insert PDF Pages. Page
www.rasteredge.com
Data Access and Change
133
Aggregation
Aggregation is an operation that computes a single value from the values of a column over several rows. The operation
is performed with an aggregate function. The simplest form of aggregation is counting, performed by the COUNT
function.
Other common aggregate functions return the maximum, minimum and average value among the values in different
rows. Aggregate functions were discussed earlier in this chapter.
Set Operations
Set and Multiset Operations
While join operations generally result in laterally expanded tables, SET and COLLECTION operations are performed
on two tables that have the same degree and result in a table of the same degree. The SET operations are UNION,
INTERSECT and EXCEPT (difference). When each of these operations is performed on two tables, the collection
of rows in each table and in the result is reduced to a set of rows, by eliminating duplicates. The set operations are
then performed on the two tables, resulting in the new table which itself is a set of rows. Collection operations are
similar but the tables are not reduced to sets before or after the operation and the result is not necessarily a set, but
a collection of rows.
The set operations on two tables A and B are: A UNION [DISTINCT] B, A INTERSECT [DISTINCT] B and A
EXCEPT [DISTINCT] B. The result table is formed in the following way: The UNION operation adds all the rows
from A and B into the new table, but avoids copying duplicate rows. The INTERSECT operation copies only those
rows from each table that also exist in the other table, but avoids copying duplicate rows. The EXCEPT operation
copies those rows from the first table which do not exist in the second table, but avoids copying duplicate rows.
The collection operations are similar to the set operations, but can return duplicate rows. They are A UNION ALL B,
A INTERSECT ALL B and A EXCEPT ALL B. The UNION ALL operation adds all the rows from A and B into
the new table. The INTERSECT operation copies only those rows from each table that also exist in the other table. If
n copies of a rows exists in one table, and m copies in the other table, the number of copies in the result table is the
smaller of n and m. The EXCEPT operation copies those rows from the first table which do not exist in the second
table. If n copies of a row exist in the first table and m copies in the second table the number of copies in the result
table is n-m, or if n < m, then zero.
With Clause and Recursive Queries
The optional WITH clause can be used in a query expression. The WITH clause lists one or more named ephemeral
tables that can be referenced in the query expression body. The ephemeral tables are created and populated before
the rest of the query expression is executed. Their contents do not change during the execution of the <query
expression body>.
<with clause> ::= WITH [ RECURSIVE ] <with list>
<with list> ::= <with list element> [ { <comma> <with list element> }... ]
<with list element> ::= <query name> [ <left paren> <with column list> <right
paren> ] AS <left paren> <query expression> <right paren>
<with column list> ::= <column name list>
An example of the use of the WITH clause is given above under UNNEST. The <query expression> in the
WITH clause is evaluated once and its result table can be referenced in the body of the main <query expression
body> using the specified <query name>.
Data Access and Change
134
The RECURSIVE keyword changes the way the elements of the <with  list> are interpreted. The <query
expression> contained in the <with list element> must be the UNION or UNION ALL of two <query
expression body> elements (simple VALUES or SELECT statements). The left element of the UNION is evaluated
first and its result becomes the result of the <with list element>. After this step, the current result of the
<with list element> is referenced in the right element (a SELECT statement) of the UNION, the UNION is performed
between the result and previous result of the <with list element>, which is enlarged by this operation. The
UNION operation is performed again and again, until the result of the <with list element> stops changing.
The result of the <with list element> is now complete and is later used in the execution of the <query
expression body>. When RECURSIVE is used, the <with column list> must be defined.
HyperSQL limits recursion to 265 rounds. If this is exceeded, an error is raised.
A trivial example of a recursive query is given below. Note the first column GEN. For example, if each row of the table
represents a member of a family of dogs, together with its parent, the first column of the result indicates the calculated
generation of each dog, ranging from first to fourth generation.
CREATE TABLE pptree (pid INT, id INT);
INSERT INTO pptree VALUES (NULL, 1) ,(1,2), (1,3),(2,4),(4,5),(3,6),(3,7);
WITH RECURSIVE tree (gen, par, child) AS (
VALUES(1, CAST(null as int), 1)
UNION
SELECT gen + 1, pid, id FROM pptree, tree WHERE pid = child
) SELECT * FROM tree;
GEN PAR    CHILD 
--- ------ ----- 
  (null) 1     
  1      2     
  1      3     
  2      4     
  3      6     
  3      7     
  4      5
if recursive queries become complex they also become very difficult to develop and debug. HyperSQL provides an
alternative to this with user-defined SQL functions which return tables. Functions can perform any complex, repetitive
task with better control, using loops, variables and, if necessary, recursion.
Query Expression
A query expression consists of an optional WITH clause and a query expression body. The optional WITH clause lists
one or more named ephemeral tables that can be referenced, just like the database tables in the query expression body.
<query expression> ::= [ <with clause> ] <query expression body>
A query expression body refers to a table formed by using UNION and other set operations. The query expression
body is evaluated from left to right and the INTERSECT operator has precedence over the UNION and EXCEPT
operators. A simplified BNF is given below:
<query expression body> ::= <query term> | <query expression body> UNION |
EXCEPT [ ALL | DISTINCT ] [ <corresponding spec> ] <query term>
<query term> ::= <query primary> | <query term> INTERSECT [ ALL | DISTINCT ]
[ <corresponding spec> ] <query term>
<query primary> ::= <simple table> | <left paren> <query expression body> [ <order
by clause> ] [ <result offset clause> ] [ <fetch first clause> ] <right paren>
Data Access and Change
135
<simple table> ::= <query specification> | <table value constructor> | <explicit
table> <explicit table> ::= TABLE <table or query name>
<corresponding spec> ::= CORRESPONDING [ BY <left paren> <column name list>
<right paren> ]
A <query  term> and a <query  primary> can be a SELECT statement, an <explicit table>, or a
<table value constructor>.
The CORRESPONDING clause is optional. If it is not specified, then the <query  term> and the <query
primary> must have the same number of columns. If CORRESPONDING is specified, the two sides need not have
the same number of columns. If no column list is used with CORRESPONDING, then all the column names that are
common in the tables on two sides are used in the order in which they appear in the first table. If a columns list is used,
it allows you to select only some columns of the tables on the left and right side to create the new table. In the example
below the columns named u and v from the two SELECT statements are used to create the UNION table.
SELECT * FROM atable UNION CORRESPONDING BY (u, v) SELECT * FROM anothertable
The type of each column of the query expression is determined by combining the types of the corresponding columns
from the two participating tables.
Ordering
When the rows of the result table have been formed, it is possible to specify the order in which they are returned to the
user. The ORDER BY clause is used to specify the columns used for ordering, and whether ascending or descending
ordering is used. It can also specify whether NULL values are returned first or last.
SELECT x + y AS xysum, y + z AS yzsum FROM atable AS t (u, v, w, x, y, z)  WHERE u + v = w ORDER
BY xysum NULLS LAST, yzsum NULLS FIRST
The ORDER BY clause specifies one or more <value expressions>. The list of rows is sorted according to the
first <value expression>. When some rows are sorted equal then they are sorted according to the next <value
expression> and so on.
<order  by  clause>  ::=  ORDER  BY  <sort  specification>  [  {  <comma>  <sort
specification> }... ]
<sort specification> ::= <value expression> [ <collate clause> ] [ ASC | DESC ]
[ NULLS FIRST | NULLS LAST ]
The defaults are ASC and NULLS FIRST. Two database properties SQL NULLS FIRST and SQL NULLS ORDER
can be modified to change the default behaviour.
A collation is used for columns of an ORDER BY expression that are of the type CHAR or VARCHAR. If a <collate
clause> is not specified then the collation of the column, or the default collation of the database is used.
The default collation for a database is ASCII, with lowercase letters sorted after all uppercase letters. The example
below shows the effect of collation on an ordered list.
-- default collation collation for the database is ASCII
SELECT id, lastname FROM customer ORDER BY lastname
ID LASTNAME 
-- -------- 
40 Clancy   
36 King     
35 White    
 king
Data Access and Change
136
-- a language collation is used, it treats king and King as adjacent entries
SELECT id, lastname FROM customer ORDER BY lastname COLLATE "English"
ID LASTNAME 
-- -------- 
40 Clancy   
 king     
36 King     
35 White
In the above example, if the LASTNAME column is itself defined in the table definition with COLLATE "English",
then the COLLATE clause is not necessary in the ORDER BY expression.
An ORDER BY operation can sometimes be optimised by the engine when it can use the same index for accessing the
table data and ordering. Optimisation can happen both with DESC + NULLS LAST and ASC + NULLS FIRST.
sort specification list
sort specification list
<sort specification list> ::= <value expression> [ASC | DESC] [NULLS FIRST |
NULLS LAST]
Specify a sort order. A sort operation is performed on the result of a <query  expression> or <query
specification> and sorts  the  result  according  to one or  more  <value  expression>.  The <value
expression> is usually a single column of the result, but in some cases it can be a column of the <table
expression> that is not used in the select list. The default is ASC and NULLS FIRST.
Slicing
A different form of limiting the rows can be performed on the result table after it has been formed according to all the
other operations (selection, grouping, ordering etc.). This is specified by the FETCH ... ROWS and OFFSET clauses
of a SELECT statement. In this form, the specified OFFSET rows are removed from start of the table, then up to the
specified FETCH rows are kept and the rest of the rows are discarded.
<result offset clause> ::= OFFSET <offset row count> { ROW | ROWS }
<fetch first clause> ::= FETCH { FIRST | NEXT } [ <fetch first row count> ]
{ ROW | ROWS } ONLY [ USING INDEX ]
<limit clause> ::= LIMIT <fetch first row count> [ USING INDEX ]
A slicing operation takes the result set that has been already processed and ordered. It then discards the specified
number of rows from the start of the result set and returns the specified number of rows after the discarded rows. The
<offset row count> and <fetch first row count> can be constants, dynamic variables, routine parameters, or routine
variables. The type of the constants must be INTEGER.
SELECT a, b FROM atable WHERE d < 5 ORDER BY absum OFFSET 3 FETCH 2 ROWS ONLY 
SELECT a, b FROM atable WHERE d < 5 ORDER BY absum OFFSET 3 LIMIT 2 /* alternative keyword */ 
When the FETCH keyword is used, the specified number of rows must be at least 1, otherwise an error is returned.
This behaviour is consistent with the SQL Standard. When the LIMIT keyword is used, the specified number of rows
can be zero, which means return all rows (no LIMIT). In MySQL and PostgreSQL syntax modes, zero limit means
no rows (empty result).
If there is an index on all the columns specified in the ORDER BY clause, it is normally used for slicing. In some
queries, an index on another column may take precedence because it is used to process the WHERE condition. It is
possible to add USING INDEX to the end of the slicing clause to force the use of the index for ordering and slicing,
instead of the index for the WHERE condition.
Data Access and Change
137
Data Change Statements
Delete Statement
DELETE FROM
delete statement: searched
<delete statement: searched> ::= DELETE FROM <target table> [ [ AS ] <correlation
name> ] [ WHERE <search condition> ][ LIMIT <fetch first row count> ]
Delete rows of a table. The search condition is a <boolean value expression> that is evaluated for each row
of the table. If the condition is true, the row is deleted. If the condition is not specified, all the rows of the table are
deleted. In fact, an implicit SELECT is performed in the form of SELECT * FROM <target table> [ WHERE
<search condition>] and the selected rows are deleted. When used in JDBC, the number of rows returned by
the implicit SELECT is returned as the update count.
If there are FOREIGN KEY constraints on other tables that reference the subject table, and the FOREIGN KEY
constraints have referential actions, then rows from those other tables that reference the deleted rows are either deleted,
or updated, according to the specified referential actions.
The LIMIT clause, or alternatively the ROWNUM() function in the WHERE clause, can be used to limit the number
of rows that are deleted. This is useful when a very large number of rows needs to be deleted. In this situation, you
can perform the operation is chunks and commit after each chunk to reduce memory usage and the total time of the
operation.
In the second example below the rows that have the maximum value for column A are deleted;
DELETE FROM T WHERE C > 5
DELETE FROM T AS TT WHERE TT.A = (SELECT MAX(A) FROM T)
Truncate Statement
TRUNCATE TABLE
truncate table statement
<truncate table statement> ::= TRUNCATE TABLE <target table> [ <identity column
restart option> ] [ <truncate options> ]
<identity column restart option> ::= CONTINUE IDENTITY | RESTART IDENTITY
<truncate options> ::= AND COMMIT [ NO CHECK ]
Delete all rows of a table without firing its triggers. This statement can only be used on base tables (not views). If
the table is referenced in a FOREIGN KEY constraint defined on another table, the statement causes an exception.
Triggers defined on the table are not executed with this statement. The default for <identity column restart
option> is CONTINUE IDENTITY. This means no change to the IDENTITY sequence of the table. If RESTART
IDENTITY is specified, then the sequence is reset to its start value.
TRUNCATE is faster than ordinary DELETE. The TRUNCATE statement is an SQL Standard data change statement,
therefore it is performed under transaction control and can be rolled back if the connection is not in the auto-commit
mode.
HyperSQL also supports the optional AND COMMIT and NO CHECK options. If AND COMMIT is used, then
the transaction is committed with the execution of the TRUNCATE statement. The action cannot be rolled back. If
Documents you may be interested
Documents you may be interested