DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)-sdccf-ChinaUnix博客

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403439) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403438) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403437) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403436) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403435) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403434) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403433) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403432) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403431) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403430) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403429) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403428) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403427) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403426) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403425) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403424) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403423) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403422) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403421) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403420) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403419) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403418) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403417) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403416) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403415) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403414) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403413) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403412) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403411) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403410) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403409) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403408) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403407) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403406) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403405) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403404) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403403) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403402) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

参数标记

一定要记住，一个参数标记替代一个字面值，如下所示：

SELECT firstname, lastname
FROM employee
WHERE empno = ?

SELECT firstname, lastname
FROM employee
WHERE hiredate > ?
    AND mgrno = ?

我们来看三个示例，它们演示了在使用参数标记时常见的错误。下面是第一个示例：

SELECT ?, lastname
FROM employee
WHERE empno = ?

让我们看一看另一个错误代码的示例：

SELECT firstname, lastname
FROM ?
WHERE empno = ?

在这个示例中，在 FROM 子句中用一个参数标记替代表名。DB2 无法确定从哪个表中提取数据，因此无法编译这个 SQL 语句。

现在是最后一个示例：

SELECT firstname, lastname
FROM employee
WHERE ? = 14
    AND ? = ?

回页首

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

以下是一个匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000056'

但是，下面这些语句都不会被当作匹配的语句：

SELECT deptName, location
FROM department
WHERE mgrno = '000055'

SELECT deptName, location
FROM department
WHERE mgrno = ?

SELECT deptName, location
FROM department
WHERE mgrno = :varMgrno

下面这个示例更深入地解释了这个概念。假设以下语句是包缓存中的初始语句：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句将匹配它：

SELECT deptName, location
FROM department
WHERE mgrno = ?

下列语句不匹配：

SELECT deptName, location
FROM department
WHERE mgrno = 55

总语句时间 = 语句编译时间 + 语句执行时间

在使用参数标记时，结果是：

0.001 + (10000 * 0.001) = 10.001 秒

(10000 * 0.001) + (10000 * 0.001) = 20 秒

在这种情况下，在每次执行时都要承担编译和执行成本。正如这个简单的示例所示，使用参数标记会将总语句时间减半！

                    
CREATE PROCEDURE SIMPLE_UPDT_PROC (IN  p_emp_id      SMALLINT, 
                                   IN  p_new_salary  DECIMAL)
LANGUAGE SQL
BEGIN
  
  DECLARE v_sqltext       VARCHAR(1000);
  
  SET v_sqltext = 'UPDATE STAFF SET salary=? WHERE id=?';
	
  PREPARE v_stmt1 FROM v_sqltext;
  EXECUTE v_stmt1 USING p_new_salary, p_emp_id;
  
END

回页首

CREATE TABLE toyLists (
	id       INTEGER NOT NULL,
	color    CHAR(10),
	type     CHAR(10),
	price    INTEGER,
	amount   INTEGER
)

假设这个表在 color 列上有索引。以下两个查询说明当使用这个表时，以何种方式使用参数标记会导致很大的性能差异：

SELECT price, amount
FROM toyLists
WHERE color = 'PINK'
	AND type = 'CAR'



SELECT price, amount
FROM toyLists
WHERE color = 'BROWN'
	AND type = 'CAR'

现在让我们考虑一下，如果使用参数标记进行类似的搜索，将发生什么情况：

SELECT price, amount
FROM toyLists
WHERE color = ?
	AND type = 'CAR'

在这个示例中，DB2 不知道必须检索什么颜色。它不知道是要返回 5 条还是 300,000 条记录。如果使用不同的颜色值，就可能选择完全不同的访问计划。

回页首

在很多情况下，参数标记可以改善应用程序的性能。应该在以下情况下包含参数标记：

执行多次并只更改其参数值的查询。
其编译时间可能长于执行时间的查询。
短的、OLTP 类型的查询。

但是，有一些查询不会受益于参数标记的使用：

只执行一次且其参数值总是相同的查询。
大的、OLAP 类型的查询，其编译时间只占总执行时间的一小部分。
其中变量值极大地影响 SQL 访问计划的创建方式的查询。
其中参数标记值可能相互关联并导致 DB2 能够识别统计数据中的模式或数据分布（例如 state-city 或 year-month 对）的查询。
对于不均匀分布的数据集运行的查询，因为使用参数标记可能导致 DB2 优化器对于某些值忽略重要的统计偏差。

阅读(403401) | 评论(0) | 转发(0) |

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们