DB2 9 数据库管理（731考试）认证指南，第 3 部分: 数据访问（4）-sdccf-ChinaUnix博客

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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

在表上定义数据约束

可检查一行中的一段，看它们是否符合所关联列的数据类型和长度。例如，“Geoff” 值不匹配数据类型为 INTEGER 的列，因而带有该值的行会被拒绝，以这种方式来确保数据库中数据的有效性。
若表上定义了主键约束，表中的各行必须在一列或共同构成主键的多个列中具有惟一值。若插入的行中存在与现有键相同的键，则新行将被拒绝。
若表上已定义了惟一约束，表中的各行必须遵循此约束，即具有惟一值或构成惟一键的值组合。
若已定义了外键约束，表中各行的外键列或多个列必须具有与父表中一行的主键相匹配的值。在某些情况下，若一列或多个列定义为外键的一部分，而这个外键可为空，则空值也是可接受的。
若列上已定义了检查约束，各行必须遵循此约束。例如，EMPLOYEE 表的 SALARY 列上的检查约束可能会阻止应用程序或用户插入工资低于 0 的新员工记录或行。插入表的任何 salary 值小于 0 的行都会被拒绝，从而最小化将错误数据插入表中的风险。

主键约束、惟一约束和外键约束均已在创建和管理索引中介绍过。本节主要探讨检查约束。

向一个包含数据的表添加检查约束时，存在两种可能性：

所有行都将满足检查约束。
所有行中有一部分不满足检查约束。

在第一种情况下，也就是所有行都满足检查约束时，检查约束将成功创建。将来，若尝试插入或更新不匹配约束业务规则的数据，则尝试将被拒绝。

若有某些不符合检查约束的行，检查约束就不会创建（也就是说，ALTER TABLE 语句将失败）。

ALTER TABLE EMPLOYEE
  ADD CONSTRAINT check_job
  CHECK (JOB IN ('Engineer','Sales','Manager'))

在创建表时，您可向表添加一个约束。要为单独列添加约束，可在列定义后添加一个 CONSTRAINT/CHECK 子句：

CREATE TABLE EMPLOYEE
  (
  EMPNO INT NOT NULL PRIMARY KEY,
  JOB VARCHAR(10) CONSTRAINT CHECK_JOB
      CHECK (JOB IN ('Engineer','Sales','Manager')),
  ...
  )

CONSTRAINT 名称并非定义的必要部分，但建议您为约束命名，以便此后修改。如果未为约束命名，就必须确定其系统定义的名称。

CREATE TABLE EMPLOYEE
  (
  ...,
  CONSTRAINT CHECK_AGE_SALARY
    CHECK (NOT(AGE < 30 AND SALARY > 60000))
  )

至此，我们定义的所有约束都是在插入或更新记录时，由 DB2 强制实施的。这会导致大量的系统开销，特别是在载入的记录数量较多时。

CREATE TABLE EMPDATA
  (
  EMPNO INT NOT NULL,
  SEX CHAR(1) NOT NULL
      CONSTRAINT SEXOK
      CHECK (SEX IN ('M','F'))
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION,
  SALARY INT NOT NULL,
      CONSTRAINT SALARYOK
      CHECK (SALARY BETWEEN 0 AND 100000)
      NOT ENFORCED
      ENABLE QUERY OPTIMIZATION
  )

若表包含 NOT ENFORCED 选项，INSERT 语句的行为可能会变得很古怪。对 EMPDATA 表运行以下 SQL 语句时，不会产生任何错误：

INSERT INTO EMPDATA VALUES
  (1, 'M', 54200),
  (2, 'F', 28000),
  (3, 'M', 21240),
  (4, 'F', 89222),
  (5, 'Q', 34444),
  (6, 'K',132333)

在上一屏运行的插入之后，如果再对 EMPDATA 表执行 SELECT 语句，其结果很可能会令您更加迷惑：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------

0 record(s) selected.

ALTER TABLE EMPDATA
  ALTER CHECK SEXOK DISABLE QUERY OPTIMIZATION

现在，再重新执行之前的查询。结果如下所示：

SELECT * FROM EMPDATA
  WHERE SEX = 'Q';

EMPNO       SEX SALARY
----------- --- -----------
          5 Q         34444

1 record(s) selected.

在 DB2 中，有多种约束可维护数据完整性。这些约束包括数据类型、主键、惟一、外键和检查约束。

合理利用检查约束有助于提高查询性能、最小化加载时间。但若没有恰当的数据清理，检索到的结果有时可能并不准确。

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

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

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