• Home
• org.opendcs
• opendcs
• 7.0.13-RC08
• source code
• CwmsTimeSeriesDAO.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

decodes.cwms.CwmsTimeSeriesDAO Maven / Gradle / Ivy

package decodes.cwms;

import ilex.util.TextUtil;
import ilex.var.NoConversionException;
import ilex.var.TimedVariable;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.TimeZone;
import java.util.concurrent.TimeUnit;

import org.opendcs.database.ExceptionHelpers;
import org.opendcs.utils.FailableResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import decodes.db.Constants;
import decodes.db.DataType;
import decodes.db.Database;
import decodes.db.EngineeringUnit;
import decodes.db.Site;
import decodes.db.SiteName;
import decodes.db.UnitConverter;
import decodes.sql.DbKey;
import decodes.tsdb.BadTimeSeriesException;
import decodes.tsdb.CTimeSeries;
import decodes.tsdb.DataCollection;
import decodes.tsdb.DbIoException;
import decodes.tsdb.IntervalCodes;
import decodes.tsdb.NoSuchObjectException;
import decodes.tsdb.RecordRangeHandle;
import decodes.tsdb.TasklistRec;
import decodes.tsdb.TimeSeriesIdentifier;
import decodes.tsdb.TsdbDatabaseVersion;
import decodes.tsdb.TsdbException;
import decodes.tsdb.TimeSeriesDb;
import decodes.tsdb.VarFlags;
import decodes.util.DecodesSettings;
import decodes.util.TSUtil;
import opendcs.dai.CompDependsDAI;
import opendcs.dai.DataTypeDAI;
import opendcs.dai.SiteDAI;
import opendcs.dai.TimeSeriesDAI;
import opendcs.dao.DaoBase;
import opendcs.dao.DatabaseConnectionOwner;
import opendcs.dao.DbObjectCache;
import opendcs.util.sql.WrappedConnection;
import usace.cwms.db.dao.ifc.ts.CwmsDbTs;
import usace.cwms.db.dao.util.services.CwmsDbServiceLookup;

public class CwmsTimeSeriesDAO
    extends DaoBase
    implements TimeSeriesDAI
{
    private final Logger log = LoggerFactory.getLogger(CwmsTimeSeriesDAO.class);
    protected static final  DbObjectCache cache =
        new DbObjectCache(60 * 60 * 1000L, false);
    protected SiteDAI siteDAO = null;
    protected DataTypeDAI dataTypeDAO = null;
    private String dbOfficeId = null;
    private static boolean noUnitConv = false;
    private static long lastCacheReload = 0L;
    private String cwmsTsidQueryBase = "SELECT a.CWMS_TS_ID, a.VERSION_FLAG, a.INTERVAL_UTC_OFFSET, "
            + "a.UNIT_ID, a.PARAMETER_ID, '', a.TS_CODE, a.LOCATION_CODE, "
            + "a.LOCATION_ID, a.TS_ACTIVE_FLAG FROM CWMS_V_TS_ID a";
    String getMinStmtQuery = null, getTaskListStmtQuery = null;


    protected CwmsTimeSeriesDAO(DatabaseConnectionOwner tsdb, String dbOfficeId)
    {
        super(tsdb, "CwmsTimeSeriesDAO");
        siteDAO = tsdb.makeSiteDAO();
        dataTypeDAO = tsdb.makeDataTypeDAO();
        this.dbOfficeId = dbOfficeId;
    }

    @Override
    public FailableResult findTimeSeriesIdentifier(DbKey key)
    {
        if (DbKey.isNull(key))
        {
            return FailableResult.failure(new NoSuchObjectException("Request for TSID with null ts_code"));
        }

        synchronized(cache)
        {
            CwmsTsId ret = (CwmsTsId)cache.getByKey(key);

            if (ret != null)
            {
                return FailableResult.success(ret);
            }

            String q = cwmsTsidQueryBase
                + " WHERE a.TS_CODE = ?";
            // Don't need to add DB_OFFICE_ID because TS_CODE is unique.

            try
            {
                final long now = System.currentTimeMillis();
                ret = getSingleResult(q,  rs ->
                {
                    try
                    {
                        CwmsTsId tmp = rs2TsId(rs, true);
                        tmp.setReadTime(now);
                        return tmp;
                    }
                    catch (Exception ex)
                    {
                        throw new SQLException("Unable to process data returned from database.", ex);
                    }
                }, key);

                if (ret != null)
                {
                    cache.put(ret);
                    return FailableResult.success(ret);
                }
            }
            catch(Exception ex)
            {
                return FailableResult.failure(new DbIoException("Error looking up TS Info for TS_CODE=" + key + ": ", ex));
            }
        }
        return FailableResult.failure(new NoSuchObjectException("No time-series with ts_code=" + key));
    }

    @Override
    public TimeSeriesIdentifier getTimeSeriesIdentifier(DbKey key)
        throws DbIoException, NoSuchObjectException
    {
        FailableResult ret = findTimeSeriesIdentifier(key);
        if (ret.isSuccess())
        {
            return ret.getSuccess();
        }
        else
        {
            return ExceptionHelpers.throwDbIoNoSuchObject(ret.getFailure());
        }
        
    }

    private CwmsTsId rs2TsId(ResultSet rs, boolean createDataType)
        throws SQLException, DbIoException, NoSuchObjectException
    {
//        private String cwmsTsidQueryBase = "SELECT a.CWMS_TS_ID, a.VERSION_FLAG, a.INTERVAL_UTC_OFFSET, "
//            + "a.UNIT_ID, a.PARAMETER_ID, '', a.TS_CODE, a.LOCATION_CODE, "
//            + "a.LOCATION_ID, a.TS_ACTIVE_FLAG FROM CWMS_V_TS_ID a, CWMS_V_LOC c";

        DbKey key = DbKey.createDbKey(rs, 7);
        String desc = rs.getString(1);
        String param = rs.getString(5);
//        String publicSiteName = rs.getString(6);
        DataType dt =
            DataType.getDataType(Constants.datatype_CWMS, param);

        int x = rs.getInt(3);
        Integer utcOffset = rs.wasNull() ? null : x;

        CwmsTsId ret = new CwmsTsId(key, desc, dt,
            desc, TextUtil.str2boolean(rs.getString(2)),
            utcOffset, rs.getString(4));


        DbKey siteId = DbKey.createDbKey(rs, 8);
        Site site = null;
        try
        {
            site = siteDAO.getSiteById(siteId);
        }
        catch(NoSuchObjectException ex)
        {
            log.atWarn()
               .setCause(ex)
               .log("rs2TsId No such Site for TS_ID '{}' with ts_code={} and location_code={}", desc, key, siteId);
            throw ex;
        }
        site.addName(new SiteName(site, Constants.snt_CWMS, rs.getString(9)));
        ret.setSite(site);

        ret.setSiteDisplayName(site.getPublicName());
        ret.setDescription(param + " at " + site.getPublicName());

        ret.setActive(TextUtil.str2boolean(rs.getString(10)));

        if (decodes.db.Database.getDb().getDbIo().getDatabaseType().equalsIgnoreCase("XML"))
        {
            return ret;
        }

        if (createDataType && dt.getId() == Constants.undefinedId)
        {
            DataType dbdt = null;
            try
            {
                dbdt = dataTypeDAO.lookupDataType(param);
            }
            catch(NoSuchObjectException ex)
            {
                dbdt = null;
            }

            if (dbdt == null || !dbdt.getStandard().equalsIgnoreCase(Constants.datatype_CWMS))
            {
                dataTypeDAO.writeDataType(dt);
            }
            else // The datatype already exists, add it to the cache.
            {
                decodes.db.Database.getDb().dataTypeSet.add(dbdt);
                ret.setDataType(dbdt);
            }
        }

        return ret;
    }


    @Override
    public FailableResult findTimeSeriesIdentifier(String uniqueString)
    {

        int paren = uniqueString.lastIndexOf('(');
        String displayName = null;
        if (paren > 0 && uniqueString.trim().endsWith(")"))
        {
            displayName = uniqueString.substring(paren+1);
            uniqueString = uniqueString.substring(0,  paren);
            int endParen = displayName.indexOf(')');
            if (endParen > 0)
            {
                displayName = displayName.substring(0,  endParen);
            }
        }

        TimeSeriesIdentifier ret = null;
        synchronized(cache)
        {
            ret = cache.getByUniqueName(uniqueString);
        }
        if (ret != null)
        {
            if (displayName != null)
            {
                ret.setDisplayName(displayName);
            }
            return FailableResult.success(ret);
        }
        else if (ret == null && lastCacheReloadWithin(1, TimeUnit.HOURS))
        {
            return FailableResult.failure(new NoSuchObjectException("No TimeSeries in fresh cache."));
        }

        DbKey ts_code = ts_id2ts_code(uniqueString);
        if (ts_code == Constants.undefinedId)
        {
            return FailableResult.failure(
                new NoSuchObjectException("No timeseries with name '"+uniqueString+"' is defined in this database.")
            );
        }
        
        FailableResult tmp = findTimeSeriesIdentifier(ts_code);
        if (tmp.isSuccess())
        {
            if (displayName != null)
            {
                tmp.getSuccess().setDisplayName(displayName);
            }        
        }
        return tmp;
    }

    /**
     * Given a 6-part time-series identifier, return the unique ts_code.
     * Implicit filtering by office ID is also done.
     * @param tsid location.parm.parmtype.interval.duration.version
     * @return ts_code surrogate key, or Constants.undefinedId if not found.
     */
    private DbKey ts_id2ts_code(String tsid)
    {
        String q = "SELECT TS_CODE FROM CWMS_V_TS_ID "
            + "WHERE upper(CWMS_TS_ID) = upper(?)";
        ArrayList