Oracle利用存储过程性 实现分页

分页的简单配置 在上一次已经说过了

这边说说怎么在存储过程中实现分页

首先建立存储过程

参考

http://www.cnblogs.com/gisdream/archive/2011/11/16/2251687.html

基本的代码如下所示

1、在oracle的sqlplus或其他工具中运行一下pl/sql块建立存储过程

------------------------------------------------------------
--分页存储过程
------------------------------------------------------------
--创建包
create or replace package testpackage as
type test_cursor is ref cursor;
end testpackage;
/ 

--创建过程
create or replace procedure fenye
(
       tableName in varchar2, --表名
       fields in varchar2,    --查询解果显示字段
       wherecase in varchar2, --查询条件
       pageSize in number,  --一页显示记录数
       pageNow in number,   --当前页
       orderField  varchar2, --排序字段，为空表示不排序
       orderFlag number,     --排序标识 0：正序 1：倒序
       myrows out number,   --总记录数
       myPageCount out number, --总分页
       p_cursor out testpackage.test_cursor     --返回的记录集
) is
--定义部分
--定义sql语句字符串
v_sql varchar2(1000);
--定义两个整数
v_begin number:=(pageNow-1)*pagesize+1; --开始记录
v_end number:=pageNow*pageSize;         --结束记录
--排序sql
v_orderSql varchar2(100):='';
v_wherecase varchar2(100):='';
begin
  --执行部分
  --如果orderField不为空，则进行排序，如果orderFlag=0为升序，1为降序
  if orderField is not null then
    if orderFlag=0 then
      v_orderSql:=' order by '||orderField;
    elsif orderFlag=1 then
      v_orderSql:=' order by '||orderField||' desc';
    else
      null;
    end if;
  end if;
  --条件判断语句
  if wherecase is not null then
    v_wherecase:=' where '||wherecase;
  end if;
  v_sql:='select * from
          (select t1.* ,rownum rn from(select '|| fields ||' from '|| tableName|| v_wherecase ||' '||v_orderSql ||') t1 where rownum<='|| v_end ||')
          where rn>='|| v_begin;
  --把游标和sql关联
  open p_cursor for v_sql;
  --计算myrows和myPageCount
  --组织一个sql
  v_sql:='select count(*) from '|| tableName || v_wherecase || ' ' ||v_orderSql;
  --执行sql,并把返回的值赋给myrows;
  execute immediate v_sql into myrows;
  --计算myPageCount
  if mod(myrows,Pagesize)=0 then
    myPageCount:=myrows/Pagesize;
  else
    myPageCount:=myrows/pagesize+1;
  end if;
  --关闭游标
  --close p_cursor;
end;
/

 2、.net中的oracle过程调用类

/// <summary>
    /// c#调用oracle的过程进行分页
    /// author:sirc_ljp
    /// date:2011.11.16
    /// </summary>
    public class Paging
    {
        private string _connectionString;
        private string _tableName;
        private string _fields = "*";
        private string _whercase="";
        private int _pageSize=10;
        private int _pageNow=1;
        private string _orderField="";
        private int _orderFlag = 0;
        private int _myRows;
        private int _myPageCount;
        private DataTable _result;

        /// <summary>
        /// 数据库连接字符串
        /// </summary>
        public string ConnectionString
        {
            get { return _connectionString; }
            set { _connectionString = value; }
        }

        /// <summary>
        /// 表名
        /// </summary>
        public string TableName
        {
            get { return _tableName; }
            set { _tableName = value; }
        }
        /// <summary>
        /// 查询结果显示字段
        /// </summary>
        public string Fields
        {
            get { return _fields; }
            set { _fields = value; }
        }
        /// <summary>
        /// 查询条件
        /// </summary>
        public string Whercase
        {
            get { return _whercase; }
            set { _whercase = value; }
        }
        /// <summary>
        /// 页显示记录数
        /// </summary>
        public int PageSize
        {
            get { return _pageSize; }
            set { _pageSize = value; }
        }
        /// <summary>
        /// 当前页
        /// </summary>
        public int PageNow
        {
            get { return _pageNow; }
            set { _pageNow = value; }
        }
        /// <summary>
        /// 排序字段，为空""表示不排序
        /// </summary>
        public string OrderField
        {
            get { return _orderField; }
            set { _orderField = value; }
        }
        /// <summary>
        /// 排序标识 0：正序 1：倒序
        /// </summary>
        public int OrderFlag
        {
            get { return _orderFlag; }
            set { _orderFlag = value; }
        }
        /// <summary>
        /// 总记录数
        /// </summary>
        public int MyRows
        {
            get { return _myRows; }
        }
        /// <summary>
        /// 总分页
        /// </summary>
        public int MyPageCount
        {
            get { return _myPageCount; }
        }
        /// <summary>
        /// 返回的记录集
        /// </summary>
        public DataTable Result
        {
            get { return _result; }
        }

        public Paging()
        {
            fenye();
        }

        public Paging(string connectionString,string tableName, string fields, string wherecase, int pageSize, int pageNow, string orderField, int orderFlag, out int myRows, out int myPageCount, out DataTable result)
        {
            _connectionString = connectionString;
            _tableName = tableName;
            _fields = fields;
            _whercase = wherecase;
            _pageSize = pageSize;
            _pageNow = pageNow;
            _orderField = orderField;
            _orderFlag = orderFlag;

            fenye();
            myRows = _myRows;
            myPageCount = _myPageCount;
            result = _result;

        }

        private void fenye()
        {
            OracleConnection conn = new OracleConnection(_connectionString);
            conn.Open();

            try
            {
                OracleCommand cmd = new OracleCommand();
                cmd.Connection = conn;
                cmd.CommandType = CommandType.StoredProcedure;

                //调用存储过程查询数据
                cmd.CommandText = "fenye";
                OracleParameter[] parameters = new OracleParameter[10];
                //注意这里的参数名和类型号与存储过程里面的一样
                parameters[0] = new OracleParameter("tableName", OracleType.VarChar);
                parameters[1] = new OracleParameter("fields", OracleType.VarChar);
                parameters[2] = new OracleParameter("wherecase", OracleType.VarChar);
                parameters[3] = new OracleParameter("pageSize", OracleType.Int32);
                parameters[4] = new OracleParameter("pageNow", OracleType.Int32);
                parameters[5] = new OracleParameter("orderField", OracleType.VarChar);
                parameters[6] = new OracleParameter("orderFlag", OracleType.Int32);
                parameters[7] = new OracleParameter("myrows", OracleType.Int32);
                parameters[8] = new OracleParameter("myPageCount", OracleType.Int32);
                parameters[9] = new OracleParameter("p_cursor", OracleType.Cursor);

                parameters[0].Value = _tableName;
                parameters[1].Value = _fields;
                parameters[2].Value = _whercase;
                parameters[3].Value = _pageSize;
                parameters[4].Value = _pageNow;
                parameters[5].Value = _orderField;
                parameters[6].Value = _orderFlag;
                parameters[7].Direction = ParameterDirection.Output;
                parameters[8].Direction = ParameterDirection.Output;
                parameters[9].Direction = ParameterDirection.Output;

                foreach (OracleParameter parameter in parameters)
                {
                    cmd.Parameters.Add(parameter);
                }
                //执行命令
                OracleDataAdapter oda = new OracleDataAdapter(cmd);
                DataSet ds = new DataSet();
                oda.Fill(ds);
                //得到查询结果表
                _result = ds.Tables[0];

                //取出总行数
                _myRows = Convert.ToInt32(parameters[7].Value);
                //取出总页数
                _myPageCount = Convert.ToInt32(parameters[8].Value.ToString());

            }
            catch (Exception ex)
            {

                throw;
            }
            finally
            {
                conn.Close();
            }

        }

    }

在数据库建立好存储过程之后

在C#控制台创建类包 Paging

建立好了之后 输出 这边给出一个示例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.OracleClient;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            /*
            string connString = "Data Source=server1;Persist Security Info=True;User ID=s227;Password=123;Unicode=True";
            string queryString = "SELECT * FROM PRODUCT ";
            OracleConnection conn = new OracleConnection(connString);
            conn.Open();
            OracleCommand command = new OracleCommand(queryString,conn);
            OracleDataReader reader = command.ExecuteReader();
            reader.Read();
            Console.WriteLine("1 "+reader["MAKER"]+" 2 "+reader["MODEL"]+" 3 "+reader["TYPE"]);
            reader.Close();
            conn.Close();
            */
            /*
             * //学习的代码块
            string connectionString;
            string queryString;

            connectionString = "Data Source=202.200.136.125/orcl;User ID=openlab;PassWord=open123";

            queryString = "SELECT * FROM T_USER";

            OracleConnection myConnection = new OracleConnection(connectionString);

            OracleCommand myORACCommand = myConnection.CreateCommand();

            myORACCommand.CommandText = queryString;

            myConnection.Open();

            OracleDataReader myDataReader = myORACCommand.ExecuteReader();

            myDataReader.Read();

            Console.WriteLine("email: " + myDataReader["EMAIL"]);

            myDataReader.Close();

            myConnection.Close();
            */
            string connString = "Data Source=server1;Persist Security Info=True;User ID=s227;Password=123;Unicode=True";
            string queryString = "SELECT * FROM PRODUCT ";
            string _connectionString="Data Source=server1;Persist Security Info=True;User ID=s227;Password=123;Unicode=True";
            string _tableName="SPJ";
            string _fields = "*";
            string _whercase = "";
            int _pageSize = 10;
            int _pageNow = 1;
            string _orderField = "";
            int _orderFlag = 0;
            int _myRows;
            int _myPageCount;
            DataTable result2;
            Paging newpage = new Paging();
            newpage.ConnectionString = connString;
            newpage.TableName = _tableName;
            newpage.fenye();
            //Paging newpage = new Paging(_connectionString, _tableName, _fields, _whercase, _pageSize, _pageNow, _orderField, _orderFlag, _myRows, _myPageCount, result2);
            for (int i = 0; i < newpage.Result.Rows.Count; i++)
            {
                for (int j = 0; j < newpage.Result.Columns.Count; j++)
                {
                    Console.Write(newpage.Result.Rows[i][j].ToString()+"  ");
                }
                Console.WriteLine(" ");
            }
            newpage.PageNow = newpage.PageNow + 1;
            Console.WriteLine(" ");
            newpage.fenye();
            for (int i = 0; i < newpage.Result.Rows.Count; i++)
            {
                for (int j = 0; j < newpage.Result.Columns.Count; j++)
                {
                    Console.Write(newpage.Result.Rows[i][j].ToString() + "  ");
                }
                Console.WriteLine(" ");
            }

        }
    }
    /// <summary>
    /// c#调用oracle的过程进行分页
    /// author:sirc_ljp
    /// date:2011.11.16
    /// </summary>
    public class Paging
    {
        private string _connectionString;
        private string _tableName;
        private string _fields = "*";
        private string _whercase = "";
        private int _pageSize = 10;
        private int _pageNow = 1;
        private string _orderField = "";
        private int _orderFlag = 0;
        private int _myRows;
        private int _myPageCount;
        private DataTable _result;

        /// <summary>
        /// 数据库连接字符串
        /// </summary>
        public string ConnectionString
        {
            get { return _connectionString; }
            set { _connectionString = value; }
        }

        /// <summary>
        /// 表名
        /// </summary>
        public string TableName
        {
            get { return _tableName; }
            set { _tableName = value; }
        }
        /// <summary>
        /// 查询结果显示字段
        /// </summary>
        public string Fields
        {
            get { return _fields; }
            set { _fields = value; }
        }
        /// <summary>
        /// 查询条件
        /// </summary>
        public string Whercase
        {
            get { return _whercase; }
            set { _whercase = value; }
        }
        /// <summary>
        /// 页显示记录数
        /// </summary>
        public int PageSize
        {
            get { return _pageSize; }
            set { _pageSize = value; }
        }
        /// <summary>
        /// 当前页
        /// </summary>
        public int PageNow
        {
            get { return _pageNow; }
            set { _pageNow = value; }
        }
        /// <summary>
        /// 排序字段，为空""表示不排序
        /// </summary>
        public string OrderField
        {
            get { return _orderField; }
            set { _orderField = value; }
        }
        /// <summary>
        /// 排序标识 0：正序 1：倒序
        /// </summary>
        public int OrderFlag
        {
            get { return _orderFlag; }
            set { _orderFlag = value; }
        }
        /// <summary>
        /// 总记录数
        /// </summary>
        public int MyRows
        {
            get { return _myRows; }
        }
        /// <summary>
        /// 总分页
        /// </summary>
        public int MyPageCount
        {
            get { return _myPageCount; }
        }
        /// <summary>
        /// 返回的记录集
        /// </summary>
        public DataTable Result
        {
            get { return _result; }
        }

        public Paging()
        {
           // fenye();
        }

        public Paging(string connectionString, string tableName, string fields, string wherecase, int pageSize, int pageNow, string orderField, int orderFlag, out int myRows, out int myPageCount, out DataTable result)
        {
            _connectionString = connectionString;
            _tableName = tableName;
            _fields = fields;
            _whercase = wherecase;
            _pageSize = pageSize;
            _pageNow = pageNow;
            _orderField = orderField;
            _orderFlag = orderFlag;

            //fenye();
            myRows = _myRows;
            myPageCount = _myPageCount;
            result = _result;

        }

        public void fenye()
        {
            OracleConnection conn = new OracleConnection(_connectionString);
            conn.Open();

            try
            {
                OracleCommand cmd = new OracleCommand();
                cmd.Connection = conn;
                //CommandType.Text代表执行的是SQL语句CommandType.StoreProcedure代表执行的是存储过程CommandType代表要执行的类型
                cmd.CommandType = CommandType.StoredProcedure;

                //调用存储过程查询数据
                cmd.CommandText = "fenye";
                OracleParameter[] parameters = new OracleParameter[10];
                //注意这里的参数名和类型号与存储过程里面的一样
                parameters[0] = new OracleParameter("tableName", OracleType.VarChar);
                parameters[1] = new OracleParameter("fields", OracleType.VarChar);
                parameters[2] = new OracleParameter("wherecase", OracleType.VarChar);
                parameters[3] = new OracleParameter("pageSize", OracleType.Int32);
                parameters[4] = new OracleParameter("pageNow", OracleType.Int32);
                parameters[5] = new OracleParameter("orderField", OracleType.VarChar);
                parameters[6] = new OracleParameter("orderFlag", OracleType.Int32);
                parameters[7] = new OracleParameter("myrows", OracleType.Int32);
                parameters[8] = new OracleParameter("myPageCount", OracleType.Int32);
                parameters[9] = new OracleParameter("p_cursor", OracleType.Cursor);

                parameters[0].Value = _tableName;
                parameters[1].Value = _fields;
                parameters[2].Value = _whercase;
                parameters[3].Value = _pageSize;
                parameters[4].Value = _pageNow;
                parameters[5].Value = _orderField;
                parameters[6].Value = _orderFlag;
                parameters[7].Direction = ParameterDirection.Output;
                parameters[8].Direction = ParameterDirection.Output;
                parameters[9].Direction = ParameterDirection.Output;

                foreach (OracleParameter parameter in parameters)
                {
                    cmd.Parameters.Add(parameter);
                }
                //执行命令
                OracleDataAdapter oda = new OracleDataAdapter(cmd);
                DataSet ds = new DataSet();
                oda.Fill(ds);
                //得到查询结果表
                _result = ds.Tables[0];

                //取出总行数
                _myRows = Convert.ToInt32(parameters[7].Value);
                //取出总页数
                _myPageCount = Convert.ToInt32(parameters[8].Value.ToString());

            }
            catch (Exception ex)
            {

                throw;
            }
            finally
            {
                conn.Close();
            }

        }

    }

}

利用Console.write输出 之后也可以把它利用网页的控件链接

输出结果如下所示 最后一行为ID 可调

S1  P1  J1  200  1

S1  P1  J3  100  2

S1  P1  J4  700  3

S1  P2  J2  100  4

S2  P3  J1  400  5

S2  P3  J2  200  6

S2  P3  J4  500  7

S2  P3  J5  400  8

S2  P5  J1  400  9

S2  P5  J2  100  10

S3  P1  J1  200  11

S3  P3  J1  200  12

S4  P5  J1  100  13

S4  P6  J3  300  14

S4  P6  J4  200  15

S5  P2  J4  100  16

S5  P3  J1  200  17

S5  P6  J2  200  18

S5  P6  J4  500  19

请按任意键继续. . .

最后补充几个常识

1 dataTable的遍历问题

            for (int i = 0; i < Table.Rows.Count; i++)
            {
                for (int j = 0; j < TableColumns.Count; j++)
                {
                    Console.Write(Table.Rows[i][j].ToString() + "  ");
                }
                Console.WriteLine(" ");
            }

2数据类型的问题

1.varchar2把所有字符都占两字节处理(一般情况下)，varchar只对汉字和全角等字符占两字节，数字，英文字符等都是一个字节；
2.VARCHAR2把空串等同于null处理，而varchar仍按照空串处理；
3.VARCHAR2字符要用几个字节存储，要看数据库使用的字符集，
大部分情况下建议使用varchar2类型，可以保证更好的兼容性。

3 Oracle基本数据类型

Character 数据类型

　　Character 数据类型用来存储字母数字型数据。当你在oracle 中定义一个character 数据时，通常需要制定字段的长度，它是该字段的最大长度。ORACLE提供以下几种character 数据类型：

　　

　　CHAR() CHAR数据类型是一种有固定长度和最大长度的字符串。存储在数据类型为CHAR字段中的数据将以空格的形式补到最大长度。长度定义在1——2000字节之间。

　　

　　当你创建一个CHAR型字段，数据库将保证在这个字段中的所有数据是定义长度，如果某个数据比定义长度短，那么将用空格在数据的右边补到定义长度。如果长度大于定义长度将会触发错误信息。

　　

　　VARCHAR() varchar型数据是varchar2型数据的快照。

　　

　　VARCHAR2() varchar2数据类型是一种可变长度的、有最大长度的字母数字型数据。Varchar2类型的字段长度可以达到4000字节，Varchar2类型的变量长度可以达到32676字节。

　　

　　一个空的varchar2(2000)字段和一个空的varchar2(2)字段所占用的空间是一样的。

　　

　　NCHAR() 和 NVARCHAR2()　NCHAR() 和 NVARCHAR2()数据类型分别与CHAR() 和 VARCHAR2()类型是相同的，只不过它们用来存储NLS（National Language Support）数据。

　　

　　LONG　LONG 数据类型是一个遗留下来的而且在将来不会被支持的数据类型。它将被LOB(Large Object)数据类型所代替。

　　

　　比较规则 Varchar2和char数据类型根据尾部的空格有不同的比较规则。对Char型数据，尾部的空格将被忽略掉，对于Varchar2型数据尾部带空格的数据排序比没有空格的要大些。比如：

　　

　　Char 型数据：　　　　　　　‘YO’=‘YO　　 ’

　　

　　Varchar2型数据：　　　　　 ‘YO’<’YO　　 ’

　　

　　Numberic 数据类型

　　

　　Numberic 数据类型用来存储负的和正的整数、分数和浮点型数据，范围在-1*10-103 和9.999…99*10125之间，有38位的精确度。标识一个数据超出这个范围时就会出错。

　　

　　Number(

,) Number数据类型存储一个有p位精确度的s位等级的数据。

　　

　　DATE 数据类型

　　DATE 数据类型用来存储日期和时间格式的数据。这种格式可以转换为其他格式的数据去浏览，而且它有专门的函数和属性用来控制和计算。以下的几种信息都包含在DATE数据类型中：

　　

　　Century

　　

　　Year

　　

　　Month

　　

　　Day

　　

　　Hour

　　

　　Minute

　　

　　Second

　　

　　LOB 数据类型

　　LOB(Large Object) 数据类型存储非结构化数据，比如二进制文件，图形文件，或其他外部文件。LOB 可以存储到4G字节大小。数据可以存储到数据库中也可以存储到外部数据文件中。LOB数据的控制通过DBMS_LOB 包实现。BLOB, NCLOB, 和CLOB 数据可以存储到不同的表空间中，BFILE存储在服务器上的外部文件中。LOB数据类型有以下几种：

　　

　　BLOB: 二进制数据

　　

　　CLOB: 字符型数据

　　

　　BFILE: 二进制文件

　　

　　其他数据类型

　　

　　ROWID ROWID 数据类型是ORACLE数据表中的一个伪列，它是数据表中每行数据内在的唯一的标识。

4CommandType的属性类型

CommandType.Text代表执行的是SQL语句
CommandType.StoreProcedure代表执行的是存储过程
CommandType代表要执行的类型
时间： 2024-10-15 11:10:22

Oracle利用存储过程性 实现分页的相关文章

asp.net利用存储过程分页代码

-最通用的分页存储过程 -- 获取指定页的数据 CREATE PROCEDURE Pagination @tblName varchar(255), -- 表名 @strGetFields varchar(1000) = '*', -- 需要返回的列 @fldName varchar(255)='', -- 排序的字段名 @PageSize int = 10, -- 页尺寸 @PageIndex int = 1, -- 页码 @doCount bit = 0, -- 返回记录总数, 非 0 值则

oracle的存储过程语法(转)

1.ORA-00942: table or view does not exist 指的你要操作的表尚未存在,需要先create出来先. 2.ORA-00922: missing or invalid option 指的是有语法错误.遗漏了分号什么的 3.Warning: Procedure created with compilation errors 比如  create or replace procedure p_test_pro1 is     begin       insert i

懵懂oracle之存储过程

/* 作为一个oracle界和厨师界的生手,笔者想给大家分享讨论下存储过程的知识,因为在我接触的通信行业中,存储过程的使用还是占据了一小块的地位. 存储过程是什么?不得不拿下百度词条的解释来:"存储过程(Stored Procedure)是在大型数据库系统中,一组为了完成特定功能的SQL 语句集,存储在数据库中, 经过第一次编译后再次调用不需要再次编译,用户通过指定存储过程的名字并给出参数(如果该存储过程带有参数)来执行它.存储过程是数据库中的一个重要对象." 其实就似我们经过一系列的

ASP.NET中利用DataGrid的自定义分页功能

ASP.NET中利用DataGrid的自定义分页功能和存储过程结合实现高效分页 ASP.Net中的DataGrid有内置分页功能, 但是它的默认的分页方式效率是很低的,特别是在数据量很大的时候,用它内置的分页功能几乎是不可能的事,因为它会把所有的数据从数据库读出来再进行分页, 这种只选取了一小部分而丢掉大部分的方法是不可去取的. 在最进的一个项目中因为一个管理页面要管理的数据量非常大,所以必须分页显示,并且不能用DataGrid的内置分页功能,于是自己实现分页. 下面介绍一下我在项目中用到的分页

三大数据库下的存储过程实现通用分页

三大数据库下的存储过程实现通用分页  SqlServer数据库下通用存储过程实现分页: 1 --通用存储过程分页 2 CREATE PROCEDURE procList 3 --我们需要传入的参数 4 @strWhere NVARCHAR(max), --查询条件 5 @PageSize INT, --每页显示多少条内容 6 @PageIndex INT , --当前页 7 @TableName NVARCHAR(max), --需要查询的表名 8 @ColName NVARCHAR(max),

Oracle下用rownum进行分页时排序的错乱 .

今天早上用户打电话说系统的排序有问题,仔细看了一下,问题好像是出在ROWNUM这个函数上. 在Oracle下ROWNUM函数是对查询结果按照顺序分配自增行序号,所以很多人都利用这个特点进行分页操作,即rownum between 30 and 60,这种限制返回行数的小窍门在普通情况下都很正常,但如果要对返回结果在进行排序就变得乱套了. 如下查询: select page.* from( select rownum page_id,    id,    unit_code,    name,  

Oracle中存储过程的作用和用法

存储过程是Oracle开发者在数据转换或查询报表时经常使用的方式之一.它就是想编程语言一样一旦运行成功,就可以被用户随时调用,这种方式极大的节省了用户的时间,也提高了程序的执行效率.存储过程在数据库开发中使用比较频繁,它有着普通SQL语句不可替代的作用.所谓存储过程,就是一段存储在数据库中执行某种功能的程序.其中包含一条或多条SQL语句,但是它的定义方式和PL/SQL中的块.包等有所区别.存储过程可以通俗地理解为是存储在数据库服务器中的封装了一段或多段SQL语句的PL/SQL代码块.在数据库中有

Oracle中存储过程传入表名学习

Oracle中存储过程传入表名: 一.动态清除该表的数据 create or replace procedure p_deletetable(i_tableName in varchar2) as --定义变量存放动态的SQL语句 dynamic_drop_sql varchar2(500); begin dynamic_drop_sql :=  'DELETE  FROM ' || i_tableName ; --执行动态SQL语句 execute immediate dynamic_drop

oracle 利用flashback将备库激活为read wirte(10g 及上)

oracle 利用flashback将备库激活为read wirte(10g 及上) 环境: OS: CENTOS 6.5 X64 DB: ORACLE 10.2.0.5 主库操作: SQL> alter system switch logfile; System altered. SQL> 备库操作 取消归档应用 SQL> alter database recover managed standby database cancel; Database altered. SQL>