精华内容
下载资源
问答
  • 数据库和ado知识

    2018-10-30 15:27:19
    外键关系的概念以及使用 数据库的主要类型 数据库的主要数据类型 使用SQL语句来创建数据库和表 约束分类 top的使用 Distinct的使用(去除重复数) 聚合函数 聚合函数注意事项 between and in 的使用 like, not ...
  • (4)创建表、确定表的主约束条件。 (5)查看修改表的结构。 (6)向数据库输入数据,观察违反列级约束时出现的情况。 (7)修改数据。 (8)删除数据,观察违反表级约束时出现的情况。 实验2 T—SQL...
  • 第 PAGE 2页共7页 A)A) A) A) A) A) 注意的考点 1窗体的概念 窗体的主要作用是接收用户输入的数据或命令编辑显示数据库中的数据构造方便美观的输入/输出界面 窗体本身没有存储数据其数据可以来源于查询或SQL语句 ...
  • 相关查询非相关子查询 1.相关查询:在查询,每查询一条记录,需要重新做一次子查询 2.非相关子查询:在查询查询只需要执行一次,查询结果不再变化,供查询使用 CSDN博客:...

    相关子查询和非相关子查询

    1.相关子查询:在主查询中,每查询一条记录,需要重新做一次子查询

    2.非相关子查询:在主查询中,子查询只需要执行一次,子查询结果不再变化,供主查询使用

    CSDN博客:http://blog.csdn.net/mascf/article/details/50288199

     

    对于SQL语句任何输入输出都是一个关系(表),也就是说任何一个SQL语句的输出都可以作为灵另一个SQL语句的输入

     

    查询的关键词的运算顺序:from > where > group by> having > select > order by

    NULL表示不存在的值,因此一个值加上NULL还会是NULL,但是有些实际的情况希望能够把NULL当做0处理,因此会使用isnull函数,查询列名为NULL直接置为0

    某一项不为空的写法:is not null

    表示区间是可以写为between A and B,即在[AB]区间

    字符串模式匹配 like 'J%',查询以J开头的结果

    查询第几个字母是什么的,得使用下划线,一个为一个字母

    当想要查询有下划线或者百分号的行时,需要使用转义字符,用escape指定哪个(不可以是下划线和百分号)为转义字符

    例:select empno,ename,sal,comm,sal+100,sal+isnull(comm,0)astotalincome 

             from emp

             where ename like '_L%' escape 'M';

    where是一个类似筛选的

    where deptno in10,20

    in后面是一个集合,此时查找的是deptno为集合中的元素的行数

     

    聚集函数:以值得一个集合(集或多重集)为输入、返回单个值的函数。例如avgminmaxsumcount

    where的输出力度小于group bygroup by是对where的同类行的分组

    having是在分组之后再挑选指定的行,如果在select对该列重命名,having里用该列名会提示列名无效,因为运算的顺序having>select

    select中如果想查询什么,此东西必须原封不动的写在group by

    order by按照某种顺序进行排列,默认是升序排列,加上DESC是降序排列

    distinct去掉重复行,比如查找有员工的部门编号可以用distinct去除重复的部门的编号

     

    集合运算:并(union),交(intersect),差(except

    并(union):自动去处重复,可使用union all加上重复

    交(intersect):自动去处重复,可使用intersect all加上重复

    差(except):自动去处重复,可使用except all加上重复

     

    连接(joinSQL为把常规连接和外连接区分开,因此常把常规连接称作内连接(包括相等连接和自然连接)。(natural join = natural inner join

    自然连接(natural join):运算作用于两个关系,并产生一个关系作为结果。其将第一个关系的每个元组与第二个关系的所有元组都进行连接,自然连接只考虑那些在两个关系模式中都出现的属性上

    取值相同的元组对。

    外连接:

    左外连接:左向外联接的结果集包括  LEFT OUTER子句中指定的左表的所有行,而不仅仅是联接列所匹配的行。如果左表的某行在右表中没有匹配行,则在相关联的结果集行中右表的所有选择列

    表列均为空值

    右外连接:右向外联接是左向外联接的反向联接。将返回右表的所有行。如果右表的某行在左表中没有匹配行,则将为左表返回空值;

    全外连接:完整外部联接返回左表和右表中的所有行。当某行在另一个表中没有匹配行时,则另一个表的选择列表列包含空值。如果表之间有匹配行,则整个结果集行包含基表的数据值。

     

    子查询:

    with语句用于在查询执行过程中临时生成一个表,后面可以直接使用。若想形成多个,不能使用多个with,可以直接用逗号加上另外的名字即可。

    with定义的临时视图必须要在后面用到,如果未使用有些数据库会报错。

     

    case某一列,对其分类处理用when(类似于switch),最后加上end结束。

    case表达式找不到要返回的数值时,需要返回NULL

    selectempno,ename,deptno,case

             when deptno=10 then''

               when deptno=20 then'一般'

              when deptno=30 then''

              else''

               end as level

    fromemp;

     

    数据库修改语句:

    1.删除(delete):删除操作只能删除整个元组而不能只删除,而不能只删除某些属性上的值。语句如下:delete from r where P;

    2.插入(insert):a.向表中插入一个行(可指定列),格式为insert into r(列名,列名…) values('…','…',…)

       b.insert语句允许吧一个或多个表中的多个行复制到另一个表,格式为insert into r(列名,列名…)select其中select子句可以是任何有效的语句,插入给定表中的行就是来自于子查

          询所生成的查询结果表。

    3.更新(update):update语句允许改变给定表中已存在的行的内容,格式为update r set columnName1=dataValue1… where … r是基表或可更新视图的名字。set子句指定需要更新的一个或多个列的名字,同时set可更新多个列。where子句是可选择的,如果省略则对给定列的所有行进行更新。如果给出了where子句,则仅对满足的行进行更新。

     

     

    展开全文
  •  本书从基础知识讲起,循序渐进,共19章,前11章主要讲解了ASP、网页数据库设计等相关基础知识,后8章主要以实例为,并通过详细讲解加以说明。读者通过对这些知识深入学习后,可以熟练地掌握ASP与数据库结合...
  • 8.5.6 SQL中的连接表和外连接 179 8.5.7 SQL中的聚集函数 180 8.5.8 分组:GROUP BY和HAVING子句 181 8.5.9 SQL查询讨论与小结 183 8.6 SQL中的插入、删除和更新语句 184 8.6.1 INSERT命令...
  • 为什么要使用实体对象的概念实体对象指的是可永久存储的数据对象,通常可以用关系数据库的一张数据表或一张主表和与之连接的几张子表来表示。为什么要引入实体对象的概念呢?我可以肯定您是看过关于面向对象优点的...

    为什么要使用实体对象的概念

    实体对象指的是可永久存储的数据对象,通常可以用关系数据库的一张数据表或一张主表和与之连接的几张子表来表示。为什么要引入实体对象的概念呢?我可以肯定您是看过关于面向对象优点的长篇大论的,不过我觉得有必要再唠叨两句,因为不是所有用C++或JAVA编程的人都是使用面向对象的方式想问题的。

    1. 在现实世界中,对象比它的属性要稳定,所以数据要抽象成对象。比如由于需求的修改,一个图书管理系统要显示更多的书目详细信息,图书的属性发生了变化,而图书这个对象并没有变,和其他对象(例如书架、借阅者)之间的关系也没有变。用一个数据对象来保存书目信息的程序修改起来要简单的多。
    2. 把实体对象如何永久储存的方法封装到对象中可以实现使用对象的外部程序的与数据库无关,便于程序的移植。
    3. 在程序设计中使用实体对象概念把面向对象分析、面向对象设计、面向对象编码着几个步骤连贯和一致。
    4. 可以减少外部程序中复杂性,使用这些实体对象的程序只需要简单的调用insert()或update()的方法,而不用去写讨厌的SQL语句。

    但是,由于历史原因,即使象Java这样的新兴语言,也没有在所有地方完全利用面向对象的思想。让我们看看JDBC吧,这是一个号称用对象封装的数据库接口。可是它封装的是什么呢?连接、语句、结果集和存储过程。这其实并不是我们设计系统所关心的东西,我们关心的是数据对象本身,而不是它从数据库中提取的方法。当然,JDBC本身也不该受到太多的指责,因为他本来的目标就是封装、屏蔽关系型数据库之间的差异,而不是企图实现一个面向对象的数据库。

    EJB第一次引起我的注意就是因为它提出的Entity Bean,也就是实体对象。它对实体对象提供了一套完整的实现思路,但是我认为它太复杂了,主要原因是EJB想要做的事太多了。大部分情况下我并不需要分布式处理,我也不需要把实体对象存储到文件中去。我需要的仅仅是在一个本地运行的基于数据库的程序。





    回页首


    EJB如何实现的实体对象

    刚才提到了EJB已经实现了实体对象,那么让我们看看它是如何实现的。EJB中Entity Bean的对象实际上是对数据对象的一种完美的抽象,在这里我们几乎看不到数据库管理系统的作用。一个实体对象有几种状态,在内存中、在磁盘缓存中、或者在数据库中,实体对象的这些状态通常我们是不关心的,EJB的容器在必要的情况下会自动转换对象的状态,也就是说自动把它存到数据库中,或从数据库中取出。我们要访问一个数据对象,要向一个对象容器提出申请,由它返回一个对象实例供我们使用。一个Entity Bean对应于数据表中的一行。如果我们访问的是同一行数据,对象容器返回的是不同的对象,但都指向同一个Entity Bean,并把我们所有的方法请求都发送给这个Entity Bean。实际上EntityBean的容器基本实现了一个面向对象的数据库。它这种实现方法带来几个显著的问题:

    1. 运行效率非常低。JAVA的速度慢是个老问题了,EJB的速度慢不光是因为大量代码用JAVA实现,而且由于它的结构,要根据数据表中的某一个属性查出一行数据,必须首先用SQL查询查找到这一行的主键(Primary Key),然后通过主键来找到这个Bean,如果这个Bean不在内存中--很不幸,这种情况经常发生,那么实际上是执行了两次SQL查询才找到一行数据。
    2. 容器本身要管理事务,以防数据的污读、污写、死锁等等一系列问题。本来DBMS管理这类问题已经有很多年经验了,已经相当完美的解决了这些问题,可是EJB不得不通过一个Transcation Server来管理这些问题。这使得容器的代码变得极其复杂,另外编程人员也不得不重新熟悉这些接口。
    3. 由于bean 中的数据是否存储在数据库里是由容器管理的,那么其他程序访问数据库会带来数据同步的问题。因此,在EJB架构中,外部程序不能直接访问数据库,只能通过EJB访问。




    回页首


    我们实现的目标

    我们只想把数据库对象更好的封装起来,为什么要购买别人昂贵的代码?为什么要为我们不会用到的分布式去牺牲大量的性能。我们想要尽量使用DBMS的功能,以实现最佳的性能和最简化的代码。

    事务处理最好还是用DBMS来管理,因为它一向管得很好,而且事务处理的代码很复杂,我不打算自己来完成。

    我不打算用同一个对象来指向数据库的一行。数据库的一行数据在程序中可能有多个对象,这些对象都应该是临时对象,而不是永久对象。他们的共享问题由DBMS本身加锁来解决。

    由于我们只是为访问DBMS提供了一个接口,外部程序完全可以不通过这个接口来访问数据库。

    实现后,使用实体对象的代码要简单。例如,数据库里有一个表account,它只有两个字段accountid和name,我们把它作为一个实体对象Account,假设我们要完成从数据库查询、修改、插入,使用它的代码片段如下:

    Connection conn=ConnectionPool.getConn(); //也可以通过标准的DriverManager得到数据库连接,这是完全一样的
      Conn.setAutoCommit(false); //如果不使用事务,这一行可以省去
    Account a1=new Account(conn);
    a1.getByAccountId(1); //查找到相应记录
    System.out.println(a1.name);
    a1.getByAccountIdForUpdate(1); //如果企图修改一个对象,必须通过forUpdate系列的方法得到这个对象
      a1.name="new name";
      a1.update();  //修改原有记录
    Account a2=new Account(conn);
    a2.accountId=3;
      a2.name="姚大";
      a2.insert();  //插入一条新记录
      conn.commit();

    实体对象的属性通过方法修改是比较理想的方式,如用getName(),setName()两个方法访问Name属性。这还可以解决属性之间相互关联的问题。例如,表中有一个地区代码和地区名称两个域,必须保持一致,这就可以考虑在属性设置方法中实现。在这里我们为了简单,直接通过属性修改,在一般情况下,我觉得也是可以接受到。

    有一点必须注意的就是多线程程序所带来的数据完整性问题。对于我们常使用的从数据库读取数据到对象中->修改对象属性->更新到数据库这个流程,非常容易出现数据完整性破坏问题。比如一个进程中甲对象读取数据后,另一个进程中乙对象又修改了同一数据,这时甲对象再次更新数据库会带来污写。解决的办法是对象增加一个方法给数据库的这条记录加锁。例如Account.getByAccountId函数改为Account.getByAccountIdForUpdate,这个函数中相应的sql语句(ORACLE数据库)改为"select AccountId,name from account where accountId=? for update",这样数据取出后就自动加锁,这个锁将会在事务提交或回滚时释放。for update在SQLServer相应的语法为holdlock。

    说到数据库加锁的问题就不能不考虑到数据库死锁的可能。想完全避免死锁是很困难的,只有尽量降低这种可能性。方法是:1、尽量少使用forUpdate这种函数,只有在更改数据库数据时才使用。查询的时候不要用,如果查询后根据某个条件有可能修改,那么在查询时不加锁,在修改前重新调用forUpdate函数加锁。2、尽量以某个特定的顺序加锁。例如有表A和表B,两个程序都要同时更新这两个表,最好都是先访问表A,再访问表B。

    Oracle有个很好的功能就是自动检测死锁。如果发生死锁,会回滚一个事务,并返回一个SQL错误,我们的程序要检测这个异常,处理程序中可能的错误。

    上面说到的对象中,只有getByXXX()这样的方法,这种方法只会返回唯一的对象,如果想要返回一组对象,这时需要一个辅助类来实现。这个辅助类称为对象浏览器EntityBrowser。再实体对象中返回一个对象浏览器的方法一般命名为getAllByXXX()

    使用对象浏览器EntityBrowser要列出所有account表中的id和name的代码如下,其实这个对象浏览器和Java定义的Enumeration接口的最大区别就是它有一个close方法。请看下面的代码片断,它输出所有的Accout对象。

          Connection conn=ConnectionPool.getConn();
           Account a1=new Account(conn);
           EntityBrowser browser=a1.getAll();
           System.out.println("==Account List==");
           While (browser.hasMoreElement()) {
                  Account a=(Account)browser.nextElement();
                  System.out.print(a.accountId);
                  System.out.print("--");
                  System.out.println(a.name);
           }
           browser.close();

    以上就是我们要实现的实体对象,下面介绍如何编写一个实体对象。





    回页首


    实现的代码解释

    首先,下面的代码定义一个所有实体对象的基础类EntityObject,这是一个抽象类,不能直接使用,但为其它实体对象定出了一个结构。

    Import java.sql.*;
    /**所有实体对象基础类*/
    abstract public class EntityObject {
           protected java.sql.Connection _conn;
           private boolean _dbStored;
           /**实体对象需要用一个数据库连接初始化,这样可以利用这个连接做事务提交或回滚*/
           public EntityObject(Connection conn) {_conn=conn;_dbStored=false;}
           /**这个方法用来插入新记录,子类必须重定义这个方法*/
           public void insert() throws SQLException{ _dbStored=true;}
           /**这个方法用来修改数据库原有记录,子类必须重定义这个方法*/
           public void update() throws SQLException {_dbStored=true; }
           /**这个方法用来删除数据库原有记录,子类必须重定义这个方法*/
           public void delete() throws SQLException {_dbStored=false; }
           /**这个方法用来把数据库select语句得出的结果映射到对象的属性中去,子类必须重定义这个方法*/
           public void _setAttribute(ResultSet rs) throws SQLException {_dbStored=true; }
           /**这个方法可以判断这个对象是否已存在数据库中*/
           public boolean isDbStored() {return _dbStored;}
           /**这个方法将实体对象设为不存在数据库中,所有的getByxxx()方法首先要调用这个方法,
           使本对象无效,才能用select语句得到符合条件的对象*/
           public void clearDbStored() {_dbStored=false;}
    }
    

    下面我们就可以定义一个实际的实体类。考虑一种简单情况,实体对象在关系数据库中只用一张表表示。这样的实体对象定义最简单。例如,数据库里有一个表account,它只有两个字段accountid和name,下面定义它的实体类。实体类必须重载insert,update,_setAttribute方法,然后根据需要增加getByXXX()方法,根据某个属性从数据库查找一个对象。

    Import java.sql.*;
    public class Account extends EntityObject {
    /*这里定义实体对象类所有的属性*/
           public int accountId;
           public String name;
    //最好将实体对象中的属性全部定义成私有,然后定义getXXX(), setXXX()两个方法来访问这个属性,
    这样的封装性最好,但略过于麻烦。如果数据结构预料会经常修改,
    最好用这个办法。否则,定义成公有属性也可。
           Public Account(Connection conn){ super(conn); }
           //重定义这个方法,执行实际的sql命令
    public void insert() throws SQLException {
                  PreparedStatement ps=_conn.prepareStatement 
                  ("insert into account(accountid,name) values(?,?)");
                  ps.setInt (1,accountId);
                  ps.setString (2,name);
                  ps.execute();
                  ps.close();
                  super.insert();  //注意,重载insert方法必须要有这一句
           }
    //重定义这个方法,执行实际的sql命令
           public void update() throws SQLException {
                  PreparedStatement ps=_conn.prepareStatement 
                  ("update account set accountid=?, name=? Where accountid=?");
                  ps.setInt(1,accountId);
                  ps.setString(2,name);
                  ps.setInt(3,accountId);
                  ps.execute();
                  ps.close();
                  super.update();  //注意,重载update方法必须要有这一句
           }
    //重定义这个方法,执行实际的sql命令
           public void delete() throws SQLException {
                  if (isDbStored()) {
                         PreparedStatement ps=_conn.prepareStatement
                         ("delete account where accountid = ? ");
                         ps.setInt(1,accountId);
                         ps.execute();
                         ps.close();
                  }
                  super.delete();
           }
        //下面这个方法把一个ResultSet转换成对象中的属性,下面所有的getByXXX方法都会用到这个方法。
           public void _setAttribute(java.sql.ResultSet rs) throws SQLException {
                   accountId=rs.getInt(1);
                   name=rs.getString(2);
                   super._setAttribute(rs);  //注意,重载_setAttribute方法必须要有这一句
           }
    //根据条件取得对象
           public boolean getByAccountId(int id) throws SQLException {
                  clearDbStored();
                  PreparedStatement ps=_conn.prepareStatement 
                  ("select AccountId,Name from account where AccountId=?");
                 //这里的select语句得到的结果集必须与上面的_setAttribute方法假定的结果集一致
            ps.setInt(1,id);
                  ResultSet rs=ps.executeQuery();
                  if (rs.next())
                         _setAttribute(rs);
                  rs.close();
                  ps.close();
                  return (isDbStored());
           }
    //根据条件取得对象并企图修改
           public boolean getByAccountIdForUpdate(int id) throws SQLException {
                  clearDbStored();
                  PreparedStatement ps=_conn.prepareStatement 
                  ("select AccountId,Name from account where AccountId=? for update");
            ps.setInt(1,id);
                  ResultSet rs=ps.executeQuery();
                  if (rs.next())
                         _setAttribute(rs);
                  rs.close();
                  ps.close();
                  return (isDbStored());
           }
    }
    

    上面说到的对象中,只有getByXXX()这样的方法,这种方法只会返回唯一的对象,这时,也不用保存数据库结果集,如果出现返回一组对象的情况,就不能不保存结果集了,这时需要一个辅助类来实现。这个辅助类称为对象浏览器,下面定义对象浏览器。

    import java.sql.*;
    /**所有实体对象的浏览器的父类*/
    abstract class EntityBrowser {
           protected ResultSet _rs;
           protected Connection _conn;
           protected boolean _hasMoreElement;
           /**浏览器是否还有下一个记录*/
           public boolean hasMoreElement() throws SQLException{
                 return _hasMoreElement;
           }
           /**返回下一个记录,子类必须重载这个函数*/
           abstract public Object nextElement() throws SQLException;
           /**关闭这个浏览器*/
           public void close () throws SQLException{
                  _rs.getStatement().close();
           }
           /**浏览器构造函数,指定一个数据库连接*/
           public EntityBrowser(ResultSet rs) throws SQLException {
                  _rs=rs;
                  _conn=_rs.getStatement().getConnection();
                  _hasMoreElement=_rs.next();
           }
           //子类重载nextElement()时调用这个方法
           protected Object _nextEntityObj(EntityObject eo) throws SQLException {
                  if (_hasMoreElement) {
                         eo._setAttribute(_rs);
                  } else eo=null;
                  _hasMoreElement=_rs.next();
                  return (eo);
           }
    }
    

    有了EntityBrowser类后,我们来修改刚才定义的Account类。第一步是要在Account类里定义一个私有的EntityBrowser子类,这个子类只要定义一个构造函数并重载nextElement()方法即可。这里使用了在一个类里定义另一个类的技巧,这个技巧在java的容器类库中经常使用。第二步是在Account类中增加一个方法getAllByXX(),返回一组实体对象的方法名常用getAll打头。请看以下修改的代码片段。

    import java.sql.*;
    public class Account extends EntityObject {
     。。。   
    /*以下是新修改的代码*/
        //定义一个子类
        private class AccountBrowser extends EntityBrowser {
                  AccountBrowser (ResultSet rs) throws SQLException { super(rs); }
                  Public Object nextElement() throws SQLException{
                         Account ac=new Account(_conn);
                         return (_nextEntityObj(ac));
                  }
    }
    //下面是实体对象的方法
           public EntityBrowser getAll() throws SQLException {
                  PreparedStatement ps=_conn.prepareStatement
                  ("select AccountId,Name from account ");
            ResultSet rs=ps.executeQuery();
                  return (new AccountBrowser(rs));
    }
    public EntityBrowser getAllByName(String name) throws SQLException {
        PreparedStatement ps=_conn.prepareStatement
        (“select AccountId,Name from account where name like ?”;
        ps.setString(1,name);
        ResultSet rs=ps.executeQuery();
        return (new AccountBrowser(rs));
    }
    

    接下来,讨论一下数据表的连接关系,关系数据库主要有一对一,一对多,多对多,多对一的关系。比如教师和学生之间的教课关系,这是一种多对多的关系。有的关系是有自己的属性,比如教课时间,我们可以把所有的关系都看作一个实体对象。但是为了简化程序,对于那些没有自己属性的一对一,一对多关系我们可以把它简化成父、子表的关系。表示数据库中的主表和子表有两种方法。

    一种方法把子表和主表看作一个实体对象,子表用Vector或HashTable这样的Collection定义成主表的一个属性,在_setAttribute方法中,再执行一次sql查询,把查询出的子表数据放入collection中。同时还要修改insert,update方法,使得主表的实体对象每次数据插入或修改时都要删除并重新插入子表的数据。这里实际上把子表看作主表的一种附属数据结构,而不是独立的对象,子表的数据库操作全部由主表来完成。

    另一种方法是把子表看作一个单独的实体类,实际上这时不存在主表和子表的概念了。只有两个实体对象,他们之间是一种关联的关系。主表通过getXXByXX()的方法来返回一个子表类的Browser。可以通过定义主表的一个方法insertXX(), 调用子表的insert()来插入一个新的子表项目;定义deleteXXX()来删除子表项目。至于更新子表数据,可以直接调用子表实体类的update()方法,不需要使用主表类的任何方法。

    对于一个视图,也可以参照定义实体类的方法定义一个视图类,不过要尽量少用视图类,因为视图类和其他实体对象虽然语法上看不出关联,但语义上实际上是有关联的。一个实体类的修改常常要修改所有相关的视图类,这对于数据封装是很不利的。只有出于性能的考虑我们才使用它。

    最后,探讨一下数据库事务的概念。事务是建立在数据库连接的基础上的,可以一次提交或回滚一系列操作。要实现事务,必须把数据库连接的自动提交属性设为false。java缺省的连接都是自动提交的,实现事务必须强制执行一个conn.setAutoCommit(false)。如果连接不是自动提交的,那么要注意,每当一个事务完成时必须执行commit或rollback,就算是select语句也必须提交事务。而且事务最好能尽早提交,比如每次select后提交,这样可以减少数据库资源的占用。

    以上是我关于实体对象实现的一些想法,欢迎大家讨论。

    展开全文
  • (一)、在已建立的数据库数据表的基础上,向数据库中添加一个临时表ST,其结构与S表结构相同。用Insert语句向临时表输入数据,输入有误时用Update语句进行修改。再用三个更新语句完成下列操作。 1、向S表添加若干...
  • Oracle数据库实验操作

    2012-07-26 15:00:43
    实验64:临时表和压缩数据表的使用 141 实验65:压缩存储数据 142 实验66:删除表指定列操作 142 实验67:使用sqlldr加载外部的数据 143 实验68:使用utl_file包来将表的数据存储到外部文件 144 实验69:使用外部...
  • 了游标的概念。因此在嵌入方式下,除了数据查询语句一次查询一条记录外,还有几种与游标 有关的语句: 游标的定义、打廾、关闭、拨动语句 游标定位方式的数据修改与删除语句。 为了有效维护数据库的完整性一致性,...
  •  本书还提供了dba完成本职工作必备基本uniix、sql、pl/sql数据建模知识,也给出了许多富有趣味性例子,通过这些实例详细、循序渐进地说明了oracle database 11g数据库的各个概念和特性。 作译者  Sam...
  •  1.4 关系数据库的概念(rdbms)  1.4.1 关系数据库模型  1.4.2  1.5 oracle的总体框架结构  1.5.1 oracle实例(oracle instance)  1.5.2 oracle的存储结构  1.6 数据字典(data dictionary)  ...
  •  1.4 关系数据库的概念(rdbms)  1.4.1 关系数据库模型  1.4.2  1.5 oracle的总体框架结构  1.5.1 oracle实例(oracle instance)  1.5.2 oracle的存储结构  1.6 数据字典(data dictionary)  ...
  • 5.2.4 创建备用数据库作为主数据库的 一个子集 5.2.5 选择备用站点 5.2.6 选择备用节点 5.2.7 进行热备用失败切换 5.2.8 关于备用激活要记住三个要点 5.2.9 备用激活后四项工作 5.2.10 将归档重做日志...
  • 数据库课程设计(基于B/S)

    热门讨论 2008-12-28 15:28:06
    订单表(Order):用于存放用户下达的订阅报刊的基本信息,包括数据项:订单编号、用户编号(用户表的主码)、报刊代号(报刊信息表的主码)、订阅份数、订阅月数等。 根据上面的设计规划出来的实体有部门实体、...
  • 10.4.1 备份还原的概念 10.4.2 数据库备份 10.4.3 数据库还原 10.5 分离附加数据库 10.5.1 分离数据库 10.5.2 附加数据库 10.6 导入、导出数据 10.6.1 导入数据库 10.6.2 导入SQL Server数据 10.6.3 导入...
  •  1.4 关系数据库的概念(RDBMS)  1.4.1 关系数据库模型  1.4.2  1.5 Oracle的总体框架结构  1.5.1 Oracle实例(Oracle Instance)  1.5.2 Oracle的存储结构  1.6 数据字典(Data Dictionary)  ...
  • 10.4.1 备份还原的概念 10.4.2 数据库备份 10.4.3 数据库还原 10.5 分离附加数据库 10.5.1 分离数据库 10.5.2 附加数据库 10.6 导入、导出数据 10.6.1 导入数据库 10.6.2 导入SQL Server数据 10.6.3 导入...
  • 并完整地介绍了几个使用Visual Basic开发Access数据库应用程序实例,包括综合人事管理系统、图书借阅管理系统、汽车租赁管理系统设备管理系统。这些 第1章 Access数据库管理 1 1.1 创建管理数据库 1 1.1.1...
  •  本书由多位工作在数据库维护一线工程师合著而成,包含了精心挑选的数据库诊断案例与性能优化实践经验,内容涉及oracle典型错误分析诊断,各种sql优化方法(包括调整索引,处理碎片,优化分页查询,改善...
  • Oracle数据库第三讲

    2012-03-14 22:03:01
    概述:查询DML语言使用 一、查询 概念 :当一个查询结果是另一个查询条件时,称之为查询 使用查询注意事项:  查询可以嵌套多层 ... 查询也可以使用查询中的字段变量 语法: SELE

    概述:子查询和DML语言使用

    一、子查询

    概念 :当一个查询的结果是另一个查询的条件时,称之为子查询

    使用子查询注意事项:

             子查询可以嵌套多层

             子查询需要圆括号()括起来

     子查询可以放到查询字段的位置

     子查询可以放到where条件位置

     子查询可以放到from后当做临时表来使用

     子查询中也可以使用主查询中的字段和变量

    语法:

    SELECT select_list 

    FROM table 

    WHERE expr operator

      (SELECT select_list 

           FROM table);

    l 子查询 (内查询在主查询之前一次执行完成。

    l 子查询的结果被主查询使用 (外查询)

    单行子查询:

    子查询的结果返回的一行且一列,就只有一个值,子查询可以返回空行 没要查询到结果是可以的。

    单行操作符对应单行子查询

    单行操作符

    >、>=、 <、 <= 、<>、=

    SQL> select * from emp where job=( select job from emp where empno=7876) and sal>( select sal from emp where empno=7521);

    子查询含有组函数

    SQL> select * from emp where sal>(select avg(nvl(sal,0)) from emp);

    多行子查询:

    返回多行结果,使用多行比较操作符。

    In   等于列表中的任何一个

    Any 子查询返回的任意一个值比较 相同还有some

    All  和子查询返回的所有值比较  

    Exists

    //查询岗位与部门编号为10相同的员工信息 不包含自己。

    SQL> select * from emp where job in(select job from emp where deptno=10) and deptno<>10;

    二、DML(Data Manipulation Language – 数据操作语言) 简介

    概述:DMLData Manipulation Language)数据操纵语言,SQL的分类之一,此外还有DDLData Definition Language数据定义语言DCLData Control Language数据控制语言DML包括:INSERTUPDATEDELETE。注意,select语句属于DQL(Data Query Language)

    DML执行条件:

    • 向表中插入数据

    • 修改现存数据

    • 删除现存数据

    a) 插入语句

    使用 INSERT 语句向表中插入数据。

    INSERT INTO table [(column [, column...])] 

    VALUES (value [, value...]);

    使用这种语法一次只能向表中插入一条数据

    注意:

    l 为每一列添加一个新值。

    l 按列的默认顺序列出各个列的值。 

    l 在 INSERT 子句中随意列出列名和他们的值。

    l 字符和日期型数据应包含在单引号中

    SQL> insert into users(username,password,name,address,zip) values('rrmy','1234','marico_zhang','北京',100089);

    备注:如果是字符串加’’ 如果是数字可与加’’也可以不加===>一般不加

    SQL> commit;

    注意:oracle数据库在DOS命令中执行插入,修改等操作时,必须手动完成提交。否则不会(正真)插入成功。

    在插入完整的记录是users()中的表对应的字段可以省略不写.但一定要与数据库中表的结构对应才行。

    常见面试题:

    //备份一张表

    SQL> create table usess as select * from users;

    //清空表中的记录

    SQL> delete from usess;

    //使用插入语句把users表中记录插入到usess中

    SQL> insert into usess(username,password,name,address,zip) select username,password,name,address,zip from users;

    SQL> commit

    注意:

    l 不必书写 VALUES 子句。 

    l 子查询中的值列表应于 INSERT 子句中的列名对应

    b) 更新数据

    采用update语法进行更新数据:

    语法如下:

      UPDATE table 

      SET column = value [, column = value, ...]

      [WHERE  condition];

    备注:一次可以更新多条记录

    update语句中使用子查询

    //更新huxz的邮编与用户liucy的邮编一致

    SQL> update users set zip=(select zip from users where username='liucy') where username='huxz';

    //备注:在更新数据的时候 where条件中也可以使用子查询。

    c) 删除数据

     在表中如果某些数据不在需要就可以使用delete语句进行删除,并释放该数据所占用的存储空间删除语法如下:

    DELETE [FROM]   table 

    [WHERE   condition];

    备注:delete语句只是从表中删除数据,不会删除表结构.删除表结构采用drop语句。

    注意:删除表中的数据时,一定要考虑表的约束(否则会出现一些异常信息)

    //清空表  delete from 表名 ||delete 表名  

    //删除数据 where条件与更新一致,必须保证唯一性(主键是唯一)条件

    SQL> delete from users where username='test';

    展开全文
  • 逻辑表 水平拆分的数据库(表)相同逻辑和数据表结构总称,例如:订单数据根据主键尾数拆...指分片规则一致的主表和子表,例如:t_order表和t_order_item 表,均按照order_id分片,则此两张表互为绑定关系,绑定.

    逻辑表

    水平拆分的数据库(表)的相同逻辑和数据表结构的总称,例如:订单数据根据主键尾数拆分为10张表,分别是t_order_0和t_order_9,他们的逻辑表名为t_order

    真实表

    在分片的数据库中真实存在的物理表,即t_order_0和t_order9 

    数据节点

    数据分片的最小单元,有数据源名称和数据表组成即ds_0.t_orderd_0

    绑定表

    指分片规则一致的主表和子表,例如:t_order表和t_order_item 表,均按照order_id分片,则此两张表互为绑定关系,绑定关系之间的多表关联不会出现笛卡尔积,查询效率将大大提升

    举例说明,如果SQL为:

    SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);
    

    在不配置绑定表关系时,假设分片键order_id将数值10路由至第0片,将数值11路由至第1片,那么路由后的SQL应该为4条,它们呈现为笛卡尔积:

    SELECT i.* FROM t_order_0 o JOIN t_order_item_0 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);
    
    SELECT i.* FROM t_order_0 o JOIN t_order_item_1 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);
    
    SELECT i.* FROM t_order_1 o JOIN t_order_item_0 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);
    
    SELECT i.* FROM t_order_1 o JOIN t_order_item_1 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);
    

    在配置绑定表关系后,路由的SQL应该为2条:

    SELECT i.* FROM t_order_0 o JOIN t_order_item_0 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);
    
    SELECT i.* FROM t_order_1 o JOIN t_order_item_1 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);
    

    其中t_order在FROM的最左侧,ShardingSphere将会以它作为整个绑定表的主表。 所有路由计算将会只使用主表的策略,那么t_order_item表的分片计算将会使用t_order的条件。故绑定表之间的分区键要完全相同。

    广播表

    指所有的分片数据源中都存在的表,表结构和表中的数据在每个数据库中均完全一致。适用于数据量不大且需要与海量数据的表进行关联查询的场景,例如:字典表

     

    分片策略存在 数据源分片策略和表分片策略

    分片策略配置

    对于分片策略存有数据源分片策略和表分片策略两种维度。

    • 数据源分片策略

    对应于DatabaseShardingStrategy。用于配置数据被分配的目标数据源。

    • 表分片策略

    对应于TableShardingStrategy。用于配置数据被分配的目标表,该目标表存在与该数据的目标数据源内。故表分片策略是依赖与数据源分片策略的结果的。

    两种策略的API完全相同。

    自增主键生成策略

    通过在客户端生成自增主键替换以数据库原生自增主键的方式,做到分布式主键无重复。

     

     

    展开全文
  • 数据库、主机、存储等领域有丰富经验,主导了主机性能评估模型、数据库水平拆分、基于数据库日志解析数据同步、基于ISCSI 廉价存储等项目,目前专注于大规模数据并行计算存储、用户行为研究与风险控制领域...
  • 业务需求分析建模

    千次阅读 2018-08-21 11:46:39
    关系数据库理论意图是消除数据库中发生异常,数据库设计异常在本质上是对数据错误修改,甚至可以对单个记录修改。 1)插入异常,将记录添加到子表中,而主表不存在相关任何记录。 2)删除异常,删除主表中...
  • MYSQL中文手册

    2013-03-11 21:21:34
    在同一个数据库中创建多个表的缺陷 7.5. 优化MySQL服务器 7.5.1. 系统因素启动参数的调节 7.5.2. 调节服务器参数 7.5.3. 控制查询优化器的性能 7.5.4. 编译链接怎样影响MySQL的速度 7.5.5. MySQL如何使用...
  • 在同一个数据库中创建多个表的缺陷 7.5. 优化MySQL服务器 7.5.1. 系统因素启动参数的调节 7.5.2. 调节服务器参数 7.5.3. 控制查询优化器的性能 7.5.4. 编译链接怎样影响MySQL的速度 7.5.5. MySQL如何使用内存 ...
  • MySQL 5.1中文手冊

    2009-12-11 09:43:12
    在同一个数据库中创建多个表的缺陷 7.5. 优化MySQL服务器 7.5.1. 系统因素启动参数的调节 7.5.2. 调节服务器参数 7.5.3. 控制查询优化器的性能 7.5.4. 编译链接怎样影响MySQL的速度 7.5.5. MySQL如何使用内存 ...
  • PHPMySQL Web开发第4版

    热门讨论 2014-08-13 15:32:15
    12.1.3 tables_priv表,columns_priv表和procs_priv表 12.1.4 访问控制:MySQL如何使用Grant表 12.1.5 更新权限:修改什么时候生效 12.2 提高MySQL数据库的安全性 12.2.1 从操作系统角度来保护MySQL 12.2.2 ...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 220
精华内容 88
关键字:

数据库中主表和子表的概念