demo-tabledata-redis/src/main/java/com/fr/plugin/db/redis/core/RedisTableData.java

package com.fr.plugin.db.redis.core;

import com.fanruan.api.conf.HolderKit;
import com.fanruan.api.data.ConnectionKit;
import com.fanruan.api.log.LogKit;
import com.fanruan.api.util.StringKit;
import com.fanruan.api.xml.XmlKit;
import com.fr.base.TableData;
import com.fr.config.holder.Conf;
import com.fr.config.holder.factory.XmlHolders;
import com.fr.data.AbstractParameterTableData;
import com.fr.data.impl.Connection;
import com.fr.general.data.DataModel;
import com.fr.intelli.record.Focus;
import com.fr.intelli.record.Original;
import com.fr.plugin.db.redis.core.order.OrderValue;
import com.fr.plugin.db.redis.core.order.impl.NumberOrderValue;
import com.fr.plugin.db.redis.util.RedisUtils;
import com.fr.record.analyzer.EnableMetrics;
import com.fr.script.Calculator;
import com.fr.stable.NameReference;
import com.fr.stable.ParameterProvider;
import com.fr.stable.xml.XMLPrintWriter;
import com.fr.stable.xml.XMLableReader;


@EnableMetrics
public class RedisTableData extends AbstractParameterTableData {

    private static final long serialVersionUID = 7017455818551800001L;
    private Conf<Connection> database = HolderKit.obj(null, Connection.class);
    private Conf<OrderValue> dbIndex = XmlHolders.obj(new NumberOrderValue(0), OrderValue.class, OrderValue.XML_TAG);
    private Conf<String> query = HolderKit.simple(StringKit.EMPTY);
    private Conf<String> script = HolderKit.simple(StringKit.EMPTY);

    public void setDatabase(Connection c) {
        this.database.set(c);
    }

    public Connection getDatabase() {
        return database.get();
    }

    public OrderValue getOrderValue() {
        return dbIndex.get();
    }

    public void setOrderValue(OrderValue dbIndex) {
        this.dbIndex.set(dbIndex);
    }

    public String getQuery() {
        return query.get();
    }

    public void setQuery(String query) {
        this.query.set(query);
    }

    public String getScript() {
        return script.get();
    }

    public void setScript(String script) {
        this.script.set(script);
    }

    public void setParameters(ParameterProvider[] providers) {
        super.setDefaultParameters(providers);
    }

    @Override
    public DataModel createDataModel(Calculator calculator) {
        return createDataModel(calculator, TableData.RESULT_ALL);
    }

    @Override
    @Focus(id = RedisConstants.PLUGIN_ID, text = "Plugin-Redis_DB", source = Original.PLUGIN)
    public DataModel createDataModel(Calculator calculator, int rowCount) {
        long start = System.currentTimeMillis();
        ParameterProvider[] ps = getParameters(calculator);
        Connection connection = database.get();
        if (connection instanceof NameReference) {
            String name = ((NameReference) connection).getName();
            RedisDatabaseConnection rc = ConnectionKit.getConnection(name, RedisDatabaseConnection.class);
            if (rc != null) {
                OrderValue orderValue = dbIndex.get();
                DataModel model = new RedisTableDataModel(calculator, ps, rc,
                        orderValue == null ? 0 : orderValue.toIndex(calculator, ps),
                        RedisUtils.calculateQuery(query.get(), ps),
                        RedisUtils.calculateQuery(script.get(), ps),
                        rowCount);
                LogKit.info("Build data model spend time {} ms.", System.currentTimeMillis() - start);
                return model;
            }
        }
        return null;
    }



    public void readXML(XMLableReader reader) {
        super.readXML(reader);

        if (reader.isChildNode()) {
            String tmpName = reader.getTagName();
            String tmpVal;

            if (OrderValue.XML_TAG.equals(tmpName)) {
                OrderValue orderValue = (OrderValue) XmlKit.readXMLable(reader);
                if (orderValue != null) {
                    setOrderValue(orderValue);
                }
            } else if (com.fr.data.impl.Connection.XML_TAG.equals(tmpName)) {
                if (reader.getAttrAsString("class", null) != null) {
                    com.fr.data.impl.Connection con = XmlKit.readXMLConnection(reader);
                    this.setDatabase(con);
                }
            } else if ("Query".equals(tmpName)) {
                tmpVal = reader.getElementValue();
                if (isNotNullValue(tmpVal)) {
                    this.setQuery(tmpVal);
                }
            } else if ("Script".equals(tmpName)) {
                tmpVal = reader.getElementValue();
                if (isNotNullValue(tmpVal)) {
                    this.setScript(tmpVal);
                }
            }
        }
    }

    @Override
    public void writeXML(XMLPrintWriter writer) {
        super.writeXML(writer);
        XmlKit.writeXMLable(writer, dbIndex.get(), OrderValue.XML_TAG);
        if (this.database.get() != null) {
            XmlKit.writeXMLConnection(writer, this.database.get());
        }
        writer.startTAG("Query").textNode(getQuery()).end();
        writer.startTAG("Script").textNode(getScript()).end();
    }

    private boolean isNotNullValue(String value) {
        return value != null && !"null".equals(value);
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        RedisTableData cloned = (RedisTableData) super.clone();
        cloned.database = (Conf<Connection>) database.clone();
        cloned.query = (Conf<String>) query.clone();
        cloned.script = (Conf<String>) script.clone();
        cloned.dbIndex = (Conf<OrderValue>) dbIndex.clone();
        return cloned;
    }
}