oracle数据库增删改查基本语句,如何在linux下 修改oracle数据库表数据
oracle数据库增删改查基本语句,如何在linux下 修改oracle数据库表数据详细介绍
本文目录一览： 如何使用java对oracle数据库进行增删查改？
用eclipse
public class Text {
public static final void main(String args[]){
Connection con = null;
try {
//1,加载驱动程序
Class.forName("oracle.jdbc.driver.OracleDriver");
//2,连接字符串
String s = "jdbc:oracle:thin:@localhost:1521:shitou";
//3,获得数据库连接
con = DriverManager.getConnection(s,"system","abc");
//4,获得语句对象
Statement stat = con.createStatement();
//5,执行sql
ResultSet rs = stat.executeQuery("select * from comp"); //查数据
对人员表TUser的业务逻辑：
package bean;
import java.sql.*;
import java.util.ArrayList;
import bean.UserBean;
import bean.DBUtil;
public class UserDAO{
public UserDAO() {
}
/*更新数据，通过传递许更新的对象以及SQL语句，对数据进行添加、删除或更新操作
*obj为实体类的对象，sql为SQL语句
*/
public boolean insertUser(UserBean ub){
boolean b=false;
Connection conn=null;
PreparedStatement stmt=null;
String sql=null;
try{
//插入一条记录
sql="insert into TUser values(user_sequence.nextval,?,?,?,?,?)";
//创建一个连接
conn=DBUtil.getConnection();
//创建PreparedStatement的对象
stmt=conn.prepareStatement(sql);
//给SQL语句内的"？"赋值
//stmt.setInt(1,ub.getUser_ID());
stmt.setString(1,ub.getMobile_Number());
stmt.setString(2,ub.getRoaming_Status());
stmt.setString(3,ub.getCom_Level());
stmt.setInt(4,ub.getCustomer_ID());
stmt.setInt(5,ub.getAccount_ID());
//返回执行更新操作后受影响的行数
int rst=stmt.executeUpdate();
if(rst!=0){
b=true;
}
//关闭相关的连接
DBUtil.closeStatement(stmt);
DBUtil.closeConnection(conn);
}catch(SQLException se){
se.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}
return b;
}
/*修改一条数据
*直接调用insertUser()方法
*/
public boolean updateUser(UserBean ub){
boolean b=false;
Connection conn=null;
PreparedStatement stmt=null;
String sql=null;
try{
//插入一条记录
sql="update TUser set Mobile_Number=?,Roaming_Status=?,Com_Level=?,Customer_ID=?,Account_ID=? where User_ID="+ub.getUser_ID();
//创建一个连接
conn=DBUtil.getConnection();
//创建PreparedStatement的对象
stmt=conn.prepareStatement(sql);
//给SQL语句内的"？"赋值
//stmt.setInt(1,ub.getUser_ID());
stmt.setString(1,ub.getMobile_Number());
stmt.setString(2,ub.getRoaming_Status());
stmt.setString(3,ub.getCom_Level());
stmt.setInt(4,ub.getCustomer_ID());
stmt.setInt(5,ub.getAccount_ID());
//返回执行更新操作后受影响的行数
int rst=stmt.executeUpdate();
if(rst!=0){
b=true;
}
//关闭相关的连接
DBUtil.closeStatement(stmt);
DBUtil.closeConnection(conn);
}catch(SQLException se){
se.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}
return b;
}
/*删除一条记录
*@返回boolean类型的标志，通过传递UserBean的实例对象，得到该对象的User_ID
*/
public boolean deleteUser(UserBean ub){
boolean b=false; //测试变量，无实在意义
Connection conn=null;
Statement stmt=null;
String sql=null;
int id=0;
try{
id=ub.getUser_ID();
//删除记录为id的记录
sql="delete from TUser where User_ID="+id;
//创建一个连接
conn=DBUtil.getConnection();
//创建PreparedStatement的对象
stmt=conn.createStatement();
//检测删除的对象是否存在
if(getUser(id)!=null&&getUser(id).getUser_ID()==id){
//返回执行更新操作后受影响的行数
int rst = stmt.executeUpdate(sql);
if (rst > 0) {
b = true;
}
}else{
System.out.println("此条记录不存在！");
}
//关闭相关的连接
DBUtil.closeStatement(stmt);
DBUtil.closeConnection(conn);
//捕获异常
}catch(SQLException se){
se.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}
return b;
}
/*查询数据/得到数据
*str为数据库对应的列名，sql为传入的SQL语句
*/
public UserBean getUser(int user_id){
Connection conn=null;
Statement stmt=null;
ResultSet rs=null;
String sql=null;
UserBean user=null;
try{
//从数据库中查询User_ID值为user_id的记录
sql="select * from TUser where User_ID="+user_id;
//创建一个连接
conn=DBUtil.getConnection();
//创建Statement的对象
stmt=conn.createStatement();
//实例化UserBean的一个对象
user =new UserBean();
//执行操作，返回一个结果集
rs=stmt.executeQuery(sql);
//从结果集中读取一条记录，并且将对应的属性值赋值给user
if(rs.next()){
//System.out.println(rs.getString("User_Address"));
user.setUser_ID(rs.getInt("User_ID"));
user.setMobile_Number(rs.getString("Mobile_Number"));
user.setRoaming_Status(rs.getString("Roaming_Status"));
user.setCom_Level(rs.getString("Com_Level"));
user.setCustomer_ID(rs.getInt("Customer_ID"));
user.setAccount_ID(rs.getInt("Account_ID"));
//System.out.println(user.getUser_ID());
}
//关闭相关的连接
DBUtil.closeResultSet(rs);
DBUtil.closeStatement(stmt);
DBUtil.closeConnection(conn);
//捕获异常
}catch(SQLException se){
se.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}
//返回user对象
// System.out.println(user.getUser_ID());
return user;
}
/*查询数据
*str为数据库对应的列名，sql为传入的SQL语句
*@返回一个数据列表
*/
public ArrayList getUsers(){
Connection conn=null;
Statement stmt=null;
ResultSet rs=null;
String sql=null;
UserBean user=null;
ArrayList list=null;
try{
//从数据库中查询User_ID值为user_id的记录
sql="select * from TUser";
//创建一个连接
conn=DBUtil.getConnection();
//创建Statement的对象
stmt=conn.createStatement();
list=new ArrayList();
//执行操作，返回一个结果集
rs=stmt.executeQuery(sql);
//从结果集中循环读取记录，并且将对应的属性值赋值给user
while(rs.next()){
//实例化UserBean的一个对象
user =new UserBean();
user.setUser_ID(rs.getInt("User_ID"));
user.setMobile_Number(rs.getString("Mobile_Number"));
user.setRoaming_Status(rs.getString("Roaming_Status"));
user.setCom_Level(rs.getString("Com_Level"));
user.setCustomer_ID(rs.getInt("Customer_ID"));
user.setAccount_ID(rs.getInt("Account_ID"));
//将user添加到list中
list.add(user);
}
//关闭相关的连接
DBUtil.closeResultSet(rs);
DBUtil.closeStatement(stmt);
DBUtil.closeConnection(conn);
//捕获异常
}catch(SQLException se){
se.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}
//返回list对象
return list;
}
}
********************与数据库的连接类DBUtil：
package bean;
import java.sql.*;
public class DBUtil {
static String serverName="localhost"; //主机地址
static String sDBDriver="oracle.jdbc.driver.OracleDriver"; //oracle驱动
static String dbInstance="cloud"; //数据库的名称
static String sConnStr="jdbc:oracle:thin:@"+serverName+":1521:"+dbInstance; //数据库的连接字符串
static String dbUser="system"; //数据库的登陆名
static String userPwd="manager"; //数据库的登陆密码
/*
*得到一个Connection对象
*@return java.sql.Connection
*/
public static Connection getConnection(){
Connection conn=null;
try{
Class.forName(sDBDriver);
conn=DriverManager.getConnection(sConnStr,dbUser,userPwd);
}catch(ClassNotFoundException e){
e.printStackTrace();
}catch(SQLException se){
se.printStackTrace();
}
return conn;
}
//关闭指定的结果集rs
public static void closeResultSet(ResultSet rs){
if(rs!=null){
try{
rs.close();
}catch(SQLException e){
e.printStackTrace();
}
}
}
//关闭指定的Statement
public static void closeStatement(Statement stmt){
if(stmt!=null){
try{
stmt.close();
}catch(SQLException e){
e.printStackTrace();
}
}
}
//关闭连接conn
public static void closeConnection(Connection conn){
if(conn!=null){
try{
conn.close();
}catch(SQLException e){
e.printStackTrace();
}
}
}
}
自己不想写，网上这样的内容太多，自己找一下
用eclipse
首先在oracle文件下找到jdbc文件，里面的lib文件下有个class12.zip
在eclipse里新建个项目，建好后在左边右击那个项目图标，选择属性（最下面的），里面有个java build path，点进去，找到add external jars按键，点一下，把那个class12.zip加载进来，然后可以开始写代码了。
我的代码如下：
import java.sql.*;
public class connect {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try{
Class.forName("oracle.jdbc.driver.OracleDriver");
}catch(ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Connection con = null;
Statement stmt = null;
ResultSet rs = null;
try{
String url="jdbc:oracle:thin:@服务器ip地址:端口号:数据库名字";
String user="用户名";
String password="密码";
String str="INSERT INTO ZZZ_2 VALUES('041110018','JHDK')";
con = java.sql.DriverManager.getConnection(url,user,password);
// 创建状态
stmt = con.createStatement();
// 执行SQL语句，返回结果集
//int rowcount = stmt.executeUpdate(str);
int j = stmt.executeUpdate("update ZZZ_2 set NAME='dbt' where ID=21");
int k = stmt.executeUpdate("delete from ZZZ_2 where ID=41110020");
rs = stmt.executeQuery("SELECT * FROM ZZZ_2");
// 对结果集进行处理
while (rs.next()) {
int id = rs.getInt("ID");
String name = rs.getString("NAME");
//Integer age = rs.getObject("age") == null ? null : rs.getInt("age");
System.out.println(id + ": " + name);
} }catch(SQLException e){
e.printStackTrace();}
// 释放资源
finally{
try{
rs.close();
}catch(SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try{
stmt.close();
}catch(SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try{
con.close();
}catch(SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
注意,上面的ip地址什么的要填对,ZZZ_2是我随便建的表,你改成自己的表名就行了
oracle create table时同时给该表赋予增删改查权限的语句怎么写
赞成一楼的，如果你现在用scott用户，那么就是create table table_name(aa number(8), name varchar2(20));
grant insert, update,select on table_name to scott.
简单举例
grant insert, update,select on table_name to user.
在表所在的用户执行
或是用有dba权限的用户执行
grant insert, update,select on 表所在useer.table_name to user.
如果在CMD命令下面写的，那可以在最后加上一条
create table xxx(.....);
grant insert,select,update to user_name on table_name;
oracle分配权限是基于角色，而不是针对某个表赋予权限，如果你的角色具备对表的增删改查权限，那么你就可以
C# 如何操作Oracle中的Long型数据（实现增删改查），求高手指点
将long类型中的数据完全显示出来：set
long
20000
1、LONG
数据类型中存储的是可变长字符串，最大长度限制是2GB。
2、对于超出一定长度的文本，基本只能用LONG类型来存储，数据字典中很多对象的定义就是用LONG来存储的。
3、LONG类型主要用于不需要作字符串搜索的长串数据，如果要进行字符搜索就要用varchar2类型。
4、很多工具，包括SQL*Plus，处理LONG
数据类型都是很困难的。
5、LONG
数据类型的使用中，要受限于磁盘的大小。
能够操作
LONG
的
SQL
语句：
1、Select语句
2、Update语句中的SET语句
3、Insert语句中的VALUES语句
限制：
1、一个表中只能包含一个
LONG
类型的列。
2、不能索引LONG类型列。
3、不能将含有LONG类型列的表作聚簇。
4、不能在SQL*Plus中将LONG类型列的数值插入到另一个表格中,如insert
into
...select。
5、不能在SQL*Plus中通过查询其他表的方式来创建LONG类型列,如create
table
as
select。
6、不能对LONG类型列加约束条件（NULL、NOT
NULL、DEFAULT除外），如：关键字列(PRIMARY
KEY)不能是
LONG
数据类型。
7、LONG类型列不能用在Select的以下子句中：where、group
by、order
by，以及带有distinct的select语句中。
8、LONG类型列不能用于分布查询。
9、PL/SQL过程块的变量不能定义为LONG类型。
10、LONG类型列不能被SQL函数所改变，如：substr、instr。
[b]因为long类型的数值不能用insert
into
...
select的方法插入,故我们要分两步走,先插入其它字段,最后再插入long类型字段,这可以通过过程来实现
Oracle数据库sys用户怎么查询其他用户对数据库中表的操作记录（增删改）？
（1）查看权限，sys用户有对其他用户增删改的权限才行。如果没有，还确实需要用sys用户操作，那么请用dba用户授权。
（2）如果权限没问题，那么在增删改的时候只要加上用户名就可以了。比如，用户a的table表。那么就是 insert into a.table values (''''''''''')，删改也类似。
oracle里面更新操作能带有四则运算吗
Oracle数据库基本操作
1.概述
Oracle数据库客户端一般需要安装在服务器上，可以在服务器端操作，一般我们可以用sql developer工具远程连接到数据库，先行建立数据库，然后对表进行增删改查。也可以使用MyEclispse的DB Broswer工具进行连接数据库并进行简单的增删改查。
2．SQL语句
Data Definition Language（DDL）：
主要用于建立、修改、删除数据库对象（表），不需要事务的参与CREATE:创建表
CREATE TABLE emp(
id NUMBER(10),
name VARCHAR2(20),
gender CHAR(1),
birth DATE,
salary NUMBER(6,2),
);
DESC :查询表结构
DESC emp;
RENAME:重命名表名
RENAME emp TO employee;
DROP：删除表
DROP TABLE emp;
ALTER:列（字段）操作
ADD：增加字段
ALTER TABLE employee ADD (birth DATE DEFAULT sysdate);MODITY：修改字段
ALTER TABLE employee MODIFY (name VARCHAR2(40) DEFAULT 'CLERK' );DROP：删除字段
ALTER TABLE employee DROP (birth);
Data Manipulation Language（DML）
用于对数据记录进行操作，包括插入，删除，修改。需要commit才能真正确认操作，如果需要撤销则rollback。
INSERT INTO：插入数据
INSERT INTO employee(id, name, salary) VALUES(1001, 'rose', 5500);UPDATE…SET..：更新数据
UPDATE employee SET salary = 8500 WHERE name = 'ROSE';DELETE FROM：删除记录
DELETE FROM employee WHERE job is null;
Transaction Control Language（TCL）
事务控制语言，包括commit提交，rollback回滚，savepoint保存点（可以回退到指定保存点）。在sql developer中为图标。
Data Query Language（DQL）
SQL基础查询：
查询语句的执行顺序
FROM 子句：执行顺序为从后往前、从右到左。数据量较少的表尽量放在后面。
WHERE子句：执行顺序为自下而上、从右到左。将能过滤掉最大数量记录的条件写在WHERE 子句的最右。
GROUP BY：执行顺序从左往右分组，最好在GROUP BY前使用WHERE将不需要的记录在GROUP BY之前过滤掉。
HAVING 子句：消耗资源。尽量避免使用，HAVING 会在检索出所有记录之后才对结果集进行过滤，需要排序等操作。
SELECT子句：少用*号，尽量取字段名称。ORACLE 在解析的过程中, 通过查询数据字典将*号依次转换成所有的列名, 消耗时间。
ORDER BY子句：执行顺序为从左到右排序，消耗资源。
也就是从哪张表中以什么样的限制条件确定数据内容，再通过分组与进一步限制分组条件得到一个处理过的数据，最后选择出来，如有需要，则对最后选择的数据进行排序。
FROM子句：
From后接表名，from前可以可以是*，但是不建议（查询效率低），一般接要查询的字段名。分组函数，字段和表名都可以使用别名，不加引号数据库中为大写，加引号别名可以用空格小写等。
WHERE子句：
当查询条件中和数字比较，可以使用单引号引起，也可以不用，当和字符及日期类型的数据比较，则必须用单引号引起。
使用条件判断：>，<，<=，<=，!=，<>，=。
SELECT ename, sal FROM emp WHERE sal< 2000;SELECT ename, sal, job FROM emp WHERE job = 'SALESMAN';SELECT ename, sal, hiredate FROM emp
WHERE hiredate>todate('2002-1-1','YYYY-MM-DD');使用AND/OR关键字
如果希望返回的结果必须满足多个条件，应该使用AND逻辑操作符连接这些条件如果希望返回的结果满足多个条件之一即可，应该使用OR逻辑操作符连接这些条件SELECT ename, sal, job FROM emp
WHERE sal> 1000 AND job = 'CLERK';
使用LIKE条件
SELECT ename, job FROM emp WHERE ename LIKE '_A%';（第二个字母为A）‘_A%’_表示占位一个字符，%表示0到多个字符。
使用IN/NOT IN
在WHERE子句中可以用比较操作符IN(list)来取出符合列表范围中的数据。其中的参数list表示值列表，当列或表达式匹配于列表中的任何一个值时，条件为TRUE，该条记录则被显示出来。
SELECT ename, job FROM emp WHERE job IN ('MANAGER', 'CLERK');使用BETWEEN 1 AND 2
用来查询符合(1，2)值域范围之内的数据，通常查询数字和日期类型的数据范围。
SELECT ename, sal FROM emp
WHERE sal BETWEEN 1500 AND 3000;
使用IS NULL和IS NOT NULL
条件筛选值为空的记录，空值不能用‘=’来判断。
使用ANY和ALL条件
在比较运算符中，可以出现ALL和ANY，表示“全部”和“任一”，> ANY : 大于最小< ANY：小于最大> ALL：大于最大< ALL：小于最小SELECT empno, ename, job, sal, deptno
FROM emp WHERE
sal> ANY (SELECT sal FROM emp WHERE job = 'SALESMAN');查询条件中使用算术表达式
当查询需要对选出的字段进行进一步计算，可以在数字列上使用算术表达式(+、-、*、/)。表达式符合四则运算的默认优先级，如果要改变优先级可以使用括号。
SELECT ename, sal, job FROMempWHERE ename = UPPER('rose');SELECT ename, sal, job FROM empWHERE sal * 12 >100000;使用DISTINCT过滤重复
DISTINCT必须紧跟SELECT，后面可以有多个字段，表示过滤掉多个字段都重复的选项，第二例中不显示重复的deptno和job相同的记录。
SELECT DISTINCT deptno FROM emp;
SELECT DISTINCT deptno, job FROM emp;
使用ORDER BY子句
对查询数据按照一定的规则排序，则使用order by子句，order by子句必须为select子句的最后一个子句。默认升序排列，从小到大，ASC表示升序。DESC表示降序，从大到小。
SELECT ename, sal FROM emp
ORDER BY sal DESC;
Order by多个列，每个列需要单独指定排序规则，先按照第一个字段排序，当第一个字段的值相同时，再按照第二个字段的值排序。
聚合函数分组函数
当需要统计的数据并不能在表里直观列出，而是需要根据现有的数据计算得到结果，这种功能可以使用聚合函数来实现。
因为是多行数据参与运算返回一行结果，也称作分组函数、多行函数、集合函数。用到的关键字：GOURP BY 按什么分组，HAVING进一步限制分组结果MAX和MIN
用来取得列或者表达式的最大最小值，包括数字，字符和日期。
SELECT MAX(sal) max_sal, MIN(sal) min_sal FROM emp;AVG和SUM
用来统计列或者表达式的平均值和求和，只能处理数字类，并且平均值忽略NULL。
SELECT AVG(sal) avg_sal, SUM(sal) sum_sal FROM emp;COUNT
用来计算表中的记录条数，同样忽略NULL。
SELECT COUNT(job) total_num FROM emp;
空值的操作
NVL(expr1, expr2)：将NULL转变为非NULL值。如果expr1为NULL，则取值expr2, expr2是非空值。
NVL2(expr1, expr2, expr3)：和NVL函数功能类似，都是将NULL转变为非空值。NVL2用来判断expr1是否为NULL，如果不是NULL，返回expr2，如果是NULL，返回expr3。
GROUP BY子句
Group by是表示对表中某个字段进行分组，值相同为一组，而分组函数的意思则是对这每一个组进行计算，平均值或是最大最小值。
HAVING子句
是对分组后的结果进行进一步的限制，HAVING子句必须紧跟在GROUP BY子句后，不能单独存在。限制分组条件不能放在WHERE子句中。
SELECT deptno, MAX(sal) max_sal FROM emp
GROUP BY deptno HAVING MAX(sal) >4000;
SQL关联查询：
概述，在实际应用中，往往我们所需要的数据是分布在不同的表上的，我们想要获取数据必须跨表格查询。
关联有两种方式：
SELECT table1.column, table2.column
FROM table1, table2
WHERE table1.column1 = table2.column2;
SELECT table1.column, table2.column
FROM table1JOIN table2
ON(table1.column1 = table2.column2);
关联查询有三种连接方式
内连接返回关联表中所有满足条件的记录（也称等值连接）外连接返回一些不满足条件的记录，外连接有左外连接，右外连接和全外连接三种形式其中左外连接返回左边所有记录而不必管右边是否匹配，如不匹配则为NULL值，右外连接返回右边所有记录而不必管左边的记录是否匹配，如不匹配则默认NULL，全外连接返回左边和右边所有的数据，左右边不匹配的数据，对应的其他字段值为NULL，格式如下
JOIN ON式
SELECT table1.column, table2.column
FROM table1 [LEFT | RIGHT | FULL] JOIN table2ON table1.column1 = table2.column2;
WHERE式
Select * from dave a,bl b where a.id=b.id(+);+号的位置和意义
‘+’号加在哪个表，哪个表就是关联表，另一张表就是基表。基表全部显示，关联表匹配显示。+在左边就是右外连接，+在右边就是左外连接。
自连接：
表示数据的来源是同一张表的内容，即将一张表中的不同列进行连接，可以是等值或者不等值。实现方式是利用别名将一张表看作两张表。
SELECT worker.empnow_empno,worker.enamew_ename, manager.empnom_empno, manager.enamem_enameFROM emp worker join emp manager
ON worker.mgr = manager.empno;
SQL高级查询：
子查询：
子查询用在WHERE里
在SELECT中，往往WHERE的限制条件并不是一个确定的值，而是来源于另一个查询结果，即需要在另一个查询结果的基础上进行查询，这个时候为另一个查询提供数据的查询就叫做子查询。
SELECT e.ename, e.job FROM emp e
WHERE e.job = (SELECT job FROM emp WHERE ename = 'SCOTT');可以与多行/单行比较操作符混合使用。
子查询用在HAVING子句
SELECT deptno, MIN(sal) min_sal FROM emp GROUP BY deptnoHAVING MIN(sal) > (SELECT MIN(sal) FROM emp WHERE deptno = 30);表示分组条件需要满足的条件。可以把子查询当成一个结果。
子查询用在FROM部分
子查询用在FROM子句中，子查询可称为行内视图或者匿名试图，可以把它当成一张单独的表，用别名进行标识。
子查询用在SELECT子句中
可以认为是外连接的一张表现
分页查询：
ROWNUM
伪列，返回标识行数据顺序的数字，伪列并不是真正的列数据，只是用来显示行数，并不能单独作为一列进行分组操作。
ROWNUM的结果从第一行数据之上开始，每查询到一条数据则指针下移一个，所以只有查询到数据后才能够出现伪列数字，因此不能直接用在where里，如果要利用ROWNUM截取结果集的部分数据，可以将含有ROWNUM伪列的SELECT子句放在FROM内，作为视图，供外部的SELECT语句使用，此时的伪列已形成顺序数据，可以进行分组函数操作。
也就是将ROWNUM先作为行内视图的一个列，在主查询中就可以使用这个列值作为条件。
SELECT * FROM (SELECT ROWNUMrn , e.* FROM emp e )WHERE rn BETWEEN 8 AND 10;
使用子查询和ROWNUM进行分页
分页操作需要有一个作为分页标准的数据，该数据线进行排序，排序的结果作为视图被父查询用伪列标识顺序数字，然后在最外面的爷爷查询对伪列进行分页。
如：
SELECT * FROM
(SELECT ROWNUMrn , t.* FROM
(SELECT empno,ename,sal FROM emp
ORDER BY sal DESC) t
)
WHERE rn BETWEEN 8 AND 10;
DECODE函数
DECODE (expr, search1, result1[, search2, result2…][, default])它用于比较参数expr的值，如果匹配到哪一个search条件，就返回对应的result结果，可以有多组search和result的对应关系，如果任何一个search条件都没有匹配到，则返回最后default的值。default参数是可选的，如果没有提供default参数值，当没有匹配到时，将返回NULL。
SELECT ename, job, sal,
DECODE(job, 'MANAGER', sal * 1.2,
'ANALYST', sal * 1.1,
'SALESMAN', sal * 1.05,
sal) bonus
FROM emp;
SELECT deptno, dname, loc
FROM dept
ORDER BY
DECODE(dname, '研发部',1,'市场部',2,'销售部',3), loc;分组函数
ROW_NUMBER
ROW_NUMBER()
OVER (PARTITION BY deptno ORDER BY empno)根据deptno分组，在分组内根据empno内排序，比ROWNUM功能更强。可以直接从结果集中取出子集RANK
RANK() OVER( PARTITION BY col1 ORDER BY col2)功能与上相同，不同在于存在并列，并列第二跳过第三直接第四的规则。
DENSE_RANK
如果有并列第二，下一个排序将是三。
高级分组函数
ROLLUP
如果对两个字段rollup，那么第一个字段相同的值会当成一组，如果有分组函数求和，就会对第一字段所有的数据求和，单独成行。此时第二字段值为空。可以用于统计年度销售（工资）和。
CUBE
CUBE函数对字段进行排列统计，比如三个字段的CUBE运算，将三个字段排列成6种情况具体需要使用的时候再参考百度。
GROUPING（）
GROUPING只能在使用ROLLUP或CUBE的查询中使用。当需要在返回空值的地方显示某个值时，GROUPING()就非常有用。案例情况复杂，具体使用时再说。
集合操作
UNION、UNION ALL、INTERSECT、MINUS
Union表示取多次SELECT结果的并集，如果去掉重复的数据。
Union All与union功能一样，只是它不会去掉重复的数据，会全部显示。
Intersect表示相交，多次查询后去相同的数据，即同时满足两个查询条件的数据Minus表示差集，即将第一个结果集中的数据，减去第二个结果集的数据。即满足第一个查询条件，而不满足第二查询条件的数据。
Data Control Language（DCL）:
用于执行权限的授予和收回操作、创建用户等，包括授予(GRANT)语句，收回(REVOKE)语句，CREATE USER语句，其中GRANT用于给用户或角色授予权限， REVOKE用于收回用户或角色已有的权限。DCL语句也不需要事务的参与，是自动提交的。
GRANT CREATE VIEW TO tarena;
3.视图、索引、序列、约束
视图
视图本质上是一条SELECT语句，当SELECT子查询在from子句中，可以把SELECT子句的结果当作一个视图。视图本身只是基表的映射，只是把基表中的数据显示出来，可以把视图当成表看待，所有操作都与表操作极其相似。
视图有三种，简单视图不包括函数，复杂视图包含了分组函数等附加的内容，连接视图是基于多个表的。
视图的优劣点：
如果需要经常执行某项复杂查询，可以基于这个复杂查询建立视图，此后查询此视图即可，简化复杂查询；视图本质上就是一条SELECT语句，所以当访问视图时，只能访问到所对应的SELECT语句中涉及到的列，对基表中的其它列起到安全和保密的作用，可以限制数据访问。
同时因为视图本质是基表的数据，所以对视图的操作会影响到基表从而不安全。这里可以使用WITH READ ONLY来限制对视图的DML语言。
CREATE OR REPLACE VIEW v_emp_10
AS
SELECT empno, ename, sal, deptno FROM empWHERE deptno = 10
WITH READ ONLY;
使用DCL语句可以授权用户创建视图的权限，
GRANT CREATE VIEW TO tarena;
创建简单视图
CREATE VIEW v_emp_10
AS
SELECT empno, ename, sal, deptno
FROM emp
WHERE deptno = 10;
查询视图
SELECT id, name, salary FROM v_emp_10;
对视图的DML操作
简单视图可以进行DML操作，但是操作的对象必须是基表里视图包含的字段，即对视图可见。而且简单视图的DML操作会对影响基表数据。
WITH CHECK OPTION短语表示，通过视图所做的修改，必须在视图的可见范围内，无论是INSERT UPDATE DELETE操作都必须在视图范围内，超过视图范围不可用。
CREATE [OR REPLACE] VIEW view_name[(alias[, alias…])]
AS subquery
[WITH CHECK OPTION];
删除视图
DROP VIEW v_emp_10;
对视图的删除不会导致基表数据的丢失，不会影响基表数据。
序列
序列(SEQUENCE)是一种用来生成唯一数字值的数据库对象。序列的值由Oracle程序按递增或递减顺序自动生成，通常用来自动产生表的主键值，是一种高效率获得唯一键值的途径。
序列是独立的数据库对象，和表是独立的对象，序列并不依附于表。
通常情况下，一个序列为一个表提供主键值，但一个序列也可以为多个表提供主键值。
CREATE SEQUENCE [schema.]sequence_name
[ START WITH i ] [ INCREMENT BY j ]
[ MAXVALUE m | NOMAXVALUE ]
[ MINVALUE n | NOMINVALUE ]
[ CYCLE | NOCYCLE ][ CACHE p | NOCACHE ]
创建一个序列，起始数据是100，步进是10：
CREATE SEQUENCE emp_seq
START WITH 100
INCREMENT BY 10;
NEXTVAL：获取序列的下个值
CURRVAL：获取序列的当前值
当序列创建以后，必须先执行一次NEXTVAL，之后才能使用CURRVAL。
获取序列的第一个值，并且使用序列值为EMP表插入新的记录：
删除序列
DROP SEQUENCE emp_seq;
索引
创建索引
CREATE [UNIQUE] INDEX index_name
ON table(column[, column…]);
index_name表示索引名称
table表示表名
column表示列名，可以建立单列索引或复合索引UNIQUE表示唯一索引
CREATE INDEX idx_emp_job_sal ON emp(job, sal);可以增加函数
CREATE INDEX emp_ename_upper_idx
ON emp(UPPER(ename));
重建索引，提高索引空间利用率
ALTER INDEX index_name REBUILD;
删除索引
DROP INDEX idx_emp_ename;
为提升查询效率，创建和使用索引的原则：
1.为经常出现在WHERE子句中的列创建索引
2.为经常出现在ORDER BY、DISTINCT后面的字段建立索引。如果建立的是复合索引，索引的字段顺序要和这些关键字后面的字段顺序一致3.为经常作为表的连接条件的列上创建索引
4.不要在经常做DML操作的表上建立索引
5.不要在小表上建立索引
6.限制表上的索引数目，索引并不是越多越好
7.删除很少被使用的、不合理的索引
约束
CONSTRAINT
非空约束(Not Null)，简称NN
创建表时添加约束
CONSTRAINT employees_hiredate_nn NOT NULL修改表时增加非空约束
ALTER TABLE employees
MODIFY (eid NUMBER(6) NOT NULL);
修改表时取消非空约束
ALTER TABLE employees
MODIFY (eid NUMBER(6));
唯一性约束(Unique)，简称UK
oracle如何授权当前用户只能增删改查当前用户的表
给用户赋予单表查询权限即可。
可用如下语句：
grant select on 表名 to 用户名;
如：将scott用户下的emp表的权限赋予system用户。
1、登录scott用户。
2、执行语句：
grant select on emp to system;
NoSQL如何实现数据的增删改查？
NoSQL数据库有很多种，实现方式差别很大。有接近SQL查询方式的，也有纯粹的键值对查询。具体可以搜“NoSQL数据库选型”、"SQL到NOSQL的思维转变"、“视觉中国的NoSQL之路：从MySQL到MongoDB”。
对于K-V型数据库，比较典型的是Redis，系统提供了get、set之类的命令用于增删改查。key值是字符串，一般被设计成查询条件的拼接，Redis习惯上用冒号分隔各个查询字段。（比如”login:1:login_times“）具体可以搜”锋利的Redis“、”十五分钟介绍 Redis数据结构“、“浅谈Redis数据库的键值设计"、”Redis作者谈Redis应用场景“。
NoSQL数据库有很多种，实现方式差别很大。有接近SQL查询方式的，也有纯粹的键值对查询。
对于K-V型数据库，比较典型的是Redis，系统提供了get、set之类的命令用于增删改查。关键是键值对的键和值怎么设计
每种nosql的操作区别很大，与传统sql非常接近的一个是iBoxDB, 它的函数名分别对应 insert update delete select, 并且select的查询语法与sql 接近 from table where a>b
for .Net版本能在 .NET， Windows Phone下运行. https://iboxdb.codeplex.com/
for Java版本能在 Java, Android下运行. https://github.com/iboxdb/forjava
package basic;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JDBC {
public void findAll() {
try {
// 获得数据库驱动
//由于长时间不写，驱动名和URL都忘记了，不知道对不对，你应该知道的，自己改一下的哈
String url = "jdbc:oracle:thin:@localhost:1521:XE";
String userName = "system";
String password = "system";
Class.forName("oracle.jdbc.driver.OracleDriver");
// 创建连接
Connection conn = DriverManager.getConnection(url, userName,
password);
// 新建发送sql语句的对象
Statement st = conn.createStatement();
// 执行sql
String sql = "select * from users";
ResultSet rs = st.executeQuery(sql);
// 处理结果
while(rs.next()){
//这个地方就是给你的封装类属性赋值
System.out.println("UserName："+rs.getString(0));
}
// 关闭连接
rs.close();
st.close();
conn.close();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void delete(){
try {
//步骤还是那六个步骤，前边的两步是一样的
String url = "jdbc:oracle:thin:@localhost:1521:XE";
String userName = "system";
String password = "system";
Class.forName("oracle.jdbc.driver.OracleDriver");
Connection conn = DriverManager.getConnection(url,userName,password);
//这里的发送sql语句的对象是PreparedStatement,成为预处理sql对象，因为按条件删除是需要不定值的
String sql = "delete from users where id = ?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setInt(0, 1);
int row = ps.executeUpdate();
if(row!=0){
System.out.println("删除成功！");
}
// 关闭连接
rs.close();
st.close();
conn.close();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
如何在linux下 修改oracle数据库表数据
你说的修改数据库表数据是指什么呢？
不过我知道，可以使用sqlplus进行数据库的任何操作，增删改查都可以。
使用安装oracle的用户登录linux，
1. 敲入sqlplus /nolog
加入/nolog是不登陆的意思，也可以直接敲sqlplus，这样会直接提示输入用户名；
2. 敲入conn scott/tiger
提示已连接，那么就可以操作scott用户下的表了。例如inset ,update，delete等等。语法就是sql语法，与操作系统无关。
当然，你可以连接到你想连接的用户进行相关操作。
oracle中的DML,DDL,DCL操作分别指的什么，请通俗点。
这几个词不是Oracle专有的词。
DML----Data Manipulation Language 数据操纵语言
如insert,delete,update,select(插入、删除、修改、检索)
DDL----Data Definition Language 数据库定义语言
如 create procedure之类
DCL----Data Control Language 数据库控制语言
如grant,deny,revoke等，只有管理员才有这样的权限。