AbstractSqlManager.java

package org.nutz.dao.impl;

import static java.lang.String.format;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.nutz.dao.SqlManager;
import org.nutz.dao.SqlNotFoundException;
import org.nutz.dao.Sqls;
import org.nutz.dao.sql.Sql;
import org.nutz.lang.Lang;
import org.nutz.lang.Streams;
import org.nutz.lang.Strings;
import org.nutz.lang.util.LinkedCharArray;

/**
 * 
 * @author zozoh(zozohtnt@gmail.com)
 * @author wendal(wendal1985@gmail.com)
 * @author mawenming at 2010-4-10 上午10:04:17
 * 
 */
public abstract class AbstractSqlManager implements SqlManager {

    protected Map<String, String> _sql_map;
    private List<String> _sql_keys;
    
    private boolean allowDuplicate = true;

    private Map<String, String> map() {
        if (null == _sql_map)
            this.refresh();
        return _sql_map;
    }

    private List<String> keylist() {
        if (null == _sql_keys)
            this.refresh();
        return _sql_keys;
    }

    public boolean contains(String key) {
        return map().containsKey(key);
    }

    public void saveAs(File f) throws IOException {
        Writer w = Streams.fileOutw(f);
        for (String key : keylist()) {
            w.append("/*").append(Strings.dup('-', 60)).append("*/\n");
            String sql = map().get(key);
            w.append(format("/*%s*/\n", key));
            w.append(sql).append('\n');
        }
        w.flush();
        w.close();
    }

    public String get(String key) {
        String sql = map().get(key);
        if (null == sql)
            throw new SqlNotFoundException(key);
        return sql;
    }

    public Sql create(String key) throws SqlNotFoundException {
        return Sqls.create(get(key));
    }

    public List<Sql> createCombo(String... keys) {
        if (null == keys || keys.length == 0)
            keys = this.keys();
        List<Sql> list = new ArrayList<Sql>(keys.length);
        for (String key : keys) {
            Sql sql = create(key);
            list.add(sql);
        }
        return list;
    }

    public int count() {
        return map().size();
    }

    public String[] keys() {
        return keylist().toArray(new String[keylist().size()]);
    }

    public void addSql(String key, String value) {
        if (map().containsKey(key) && !allowDuplicate)
            throw Lang.makeThrow("duplicate key '%s'", key);
        key = Strings.trim(key);
        map().put(key, value);
        keylist().add(key);
    }

    static final Pattern ptn = Pattern.compile("(?<=^\n/[*])(.*)(?=[*]/)");

    static class InnerStack {

        LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
        LinkedCharArray list = new LinkedCharArray();
        LinkedCharArray cmts = new LinkedCharArray();
        String key = null;
        boolean inNormalComment;

        void eat(int c) {
            if (inNormalComment) {
                if (cmts.push(c).endsWith("*/")) {
                    cmts.clear();
                    inNormalComment = false;
                }
            } else if (key != null) {
                if (list.push(c).endsWith("\n/*")) {
                    list.popLast(3);
                    addOne();
                    list.push("\n/*");
                } else if (list.endsWith("/*")) {
                    list.popLast(2);
                    inNormalComment = true;
                }
            } else {
                if (list.size() < 3) {
                    if (!"\n/*".startsWith(list.push(c).toString())) {
                        list.clear();
                    }
                } else {
                    if (list.push(c).endsWith("*/")) {
                        Matcher matcher = ptn.matcher(list.popAll());
                        if (matcher.find()) {
                            key = Strings.trim(matcher.group());
                        }
                    }
                }
            }
        }

        void addOne() {
            String value = Strings.trim(list.popAll());
            if (!Strings.isBlank(value))
                map.put(key, value);
            key = null;
        }

    }

    static class SqlFileBuilder {
        LinkedHashMap<String, String> map;

        SqlFileBuilder(BufferedReader reader) throws IOException {
            InnerStack stack = new InnerStack();
            int c;
            stack.eat('\n');
            while (-1 != (c = reader.read())) {
                stack.eat(c);
            }
            if (stack.key != null)
                stack.addOne();
            map = stack.map;
            Streams.safeClose(reader);
        }

        Set<String> keys() {
            return map.keySet();
        }

        String get(String key) {
            return map.get(key);
        }
    }

    public void remove(String key) {
        this.keylist().remove(key);
        this.map().remove(key);
    }

    /**
     * 执行根据字符流来加载sql内容的操作
     * 
     * @param reader
     * @throws IOException
     */
    protected void loadSQL(Reader reader) throws IOException {
        BufferedReader bufferedReader = null;
        try {
            if(reader instanceof BufferedReader)
                bufferedReader = (BufferedReader)reader;
            else
                bufferedReader = new BufferedReader(reader);
            SqlFileBuilder p = new SqlFileBuilder(bufferedReader);

            Iterator<String> it = p.keys().iterator();
            _sql_keys = new ArrayList<String>(p.map.size());
            while (it.hasNext()) {
                String key = it.next();
                String value = Strings.trim(p.get(key));
                addSql(key, value);
            }
        }
        finally {
            Streams.safeClose(bufferedReader);
        }

    }

    public void setAllowDuplicate(boolean allowDuplicate) {
        this.allowDuplicate = allowDuplicate;
    }
}