数据库MySQL与Oracle的一些去O注意项

一、oracle递归查询语句start with ...connect by prior

①　给你一张表，表里面有主键id,以及该项的父节点parent_id,查询出该表中所有的父子关系节点树？

Oracle: start with ...connect by prior

例如：对分类下的所有组图(包括子分类下的组图)列表进行分页

select g.* from t_group g, t_counter c where g.counter_id = c.id and g.category_id in ( select id from t_category start with id = ? connect by prior id = parent_id and status = 1) and status = 1 order by c.pv desc

mysql:没有oracle那种自带的查询参数，在java端写递归函数，或者递归的存储过程

递归查找某一分类下的所有子分类,数据表结构如图

CREATE TABLE t_category (

  category_id int() unsigned NOT NULL COMMENT '栏目id，主键',

  parent_id int() unsigned COMMENT '分类父类id',

  original_parent_id int() unsigned COMMENT '原始父类id，放到垃圾箱保留原有从属关系',

  name varchar() COMMENT '名称',

  code varchar() COMMENT '编码',

  ...

  status int() COMMENT '状态；0： 草稿, 1： 通过（发布）, -1： 删除',

  ...

)

java解决方案:

public void getAllChildren(long categoryId, int status, List<Long> categoryIdList) {

        List<Long> childrenIds = getCategoryChildrenIds(categoryId, status);

        for (long cateId : childrenIds) {

            categoryIdList.add(cateId);

            int count = geliDao.count("select count(1) from t_category where parent_id = ? and status = ?", cateId, status);

            if (count > ) {

                getAllChildren(cateId, status, categoryIdList);

            }

        }

    }

在要使用该递归函数的地方，该这样使用

public Pager<Group> findGroupByCateAndName(long categoryId, String name, int pageNo, int pageSize) {

        SqlBuilder sqlBuilder = new SqlBuilder();

        sqlBuilder.appendSql("select group_id from t_group where category_id in ");

        List<Long> routeIds = new ArrayList<Long>();

        routeIds.add(categoryId);

        getAllChildren(categoryId, Category.STATUS_NORMAL, routeIds);

        sqlBuilder.appendValues(routeIds.toArray());

        if(StringUtils.isNotBlank(name)) {

            sqlBuilder.appendSql(" and name like ");

            sqlBuilder.appendValue("%" + name + "%");

        }

        sqlBuilder.appendSql(" order by group_id desc");

        LOG.debug("findGroupByCateAndName : {}; {}", sqlBuilder.getSql(), sqlBuilder.getValues());

        return new Pager<Group>(sqlBuilder.getSqlExt(), sqlBuilder.getValuesExt(), pageNo, pageSize);

    }

二、oracle函数decode处理

在Oracle/PLSQL中, decode 具有和 IF-THEN-ELSE 一样的功能。

decode 函数语法如下：

decode( expression , search , result [, search , result]... [, default] )

expression 要比较的表达式.

search 要与expression 比较的字段。.

result 如果expression 与search 一样的话，返回该结果。.

default 此参数可选，如果没有与expression 匹配上的search . 就返回此结果，如果此参数没有设置，当没有与expression匹配上的search时，返回null。

search 和 result可成对出现多次，代表各种要匹配的情况。

sign(number) 函数返回一个数字的正负标志.

问题1: 现在一个阅读者想问，怎么使用decode函数来比较两个日期呢？（例如：date1 和 date2）, 如果date1 > date2, decode 函数返回date2. 否则decode函数返回 date1.

可用decode函数绑定SIGN 函数像下面这样:

上面比较日期的语句可修改如下:

DECODE(SIGN(date1-date2), 1, date2, date1)

eg：如果有app参数就查询该app对应的指令数目,否则查询所有指令数目

public long searchCommandCount(String app)

    {

        if(app == null) app="";

        String sql = "select count(0)  "+

                    "from t_command a,t_application b where a.applicationid=b.id and b.application = decode(?,'',b.application,?) ";

        return  simpleJdbcTemplate.queryForLong(sql, app, app);

    }

mysql处理后

public long searchCommandCount(String app)

    {

        if(app == null) app="";

        StringBuilder sb = new StringBuilder();

        sb.append("select count(0) from t_command a,t_application b where a.applicationid=b.id");

        if(!"".equals(app)){

            sb.append(" and b.application = "+ app);

        }

        /*String sql = "select count(0)  "+

                    "from t_command a,t_application b where a.applicationid=b.id and b.application = decode(?,'',b.application,?) ";*/

        return  simpleJdbcTemplate.queryForLong(sb.toString());

    }

三、oracle自增长序列处理

关于SEQUENCE 的基本知识请参考ORACLE SEQUENCE用法

原处理方案：

CREATE SEQUENCE SEQ_TONY_APK_ID MINVALUE 1 MAXVALUE 999999999999999999999999999 INCREMENT BY 1 START WITH 1976634 CACHE 20 NOORDER NOCYCLE ;

//获取id

public long createTonyId()

{

    return simpleJdbcTemplate.queryForLong("select seq_tony_apk_id.nextval from dual");

}

mysql解决方案：

普通的可能会想到用mysql的自增长auto_increament,不过这个在数据库做分库分表的时候，有可能出问题，具体原因请参照数据库分库分表(sharding)系列(二) 全局主键生成策略

使用全局主键表

CREATE TABLE gl_keygen(

  table_name varchar() NOT NULL COMMENT '表名，主键',

  last_used_id int() unsigned NOT NULL COMMENT '最后使用的id'

) ENGINE= InnoDB DEFAULT CHARSET=gbk;

我们使用一个Java类来控制某一字段自增长

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.Map;

import javax.sql.DataSource;

public class IdTableGenerator {

    DataSource idGenDataSource;

    public void setIdDataSource(DataSource idGenDataSource) {

        this.idGenDataSource = idGenDataSource;

    }

    int size = ;

    Map<String, IdHolder> holderMap = new java.util.concurrent.ConcurrentHashMap<String, IdHolder>();

    public long generate(String tableName, String columnName) {

        IdHolder holder = holderMap.get(tableName);

        if (holder == null) {

            holder = new IdHolder();

            holderMap.put(tableName, holder);

        }

        synchronized (holder) {

            if (holder.needAlloc()) {

                long lastUsedId = alloc(tableName, columnName, size);

                holder.currentId = lastUsedId + ;

                holder.limit = lastUsedId + size;

            } else {

                holder.currentId ++;

            }

            return holder.currentId;

        }

    }

    static class IdHolder {

        long currentId;

        long limit;

        boolean needAlloc() {return currentId >= limit; }

    }

    public long alloc(String tableName, String columnName, int size) {

        long result = ;

        Connection con = null;

        boolean oldAutoCommit = false;

        try {

            con = idGenDataSource.getConnection();

            oldAutoCommit = con.getAutoCommit();

            con.setAutoCommit(false);

            int updateCount = updateLastUsedId(con, tableName, columnName, size);

            if (updateCount == ) {

                initIdTable(con, tableName, columnName);

            }

            result = getLastUsedId(con, tableName, columnName);

            con.commit();

        } catch (Exception e) {

            try {

                con.rollback();

            } catch (Exception ex) {

                ex.printStackTrace();

            }

            throw new RuntimeException(e);

        } finally {

            if (con != null) {

                try {

                    con.setAutoCommit(oldAutoCommit);

                    con.close();

                } catch (Exception ex) {

                    ex.printStackTrace();

                }

            }

        }

        return result;

    }

    static long getLastUsedId(Connection con, String tableName, String columnName) throws SQLException {

        PreparedStatement ps = con.prepareStatement("select LAST_USED_ID from GL_KEYGEN where table_name = ?");

        ps.setString(, tableName);

        ResultSet rs = ps.executeQuery();

        rs.next();

        long result = rs.getLong();

        rs.close();

        ps.close();

        return result;

    }

    static int updateLastUsedId(Connection con, String tableName, String columnName, int size) throws SQLException  {

        PreparedStatement ps = con.prepareStatement("update GL_KEYGEN set last_used_id = last_used_id + ?" +

        " where table_name = ?");

        ps.setInt(, size);

        ps.setString(, tableName);

        int result = ps.executeUpdate();

        ps.close();

        return result;

    }

    static void initIdTable(Connection con, String tableName, String columnName) throws SQLException {

        PreparedStatement ps = con.prepareStatement("select max(" + columnName + ") from " + tableName);

        ResultSet rs = ps.executeQuery();

        rs.next();

        long maxId = rs.getLong();

        rs.close();

        ps.close();

        ps = con.prepareStatement("insert into GL_KEYGEN (table_name, last_used_id) values (?, ?)");

        ps.setString(, tableName);

        ps.setLong(, maxId);

        ps.executeUpdate();

        ps.close();

    }

}

<jee:jndi-lookup id="dataSource" jndi-name="jdbc/test"/>

<bean id="idGenerator" class="cn.tony.repository.IdTableGenerator" p:idDataSource-ref="dataSource"/>

数据源配置

<database>

        <jndi-name>jdbc/test</jndi-name>

        <driver type="com.mysql.jdbc.Driver">

        <url>jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&amp;characterEncoding=GBK&amp;zeroDateTimeBehavior=convertToNull

        </url>

        <user>root</user>

        <password>root</password>

        </driver>

        <prepared-statement-cache-size></prepared-statement-cache-size>

        <max-connections></max-connections>

        <max-idle-time>30s</max-idle-time>

    </database>

主键自增生成器使用案例：

public abstract class AbstractRepository <T> {

    @Autowired

    IdTableGenerator idGenerator;

    protected long getNextId(String tableName, String columnName){

        return idGenerator.generate(tableName, columnName);

    }

    //默认使用id做主键

    protected long getNextId(String tableName){

        return idGenerator.generate(tableName, "id");

    }

}

public class TonyRepository extends AbstractRepository<Tony> {

    public long createTonyId(){

        return getNextId(Tony.TABLE_NAME);

    }

}

四、其他函数

to_date---> str_to_date
(yyyy-MM-dd HH24:mi:ss) --- (%Y-%m-%d %H:%i:%s)
sysdate --->sysdate()
to_char --->mysql中没有对应的函数，MySQL必要时自动变换数字为字符串

mysql数据类型和长度

mysql中key 、primary key 、unique key 与index区别

Oracle的to_date函数

五、SQL中特殊符号处理

单引号处理

用字符串拼接的话，单引号必须经过判断并替换，在数据库中，用2个单引号代表1个实际的单引号。所以，如果是拼接方式，需要用String.Replace("’", "”")来替换一下，将1个单引号替换为2个就没有问题了。在模糊查询中,为了避免单引号，我们使用参数的方式，下面的语句是不对的：

SELECT * FROM yourTable WHERE name LIKE ‘%?%’;在这个句子中，’%?%’被整体当作一个字符串来处理，你无论如何查询不到结果。修改一下，SELECT * FROM yourTable WHERE name LIKE ?;然后添加参数的时候这么添加：

new Parameter("?", "%" + categoryName + "%");

通配符_ % 处理

如果用户输入的查询条件中含有通配符，必须将这些字符作为数据而不是通配符来对待

s = s.Replace("%", "[%]");
s = s.Replace("_", "[_]");

左方括号([)问题

如果用户输入的查询参数本身就包括方括号时，会出现什么结果呢？
根据用户的期望，如果输入一个方括号，查询结果中应该只包括那些字段值中含有方括号的记录。
但是实验结果表明，如果是没有配成对的单个左方括号，查询时这个左方括号会被忽略。
也就是说，下面这个语句：
WHERE T2.name like (%+ [ + %)
等价于下面这个语句：
WHERE T2.name like (%+ + %)
这将导致查询结果中包含表中的全部记录，就像没有任何过滤条件一样。
为此，如果用户输入的查询条件中含有左方括号的话，还必须对左方括号进行转义：
s = s.Replace("[", "[[]");
注：右方括号没有这个问题。

结论

为了防止SQL注入，同时避免用户输入特殊字符时查询结果不准确的问题，应该做两件事：
（1）使用参数化查询。
（2）在使用用户输入的字符串数据设置查询参数值之前，首先调用下面的共通处理函数：
private static string ConvertSql(string sql) {
sql = sql.Replace("[", "[[]"); // 这句话一定要在下面两个语句之前，否则作为转义符的方括号会被当作数据被再次处理
sql = sql.Replace("_", "[_]").Replace("%", "[%]");
return sql;
}

巴特西