精华内容
下载资源
问答
  • 导出insertsql语句import java.io.BufferedWriter;import java.io.File;import java.io.FileWriter;import java.io.IOException;import java.sql.Connection;import java.sql.DriverManager;import java.sql....

    导出insertsql语句

    import java.io.BufferedWriter;

    import java.io.File;

    import java.io.FileWriter;

    import java.io.IOException;

    import java.sql.Connection;

    import java.sql.DriverManager;

    import java.sql.ResultSet;

    import java.sql.ResultSetMetaData;

    import java.sql.SQLException;

    import java.sql.Statement;

    import java.sql.Types;

    import java.util.ArrayList;

    import java.util.List;

    public class Test {

    private static Connection conn=null;

    private static Statement sm = null;

    private static String schema="FJSTL";//模式名

    private static String select="SELECT * FROM";//查询sql

    private static String insert="INSERT INTO";//插入sql

    private static String values="VALUES";//values关键字

    private static String []table={"T_USER"};//table数组

    private static ListinsertList=new ArrayList();//全局存放insertsql文件的数据

    private static String filePath="E://insertSQL.txt";//绝对路径导出数据的文件

    /**

    *导出数据库表

    *@param args

    *@throws SQLException

    */

    public static void main(String[] args) throws SQLException { ListlistSQL=new ArrayList();

    connectSQL("oracle.jdbc.driver.OracleDriver", "xxx.xxx.xxx", "xxx", "xxx");//连接数据库

    listSQL=createSQL();//创建查询语句

    executeSQL(conn,sm,listSQL);//执行sql并拼装

    createFile();//创建文件

    }

    /**

    *创建insertsql.txt并导出数据

    */

    private static void createFile() {

    File file=new File(filePath);

    if(!file.exists()){

    try {

    file.createNewFile();

    } catch (IOException e) {

    System.out.println("创建文件名失败!!");

    e.printStackTrace();

    }

    }

    FileWriter fw=null;

    展开全文
  • JAVA数据库插入操作

    千次阅读 2009-04-15 13:23:00
    因为数据库的更新,新的数据库是基于原有的数据库,只是新的数据库对部分... 先把原有的数据库数据导出到一个文件中,再用java代码来读取文件中的insert语句,并执行。由于某些表的数据量有点多,就会出现多次 insert

         因为数据库的更新,新的数据库是基于原有的数据库,只是新的数据库对部分表进行了修改,并加入了一些新的表。但原数据库中的数据是比需要导入到新的数据库中。手工的话,工作量太大,也没有什么通用性。所有就想用JAVA代码来实现此功能。

     

         先把原有的数据库数据导出到一个文件中,再用java代码来读取文件中的insert语句,并执行。由于某些表的数据量有点多,就会出现多次 insert 同一表的语句。基于不想统计重复表,刚开始时是采用了Map 和HashMap的方式。因为构想是一个Key 对应多个Value。后面陈部指导我说,Map一般是适用数据量是W级别的,他的原理是牺牲空间来换取时间(O(1))。后面采取了用Bean来取代的办法,即定义了2个属性,一个tableName,一个value数组。

     

        下面是实现插入的代码:

     

        public class SqlInsertReader {
        public static List<TableStatement> getSqls(String fileName) throws FileNotFoundException, IOException
        {
            List<TableStatement> tables = new LinkedList<TableStatement>();
            FileReader fileReader = new FileReader(fileName);
            BufferedReader reader = new BufferedReader(fileReader);
            String record = null;
            String tableName = null;
            StringBuffer sqlBuffer = new StringBuffer();
            TableStatement table = null;
            boolean isInsertStatement = false;
            while ((record = reader.readLine()) != null) {
                if (record.indexOf("INSERT") != -1) {
                    isInsertStatement = true;
                    tableName=getTableName(record);
                    table=find(tables,tableName);
                }
               
                if (isInsertStatement) {
                    sqlBuffer.append(record);
                    if (record.indexOf(";") != -1) {
                        table.getSqlValues().add(adjustSQL(tableName, sqlBuffer.toString()));
                        isInsertStatement = false;
                        //清空
                        sqlBuffer = new StringBuffer();
                    }
                }
            }
            return tables;
        }

        private static String getTableName(String record)
        {
            String strTemp = record.substring(record.indexOf(".") + 1);
            String []aString = strTemp.split(" ");
             return aString[0].replaceAll("`", "");
        }

        private static TableStatement find(List<TableStatement> tables, String tableName) {
            //遍历tables,查找和tableName相同的元素,返回;
            //如果找不到,则创建一个TableStatement对象,并加入到tables中,然后返回
            for (TableStatement table : tables) {
                if (table.getTableName().equals(tableName)) {
                    return table;
                }
            }

            TableStatement statement = new TableStatement();
            statement.setTableName(tableName);
            tables.add(statement);
            return statement;
        }

        private static String adjustSQL(String tableName, String sql) {
            //删除  `OA`.
            sql = sql.replaceAll("`OA`.", "");
            //Project表的数据移动数据的位置
            if ("Project".equals(tableName)) {
                StringBuffer buffer = new StringBuffer();
                String []aString = sql.split("[()]");
                buffer.append(aString[0]);
                for(int i=1;i<aString.length;i++){
                  if(aString[i].length()>2){
                    buffer.append(generateNewRecord(aString[i]));
                    buffer.append(",");
                  }
                }
                buffer.setCharAt(buffer.length()-1, ';');
                return buffer.toString();
                //return buffer.toString().substring(0, buffer.toString().length()-1)+";";
            }
            return sql;
        }

        //生成专门用于Project表的Insert语句的一行记录的sql语法,
        //比如(xx,xxx,xxxx),调整了字段位置,以适应Alpha3数据库的变化
        private static String generateNewRecord(String sql){
          StringBuffer buffer = new StringBuffer();
          String[] sqlString = sql.split(",");
          buffer.append("(");
          buffer.append(sqlString[0]);
          buffer.append(",");
          buffer.append(sqlString[6]);
          buffer.append(",");
          buffer.append(sqlString[1]);
          buffer.append(",");
          buffer.append(sqlString[2]);
          buffer.append(",");
          buffer.append(sqlString[3]);
          buffer.append(",");
          buffer.append(sqlString[4]);
          buffer.append(",");
          buffer.append(sqlString[5]);
          buffer.append(")");
          return buffer.toString();
        }
    }

     

    在主函数出调用代码如下:

          //把传入的文件作为参数(项目名称--属性--运行--参数(Netbeans))

           List<TableStatement> tables = SqlInsertReader.getSqls(args[0]);
                for (TableStatement table : tables) {
                    for (String sql : table.getSqlValues()) {
                        errorSql = sql;
                        statement = connection.prepareStatement(sql);
                        statement.executeUpdate();
                    }
                }

       因为有外键约束所以写了如下代码:

     

            private static void adjustInsertTableOrder(String tableName, int index, List<TableStatement> tables) {
            for (int j = 0; j < tables.size(); j++) {
                if (tableName.equals(tables.get(j).getTableName())) {
                    //把对象删除之前,先保存下来
                    TableStatement employeeTable = tables.get(j);
                    tables.remove(j);
                    tables.add(index, employeeTable);
                    return;
                }
            }
        }

     

       写此文章也算是对自己的一次总结,也希望能给大家带来帮助。呵~

    展开全文
  • 序列的主要作用是生成表的主键值,可以在插入语句中使用,也可以通过检查当前值,使得序列曾只下一个值。创建序列创建序列需要CREATE SEQUENCE系统权限。序列的创建语法如下:CREATE SEQUENCE序列名[INCREMENT BY n]...

    序列的作用

    序列是指的是序列号生成器(SEQUENCE),可以为表中的行自动生成序列号,产生一组等间隔的数值。不占用磁盘空间,但是占用内存空间。

    序列的主要作用是生成表的主键值,可以在插入语句中使用,也可以通过检查当前值,使得序列曾只下一个值。

    创建序列

    创建序列需要CREATE SEQUENCE系统权限。序列的创建语法如下:

    CREATE SEQUENCE 序列名

    [INCREMENT BY n]    用于定义序列的步长,如果省略,则默认为1,出现负值,则oralce序列的值按照此步长呈现递减变化。

    [START WITH n] 定义序列的初始值

    [{MAXVALUE/ MINVALUE n}] 定义序列产生的最大值/最小值

    [{CYCLE|NOCYCLE}] CYCLE和NOCYCLE 表示当序列生成器的值达到限制值后是否循环。CYCLE代表循环,NOCYCLE代表不循环。如果循环,则当递增序列达到最大值时,循环到最小值;对于递减序列达到最小值时,循环到最大值。如果不循环,达到限制值后,继续产生新值就会发生错误。

    [{CACHE n| NOCACHE}];定义存放序列的内存块的大小,默认为20。NOCACHE表示不对序列进行内存缓冲。对序列进行内存缓冲,可以改善序列的性能。

    NEXTVAL 返回序列中下一个有效的值,任何用户都可以引用。

    CURRVAL 中存放序列的当前值,NEXTVAL 应在 CURRVAL 之前指定 ,二者应同时有效。

    例如:新建表student

    CREATE TABLE "DEARZ"."student" (

    "id" NUMBER NOT NULL,

    "name" VARCHAR2(255 BYTE),

    "age" NUMBER(10,0),

    "gender" NUMBER,

    CONSTRAINT "SYS_C0011053" PRIMARY KEY ("id")

    )

    1b80a66d96ddeabf985b2c5faf9d0c06.png

    创建序列,注意序列初始值不能小于最小值 否则会报错

    CREATE sequence seq_stu

    INCREMENT by 1

    START WITH 1

    minvalue 1

    maxvalue 99999

    order

    cache 20

    cycle

    在插入语句的时候使用序列,主键id的值会自动增加

    insert into "student" values (seq_stu.nextval,'zhangsan',null,null)

    对student表添加触发器,则不需要写id这一列,id也会自动增加

    create or replace TRIGGER tg_insertId

    before insert on "student" for each row

    BEGIN

    SELECT seq_stu.Nextval into:new."id" from dual;END;

    测试一下:

    insert into "student"("name","age","gender") values ('王五',null,null)

    通过JAVA导出ORACLE序列、表结构、触发器、索引的SQL语句

    查询这四种类型的关键的SQL语句为

    SELECT DBMS_METADATA.GET_DDL(U.OBJECT_TYPE, U.object_name) as sql_statement, U.OBJECT_TYPE as table_factor

    FROM USER_OBJECTS U

    where U.OBJECT_TYPE = 'TABLE'

    or U.OBJECT_TYPE = 'VIEW'

    or U.OBJECT_TYPE = 'INDEX'

    or U.OBJECT_TYPE = 'PROCEDURE'

    or U.OBJECT_TYPE = 'SEQUENCE'

    or U.OBJECT_TYPE = 'TRIGGER'

    order by U.OBJECT_TYPE desc;

    测试结果如下,可以看出对应的SQL语句已经被查询出来了

    628c25e74cc5a21d30b419394cc90047.png

    接下来就是通过java代码来获取查询的结果,并写入新建的sql文件中

    主要步骤如下

    1 连接Oracle数据库

    2 执行上述SQL语句

    3 解析返回的结果

    4 通过Java IO流写入SQL文件中

    import lombok.extern.slf4j.Slf4j;

    import org.junit.Test;

    import org.springframework.util.StringUtils;

    import java.io.*;

    import java.sql.*;

    import java.util.HashMap;

    import java.util.Map;

    @Slf4j

    public class test1 {

    private static final String TYPE = "oracle";

    private static final String URL = "localhost:1521";

    private static final String SERVICE_NAME = "ORCL";

    /*

    * oracle jdbc连接后缀为服务名 username 等价于 mysql的数据库名 原因在于表空间和用户进行了绑定

    * */

    private static final String USERNAME = "DEARZ";

    private static final String PASSWORD = "123456";

    //sql DBMS_METADATA

    private static final String SQL = "SELECT DBMS_METADATA.GET_DDL(U.OBJECT_TYPE, U.object_name) as sql_statement, U.OBJECT_TYPE as table_factor " +

    " FROM USER_OBJECTS U " +

    " where U.OBJECT_TYPE = 'TABLE' " +

    " or U.OBJECT_TYPE = 'VIEW' " +

    " or U.OBJECT_TYPE = 'INDEX' " +

    " or U.OBJECT_TYPE = 'PROCEDURE' " +

    " or U.OBJECT_TYPE = 'SEQUENCE' " +

    " or U.OBJECT_TYPE = 'TRIGGER' " +

    " order by U.OBJECT_TYPE desc";

    //导出oracle table 文件

    @Test

    public void importOracle() throws SQLException {

    Connection conn = null;

    try {

    Class.forName("oracle.jdbc.driver.OracleDriver");

    // conn = ConnectionUtil.getConnection(TYPE,URL, USERNAME,PASSWORD,SERVICE_NAME);

    //三个参数的分别为连接的URL,用户名,密码

    conn = DriverManager.getConnection("jdbc:oracle:thin:@"+URL+":"+SERVICE_NAME,USERNAME,PASSWORD);

    log.info(conn.getCatalog());

    // String sql = "select * from \"student\"";

    //创建sql语句执行的对象

    PreparedStatement ps = conn.prepareStatement(SQL);

    //执行查询语句,返回结果集合

    ResultSet res = ps.executeQuery();

    //处理任何语句,有结果集合返回true,没有结果集合返回false

    //boolean execute = ps.execute(); 执行完之后会调用conn.close()方法

    /* List list = new ArrayList<>();

    Student student = new Student();

    while (res.next()){

    Integer id = res.getInt("id");

    String name = res.getString("name");

    Integer age = res.getInt("age");

    Integer gender = res.getInt("gender");

    student.setId(id);

    student.setAge(age);

    student.setName(name);

    student.setGender(gender);

    list.add(student);

    }

    System.out.println(list);*/

    Map map = new HashMap<>();

    while (res.next()){

    String sql_statement = res.getString("sql_statement");

    String table_factor = res.getString("table_factor");

    map.put(table_factor,sql_statement);

    }

    System.out.println(map);

    //导出DEARZ库中表的序列

    importSequence(map);

    } catch (Exception e) {

    e.printStackTrace();

    }finally {

    conn.close();

    }

    }

    public void importSequence(Map map) throws IOException {

    //todo import sequence file

    String seq = (String) map.get("SEQUENCE");

    File file = new File("D:\\import\\sequence.sql");

    if (!file.exists()){

    file.createNewFile();

    }

    FileWriter fw = null;

    BufferedWriter bw = null;

    try {

    fw = new FileWriter(file, true);

    bw = new BufferedWriter(fw);

    if (!StringUtils.isEmpty(seq)){

    bw.write(seq.trim());

    bw.newLine();

    }

    } catch (FileNotFoundException e) {

    e.printStackTrace();

    }finally {

    bw.close();

    fw.close();

    }

    }

    }

    导出结果如下图所示,其余的也是三类SQL语句也是类似的做法。

    aaaeaca46443650cb8900deea61860fb.png

    标签:JAVA,String,SEQUENCE,OBJECT,序列,student,sql,ORACLE,TYPE

    来源: https://blog.csdn.net/LonerPYZ/article/details/110195655

    展开全文
  • 主要先从properties读取你实现配置好的数据表,根据你自己定义的规范在数据库里面建模,然后下一步从excel里面读取具体的内容存入到自己的一个容器里面,最后描述生成多个insert语句插入数据库里面去[/color]...
    [color=darkred]  上一篇文章主要针对的是java操作excel的描述,但是具体很没有真正的完善,仍然需要与数据库打交道。先简单介绍这个功能的具体实现吧,主要先从properties读取你实现配置好的数据表,根据你自己定义的规范在数据库里面建模,然后下一步从excel里面读取具体的内容存入到自己的一个容器里面,最后描述生成多个insert语句插入到数据库里面去[/color]


    //定义读文件接口
    package xls.io;

    import xls.core.CoreException;
    import xls.core.Record;
    import xls.core.Schema;

    public interface Reader {

    public boolean hasNext() throws CoreException;

    public Record next() throws CoreException;

    public void close() throws CoreException;

    public Schema getSchema();
    }




    //接口的实现类
    package xls.io;

    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    import java.sql.SQLException;
    import java.sql.Statement;

    import xls.core.Cell;
    import xls.core.Column;
    import xls.core.CoreException;
    import xls.core.Record;
    import xls.core.Schema;
    import xls.core.Type;
    import xls.util.ConnUtils;
    import xls.util.IoUtils;

    public class SQLReader implements Reader {

    private Schema schema;
    private ResultSet rs;
    private ResultSetMetaData metadata;
    private int rowCount;
    private Record record;

    public SQLReader(Schema schema, ResultSet rs) {
    this.schema = schema;
    this.rs = rs;
    this.rowCount = 0;
    }

    public boolean hasNext() throws CoreException {
    try {
    while (rowCount < schema.getStartRow()) {
    System.err.println("[Skip Record] row=" + rowCount);
    if (!rs.next()) {
    return false;
    }
    ++rowCount;
    }
    if (rowCount > schema.getEndtRow()) {
    return false;
    }
    return rs.next();
    } catch (SQLException sqlex) {
    throw new CoreException(sqlex);
    }
    }

    public Record next() throws CoreException {
    if (record == null) {
    record = new Record(schema, rowCount);
    } else {
    record.setRowIndex(rowCount);
    record.clearCells();
    }
    try {
    if (metadata == null) {
    metadata = rs.getMetaData();
    }
    int colTotal = metadata.getColumnCount();
    Type srcType = null;
    Type dstType = null;
    Column column = null;

    Cell cellObject = null;

    for (int i = 1; i <= colTotal && (i <= schema.getColumnCount()); ++i) {
    column = schema.getColumn(i - 1);
    if (column.isNull()) {
    record.addCell(Cell.NULL_CELL);
    } else {
    srcType = column.getInType();
    dstType = column.getType();
    if (srcType == null) {
    srcType = dstType;
    }
    if (column.useDefault()) {
    cellObject = new Cell(schema, rowCount, i - 1,
    column.getDefaultValue());
    } else {
    cellObject = new Cell(schema, rowCount, i - 1,
    IoUtils.readCell(rs, i, srcType, dstType));
    }
    record.addCell(cellObject);

    }
    }
    } catch (SQLException sqlex) {
    throw new CoreException(sqlex);
    }

    ++rowCount;
    System.err.println("[Read]{" + record + "}");
    return record;
    }

    public void close() throws CoreException {
    }

    public Schema getSchema() {
    return schema;
    }

    public static void main(String args[]) throws Exception {
    //POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(".\\conf\\in.xls"));
    //HSSFWorkbook hssfworkbook = new HSSFWorkbook(fs);
    //HSSFSheet sheet = hssfworkbook.getSheetAt(0);
    Schema schema = new Schema();
    schema.open();
    Connection conn = ConnUtils.getConnection(schema.getStoreConfig());
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt
    .executeQuery("select vc_billmonth,vc_clientId,vc_clientName from study");
    SQLReader reader = new SQLReader(schema, rs);
    while (reader.hasNext()) {
    reader.next();
    }
    conn.close();
    }
    }




    package xls.io;

    import java.io.FileInputStream;
    import java.util.Iterator;

    import org.apache.poi.hssf.usermodel.HSSFCell;
    import org.apache.poi.hssf.usermodel.HSSFRow;
    import org.apache.poi.hssf.usermodel.HSSFSheet;
    import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    import org.apache.poi.poifs.filesystem.POIFSFileSystem;

    import xls.core.Cell;
    import xls.core.Column;
    import xls.core.CoreException;
    import xls.core.Record;
    import xls.core.Schema;
    import xls.core.Type;
    import xls.util.IoUtils;

    public class XlsReader implements Reader {

    private Iterator<?> rowIterator;
    private int rowCount;
    private Record record;
    private Schema schema;

    public XlsReader(Schema schema, HSSFSheet sheet) {
    this.schema = schema;
    this.rowIterator = sheet.rowIterator();
    this.rowCount = 0;
    }

    public boolean hasNext() throws CoreException {
    while (rowCount < schema.getStartRow()) {
    System.err.println("[Skip Record] row=" + rowCount);
    if (!rowIterator.hasNext()) {
    return false;
    }
    rowIterator.next();
    ++rowCount;
    }
    if (rowCount > schema.getEndtRow()) {
    return false;
    }

    return rowIterator.hasNext();
    }

    public Record next() throws CoreException {
    int cellCount = 0;
    try {
    HSSFRow row = (HSSFRow) rowIterator.next();
    Iterator<?> cells = row.cellIterator();
    HSSFCell cell = null;

    if (record == null) {
    record = new Record(schema, rowCount);
    } else {
    record.setRowIndex(rowCount);
    record.clearCells();
    }

    Cell cellObject = null;

    Type srcType = null;
    Type dstType = null;
    Column column = null;

    while (cells.hasNext() && (cellCount < schema.getColumnCount())) {
    cell = row.getCell((short) cellCount);
    cells.next();

    if (cell == null) {
    column = schema.getColumn(cellCount);
    srcType = column.getInType();
    dstType = column.getType();

    if (srcType == null) {
    srcType = dstType;
    }
    if (column.useDefault()) {
    cellObject = new Cell(schema, rowCount, cellCount,
    column.getDefaultValue());
    } else {
    cellObject = new Cell(schema, rowCount, cellCount, null);
    }

    record.addCell(cellObject);
    } else {
    column = schema.getColumn(cell.getCellNum());

    if (column.isNull()) {
    record.addCell(Cell.NULL_CELL);
    } else {
    srcType = column.getInType();
    dstType = column.getType();

    if (srcType == null) {
    srcType = dstType;
    }
    if (column.useDefault()) {
    cellObject = new Cell(schema, rowCount, cellCount,
    column.getDefaultValue());
    } else {
    cellObject = new Cell(schema, rowCount, cellCount,
    IoUtils.readCell(cell, srcType, dstType));
    }
    record.addCell(cellObject);
    }
    }
    ++cellCount;
    }

    int columnCount = schema.getColumnCount();
    if (cellCount < columnCount) {
    for (int i = cellCount; i < columnCount; ++i) {
    column = schema.getColumn(cellCount);
    srcType = column.getInType();
    dstType = column.getType();
    cellObject = new Cell(schema, rowCount, i, null);
    record.addCell(cellObject);
    }
    }
    ++rowCount;
    } catch (Exception ex) {
    System.err.println("[XlsReader read] { row=" + rowCount
    + ",column=" + cellCount + " }");
    throw new CoreException(ex);
    }
    return record;
    }

    public void close() throws CoreException {
    }

    public Schema getSchema() {
    return (this.schema);
    }

    public static void main(String args[]) throws Exception {
    POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(
    "D://project/excelUtil/conf_file/out.xls"));
    HSSFWorkbook hssfworkbook = new HSSFWorkbook(fs);
    HSSFSheet sheet = hssfworkbook.getSheetAt(0);
    Schema schema = new Schema();
    schema.open();
    XlsReader reader = new XlsReader(schema, sheet);
    while (reader.hasNext()) {
    System.out.println(reader.next());
    }
    }
    }





    //定义一个写的接口
    package xls.io;

    import xls.core.CoreException;
    import xls.core.Record;
    import xls.core.Schema;

    public interface Writer {

    public void write(Record record) throws CoreException;

    public void close() throws CoreException;

    public Schema getSchema();
    }



    package xls.io;

    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;

    import xls.core.Cell;
    import xls.core.Column;
    import xls.core.CoreException;
    import xls.core.Record;
    import xls.core.Schema;
    import xls.util.IoUtils;

    public class SQLWriter implements Writer {

    private Schema schema;
    private Connection conn;
    private PreparedStatement stmt;

    public SQLWriter(Schema schema, Connection conn) {
    this.schema = schema;
    this.conn = conn;
    }

    public void write(Record record) throws CoreException {
    try {
    if (stmt == null) {
    stmt = conn.prepareStatement(generateSQL(record));
    }
    PreparedStatement pstmt = (PreparedStatement) stmt;
    setParameter(pstmt, record);
    pstmt.execute();
    } catch (SQLException sqlex) {
    System.err.println("[SQLWriter write]{" + record + "}");
    throw new CoreException(sqlex);
    }
    }

    public void close() throws CoreException {
    try {
    if (stmt != null) {
    PreparedStatement pstmt = (PreparedStatement) stmt;
    pstmt.close();
    }
    } catch (SQLException sqlex) {
    throw new CoreException(sqlex);
    }
    }

    public Schema getSchema() {
    return schema;
    }

    private String generateSQL(Record record) {
    int colTotal = schema.getColumnCount();
    StringBuffer columns = new StringBuffer();
    StringBuffer values = new StringBuffer();
    Column column = null;
    String colName = null;
    for (int i = 0; i < colTotal; ++i) {
    column = schema.getColumn(i);
    if (!column.isNull()) {
    colName = column.getName();
    columns.append(colName + ",");
    values.append("?,");
    }
    }
    String col = columns.toString();
    String val = values.toString();

    int chopIndex = col.lastIndexOf(",");
    if (chopIndex > 0) {
    col = col.substring(0, chopIndex);
    }

    chopIndex = val.lastIndexOf(",");
    if (chopIndex > 0) {
    val = val.substring(0, chopIndex);
    }
    return "insert into " + schema.getTableName() + "(" + col + ") values("
    + val + ")";
    }

    private void setParameter(PreparedStatement pstmt, Record record)
    throws SQLException, CoreException {

    int cellSize = record.getCellCount();
    int paramIndex = 1;

    for (int i = 0; i < cellSize; ++i) {
    Cell cell = record.getCell(i);
    if (!cell.isNull()) {
    IoUtils.writeCell(pstmt, cell, paramIndex);
    ++paramIndex;
    }
    }
    }
    public static void main(String args[]){

    }
    }



    package xls.io;

    import java.io.OutputStream;

    import org.apache.poi.hssf.usermodel.HSSFRow;
    import org.apache.poi.hssf.usermodel.HSSFSheet;
    import org.apache.poi.hssf.usermodel.HSSFWorkbook;

    import xls.core.Cell;
    import xls.core.Column;
    import xls.core.CoreException;
    import xls.core.Record;
    import xls.core.Schema;
    import xls.util.IoUtils;

    public class XlsWriter {

    private Schema schema;
    private OutputStream fout;
    HSSFWorkbook workBook;
    HSSFSheet sheet;

    int rowCount;

    public XlsWriter(Schema schema_, OutputStream fout_) {
    this.schema = schema_;
    this.fout = fout_;
    this.workBook = new HSSFWorkbook();
    this.sheet = workBook.createSheet();
    this.rowCount = 0;
    }

    public void write(Record record) throws CoreException {
    HSSFRow row = sheet.createRow(rowCount);
    int sizeCell = record.getCellCount();
    Cell cellObject = null;
    int cellIndex = 0;
    for (int i = 0; i < sizeCell; ++i) {
    cellObject = record.getCell(i);
    if (!cellObject.isNull()) {
    IoUtils.writeCell(workBook, row, cellIndex, cellObject);
    ++cellIndex;
    }
    }
    ++rowCount;
    System.err.println("[Write]{" + record + "}");
    }

    public void close() throws CoreException {
    try {
    workBook.write(fout);
    } catch (Exception ex) {
    throw new CoreException(ex);
    }
    }

    public void writeTitle() throws CoreException {
    HSSFRow row = sheet.createRow(rowCount);
    int sizeColumn = schema.getColumnCount();
    Column column = null;
    int titleIndex = 0;
    for (int i = 0; i < sizeColumn; ++i) {
    column = schema.getColumn(i);
    if (!column.isNull()) {
    IoUtils.writeTitle(row, titleIndex, column.getName());
    ++titleIndex;
    }
    }
    ++rowCount;
    }

    public Schema getSchema() {
    return schema;
    }
    }


    这个针对文件操作实现读写流
    展开全文
  • 序列的主要作用是生成表的主键值,可以在插入语句中使用,也可以通过检查当前值,使得序列曾只下一个值。 创建序列 创建序列需要CREATE SEQUENCE系统权限。序列的创建语法如下:  CREATE SEQUENCE序列名  ...
  • java读取大文本直接插入数据库: 需求如下:  需要解析的文本文件是从考勤机中导出的1_attlog.dat,dat文件,根据项目需要,我只要2列数据,如下图 第一列在数据库对应的字段为 column3,第二列在数据库对应的...
  • Java数据库编程宝典2

    2008-09-28 11:11:49
    第1部分 介绍数据库、SQL和JDBC 第1章 关系型数据库 1.1 理解关系型数据库管理系统 1.1.1 关系模型 1.1.2 Codd法则 1.1.3 表、行、列和关键字 1.1.4 主键 1.1.5 外键 1.1.6 关系 1.1.7 视图 1.1.6 范式...
  • Java数据库编程宝典4

    2008-09-28 11:18:35
    第1部分 介绍数据库、SQL和JDBC 第1章 关系型数据库 1.1 理解关系型数据库管理系统 1.1.1 关系模型 1.1.2 Codd法则 1.1.3 表、行、列和关键字 1.1.4 主键 1.1.5 外键 1.1.6 关系 1.1.7 视图 1.1.6 范式...
  • Java数据库编程宝典3

    2008-09-28 11:14:41
    第1部分 介绍数据库、SQL和JDBC 第1章 关系型数据库 1.1 理解关系型数据库管理系统 1.1.1 关系模型 1.1.2 Codd法则 1.1.3 表、行、列和关键字 1.1.4 主键 1.1.5 外键 1.1.6 关系 1.1.7 视图 1.1.6 范式...
  • Java数据库编程宝典1

    2008-09-28 11:06:57
    第1部分 介绍数据库、SQL和JDBC 第1章 关系型数据库 1.1 理解关系型数据库管理系统 1.1.1 关系模型 1.1.2 Codd法则 1.1.3 表、行、列和关键字 1.1.4 主键 1.1.5 外键 1.1.6 关系 1.1.7 视图 1.1.6 范式...
  • 需求是从一个mysql数据库导出数据再导入到sqlite中,考虑从mysql查询,只能逐行插入sqlite效率会很低,所以把mysql中的数据导出到sql文件中,删除表结构语句,保留insert语句,在sqlite中先建好跟该表一样的结构,...
  • ​ 本文介绍的是利用Apache poi 的api将mysql中的数据导出到excel表中及将excel表中的数据插入到mysql中。我封装成了工具类,导出的时候想导出哪张表只需要写sql语句就可以了。导入到mysql的时候因为我项目中用到了...
  • 导出的数据既可导出为sqlldr导入数据文件,也可通过PRM-DUL的Data Bridge功能直接导出插入到指定新库中,实现不落地恢复。 PRM-DUL Oracle数据库恢复工具功能 》》可以在不需要运行Oracle数据库的情况下直接...
  • 通过作者历时3年的写作,本书介绍了Oracle的安装及卸载、数据库的启动关闭、表空间和数据文件的管理、Oracle网络管理、口令文件管理、内存管理、进程管理、用户管理、数据的导入导出、备份与恢复、模式对象的管理...
  • 通过作者历时3年的写作,本书介绍了Oracle的安装及卸载、数据库的启动关闭、表空间和数据文件的管理、Oracle网络管理、口令文件管理、内存管理、进程管理、用户管理、数据的导入导出、备份与恢复、模式对象的管理...
  • 书中内容主要集中在大多数企业常见的问题之上,如安装和升级到oracle database 11g数据库软件、创建数据库导出和导入数据、数据库的备份与恢复、性能调优,等等。  本书还提供了dba完成本职工作必备的基本的uniix...
  • 通过作者历时3年的写作,本书介绍了Oracle的安装及卸载、数据库的启动关闭、表空间和数据文件的管理、Oracle网络管理、口令文件管理、内存管理、进程管理、用户管理、数据的导入导出、备份与恢复、模式对象的管理...
  • 通过作者历时3年的写作,本书介绍了Oracle的安装及卸载、数据库的启动关闭、表空间和数据文件的管理、Oracle网络管理、口令文件管理、内存管理、进程管理、用户管理、数据的导入导出、备份与恢复、模式对象的管理...
  • 通过作者历时3年的写作,本书介绍了Oracle的安装及卸载、数据库的启动关闭、表空间和数据文件的管理、Oracle网络管理、口令文件管理、内存管理、进程管理、用户管理、数据的导入导出、备份与恢复、模式对象的管理...
  • 通过作者历时3年的写作,本书介绍了Oracle的安装及卸载、数据库的启动关闭、表空间和数据文件的管理、Oracle网络管理、口令文件管理、内存管理、进程管理、用户管理、数据的导入导出、备份与恢复、模式对象的管理...
  • 通过作者历时3年的写作,本书介绍了Oracle的安装及卸载、数据库的启动关闭、表空间和数据文件的管理、Oracle网络管理、口令文件管理、内存管理、进程管理、用户管理、数据的导入导出、备份与恢复、模式对象的管理...
  • 通过作者历时3年的写作,本书介绍了Oracle的安装及卸载、数据库的启动关闭、表空间和数据文件的管理、Oracle网络管理、口令文件管理、内存管理、进程管理、用户管理、数据的导入导出、备份与恢复、模式对象的管理...
  • 通过作者历时3年的写作,本书介绍了Oracle的安装及卸载、数据库的启动关闭、表空间和数据文件的管理、Oracle网络管理、口令文件管理、内存管理、进程管理、用户管理、数据的导入导出、备份与恢复、模式对象的管理...
  • 通过作者历时3年的写作,本书介绍了Oracle的安装及卸载、数据库的启动关闭、表空间和数据文件的管理、Oracle网络管理、口令文件管理、内存管理、进程管理、用户管理、数据的导入导出、备份与恢复、模式对象的管理...
  • Java BCP 改进

    千次阅读 2012-03-19 22:55:55
    BCP(Bulk CopyProgram批量数据拷贝工具,下同)是MicrosoftSQL Server和Sybase数据库提供的非常...常规的做法是用insert into语句直接插入数据,或者调用BCP命令导入数据。但这两种方法都有其固有的局限性,有没有一
  • db2数据库入门教程(官方中文版)

    千次下载 热门讨论 2010-10-20 13:30:33
    2.2.1数据库分区............................................................................................................23 2.2.2连接集中器(Connection Concentrator ).................................
  • 获得一个表insert语句

    2009-06-04 15:04:24
    因为项目需要支持两个数据库,在数据移植上会有很多麻烦,特别是数据量很大的情况下,总不能把同样的数据插入2遍吧? 我们想到的解决方案是写sql脚本,在不同的数据上跑一遍就可以了,create语句我可以直接用PL/...
  • 使用 LOAD DATA 导入数据MySQL 中提供了LOAD DATA INFILE语句插入数据。 以下实例中将从当前目录中读取文件 dump.txt ,将该文件中的数据插入到当前数据库的 mytbl 表中。mysql> LOAD DATA LOCAL INFILE 'dump....
  • db2数据库入门官方教程(中文版)

    热门讨论 2013-05-02 14:48:46
    2.2.1数据库分区............................................................................................................23 2.2.2连接集中器(Connection Concentrator ).................................
  • 他最热衷的是逻辑与物理数据库的设计、 数据库Java应用程序的集成、查询优化器,以及与性能管理和优化相关的所有方面。他还是Trivadis性能团队和OakTable 网站的核心成员。.  童家旺 安徽芜湖人。毕业于上海电力...

空空如也

空空如也

1 2 3 4
收藏数 73
精华内容 29
关键字:

java导出数据库插入语句

java 订阅