1) Oracle 快速入门

Oracle 快速入门

本节教程将针对那些没有使用过Oracle数据库或任何其他关系数据库系统(RDBMS)的用户，从最基础的入手，让用户从以下步骤来快速了解安装配置Oracle学习所需的环境：

1、首先，我们需要了解Oracle数据库到底是什么？

2、接下来，当对Oracle数据库有了很好的了解之后，应该将其安装在本地计算机或服务器上。 安装Oracle教程将引导完成设置Oracle Database 12c的步骤。

3、安装好Oracle后，我们需要了解如何创建或者加载示例数据库到Oracle数据库服务器中，请查看如何创建和加载示例数据库教程。

4、最后，演示如何使用SQL * plus和SQL Developer工具连接到Oracle数据库服务器。选择这些工具是因为在安装Oracle数据库服务器软件时可以免费使用这些工具。

如果您已经完成了以上所有步骤，那么恭喜您，离掌握Oracle数据库就更近了一步。

来自 https://www.w3cschool.cn/oraclejc/oraclejc-eswu2qqq.html

1.1)Oracle 简介

来自 https://www.w3cschool.cn/oraclejc/oraclejc-dxgu2qqt.html

1.2)Oracle 11g安装

来自 https://www.w3cschool.cn/oraclejc/oraclejc-41xa2qqv.html

1.3)Oracle 12C安装

来自  https://www.w3cschool.cn/oraclejc/oraclejc-vuqx2qqu.html

1.4) Oracle 数据库创建导入

Oracle 数据库创建导入

2020-10-29 14:16 更新

在本章教程中，将教大家如何在 Oracle 中创建导入数据库。

注意：本教程中的有些命令您可能并不熟悉，但没关系，只需按照说明一步一步创建示例数据库即可。在之后的教程中，会详细介绍每个命令。

1.创建新用户并授予权限

1.1.打开

首先，启动 SQL plus 程序的命令行：

sqlplus

如下所示：

或者从开始菜单的安装目录打开 SQL Plus：

1.2.登录

当 SQL Plus 启动后，它会提示您输入用户名和密码。继续使用在安装 Oracle 数据库服务器期间输入的密码以 sys 用户身份登录：

C:\Users\Administrator>sqlplus

SQL*Plus: Release 11.2.0.1.0 Production on 星期五 11月 10 04:32:17 2017
Copyright (c) 1982, 2010, Oracle.  All rights reserved.

请输入用户名:  sys as sysdba
输入口令:

1.3.创建新用户

使用以下 CREATE USER 语句创建一个新用户：ot，用于在可插入数据库中创建示例

ot 可为任意名字

数据库：

SQL> CREATE USER OT IDENTIFIED BY Orcl1234;

User created.

上面的语句创建了一个名为:OT 的新用户，并在 IDENTIFIED BY 子句之后指定了一个密码，在这个示例中，创建的用户：OT 对应的密码为：Orcl1234 。

1.4.授权

通过使用以下 GRANT 语句授予 OT 用户权限：

SQL> GRANT CONNECT, RESOURCE, DBA TO OT;

Grant succeeded.

2.登录新账号

使用OT用户帐户连接到数据库(ORCL)。 当 SQL Plus 提示输入用户名和密码时，输入：OT 和 Orcl1234。

对于 Oracle 11g/12c，使用如下命令：

SQL> CONNECT ot@orcl
输入口令:
已连接。

注意，OT 用户仅存在于 ORCL 数据库中，因此，必须在 CONNECT 命令中明确指定用户名为 ot@orcl。

3.创建数据库表

要为示例数据库创建表，需要从 SQL plus 执行 ot_schema.sql 文件中的语句，

在 SQL plus 的文件中执行 SQL 语句，可以使用下面的命令(语法)：

SQL> @path_to_sql_file

假设 ot_schema.sql 文件位于 F:\website\oraok\ot 目录中，则执行下面的语句 ：

SQL>@F:\website\oraok\ot\11g\ot_schema.sql

当执行语句完成后，可以通过列出 OT 用户拥有的表来验证表是否成功创建。以下是这样做的声明：

SQL> SELECT table_name FROM user_tables ORDER BY Table_name;

TABLE_NAME
------------------------------
CONTACTS
COUNTRIES
CUSTOMERS
EMPLOYEES
INVENTORIES
LOCATIONS
ORDERS
ORDER_ITEMS
PRODUCTS
PRODUCT_CATEGORIES
REGIONS

TABLE_NAME
------------------------------
WAREHOUSES

已选择12行。

SQL>

在这个语句中，我们从 user_tables 表中选择了 table_name 列中的值，并按字母顺序排列了表名。如上结果中所见，有12个表名按预期方式返回。

接下来，我们可以将数据加载/导入到这些表中。

4.将数据加载到表中

要将数据加载到表中，请按如下所示执行 ot_data.sql 文件中的语句：

SQL>@F:\website\oraok\ot\11g\ot_data.sql

如果没有看到任何错误消息，则意味着数据已成功加载导入。

还可以使用 SELECT 语句验证数据是否已成功加载导入。 例如，要获取 contacts 表中的行数，请使用以下语句：

SQL> SELECT COUNT(*) FROM contacts;

  COUNT(*)
----------
       319

SQL> SELECT COUNT(*) FROM countries;

  COUNT(*)
----------
        25

SQL> SELECT COUNT(*) FROM customers;

  COUNT(*)
----------
       319

SQL> SELECT COUNT(*) FROM employees;

  COUNT(*)
----------
       107

SQL> SELECT COUNT(*) FROM inventories;

  COUNT(*)
----------
      1112

SQL> SELECT COUNT(*) FROM locations;

  COUNT(*)
----------
        23

SQL> SELECT COUNT(*) FROM orders;

  COUNT(*)
----------
       105

SQL> SELECT COUNT(*) FROM order_items;

  COUNT(*)
----------
       665

SQL> SELECT COUNT(*) FROM product_categories;

  COUNT(*)
----------
         5

SQL> SELECT COUNT(*) FROM products;

  COUNT(*)
----------
       288

SQL> SELECT COUNT(*) FROM regions;

  COUNT(*)
----------
         4

SQL> SELECT COUNT(*) FROM warehouses;

  COUNT(*)
----------
         9

查询返回319表示 contacts 表有319行。通过用另一个表替换表名(联系人)，可以检查所有表中的数据。如果这是您第一次使用数据库系统，这对您来说是一个很好的练习。

要删除上面模式中的表，请执行：

SQL>@F:\website\oraok\ot\11g\ot_drop.sql

来自 https://www.w3cschool.cn/oraclejc/oraclejc-gpa52qqy.html

1.5)  Oracle 数据库连接

如何连接到Oracle数据库？

经过前几章的介绍，我们已经了解了什么是Oracle数据库以及其安装方法，那么本章节，将和大家说说如何使用SQL * plus和SQL Developer 工具连接到Oracle数据库服务器。

使用SQL * Plus连接Oracle数据库服务器

SQL * Plus 是交互式查询工具，我们在安装 Oracle 数据库服务器或客户端时会自动安装。SQL * Plus 有一个命令行界面，允许您连接到 Oracle 数据库服务器并交互执行语句。

注意：如果有使用过 MySQL 或 PostgreSQL，SQL * plus 与 MySQL 中的 mysql 程序或 PostgreSQL 中的 psql 类似。

我们可以在终端输入 sqlplu s命令，以此来在 Linux 或 Window 中启动 SQL * Plus。

sqlplus

以 Windows 10 系统为例，在 Windows 的“开始”菜单的“程序”文件夹中找到 SQL * Plus 程序，如下所示：

启动 SQLPlus 图标时，会提示输入用户名和密码。输入在安装Oracle数据库服务器期间设置的用户名和密码。如果不知道要使用哪个帐户，请询问安装数据库的管理员。

假设要使用 sys 帐户连接到本地 Oracle 数据库服务器，请输入以下信息：

按下 Enter 后，您应该看到一条消息，后面跟着SQL>命令行，如下所示：

如上图所示，您已成功连接到 Oracle 数据库服务器。

在 Oracle 12c 中，当连接到数据库服务器时，默认数据库是名为 CDB$ROOT 的 ROOT 容器数据库。 要显示数据库名称，请使用 SHOW 命令：

SQL> SHOW con_name;

CON_NAME
------------------------------
CDB$ROOT

如果要切换到可插拔数据库，请使用ALTER SESSION语句将当前数据库设置为可插入数据库，例如：PDBORDL，如下所示：

SQL> ALTER SESSION SET CONTAINER = PDBORDL;

Session altered.

现在，您连接到 PDBORCL 数据库。

要断开用户与 Oracle 数据库服务器的连接，请使用 EXIT 命令：

SQL> EXIT

要将OT用户连接到位于PDBORCL可插拔数据库中的示例数据库，请输入以下命令：

sqlplus OT@PDBORCL

SQL Plus 会提示输入 OT 用户的密码。输入密码，您将连接到 Oracle 数据库服务器中的 PDBORCL* 数据库。

使用 SQL Developer 连接到 Oracle 数据库服务器

SQL Developer 是一个用于在 Oracle 数据库中使用 SQL 的免费 GUI 工具。与 SQL * Plus 程序一样，SQL Developer 在安装 Oracle 数据库服务器或客户端时自动安装。

要启动 SQL Developer 程序，请单击开始菜单中Oracle程序文件夹中的SQL Developer图标，如下图所示：

安装 Oracle 11g 会自带一个叫做 SQL Developer 的工具，它的功能非常强大，以前一直不知道，还用着 plsqldev 和 navicat 来连接数据库，其实这个工具拥有前面两个软件的所有功能（如果说的太绝对请指正）。首先我们打开 SQL Developer，如下图所示：

SQL Developer 不能用于创建 Oracle 数据库，只能用来连接已创建的数据库，我们一般都是使用 Database Configuration Assistant（简称 DBCA）来创建数据库，如下图所示：

打开 DBCA 以后按照向导来创建数据库，非常简单，这里不再赘述。

在 SQL Developer 中我们新建一个连接，点击左上角的“绿色加号”如下图所示：

创建数据库连接，如下图所示：

填写完配置以后可以点击“Test”来测试数据库连接是否正确，如上图所示，左下角有“Status：Success”则表明数据库连接正确。

2.创建新用户

接着为 ORCL 这个数据库创建新用户，如下图所示

填写用户名和密码，以及为用户指定表空间。如下图所示：

为用户分配权限

 查看创建用户和分配权限所对应的 sql 代码，如下图所示。

 3.使用新用户创建数据库连接

使用新账户创建数据库连接的方法和第一步类似，这里不再赘述。

代码连接

1. 先写好驱动字符串，连接字符串，用户名和密码字符串。

localhost 是本地地址

1521 是Oracle 默认端口

orcl 是Oracle 默认名称

uname 和 pwd 是 Oracle的用户名和密码

2. 加载驱动 Class.forName(driverStr);

3. 获取连接 conn=DriverManager.getConnection(orclStr,uname,pwd);

4. 然后就可以进行数据库的操作。

5. 关闭数据库，一定要记住反序关闭，先内后外。

6. 这样就连接到数据库并成功对数据库进行了一次操作。

来自 https://www.w3cschool.cn/oraclejc/oraclejc-elp62qqx.html

2)Oracle 基础知识

来自 https://www.w3cschool.cn/oraclejc/oraclejc-21an2qtd.html

2.1)  Oracle Select语句

Oracle Select语句

Oracle Select语句的作用是在表单中查询数据，本文将为大家带来Select语句的详细用法介绍。

SELECT语句使用方法

在Oracle中，表是由列和行组成。 例如，示例数据库中的customers表具有以下列：customer_id，name，address，website和credit_limit。customers表中这些列中也有对应的数据。

要从表的一个或多个列(column_1,column_2,...,column_n)中检索数据，请使用以下语法的SELECT语句：

SELECT
  column_1, 
  column_2, 
  ...
FROM
  table_name;

在这个SELECT语句中：

   ● 首先，需要指定要查询数据的表名。

   ● 其次，指定想要返回数据的列。 如果需要返回多个列，则需要用逗号(，)将这些列分隔。

注意，SELECT语句非常复杂，由许多子句组成，如ORDER BY，GROUP BY，HAVING，JOIN。 为了简单起见，在本教程中，我们只关注SELECT和FROM子句的用法。

Oracle SELECT示例

为了方便大家更加了解和掌握Oracle Select语句，下面为大家带来一些示例代码。

1. 查询单个列的数据

要从客户(customers)表中获取客户名称(name)列，请使用以下语句：

SELECT
  name
FROM
  customers;

执行上面语句，返回部分结果如下：

NAME
------------------------------------------------------------------------
Aetna
AIG
Intel
Pfizer
FedEx
New York Life Insurance
Ingram Micro
American Airlines Group
Johnson Controls
Goldman Sachs Group
Oracle

已选择319行。

2. 查询多个列的数据

要从多个列查询数据，请指定一个以逗号分隔的列名称列表。

以下示例显示如何从客户(customers)表的customer_id，name和credit_limit列中查询数据。

SELECT
    customer_id,
    name,
    credit_limit
FROM
    customers;

执行上面示例代码，得到以结果：

3. 查询表中所有列的数据

以下示例将检索customers表的所有列中的数据，列出所有列的名称，如下所示：

SELECT
    customer_id,
    name,
    address,
    website,
    credit_limit
FROM
    customers;

执行上面示例代码，得到以下结果：

为了方便起见，查看所有列可以使用简写星号(*)来指示Oracle从表中返回所有列的数据，如下所示：

SELECT
    *
FROM
    customers;

执行上面示例代码，得到以下结果：

请注意，应尽量避免使用星号(*)进行测试。 在实践中，即使想要从表的所有列中检索数据，也应该明确指定要从中查询数据的列。

这是因为业务变化，表格未来可能会有更多或更少的列。 如果在应用程序代码中使用星号(*)，并假定该表有一组固定的列，但应用程序可能不处理其他不相关的列或访问已删除的列。

以上就是Oracle Select语句用法的详细介绍了，下一章我们将为大家带来Oracle Order By子句的使用教程，不要错过哦。

来自 https://www.w3cschool.cn/oraclejc/oraclejc-e2ua2qu5.html

2.2) Oracle Order By子句

Oracle Order By用法详解

在Oracle中，ORDER BY子句可以用来对一列或多列的结果集按升序或降序进行排序。本文，将为大家带来ORDER BY子句的具体用法。

Oracle ORDER BY子句基本用法

在Oracle中，表中是以非指定顺序存储行数据记录的，它不管行插入数据库的顺序如何。要按列以升序或降序查询行记录，必须明确指示Oracle数据库要如何去排序。

例如，您可能希望按名称的字母顺序列出所有客户，或者按照从最低到最高信用限额的顺序显示所有客户。

要对数据进行排序，我们可以将ORDER BY子句添加到SELECT语句中，参考以下语法：

SELECT
    column_1,
    column_2,
    column_3,
    ...
FROM
    table_name
ORDER BY
    column_1 [ASC | DESC] [NULLS FIRST | NULLS LAST],
    column_1 [ASC | DESC] [NULLS FIRST | NULLS LAST],

要按列排序结果集，可以在ORDER BY子句之后列出该列。

按照列名是一个排序顺序，可以是：

• ASC表示按升序排序

• DESC表示按降序排序

默认情况下，无论是否指定ASC，ORDER BY子句都按升序对行进行排序。如果要按降序对行进行排序，请明确使用DESC。

NULLS FIRST在非NULL值之前放置NULL值，NULLS LAST在非NULL值之后放置NULL值。

ORDER BY子句可以按多列对数据进行排序，每列可能有不同的排序顺序。

请注意，ORDER BY子句总是SELECT语句中的最后一个子句。

Oracle ORDER BY用法示例：

下面将使用示例数据库中的customers表进行演示。

以下语句从客户(customers)表中检索客户的：name, address 和 credit limit ：

SELECT name, address, credit_limit FROM customers;

执行上面查询语句，得到以下结果：

1. 按列排序行示例

要按照字母顺序按升序排列客户名称，请使用以下语句：

SELECT name,address,credit_limit
FROM customers
ORDER BY name ASC;

执行上面示例代码，得到以下结果：

ASC指示Oracle按升序对行进行排序。但是ASC是可选的，如果省略，则在默认情况下，ORDER BY子句按指定的列按升序对行进行排序。

因此，下面的表达式：

ORDER BY name ASC

等效于

ORDER BY name

要按字母顺序降序排列客户名称，请在ORDER BY子句中的列名之后显式使用DESC，如下所示：

SELECT name, address, credit_limit
FROM customers
ORDER BY name DESC;

执行上面查询语句，得到以下结果：

2. 按多个列排序行示例

要对多列进行排序，可以用逗号分隔ORDER BY子句中的每列。

请参阅示例数据库中的以下联系人(contacts)表。

例如，要按first_name进行按升序排序，并按降序对last_name列进行排序，请使用以下语句：

SELECT first_name, last_name
FROM contacts
ORDER BY first_name, last_name DESC;

执行上面示例代码，可以看到如下结果：

从上面截图中可以看到，contact_id为91和311这两条记录的first_name的值相同，last_name的值是以降序来排列的。

在这个例子中，Oracle首先按first_name升序对行进行排序，以创建初始结果集。 然后Oracle按降序对last_name排序初始结果集。

看到类似下面的结果如下：

在上面的这个结果中：

• 首先，按first_name升序排序。

• 其次，如果两个名字相同，按last_name降序排列，如Daniel Glass和Daniel Costner，Dianne Sen和Dianne Derek，Doretha Tyler和Dorotha Wong。

3. 按列位置排序行示例

不需要指定用于排序数据的列名称。如果您愿意，可以使用ORDER BY子句中列的位置。

请参考下语句：

SELECT name, credit_limit,address
FROM customers
ORDER BY 2 DESC, 1;

在这个例子中，name列的位置是1，credit_limit列的位置是2。相当于以下查询语句：

SELECT name, credit_limit,address
FROM customers
ORDER BY credit_limit DESC, name;
SQL

在ORDER BY子句中，使用这些列位置来指示Oracle对行进行排序。

4.用NULL值排序行的示例

请参阅示例数据库中的以下地区(locations)表：

以下语句按城市(city)和州(state)检索位置并对其进行排序：

SELECT country_id, city, state
FROM locations 
ORDER BY state DESC;
SQL

执行上面查询语句，得到以下结果：

state列有NULL值，这意味着state数据与某些城市(例如：Beijing, Hiroshima 和 London)无关。

当使用非NULL值对混合NULL进行排序时，Oracle允许指定哪个应该首先出现。

例如，以下语句按升序对state列进行排序，并首先将NULL值放置在前面。

SELECT country_id, city, state
FROM
    locations
ORDER BY
    state ASC NULLS FIRST;
SQL

要放置NULL值在后面，可以使用NULLS LAST，如下面的语句所示：

SELECT country_id, city, state
FROM
    locations
ORDER BY
    state ASC NULLS LAST;
SQL

执行上面示例查询语句，得到以下结果：

5. 按函数或表达式排序数据

ORDER BY子句可在一列上应用一个函数，例如字符串函数，数学函数等，并按函数的结果对数据进行排序。

例如，以下语句使用ORDER BY子句中的UPPER()函数来区分客户名称的大小写：

SELECT customer_id, name
FROM customers
ORDER BY UPPER( name );
SQL

执行上面查询语句，得到以下结果：

以上内容是否对您有帮助

来自 https://www.w3cschool.cn/oraclejc/oraclejc-xzfk2qv3.html

2.3)Oracle Distinct子句

Oracle Distinct用法

SELECT DISTINCT可以用来过滤结果集中的重复行，确保SELECT子句中返回指定的一列或多列的值是唯一的。本文将为大家带来SELECT DISTINCT的具体用法。

Oracle SELECT DISTINCT用法

SELECT DISTINCT语句的语法如下：

SELECT DISTINCT
    column_1
        FROM
    table_name;

在上面语法中，table_name表的column_1列中的值将进行比较以过滤重复项。

要根据多列检索唯一数据，只需要在SELECT子句中指定列的列表，如下所示：

SELECT DISTINCT column_1,    column_2,
        ...
        FROM
    table_name;

在此语法中，column_1，column_2和column_n中的值的组合用于确定数据的唯一性。

DISTINCT子句只能在SELECT语句中使用。

请注意，在Oracle中DISTINCT和UNIQUE没有区别，二者为同义词，DISTINCT遵循ANSI标准，UNIQUE是Oracle特定的用法，从移植角度考虑，使用遵循ANSI标准的DISTINCT是一个更好的选择。

Oracle DISTINCT示例

下面来看看如何使用SELECT DISTINCT来看看它是如何工作的一些例子。

1. Oracle DISTINCT简单的例子

以下是一个table表

字段1     字段2
 id       name
 1         a
 2         b
 3         c
 4         c
 5         b

如果想用一条语句查询得到name不重复的所有数据，那就必须使用distinct去掉多余的重复记录。所以首先输入：

select *, count（distinct name） from table group by name

然后我们再输入：

id name count（distinct name）

得到结果：

1 a 1

2 b 1

3 c 1

2. Oracle DISTINCT在一列上应用的例子

以下示例检索所有联系人的名字：

SELECT first_name
FROM contacts
ORDER BY first_name;

执行上面查询语句，得到以下结果：

该查询返回了319行，表示联系人(contacts)表有319行。

要获得唯一的联系人名字，可以将DISTINCT关键字添加到上面的SELECT语句中，如下所示：

该查询返回了302行，表示联系人(contacts)表有17行是重复的，它们已经被过滤了。

2. Oracle DISTINCT应用多列示例

看下面的order_items表，表的结构如下：

以下语句从order_items表中选择不同的产品ID和数量：

SELECT
    DISTINCT product_id,
    quantity
FROM
    ORDER_ITEMS
ORDER BY product_id;

执行上面查询语句，得到以下结果

在此示例中，product_id和quantity列的值都用于评估结果集中行的唯一性。

3. Oracle DISTINCT和NULL

DISTINCT将NULL值视为重复值。如果使用SELECT DISTINCT语句从具有多个NULL值的列中查询数据，则结果集只包含一个NULL值。

请参阅示例数据库中的locations表，结构如下所示：

以下语句从state列中检索具有多个NULL值的数据：

SELECT DISTINCT state
FROM locations
ORDER BY state NULLS FIRST;

执行上面示例代码，得到以下结果：

正如上图所看到的，只返回一个NULL值。

以上内容是否对您有帮助

来自 https://www.w3cschool.cn/oraclejc/oraclejc-jhpr2qvb.html

2.4) Oracle Where子句

Oracle Where子句用法

Where是Oracle中的条件查询子句，本教程，将学习如何使用Oracle Where子句来指定过滤的条件返回符合查询条件的行记录。

Oracle WHERE子句简介

WHERE子句指定SELECT语句返回符合搜索条件的行记录。下面说明了WHERE子句的语法：

SELECT
    column_1,
    column_2,
    ...
FROM
    table_name
WHERE
    search_condition
ORDER BY
    column_1,
    column_2;

WHERE子句出现在FROM子句之后但在ORDER BY子句之前。在WHERE关键字之后是search_condition - 它定义了返回行记录必须满足的条件。

除了SELECT语句之外，还可以使用DELETE或UPDATE语句中的WHERE子句来指定要更新或删除的行记录。

Oracle WHERE示例

参阅示例数据库中的以下产品(products)表，其表结构如下：

1. 通过使用简单的相等运算符来查询行记录

以下示例仅返回名称为“Kingston”的产品：

SELECT
    product_name,
    description,
    list_price,
    category_id
FROM
    products
WHERE
    product_name = 'Kingston';

执行上面示例中的查询语句，得到以下结果：

在这个例子中，Oracle按以下顺序评估子句：FROM WHERE和SELECT

• 首先，FROM子句指定查询数据的表。

• 其次，WHERE子句基于条件(例如product_name ='Kingston'过滤行记录)。

• 第三，SELECT子句选择了应该返回的列。

2. 使用比较运算符选择行记录

除了等于(=)运算符之外，Oracle还提供了下表中所示的许多其他比较运算符：

例如，要获取标价大于500的产品，请使用以下语句：

SELECT
    product_name,
    list_price
FROM
    products
WHERE
    list_price > 500;

执行上面查询语句，得到以下结果：

3. 选择符合某些条件的行

要组合条件，可以使用AND，OR和NOT逻辑运算符。

例如，要获取属于类别编号是4且标价大于500的所有主板，请使用以下语句：

SELECT
    product_name,
    list_price
FROM
    products
WHERE
    list_price > 500
    AND category_id = 4;

执行上面示例代码，得到以下结果：

4. 选择在两个值之间的值的行记录

要查找具有两个值之间的值的行，请在WHERE子句中使用BETWEEN运算符。

例如，要获取标价在650到680之间(650 <= list_price <= 680)的产品，请使用以下语句：

SELECT
    product_name,
    list_price
FROM
    products
WHERE
    list_price BETWEEN 650 AND 680
ORDER BY
    list_price;

执行上面查询语句，得到以下结果：

请注意，以下表达式是等效的：

SELECT
    product_name,
    list_price
FROM
    products
WHERE
    list_price >= 650 AND list_price <= 680
ORDER BY
    list_price;

5. 选择符合值列表中的行记录

要查询值列表中的行记录，可以使用IN运算符，如下所示：

SELECT
    product_name,
    category_id
FROM
    products
WHERE
    category_id IN(1, 4)
ORDER BY
    product_name;

执行上面查询语句，得到以下结果：

表达方式：

category_id IN (1, 4)

等效于 -

category_id = 1 OR category_id = 4

6. 选择包含值的行作为字符串的一部分

以下语句检索名称以Asus开头的产品：

SELECT
   product_name,
   list_price
FROM
   products
WHERE
   product_name LIKE 'Asus%'
ORDER BY
   list_price;

在这个例子中，我们使用LIKE运算符来根据指定的模式来匹配行记录。

以上内容是否对您有帮助

来自 https://www.w3cschool.cn/oraclejc/oraclejc-932p2qvx.html

2.5) Oracle And子句

Oracle And子句

Oracle AND是一个逻辑运算符，可以用来组合两个或更多的布尔表达式。本文就将为大家带来Oracle AND的使用方法。

Oracle AND运算符语法

AND运算符是一个逻辑运算符，它组合了布尔表达式，如果两个表达式都为真，则返回true。 如果其中一个表达式为假，则AND运算符返回false。

AND运算符的语法如下所示：

expression_1 AND expression_2

下表说明了使用AND运算符合并true，false和NULL值时的结果：

通常，在SELECT，DELETE和UPDATE语句的WHERE子句中使用AND来形成匹配数据的条件。 另外，在JOIN子句的谓词中使用AND运算符来形成连接条件。

在声明中使用多个逻辑运算符时，Oracle始终首先评估AND运算符。 但是，可以使用括号来更改评估的顺序。

Oracle AND算符实例

以以下数据库中的订单(orders)表为例：

1. Oracle AND结合两个布尔表达式的例子

以下示例查找具有客户编号为2的那些状态为挂起(Pending)的订单：

SELECT order_id, customer_id, status, TO_CHAR(order_date,'YYYY-MM-DD') AS order_date
FROM orders
WHERE  status = 'Pending'  AND customer_id = 2
ORDER BY order_date;

在这个例子中，查询返回了满足两个表达式的所有订单信息，即：

status = 'Pending'

和

customer_id = 2

执行上面的代码可以得到以下结果：

2. Oracle AND结合两个以上的布尔表达式的例子

可以使用多个AND运算符来组合布尔表达式。

例如，以下语句检索满足以下所有条件的订单：

• 在2017年放置。

• 负责售货员编号为60。

• 有发货状态。

参考以下查询语句：

SELECT
    order_id,
    customer_id,
    status,
    TO_CHAR(order_date, 'YYYY-MM-DD') AS order_date
FROM
    orders
WHERE
    status = 'Shipped'
    AND salesman_id = 60
    AND EXTRACT(YEAR FROM order_date) = 2017
ORDER BY
    order_date;

执行上面的代码可以得到以下结果：

3. Oracle AND与OR运算符结合示例

可以将AND运算符与其他逻辑运算符(如OR和NOT)组合，以形成一个条件。

例如，以下查询查找客户ID为44的订单，并且状态已取消(Canceled) 或 待定(Pending)。参考以下实现语句：

SELECT
    order_id,
    customer_id,
    status,
    salesman_id,
    TO_CHAR(order_date, 'YYYY-MM-DD') AS order_date
FROM
    orders
WHERE
    (status = 'Canceled' OR status = 'Pending')
    AND customer_id = 44
ORDER BY
    order_date;

执行上面的代码可以得到以下结果：

以上内容是否对您有帮助

来自 https://www.w3cschool.cn/oraclejc/oraclejc-4gxo2qyi.html

2.6) Oracle Or子句

Oracle Or子句

OR是Oracle中的逻辑运算符，本教程，将来学习如何使用OR运算符来组合两个或更多的布尔表达式。

Oracle OR运算符语法

OR运算符组合了布尔表达式，如果其中一个表达式为真(true)，则返回true。

以下是OR运算符的语法：

expression_1 OR expression_2

下表显示了OR运算符在true，false和NULL值之间的结果。

我们经常在SELECT，DELETE和UPDATE语句的WHERE子句中使用OR运算符来形成过滤数据的条件。

如果在语句中使用多个逻辑运算符，则Oracle会在评估NOT和AND运算符之后评估OR运算符。 但是，可以使用括号更改评估的顺序。

Oracle OR运算符使用实例

我们将使用以下的orders表进行演示：

1. Oracle OR运算符组合两个布尔表达式的例子

以下示例查找状态为挂起(Pending)或取消(Canceled)的订单，参考以下查询语句：

SELECT
    order_id,
    customer_id,
    status,
    TO_CHAR(order_date, 'YYYY-MM-DD') AS order_date
FROM
    orders
WHERE
    status = 'Pending'
    OR status = 'Canceled'
ORDER BY
    order_date DESC;

在这个例子中，语句返回了满足下列表达式之一的所有订单：

status = 'Pending' 
-- 或
status = 'Canceled'

执行上面的代码可以得到以下结果：

2. Oracle OR运算符结合两个以上的布尔表达式的例子

我们经常使用OR运算符来组合两个以上的布尔表达式。 例如，以下语句检索负责以下销售员ID是60,61或62的订单：

SELECT
    order_id, 
    customer_id, 
    status, 
    salesman_id,
    TO_CHAR(order_date, 'YYYY-MM-DD') AS order_date
FROM
    orders
WHERE
    salesman_id = 60 
    OR salesman_id = 61 
    OR salesman_id = 62
ORDER BY
    order_date DESC;

执行上面的代码可以得到以下结果：

可以使用IN运算符来代替使用多个OR运算符，如下例所示：

SELECT
    order_id,
    customer_id,
    status,
    salesman_id,
    TO_CHAR(order_date, 'YYYY-MM-DD') AS order_date
FROM
    orders
WHERE
    salesman_id IN(60, 61, 62)
ORDER BY
    order_date DESC;

该查询返回的结果与使用上面的OR运算符返回的结果相同。

3. Oracle OR运算符与AND运算符结合使用的示例

可以将OR运算符与其他逻辑运算符(如AND和NOT)结合起来，形成一个条件。 例如，以下查询将返回属于客户ID为44并且已取消(Canceled)或挂起(Pending)状态的订单。参考以下查询语句：

SELECT
    order_id,
    customer_id,
    status,
    salesman_id,
    TO_CHAR(order_date, 'YYYY-MM-DD') AS order_date
FROM
    orders
WHERE
    ( status = 'Canceled' OR status = 'Pending')
    AND customer_id = 44
ORDER BY
    order_date;

执行上面的代码可以得到以下结果：

以上内容是否对您有帮助

来自 https://www.w3cschool.cn/oraclejc/oraclejc-kd9u2qyp.html

2.7) Oracle Fetch子句

Oracle Fetch子句

Oracle Fetch 子句

FETCH 子句在 Oracle 中可以用来限制查询返回的行数，本教程将教大家如何使用 FETCH 子句。

Oracle FETCH 子句语法

以下说明了行限制子句的语法：

[ OFFSET offset ROWS]
 FETCH  NEXT [  row_count | percent PERCENT  ] ROWS  [ ONLY | WITH TIES ]

OFFSET 子句

OFFSET 子句指定在行限制开始之前要跳过行数。OFFSET 子句是可选的。 如果跳过它，则偏移量为 0，行限制从第一行开始计算。

偏移量必须是一个数字或一个表达式，其值为一个数字。偏移量遵守以下规则：

• 如果偏移量是负值，则将其视为 0。

• 如果偏移量为 NULL 或大于查询返回的行数，则不返回任何行。

• 如果偏移量包含一个分数，则分数部分被截断。

FETCH 子句

FETCH 子句指定要返回的行数或百分比。

为了语义清晰的目的，您可以使用关键字 ROW 而不是 ROWS，FIRST 而不是 NEXT。 例如，以下子句的行为和产生的结果相同：

FETCH NEXT 1 ROWS
FETCH FIRST 1 ROW

ONLY | WITH TIES 选项

仅返回 FETCH NEXT (或 FIRST) 后的行数或行数的百分比。

WITH TIES 返回与最后一行相同的排序键。请注意，如果使用 WITH TIES，则必须在查询中指定一个 ORDER BY 子句。如果不这样做，查询将不会返回额外的行。

Oracle FETCH 子句实例

1. 获取前 N 行记录的示例

以下语句返回库存量最高的前 5 个产品：

-- 以下查询语句仅能在Oracle 12c以上版本执行
SELECT
    product_name,
    quantity
FROM
    inventories
INNER JOIN products
        USING(product_id)
ORDER BY
    quantity DESC 
FETCH NEXT 5 ROWS ONLY;

得到结果如下

2. WITH TIES 示例

以下查询使用 WITH TIES 选项的行限制子句：

-- 以下查询语句仅能在Oracle 12c以上版本执行
SELECT
 product_name,
 quantity
FROM
 inventories
INNER JOIN products
 USING(product_id)
ORDER BY
 quantity DESC 
FETCH NEXT 10 ROWS WITH TIES;

即使查询请求了 10 行数据，因为它具有 WITH TIES 选项，查询还返回了另外两行。 

请注意，这两个附加行在 quantity 列的值与第 10 行 quantity 列的值相同。

3. 以百分比限制返回行的示例

以下查询返回库存量最高的前 1％ 的产品：

-- 以下查询语句仅能在Oracle 12c以上版本执行
SELECT
    product_name,
    quantity
FROM
    inventories
INNER JOIN products
        USING(product_id)
ORDER BY
    quantity DESC 
FETCH FIRST 1 PERCENT ROWS ONLY;

SQL

执行上面示例查询语句，得到以下结果 ：

库存 (inventories) 表总共有 1112 行，因此，1112 中的 1％ 是 11.1，所以提取 12 (行)。

4. OFFSET 示例

以下查询将跳过库存量最高的前 10 个产品，并返回接下来的 10 个产品：

-- 以下查询语句仅能在Oracle 12c以上版本执行
SELECT
 product_name,
 quantity
FROM
 inventories
INNER JOIN products
 USING(product_id)
ORDER BY
 quantity DESC 
OFFSET 10 ROWS 
FETCH NEXT 10 ROWS ONLY;

得到以下结果 –

SQL

注意：这个功能可以用于分页的实现

以上内容是否对您有帮助

来自 https://www.w3cschool.cn/oraclejc/oraclejc-ldr72qz5.html

2.8)Oracle In子句

Oracle In子句

Oracle IN 运算符可以用来确定值是否与列表或子查询中的任何值相匹配，本文就将为大家带来 Oracle IN 运算符的具体用法。

Oracle IN语法： 

确定表达式是否与值列表匹配的 Oracle IN 运算符的语法如下所示：

expression [NOT] IN (v1,v2,...)

并且表达式的语法与子查询匹配：

expression [NOT] IN (subquery)

参数

在上面语法中，这里将介绍每个参数含义：

• expression - 该表达式(expression)是任何有效的表达式，它可以是要匹配的表的列。

• v1, v2, v3.. - IN 运算符后面是逗号分隔值列表，用于测试匹配。所有值必须与表达式具有相同的数据类型。

• subquery - 子查询返回一列的结果集以测试匹配。该列还必须具有与表达式相同的数据类型。

返回值

如果表达式(expression)的值等于值列表中的任何值或由子查询返回的结果集，则 IN 运算符返回 true。 否则，它返回 false。

NOT 运算符否定 IN 运算符的结果。

Oracle IN实例

以下面的这两种表为例：

1. Oracle IN 示例

以下语句查找所有销售员 ID 为54,55和56所负责的订单：

SELECT
    order_id,customer_id,status,salesman_id
FROM
    orders
WHERE
    salesman_id IN (54,55,56)
ORDER BY
    order_id;

执行以上代码可以得到以下结果：

如上图中所示，查询结果集返回了 salesman_id 列中值为54,55或56的所有订单。同样，以下示例将检索状态(status)列的值为"Pending"或"Canceled"的销售订单信息：

SELECT
    order_id, customer_id, status, salesman_id
FROM
    orders
WHERE
    status IN('Pending','Canceled')
ORDER BY
    order_id;

执行上面查询语句返回状态(status)列的值为"Pending"或"Canceled"的销售订单信息，如下所示：

2. Oracle NOT IN示例

这个示例演示如何查找状态(status)不是"Shipped"或"Canceled"的订单：

SELECT
    order_id, customer_id, status, salesman_id
FROM
    orders
WHERE
    status NOT IN( 'Shipped', 'Canceled')
ORDER BY
    order_id;

执行上面查询语句返回状态(status)列的值不是"Shipped"或"Canceled"的销售订单信息，如下所示：

3. Oracle IN 子查询示例

以下示例返回负责订单状态为取消(Canceled)的销售员的ID，名字和姓氏，参考以下查询语句

SELECT employee_id, first_name, last_name
FROM employees
WHERE
    employee_id IN(
        SELECT
            DISTINCT salesman_id
        FROM
            orders
        WHERE
            status = 'Canceled'
    )
ORDER BY first_Name;

执行上面查询语句，得到以下结果：

在这个例子中，子查询首先执行并返回一个销售员ID列表：

SELECT
    DISTINCT salesman_id
FROM
    orders
WHERE
    status = 'Canceled'

执行上面查询语句，得到以下结果 

这些销售人员id用于外部查询，查找所有员工的ID与销售员ID列表中的任何id相同。

以上内容是否对您有帮助

来自 https://www.w3cschool.cn/oraclejc/oraclejc-okdx2r0q.html

2.9)Oracle Between子句

Oracle Between子句

BETWEEN运算符可以用来在Oracle中选择值在一个范围内的行数据，本教程将为大家介绍BETWEEN运算符的具体使用方法。

Oracle BETWEEN运算符语法

BETWEEN运算符允许指定要测试的范围。当使用BETWEEN运算符为SELECT语句返回的行形成搜索条件时，只返回其值在指定范围内的行。

以下说明BETWEEN运算符的语法：

expression [ NOT ] BETWEEN low AND high

在上面的语法中：

• low 和high - low和hight指定要测试的范围的下限值和上限值。low和hight值可以是文字或表达式。

• expression - 是low和hight定义的范围内测试的表达式。 为了能够比较，expression，low和hight的数据类型必须是相同的。

• AND - AND运算符充当占位符来分隔low和hight的值。

如果表达式(expression)的值大于或等于low的值，小于或等于hight的值，则BETWEEN运算符返回true。

value >= low AND value <= high

NOT BETWEEN运算符否定BETWEEN运算符的结果。

Oracle BETWEEN示例

下面来看看使用Oracle BETWEEN运算符的一些使用示例。

1. Oracle BETWEEN数值示例

以下方的products表为例：

以下语句返回标准成本在500到600之间的所有产品：

SELECT
    product_name,
    standard_cost
FROM
    products
WHERE
    standard_cost BETWEEN 500 AND 600
ORDER BY
    standard_cost;

在此示例中，我们将标准成本(standard_cost)列中的值在500到600之间的范围进行比较筛选。该查询仅返回标准成本在以下范围之间的产品：

要查询标准成本不在500和600之间的产品，请按如下方式将NOT运算符添加到上述查询中：

SELECT
    product_name,
    standard_cost
FROM
    products
WHERE
    standard_cost NOT BETWEEN 500 AND 600
ORDER BY
    product_name;

2. Oracle BETWEEN日期示例

以下方的orders表为例进行演示：

要查询2016年12月1日至2016年12月31日期间客户的订单，可以使用以下语句：

SELECT
    order_id, customer_id, status, order_date
FROM
    orders
WHERE
    order_date BETWEEN DATE '2016-12-01' AND DATE '2016-12-31'
ORDER BY
    order_date;

执行语句后，可以得到以下结果：

以上就是W3Cschool为大家带来Oracle Between子句的用法介绍，希望对大家有所帮助。

以上内容是否对您有帮助

来自:  https://www.w3cschool.cn/oraclejc/oraclejc-6py42qz7.html

2.10)Oracle Like子句

Oracle Like子句

LIKE运算符在Oracle可以用来测试列中的值是否与指定的模式匹配，本教程将教大家LIKE运算符的正确用法。

Oracle LIKE运算符语法：

有时候，想根据指定的模式来查询数据。 例如，您可能希望查找姓氏以 St 开头或姓氏以 er 结尾的联系人。在这种情况下，可使用 Oracle LIKE 运算符。

Oracle LIKE 运算符的语法如下所示：

expresion [NOT] LIKE pattern [ ESCAPE escape_characters ]

在上面的语法中，

• expression：该表达式是一个列名称或一个表达式，要针对该模式 (pattern) 进行测试。

• pattern：该模式是在表达式中搜索的字符串。此模式包含以下通配符：

• ％(百分号)匹配零个或多个字符的任何字符串。

• _(下划线)匹配任何单个字符。

• escape_character：escape_character 是出现在通配符前面的字符，用于指定通配符不应被解释为通配符而是常规字符。

escape_character (如果指定)必须是一个字符，并且没有默认值。

如果表达式匹配模式，LIKE 运算符返回 true。 否则，它返回 false。

NOT 运算符(如果指定)可以否定 LIKE 运算符的结果。

Oracle LIKE 示例

下面举一些使用 Oracle LIKE 运算符的例子来看看它是如何工作的，以 contacts 表为例进行演示：

1. ％ 通配符的例子

以下示例使用 ％ 通配符查找姓氏以St开头的联系人的电话号码：

SELECT
    first_name,
    last_name,
    phone
FROM
    contacts
WHERE
    last_name LIKE 'St%'
ORDER BY
    last_name;

查询结果如下：

在这个例子中，使用了这个模式：

'St%'

LIKE 运算符匹配任何以“St”开头的字符串，后跟任意数量的字符，例如 Stokes，Stein 或 Steele 等。

要查找姓氏以字符串“er”结尾的联系人的电话号码，请使用以下语句：

SELECT
    first_name,
    last_name,
    phone
FROM
    contacts
WHERE
    last_name LIKE '%er'
ORDER BY
    last_name;

查询结果如下：

匹配的模式 

%er

匹配任何以“er”字符串结尾的字符串。

要执行不区分大小写的匹配，可以使用 LOWER() 或 UPPER() 函数，如下所示：

UPPER( last_name ) LIKE 'ST%'

LOWER(last_name LIKE 'st%'

例如，以下语句查找名字以 CH 开头的联系人的电子邮件：

SELECT
    first_name,
    last_name,
    email
FROM
    contacts
WHERE
    UPPER( first_name ) LIKE 'CH%'
ORDER BY
    first_name;

执行上放代码，得到以下结果：

以下示例使用 NOT LIKE 运算符来查找电话号码不以“+1”开头的联系人：

SELECT
  first_name, last_name, phone
FROM
  contacts
WHERE
  phone NOT LIKE '+1%'
ORDER BY
  first_name;

执行上面查询语句，得到以下结果：

2、_ 通配符的例子

以下示例查找名字具有以下模式“Je_i”的联系人的电话号码和电子邮件：

SELECT
    first_name,
    last_name,
    email,
    phone
FROM
    contacts
WHERE
    first_name LIKE 'Je_i'
ORDER BY 
    first_name;

查询结果如下：

模式 'Je_i' 匹配任何以'Je'开头的字符串，然后是一个字符，最后是 'i'，例如 Jeri 或Jeni，但不是 Jenni。

3. 混合通配符字符的例子

可以在模式中混合通配符。例如，以下语句查找名字以 Je 开头，后跟一个字符，然后是任意数量字符的联系人。换句话说，它将匹配以 Je 开头并且至少有 3 个字符的任何姓氏(first_name)：

SELECT
    first_name,
    last_name,
    email,
    phone
FROM
    contacts
WHERE
    first_name LIKE 'Je_%';

结果如下：

以上内容是否对您有帮助

来

来自 https://www.w3cschool.cn/oraclejc/oraclejc-h37o2r0u.html

3)Oracle 事务

COMMIT [ WORK ] [ COMMENT clause ] [ WRITE clause ] [ FORCE clause ];

COMMIT;

COMMIT WORK WRITE WAIT IMMEDIATE;

COMMIT COMMENT 'This is the comment for the transaction';
SQL

COMMIT WORK COMMENT 'This is the comment for the transaction';

COMMIT FORCE '22.14.67';

COMMIT WORK FORCE '22.14.67';

ROLLBACK [ WORK ] [ TO [SAVEPOINT] savepoint_name  | FORCE 'string' ];

ROLLBACK;

ROLLBACK WORK;

ROLLBACK TO SAVEPOINT savepoint1;

ROLLBACK WORK TO SAVEPOINT savepoint1;

ROLLBACK FORCE '22.14.67';

ROLLBACK WORK FORCE '22.14.67';

ROLLBACK [ WORK ] [ TO [SAVEPOINT] savepoint_name  | FORCE 'string' ];

ROLLBACK;

ROLLBACK WORK;

ROLLBACK TO SAVEPOINT savepoint1;

ROLLBACK WORK TO SAVEPOINT savepoint1;

ROLLBACK FORCE '22.14.67';

ROLLBACK WORK FORCE '22.14.67';

SET TRANSACTION [ READ ONLY | READ WRITE ]
                [ ISOLATION LEVEL [ SERIALIZE | READ COMMITED ]
                [ USE ROLLBACK SEGMENT 'segment_name' ]
                [ NAME 'transaction_name' ];

SET TRANSACTION READ ONLY NAME 'RO_example';

SET TRANSACTION READ WRITE NAME 'RW_example';

DECLARE
  l_name VARCHAR2(100);
  l_age  NUMBER;
  l_sex  VARCHAR2(2);
BEGIN
  -- 为保证set transaction是事务的第一条语句，先使用commit或rollback来结束掉前面可能存在的事务
  COMMIT;
  -- 使用name给事务命名
  SET TRANSACTION READ ONLY NAME '查询报表';
  SELECT NAME
    INTO l_name
    FROM student
   WHERE student_id = 1001;
  SELECT age
    INTO l_age
    FROM student
   WHERE student_id = 1001;
  SELECT sex
    INTO l_sex
    FROM student
   WHERE student_id = 1001;
  -- 终止只读事务
  COMMIT;
  dbms_output.put_line('输出：' || l_name || l_age || l_sex);
END;

LOCK TABLE tables IN lock_mode MODE [ WAIT [, integer] | NOWAIT ];

LOCK TABLE suppliers IN SHARE MODE NOWAIT;

CREATE TABLE table_name
(
  column1 datatype null/not null,
  column2 datatype null/not null,
  ...

  CONSTRAINT fk_column
    FOREIGN KEY (column1, column2, ... column_n)
    REFERENCES parent_table (column1, column2, ... column_n)
);

CREATE TABLE supplier
( supplier_id numeric(10) not null,
  supplier_name varchar2(50) not null,
  contact_name varchar2(50),
  CONSTRAINT supplier_pk PRIMARY KEY (supplier_id)
);

CREATE TABLE products
( product_id numeric(10) not null,
  supplier_id numeric(10) not null,
  CONSTRAINT fk_supplier
    FOREIGN KEY (supplier_id)
    REFERENCES supplier(supplier_id)
);

CREATE TABLE supplier
( supplier_id numeric(10) not null,
  supplier_name varchar2(50) not null,
  contact_name varchar2(50),
  CONSTRAINT supplier_pk PRIMARY KEY (supplier_id, supplier_name)
);

CREATE TABLE products
( product_id numeric(10) not null,
  supplier_id numeric(10) not null,
  supplier_name varchar2(50) not null,
  CONSTRAINT fk_supplier_comp
    FOREIGN KEY (supplier_id, supplier_name)
    REFERENCES supplier(supplier_id, supplier_name)
);

ALTER TABLE table_name
ADD CONSTRAINT constraint_name
   FOREIGN KEY (column1, column2, ... column_n)
   REFERENCES parent_table (column1, column2, ... column_n);

ALTER TABLE products
ADD CONSTRAINT fk_supplier
  FOREIGN KEY (supplier_id)
  REFERENCES supplier(supplier_id);

ALTER TABLE products
ADD CONSTRAINT fk_supplier
  FOREIGN KEY (supplier_id, supplier_name)
  REFERENCES supplier(supplier_id, supplier_name);

CREATE TABLE table_name
(
  column1 datatype null/not null,
  column2 datatype null/not null,
  ...

  CONSTRAINT fk_column
     FOREIGN KEY (column1, column2, ... column_n)
     REFERENCES parent_table (column1, column2, ... column_n)
     ON DELETE CASCADE
);

CREATE TABLE supplier
( supplier_id numeric(10) not null,
  supplier_name varchar2(50) not null,
  contact_name varchar2(50),
  CONSTRAINT supplier_pk PRIMARY KEY (supplier_id)
);

CREATE TABLE products
( product_id numeric(10) not null,
  supplier_id numeric(10) not null,
  CONSTRAINT fk_supplier
    FOREIGN KEY (supplier_id)
    REFERENCES supplier(supplier_id)
    ON DELETE CASCADE
);

CREATE TABLE supplier
( supplier_id numeric(10) not null,
  supplier_name varchar2(50) not null,
  contact_name varchar2(50),
  CONSTRAINT supplier_pk PRIMARY KEY (supplier_id, supplier_name)
);

CREATE TABLE products
( product_id numeric(10) not null,
  supplier_id numeric(10) not null,
  supplier_name varchar2(50) not null,
  CONSTRAINT fk_supplier_comp
    FOREIGN KEY (supplier_id, supplier_name)
    REFERENCES supplier(supplier_id, supplier_name)
    ON DELETE CASCADE
);

ALTER TABLE table_name
ADD CONSTRAINT constraint_name
   FOREIGN KEY (column1, column2, ... column_n)
   REFERENCES parent_table (column1, column2, ... column_n)
   ON DELETE CASCADE;

ALTER TABLE products
ADD CONSTRAINT fk_supplier
  FOREIGN KEY (supplier_id)
  REFERENCES supplier(supplier_id)
  ON DELETE CASCADE;

ALTER TABLE products
ADD CONSTRAINT fk_supplier
  FOREIGN KEY (supplier_id, supplier_name)
  REFERENCES supplier(supplier_id, supplier_name)
  ON DELETE CASCADE;

alter table  "表名" drop constraint "主键名"
        
或
alter table  "表名" drop primary key
        

CREATE TABLE supplier
(
    supplier_id numeric(10) not null,
    supplier_name varchar2(50) not null,
    contact_name varchar2(50),
    CONSTRAINT supplier_pk PRIMARY KEY (supplier_id)
);

CREATE TABLE products
( 
    product_id numeric(10) not null,
    supplier_id numeric(10) not null,
    CONSTRAINT fk_supplier
    FOREIGN KEY (supplier_id)
    REFERENCES supplier(supplier_id)
);

ALTER TABLE products 
DROP CONSTRAINT fk_supplier

ALTER TABLE table_name
DISABLE CONSTRAINT constraint_name;

CREATE TABLE supplier
( supplier_id numeric(10) not null,
  supplier_name varchar2(50) not null,
  contact_name varchar2(50),
  CONSTRAINT supplier_pk PRIMARY KEY (supplier_id)
);

CREATE TABLE products
( product_id numeric(10) not null,
  supplier_id numeric(10) not null,
  CONSTRAINT fk_supplier
    FOREIGN KEY (supplier_id)
    REFERENCES supplier(supplier_id)

ALTER TABLE products
DISABLE CONSTRAINT fk_supplier;

ALTER TABLE table_name
ENABLE CONSTRAINT constraint_name;

ALTER TABLE products
ENABLE CONSTRAINT fk_supplier;

ASCII( single_character )

ASCII('t')
Result: 116

ASCII('T')
Result: 84

ASCII('T2')
Result: 84

ASCIISTR( string )

ASCIISTR('A B C Ä Ê')
Result: 'A B C 0C4 0CA'

ASCIISTR('A B C Õ Ø')
Result: 'A B C 0D5 0D8'

ASCIISTR('A B C Ä Ê Í Õ Ø')
Result: 'A B C 0C4 0CA 0CD 0D5 0D8'

CHR( number_code )

CHR(116)
Result: 't'

CHR(84)
Result: 'T'

COMPOSE( string )

COMPOSE('o' || unistr('\0308') )
Result: ö

COMPOSE('a' || unistr('\0302') )
Result: â

COMPOSE('e' || unistr('\0301') )
Result: é

CONCAT( string1, string2 )

CONCAT('Oraok', '.com')
-- Result: 'Oraok.com'

CONCAT('a', 'b')
-- Result: 'ab'

SELECT CONCAT(CONCAT('A', 'B'),'C')
FROM dual;
-- Result: 'ABC'

SELECT CONCAT(CONCAT(CONCAT('A', 'B'),'C'),'D')
FROM dual;
- Result: 'ABCD'

SELECT CONCAT('Let''s', ' learn Oracle')
FROM dual;
-- Result: Let's learn Oracle

string1 || string2 [ || string_n ]

'oraok' || '.com'

'a' || 'b' || 'c' || 'd'

'oraok.com'

'abcd'

SELECT 'Dave' || ' ' || 'Anderson'
FROM dual;
-- Result: 'Dave Anderson'

'Dave Anderson'

SELECT first_name || ' ' || last_name AS customer_name
FROM customers;

SELECT 'Let''s' || ' learn Oracle'
FROM dual;

'Let's learn Oracle'

SELECT 'Let' || '''' || 's' || ' learn Oracle'
FROM dual;

 'Let's learn Oracle'

CONVERT( string1, char_set_to [, char_set_from] )

SELECT CONVERT('Ä Ê Í Õ Ø A B C D E ', 'US7ASCII', 'WE8ISO8859P1') 
   FROM DUAL; 

CONVERT('ÄÊÍÕØABCDE' 
--------------------- 
A E I ? ? A B C D E ? 

SELECT * FROM V$NLS_VALID_VALUES WHERE parameter = 'CHARACTERSET'

DUMP( expression [, return_format] [, start_position] [, length] )

DUMP('Tech')
-- Result: 'Typ=96 Len=4: 84,101,99,104'

DUMP('Tech', 10)
-- Result: 'Typ=96 Len=4: 84,101,99,104'

DUMP('Tech', 16)
-- Result: 'Typ=96 Len=4: 54,65,63,68'

DUMP('Tech', 1016)
-- Result: 'Typ=96 Len=4 CharacterSet=US7ASCII: 54,65,63,68'

DUMP('Tech', 1017)
-- Result: 'Typ=96 Len=4 CharacterSet=US7ASCII: T,e,c,h'

INITCAP( string1 )

INITCAP('tech on the oraok');
-- Result: 'Tech On The Oraok'

INITCAP('GEORGE BURNS');
-- Result: 'George Burns'

select a.*, b.coursename, c.stuname
  from score a, course b, stuinfo c
 where a.courseid = b.courseid
   and a.stuid = c.stuid;

select b.coursename, sum(a.score) / count(1)
  from score a, course b
 where a.courseid = b.courseid
   and a.courseid = 'R20180101'
 group by b.coursename;

select a.*,b.coursename,c.stuname
    from score a,course b,stuinfo c
where a.courseid=b.courseid
    and a.stuid=c.stuid and a.score>='85'and a.score<='95'