`
心动音符
  • 浏览: 336985 次
  • 性别: Icon_minigender_2
  • 来自: 北京
社区版块
存档分类
最新评论

数组、二维数组、及类型，存储过程调用

OracleJavaSQLCC++ 
阅读更多
Oracle部分：
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－ 
create table parent(
    id number(10),
    name varchar2(100),
    title varchar2(10)
);

create table child(
    id number(10),
    parent_id number(10),
    child_name varchar2(100),
    child_title varchar2(10),
    child_content varchar2(200),
    child_time timestamp
);

create sequence seq_p_c_id
minvalue 1
maxvalue 9999999999
start with 1
increment by 1
nocache;

drop type t_child_lst_map;
drop type t_child_lst;
drop type t_parent_lst;

--创建表对象类型
create or replace type t_parent as object (
    name varchar2(100),
    title varchar2(10)
);
/

--创建表对象类型
create or replace type t_child as object (
    child_name varchar2(100),
    child_title varchar2(10),
    child_content varchar2(200)
);
/

--创建自定义类型变量
create or replace type t_parent_lst as table of t_parent; 
/

--创建自定义类型变量
create or replace type t_child_lst as table of t_child;
/

--创建自定义类型变量
create or replace type t_child_lst_map as table of t_child_lst;
/

--创建存储过程
create or replace procedure proc_ins_parent_child(
    i_parent_lst in t_parent_lst,        --parent列表
    i_child_map_lst in t_child_lst_map,  --child列表集合，一个map元素对应一个child_lst，其下标与 parent列表的下标相同。
    o_ret out number
) as
var_parent t_parent;
var_child_lst t_child_lst;
var_child t_child;
var_parent_id number;
var_child_id number;
begin
    for i in 1..i_parent_lst.count loop
        --取得parent各列的值
        var_parent := i_parent_lst(i);

        --取得parent_id;
        select seq_p_c_id.nextVal into var_parent_id from dual;
        
        --插入parent表
        insert into parent(
            id,
            name,
            title
        )
        values(
            var_parent_id,
            var_parent.name,
            var_parent.title
        );
        
        --取得该parent对应的child列表
        var_child_lst := i_child_map_lst(i);

        for j in 1..var_child_lst.count loop
            var_child := var_child_lst(j);
            
            --取得child_id;
            select seq_p_c_id.nextVal into var_child_id from dual;

            --插入child表
            insert into child(
                id,
                parent_id,
                child_name,
                child_title,
                child_content,
                child_time
            )
            values(
                var_child_id,
                var_parent_id,
                var_child.child_name,
                var_child.child_title,
                var_child.child_content,
                systimestamp
            );
        end loop;
    
    end loop;
    o_ret := 0;

    exception when others then
    begin
        o_ret := -1;
        raise;
    end;
end proc_ins_parent_child;
/

Java部分：
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－ 
package test.oracle.conn;    
import java.sql.Connection;    
import java.sql.DriverManager;    
public class OConnection {    
    public static Connection getConn() {    
        String URL = "jdbc:oracle:thin:@127.0.0.1:1521:oradb";    
        String user = "cartoon";// 这里替换成你自已的数据库用户名    
        String password = "oracle";// 这里替换成你自已的数据库用户密码    
        Connection connection = null;    
        try {    
            Class.forName("oracle.jdbc.driver.OracleDriver");    
            System.out.println("类实例化成功!");    
            connection = DriverManager.getConnection(URL, user, password);    
            System.out.println("创建连接对像成功!");    
        } catch (Exception err) {    
            err.printStackTrace();    
            return null;    
        }    
        return connection;    
    }    
}


构造Java映射对象 
package test.oracle.array;    
public class Parent {    
    private String id;    
    private String name;    
    private String title;    
    public String getId() {    
        return id;    
    }    
    public void setId(String id) {    
        this.id = id;    
    }    
    public String getName() {    
        return name;    
    }    
    public void setName(String name) {    
        this.name = name;    
    }    
    public String getTitle() {    
        return title;    
    }    
    public void setTitle(String title) {    
        this.title = title;    
    }    
    public String toString() {    
        return "Parent{id=" + this.id + ",name=" + this.name + ",title="   
                + this.title + "}";    
    }    
}

构造Java映射对象 
package test.oracle.array;    
public class Child {    
    private String id;    
    private String parentId;    
    private String childName;    
    private String childTitle;    
    private String childContent;    
    private String childTime;    
    public String getChildContent() {    
        return childContent;    
    }    
    public void setChildContent(String childContent) {    
        this.childContent = childContent;    
    }    
    public String getChildName() {    
        return childName;    
    }    
    public void setChildName(String childName) {    
        this.childName = childName;    
    }    
    public String getChildTime() {    
        return childTime;    
    }    
    public void setChildTime(String childTime) {    
        this.childTime = childTime;    
    }    
    public String getChildTitle() {    
        return childTitle;    
    }    
    public void setChildTitle(String childTitle) {    
        this.childTitle = childTitle;    
    }    
    public String getId() {    
        return id;    
    }    
    public void setId(String id) {    
        this.id = id;    
    }    
    public String getParentId() {    
        return parentId;    
    }    
    public void setParentId(String parentId) {    
        this.parentId = parentId;    
    }    
    public String toString() {    
        return "Child{id=" + this.id + ",parentId=" + this.parentId    
                + ",childName=" + this.childName + ",childTitle="   
                + this.childTitle + ",childContent=" + this.childContent    
                + ",childTime=" + this.childTime + "}";    
    }    
}

Java方法实现Oracle对象数组 
package test.oracle.array;    
import java.sql.CallableStatement;    
import java.sql.Connection;    
import java.sql.SQLException;    
import java.util.ArrayList;    
import oracle.jdbc.driver.OracleTypes;    
import oracle.sql.ARRAY;    
import oracle.sql.ArrayDescriptor;    
import oracle.sql.STRUCT;    
import oracle.sql.StructDescriptor;    
public class OracleArray {    
    private static final String T_PARENT = "T_PARENT";    
    private static final String T_PARENT_LST = "T_PARENT_LST";    
    private static final String T_CHILD = "T_CHILD";    
    private static final String T_CHILD_LST = "T_CHILD_LST";    
    private static final String T_CHILD_LST_MAP = "T_CHILD_LST_MAP";    
    private static final String PROC_INS_PARENT_CHILD = "{ call PROC_INS_PARENT_CHILD(?,?,?)}";    
    public static int insParentChils(ArrayList<Parent> plst,    
            ArrayList<ArrayList<Child>> clstMap, Connection con)    
            throws Exception {    
        CallableStatement cstmt = null;    
        int retVal = -1;    
        try {    
            ArrayDescriptor parentLstDesc = ArrayDescriptor.createDescriptor(    
                    T_PARENT_LST, con);    
            StructDescriptor parentDesc = StructDescriptor.createDescriptor(    
                    T_PARENT, con);    
            ArrayDescriptor childLstMapDesc = ArrayDescriptor.createDescriptor(    
                    T_CHILD_LST_MAP, con);    
            ArrayDescriptor childLstDesc = ArrayDescriptor.createDescriptor(    
                    T_CHILD_LST, con);    
            StructDescriptor childDesc = StructDescriptor.createDescriptor(    
                    T_CHILD, con);    
            ArrayList<STRUCT> pstruct = new ArrayList<STRUCT>();    
            // 转换plst为Oracle 对象数组    
            for (int i = 0; i < plst.size(); i++) {    
                Parent p = plst.get(i);    
                Object[] record = new Object[2];    
                record[0] = p.getName();    
                record[1] = p.getTitle();    
                STRUCT item = new STRUCT(parentDesc, con, record);    
                pstruct.add(item);    
            }    
            ARRAY dataps = new ARRAY(parentLstDesc, con, pstruct.toArray());    
            ArrayList<ARRAY> cMap = new ArrayList<ARRAY>();    
            // 转换clst为Oracle 对象数组    
            for (int i = 0; i < clstMap.size(); i++) {    
                ArrayList<Child> childLst = clstMap.get(i);    
                ArrayList<STRUCT> cstruct = new ArrayList<STRUCT>();    
                for (int j = 0; j < childLst.size(); j++) {    
                    Child c = childLst.get(j);    
                    Object[] record = new Object[3];    
                    record[0] = c.getChildName();    
                    record[1] = c.getChildTitle();    
                    record[2] = c.getChildContent();    
                    STRUCT item = new STRUCT(childDesc, con, record);    
                    cstruct.add(item);    
                }    
                ARRAY datacs = new ARRAY(childLstDesc, con, cstruct.toArray());    
                cMap.add(datacs);    
            }    
            ARRAY datacsMap = new ARRAY(childLstMapDesc, con, cMap.toArray());    
            cstmt = con.prepareCall(PROC_INS_PARENT_CHILD);    
            cstmt.setArray(1, dataps);    
            cstmt.setArray(2, datacsMap);    
            cstmt.registerOutParameter(3, OracleTypes.INTEGER);    
            cstmt.execute();    
            retVal = cstmt.getInt(3);    
        } catch (Exception ex) {    
            ex.printStackTrace();    
        } finally {    
            try {    
                if (cstmt != null) {    
                    cstmt.close();    
                }    
            } catch (SQLException sqle) {    
                sqle.printStackTrace();    
            }    
        }    
        return retVal;    
    }    
}


测试Java调用Oracle对象数组 
package test.oracle;    
import java.sql.Connection;    
import java.sql.SQLException;    
import java.util.ArrayList;    
import java.util.Date;    
import test.oracle.array.Child;    
import test.oracle.array.OracleArray;    
import test.oracle.array.Parent;    
import test.oracle.conn.OConnection;    
public class TestOracleArray {    
    public static void main(String[] args) {    
        ArrayList<Parent> plst = new ArrayList<Parent>();    
        for (int i = 0; i < 100; i++) {    
            Parent p = new Parent();    
            p.setName("name" + i);    
            p.setTitle("title" + i);    
            plst.add(p);    
        }    
        ArrayList<ArrayList<Child>> clstMap = new ArrayList<ArrayList<Child>>();    
        for (int i = 0; i < 100; i++) {    
            ArrayList<Child> clst = new ArrayList<Child>();    
            for (int j = 0; j < 100; j++) {    
                Child c = new Child();    
                c.setChildName("childName" + j);    
                c.setChildTitle("childT" + j);    
                c.setChildContent("childContent"+j);    
                clst.add(c);    
            }    
            clstMap.add(clst);    
        }    
        Connection con = null;    
        try {    
            long startTime = 0;    
            long endTime = 0;    
            con = OConnection.getConn();    
            startTime = new Date().getTime();    
            OracleArray.insParentChils(plst, clstMap, con);    
            endTime = new Date().getTime();    
            System.out.println("It takes " + (endTime - startTime)    
                    + " milliseconds to execute");    
        } catch (Exception e) {    
            e.printStackTrace();    
        } finally {    
            try {    
                if (con != null) {    
                    con.close();    
                    System.out.println("disconnected");    
                }    
            } catch (SQLException sqle) {    
                sqle.printStackTrace();    
            }    
        }    
        System.exit(0);    
    }    
}
分享到：
| Java中传入1维数组调用oracle存储过程
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    数据结构与算法 一维数组-二维数组-三维数组

    在本主题中，我们将深入探讨一维数组、二维数组和三维数组的概念，以及如何使用模板来实现这些数据结构。这些基础知识在编程中至关重要，尤其是在处理大量数据时。 一维数组是最基础的数据结构之一，它是一个有序的...

    Delphi中静态二维数组的使用

    这里，我们定义了一个名为`MultiplicationTable`的二维数组，其大小为9x9，存储整数类型的数据。 在`implementation`部分，我们将在`FormCreate`事件处理程序中初始化数组并输出乘法表： ```pascal procedure TForm...

    二维数组表单提交

    在IT领域，尤其是在Web开发中，二维数组常常用于存储复杂的数据结构，比如表格数据或层级关系数据。在本例中，我们关注的是如何利用JQuery处理一个变长的二维数组，以便于提交多个相关联的数据。这样的场景常见于...

    动态二维数组 c#编程

    动态二维数组广泛应用于矩阵运算、网格数据存储、游戏开发（例如地图格子）、数据分析等领域。 6. 示例代码： 以下是一个简单的动态二维数组用于存储和打印棋盘的例子： ```csharp using System; class Program { ...

    CStringArray二维数组的定义和操作

    总结，`CStringArray`二维数组的定义和操作主要包括定义新类型、动态创建子数组并插入数据以及遍历和读取数据。在实际使用中，还需要考虑内存管理，确保在不再使用子数组时释放它们占用的内存。此外，对于更复杂的...

    二维数组去除重复项

    在IT领域，尤其是在编程与数据处理中，二维数组的去重是一个常见的需求，尤其是在处理大量数据或进行数据清洗时。本文将深入解析如何在PHP中实现二维数组的去重，并详细解释给定代码片段的工作原理。 ### 核心概念...

    易语言二维数组分页

    “子_数据到二维数组”可能是指将从数据源读取的原始数据转换成适合在二维数组中存储的格式。这一步可能涉及数据类型转换、数据结构构建等操作。在易语言中，由于其独特的语法特性，这一过程可能涉及到易语言特有的...

    用php递归将二维数组转换成一维数组

    二维数组，顾名思义，就是数组中的元素还是数组，形成一种类似于表格的数据结构。然而，在某些场景下，我们可能需要将这样的二维数组转换为一维数组，以简化数据处理或满足特定的接口要求。本文将详细介绍如何使用...

    Java程序设计基础：一维数组应用数组作为方法返回值类型.pptx

    数组作为方法返回值类型 学习目标 1 理解方法返回值类型是数组 引用类型的方法签名； 2 理解并学会数组作为方法返 回值类型的方法编写； 3 理解并熟知数组作为返回值 类型的方法调用。 方法的返回值类型 方法的...

    函数、内存、一维数组、二维数组

    元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 示例：int[] arr = new int[5]; 格式2： 元素类型[]　数组名 = new 元素类型[]{元素，元素，……}; int[] arr = new int[]{3,5,1,7}; int[] arr = {3,5...

    c语言二维数组冒泡排序

    对于二维数组，我们通常是对每一行进行单独的冒泡排序，因为二维数组中的元素并不是连续存储的，无法直接进行整体排序。 下面是一个基本的C++实现二维数组冒泡排序的代码示例： ```cpp #include using namespace ...

    易语言生成二维json数组源码

    1. **创建结构体**：根据需要存储的数据，定义相应的结构体，例如，如果要生成学生信息的二维数组，可以定义一个包含“姓名”、“年龄”等字段的结构体。 2. **初始化数据**：在程序中创建结构体实例，填充数据。这...

    大一c语言数组实验心得.docx

    数组可以是一维数组或二维数组，一维数组用于存储单行数据，而二维数组用于存储表格数据。数组的定义需要指定数组的名称、类型和大小，例如 int a[10]; 定义了一个名为 a 的整型数组，大小为 10个元素。 数组的赋值...

    基于数组指针实现二维数组中最小值所在行的查找与显示程序

    ### 基于数组指针实现二维数组中最小值所在行的查找与显示程序 #### 知识点一：理解数组指针与指针数组的区别 在C语言中，数组指针与指针数组有着本质的区别，它们在内存中的表示方式、使用场景以及功能上都存在...

    基于指针数组实现二维数组中的查找与显示程序

    - 定义了一个二维数组`a[M][N]`，以及一个指针数组`p1[M]`用于存储每一行的起始地址。 - 使用循环为`p1`中的每个元素赋值，使其指向`a`中对应行的起始位置。 - 调用`getMinRow`函数，传入`p1`和`N`（列数），得到...

    AndEngine二维数组地图

    二维数组通常被用来表示地图的格子结构，每个元素代表地图上的一个位置，可能包含不同的属性，如地形类型、障碍物等。通过这种方式，我们可以用数字或特定值来编码地图的细节，方便程序处理。 AndEngine中的...

    TIA博途-使用AT指令实现IO点位映射到二维数组中-全局FB库文件-V17版本-GF-二维数组IO点位映射.zip

    - 首先，创建一个全局FB库文件，定义一个二维数组以存储IO点位的数据。 - 使用AT指令获取IO状态，并根据需要将这些状态更新到二维数组中。 - 设计适当的接口，使其他程序块能方便地访问这个二维数组，以便进行...

    二维数组旋转.zip

    可以创建一个二维数组并打印其初始状态，调用旋转函数后再打印旋转后的状态，通过比较两者来检查旋转是否符合预期。 6. **优化考虑**：虽然上述方法直观易懂，但效率不是最优。对于大型数组，可以考虑使用两个辅助...

    juzhenchengfa.rar.rar_C语言二维数组_QT 矩阵_qt二维数组_二维数组

    用户在界面上输入矩阵后，程序通过读取QTableWidgetItem的文本，将其转换为整数并存储到二维数组中。然后调用C语言实现的矩阵乘法函数，最后将结果输出到结果矩阵的QTableWidget上。 ```cpp // 读取矩阵数据到二维...

Magicbox
Global site tag (gtag.js) - Google Analytics