经验丰富的新手的 Oracle 陷阱

Question

对于刚接触该平台但对关系数据库（MySQL、MS SQL Server、Postgres 等）不熟悉的人来说，Oracle 的一些陷阱是什么？

我正在寻找的东西的两个例子

1. 许多关系数据库产品都会为您创建一个 auto_increment 键。 oracle没有，必须手动创建序列，然后创建触发器

2. 通过 SQL Developer 界面插入数据时，您必须手动提交数据

PHP 相关问题的加分点，因为这是这个假设的经验丰富的新手将使用的平台我会。

Answer 1

注意：我在这里只解释陷阱，即。 e. Oracle 的行为与其他系统不同的情况。 Oracle 比其他 RDBMS 有很多好处，但它们不是帖子的主题。

• 没有FROM，你就不能SELECT。

  SELECT  1
  

  会失败，你需要：

  SELECT  1
  FROM    dual
  

• 空字符串和NULL是一回事。

  SELECT  *
  FROM    dual
  WHERE   '' = ''
  

  什么都不返回。

• 既没有TOP，也没有LIMIT。您将结果限制在 WHERE 子句中：

  SELECT  *
  FROM    (
          SELECT  *
          FROM    mytable
          ORDER BY
                  col
          )
  WHERE   rownum < 10
  

  正是这样，使用子查询，因为ROWNUM 在ORDER BY 之前被评估。

• 您不能将相关的子查询嵌套超过一层。这个会失败：

  SELECT  (
          SELECT  *
          FROM    (
                  SELECT  dummy
                  FROM    dual di
                  WHERE   di.dummy = do.dummy
                  ORDER BY
                          dummy
                  )
          WHERE   rownum = 1
          )
  FROM    dual do
  

  这是个问题。

• NULL 值未编入索引。此查询将不使用索引进行排序：

  SELECT  *
  FROM    (
          SELECT  *
          FROM    mytable
          ORDER BY
                  col
          )
  WHERE   rownum < 10
  

  ，除非col 被标记为NOT NULL。

  请注意，未编入索引的是NULL 值，而不是列。您可以在可为空的列上创建索引，非NULL 值将进入索引。

  但是，当查询条件假设NULL 值可能满足时，不会使用索引。

  在上面的示例中，您希望返回所有值（包括NULLs）。然后索引不知道非NULL 值，因此无法检索它们。

  SELECT  *
  FROM    (
          SELECT  *
          FROM    mytable
          ORDER BY
                  col
          )
  WHERE   rownum < 10
  

  但是这个查询会使用索引：

  SELECT  *
  FROM    (
          SELECT  *
          FROM    mytable
          WHERE   col IS NOT NULL
          ORDER BY
                  col
          )
  WHERE   rownum < 10
  

  ，因为非NULL 值永远无法满足条件。

• 默认情况下，NULLs 排在最后，而不是排在最前面（类似于 PostgreSQL，但与 MySQL 和 SQL Server 不同）

  这个查询：

  SELECT  *
  FROM    (
          SELECT  1 AS id
          FROM    dual
          UNION ALL
          SELECT  NULL AS id
          FROM    dual
          ) q
  ORDER BY
          id
  

  会回来

  id
  ---
  1
  NULL
  

  要在SQL Server 和MySQL 中进行排序，请使用：

  SELECT  *
  FROM    (
          SELECT  1 AS id
          FROM    dual
          UNION ALL
          SELECT  NULL AS id
          FROM    dual
          ) q
  ORDER BY
          id NULLS FIRST
  

  请注意，它会破坏rownum 的顺序，除非后者未在子查询之外使用（如上所述）

• "MYTABLE" 和 "mytable"（双引号很重要）是不同的对象。

  SELECT  *
  FROM    mytable -- wihout quotes
  

  将选择前者，而不是后者。如果前者不存在，则查询失败。

  CREATE TABLE mytable
  

  创建"MYTABLE"，而不是"mytable"。

• 在Oracle 中，所有隐式锁（由DML 操作产生）都是行级的，并且永远不会升级。也就是说，没有任何不受事务影响的行可以被隐式锁定。

  作家从不阻止读者（反之亦然）。

  要锁定整个表，您应该发出明确的LOCK TABLE 语句。

  行锁存储在数据页上。

• 在Oracle 中，没有“CLUSTERED 索引”，有“索引组织表”。默认情况下，表是堆组织的（不像SQL Server 和MySQL 与InnoDB）。

  在Oracle 世界中，“集群存储”意味着组织多个表，以便共享一个公共键（来自多个表）的行也共享一个数据页。

  单个数据页托管来自多个表的多行，这使得在此键上的连接超级快。

Answer 2

SELECT 1 不起作用，请改为从 dual 中选择 1。

如果您使用分层数据，连接方式非常好。

Answer 3

与 SQL Server 相比，我遇到的对模式对象和数据区分大小写的 Oracle 数据库似乎更多。

Answer 4

不要忘记在行集中可能完全用空值填充的任何列周围使用 nvl(column)。否则，该列将从行集中丢失。

没错，完全没有！

例子：

SELECT nvl(employeeName,'Archie'), nvl(employeeSpouse,'Edith') FROM Employee

这将保证您在行集中获得两列，即使两者中的所有值都为空。您只会看到一堆 'Archie' 和 'Edith' 值。如果你不使用 nvl()，你可能只得到一列，或者都不回来。问题的关键在于，您的代码可以在您的开发环境中正常运行，甚至可以通过 QA，但是当它进入生产环境时，表中的 values 可能会改变 结构 的结果！

因此，简而言之，无论何时选择可空列，请务必使用 nvl()。

Answer 5

没有像 MySQL 那样的组连接。如果你想要一个组连接聚合函数，你必须自己编写。这是我的实现：

drop type T_GROUP_CONCAT;

create or replace type GROUP_CONCAT_PARAM as object
(
  val varchar2(255),
  separator varchar2(10),
  numToConcat NUMBER,
  MAP MEMBER FUNCTION GROUP_CONCAT_PARAM_ToInt  return VARCHAR2
);

--map function needed for disctinct in select clauses
CREATE OR REPLACE TYPE BODY GROUP_CONCAT_PARAM IS
    MAP MEMBER FUNCTION GROUP_CONCAT_PARAM_ToInt return VARCHAR2 is 
      begin 
        return val; 
      end; 

end;


/

CREATE OR REPLACE TYPE T_GROUP_CONCAT 
AS OBJECT (

runningConcat VARCHAR2(5000),
runningCount NUMBER,

STATIC FUNCTION ODCIAggregateInitialize
  ( actx IN OUT T_GROUP_CONCAT
  ) RETURN NUMBER,

MEMBER FUNCTION ODCIAggregateIterate
  ( self  IN OUT T_GROUP_CONCAT,
    val   IN       GROUP_CONCAT_PARAM
  ) RETURN NUMBER,

MEMBER FUNCTION ODCIAggregateTerminate
  ( self             IN   T_GROUP_CONCAT,
    returnValue  OUT VARCHAR2,
    flags           IN   NUMBER
  ) RETURN NUMBER,

MEMBER FUNCTION ODCIAggregateMerge
  (self  IN OUT T_GROUP_CONCAT,
   ctx2 IN      T_GROUP_CONCAT
  ) RETURN NUMBER

);
/

CREATE OR REPLACE TYPE BODY T_GROUP_CONCAT AS

STATIC FUNCTION ODCIAggregateInitialize
  ( actx IN OUT T_GROUP_CONCAT
  ) RETURN NUMBER IS 
  BEGIN
    IF actx IS NULL THEN
      actx := T_GROUP_CONCAT ('', 0);
    ELSE
      actx.runningConcat := '';
      actx.runningCount := 0;
    END IF;
    RETURN ODCIConst.Success;
  END;

MEMBER FUNCTION ODCIAggregateIterate
  ( self  IN OUT T_GROUP_CONCAT,
    val   IN     GROUP_CONCAT_PARAM
  ) RETURN NUMBER IS
  BEGIN
    if self.runningCount = 0 then
        self.runningConcat := val.val;
    elsif self.runningCount < val.numToConcat then
        self.runningConcat := self.runningConcat || val.separator || val.val;
    end if;
    self.runningCount := self.runningCount + 1;
    RETURN ODCIConst.Success;
  END;

MEMBER FUNCTION ODCIAggregateTerminate
  ( self        IN  T_GROUP_CONCAT,
    ReturnValue OUT VARCHAR2,
    flags       IN  NUMBER
  ) RETURN NUMBER IS
  BEGIN
    returnValue := self.runningConcat;
    RETURN ODCIConst.Success;
  END;

MEMBER FUNCTION ODCIAggregateMerge
  (self IN OUT T_GROUP_CONCAT,
   ctx2 IN     T_GROUP_CONCAT
  ) RETURN NUMBER IS
  BEGIN
    self.runningConcat := self.runningConcat || ',' || ctx2.runningConcat;
    self.runningCount := self.runningCount + ctx2.runningCount;
    RETURN ODCIConst.Success;
  END;

END;
/

CREATE OR REPLACE FUNCTION GROUP_CONCAT
( x GROUP_CONCAT_PARAM
) RETURN VARCHAR2
--PARALLEL_ENABLE
AGGREGATE USING T_GROUP_CONCAT;
/

使用它：

select GROUP_CONCAT(GROUP_CONCAT_PARAM(tbl.someColumn, '|', 2)) from someTable tbl

Answer 6

我在这里写了一些不同之处：Think ANSI Standard SQL Is Fully Portable Between Databases? Think Again.

Answer 7

一条评论：您不必为了使用序列而创建触发器，除非您坚持要复制 Sybase/SQL Server IDENTITY 列的行为。我发现直接在实际插入语句中使用序列更有用，例如

INSERT
  INTO MyTable
     ( KeyCol
     , Name
     , Value
     )
SELECT Seq_MyTable.NextVal
     , 'some name'
     , 123
  FROM dual;

您无需担心触发器执行的开销，并且您可以灵活地处理向表中插入行，而不必担心分配序列值（例如将数据从架构移动到另一个架构时） .您还可以从序列中预先选择值，以插入数据范围以及 IDENTITY 功能难以实现或无法实现的其他技术。

Answer 8

临时表

您可以像普通表一样创建和索引它们，但每个会话/事务只能看到自己的数据。这与 MS SQL 不同。

全局变量

它们是通过引用传递的。这意味着如果将全局变量作为参数传递给过程，并在过程中修改全局变量，则参数值也会发生变化。不过，这不是一种非常流行的方法。

触发器

在最近的版本之前，无法确定触发类似触发器的方式。如果您真的关心“每行更新之前”是哪一个，您可以将其全部放在一个触发器中。