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 优化器对于某些值忽略重要的统计偏差。

阅读(405209) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405208) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405207) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405206) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405205) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405204) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405203) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405202) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405201) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405200) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405199) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405198) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405197) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405196) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405195) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405194) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405193) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405192) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405191) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405190) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405189) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405188) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405187) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405186) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405185) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405184) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405183) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405182) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405181) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405180) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405179) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405178) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405177) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405176) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405175) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405174) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405173) | 评论(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 优化器对于某些值忽略重要的统计偏差。

阅读(405172) | 评论(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 优化器对于某些值忽略重要的统计偏差。

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

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

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