Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   * See the COPYRIGHT.txt file distributed with this work for information
   * regarding copyright ownership.  Some portions may be licensed
   * to Red Hat, Inc. under one or more contributor license agreements.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301 USA.
  */
 package org.teiid.olingo.service;
 
 import java.util.List;
 import java.util.Map;
 
 
 public class LocalClient implements Client {
     static final String DELIMITER = "--" ; //$NON-NLS-1$
 
     private volatile VDBMetaData vdb;
     private final String vdbName;
     private final int vdbVersion;
     private ConnectionImpl connection;
     private Properties properties;
 
     public LocalClient(String vdbNameint vdbVersionProperties properties) {
         this. = vdbName;
         this. = vdbVersion;
         this. = properties;
     }
         
     private long getCacheTime() {
         return PropertiesUtils.getLongProperty(this.., 300000L);        
     }
     
     @Override
     public Connection open() throws SQLException {
         this. = buildConnection(TeiidDriver.getInstance(), this.this.this.);
         ODBCServerRemoteImpl.setConnectionProperties();
         ODBCServerRemoteImpl.setConnectionProperties(this.);
         return this.;
     }
 
     @Override
     public void close() throws SQLException {
         if (this. != null) {
             this..close();
         }
     }    
     
     public ConnectionImpl getConnection() {
        return this.;
    }
    
    public static ConnectionImpl buildConnection(TeiidDriver driverString vdbNameint versionProperties propsthrows SQLException {
        StringBuilder sb = new StringBuilder();
        sb.append("jdbc:teiid:").append(vdbName).append(".").append(version).append(";"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
        
        Properties properties = new Properties();
        properties.put(.."true"); //$NON-NLS-1$
        properties.put(.props.getProperty(."odata")); //$NON-NLS-1$
        properties.put(."0"); //$NON-NLS-1$
        ConnectionImpl connection = driver.connect(sb.toString(), properties);
        return connection;
    }    
    
    @Override
    public VDBMetaData getVDB() {
        if (this. == null) {
            try {
                LocalServerConnection lsc = (LocalServerConnectiongetConnection().getServerConnection();
                VDBMetaData vdb = lsc.getWorkContext().getVDB();
                if (vdb == null) {
                    throw new TeiidRuntimeException(..gs(
                            ..this.,
                            this.));
                }
                this. = vdb;
            } catch (SQLException e) {
                throw new TeiidRuntimeException(e);
            }
        }
        return this.;
    }
    @Override
    public void executeCall(String sqlList<SQLParameterparametersProcedureReturnType returnType
            OperationResponse responsethrows SQLException {
        
        LogManager.logDetail(."Teiid-Query:",sql); //$NON-NLS-1$
        final CallableStatement stmt = getConnection().prepareCall(sql);
        int i = 1;
        if (!returnType.hasResultSet()) {
            stmt.registerOutParameter(i++, returnType.getSqlType());
        }
        if (!parameters.isEmpty()) {
            for (SQLParameter param:parameters) {
                stmt.setObject(i++, param.getValue(), param.getSqlType());
            }
        }
        boolean results = stmt.execute();
        if (results) {
            final ResultSet rs = stmt.getResultSet();
            while (rs.next()) {
                if (returnType.hasResultSetBasedLob()) {
                    response.addPrimitive(rs.getObject(1));
                }
                else {
                    response.addRow(rs);
                }
            }
        }
        if (!returnType.hasResultSet()) {
            Object result = stmt.getObject(1);
            response.addPrimitive(result);
        }
    }
    @Override
    public MetadataStore getMetadataStore() {
    }
    @Override
    public void executeSQL(Query queryList<SQLParameterparameters,
            boolean calculateTotalSizeInteger skipOptionInteger topOption,
            String nextOptionint pageSizefinal QueryResponse response)  throws SQLException {
        boolean cache = pageSize > 0; 
        if (cache) {
            CacheHint hint = new CacheHint();
            hint.setTtl(getCacheTime());
            hint.setScope(..);
            query.setCacheHint(hint);
        }
        
        boolean getCount = false
        getCount = calculateTotalSize;
        if (!getCount && (topOption != null || skipOption != null)) {
            if (topOption != null && skipOption != null) {
                query.setLimit(new Limit(new Constant(skipOption), new Constant(topOption)));
            }
            else if (topOption != null) {
                query.setLimit(new Limit(new Constant(0), new Constant(topOption)));
            }
        }
        
        String nextToken = null;            
        if (nextOption != null) {
            nextToken = nextOption;
            if (cache) {
                int idx = nextOption.indexOf();
                sessionId = nextOption.substring(0, idx);
                nextToken = nextOption.substring(idx+2);
                
            }
        }
        String sql = query.toString();
        if (cache) {
            sql += " /* "sessionId +" */"//$NON-NLS-1$ //$NON-NLS-2$
        }
        LogManager.logDetail(."Teiid-Query:",sql); //$NON-NLS-1$
        
        if (parameters!= null && !parameters.isEmpty()) {
            for (int i = 0; i < parameters.size(); i++) {
                stmt.setObject(i+1, parameters.get(i).getValue(), parameters.get(i).getSqlType());
            }
        }
        final ResultSet rs = stmt.executeQuery();
                    
        //skip to the initial position
        int count = 0;
        int skipSize = 0;
        //skip based upon the skip value
        if (getCount && skipOption != null) {
            skipSize = skipOption;
        }
        //skip based upon the skipToken
        if (nextToken != null) {
            skipSize += Integer.parseInt(nextToken);
        }
        if (skipSize > 0) {
            count += skip(cachersskipSize);
        }
        //determine the number of records to return
        int size = pageSize;
        int top = .;
        if (getCount && topOption != null) {
            top = topOption;
            size = top
            if (pageSize > 0) {
                size = Math.min(pageSizesize);
            }
        } else if (size < 1) {
            size = .;
        }
        
        //build the results
        for (int i = 0; i < sizei++) {
            count++;
            if (!rs.next()) {
                break;
            }
            response.addRow(rs);
        }
        
        //set the count
        if (getCount) {
            if (!cache) {
                while (rs.next()) {
                    count++;
                }
            } else {
                rs.last();
                count = rs.getRow();
            }
        }
        response.setCount(count);
        
        //set the skipToken if needed
        if (cache && response.size() == pageSize) {
            long end = skipSize + response.size();
            if (getCount) {
                if (end < Math.min(topcount)) {
                    response.setNextToken(nextToken(cachesessionIdend));
                }
            } else if (rs.next()) {
                response.setNextToken(nextToken(cachesessionIdend));
                //will force the entry to cache or is effectively a no-op when already cached
                rs.last();    
            }
        }
    }
    
    private String nextToken(boolean cacheString sessionidlong skip) {
        if (cache) {
            return sessionid++String.valueOf(skip);
        }
        return String.valueOf(skip);
    }
    
    private int skip(boolean cachefinal ResultSet rsint skipSize)
            throws SQLException {
        int skipped = 0;
        if (!cache) {
            for (int i = 0; i < skipSizei++) {
                skipped++;
                if (!rs.next()) {
                    break;
                }
            }
        } else {
            rs.absolute(skipSize);
        }
        return skipped;
    }
    @Override
    public CountResponse executeCount(Query queryList<SQLParameterparameters)  throws SQLException {
        String sql = query.toString();
        LogManager.logDetail(."Teiid-Query:"sql); //$NON-NLS-1$
        final PreparedStatement stmt = getConnection().prepareStatement(sql);
        if (!parameters.isEmpty()) {
            for (int i = 0; i < parameters.size(); i++) {
                stmt.setObject(i + 1, parameters.get(i).getValue(),
                        parameters.get(i).getSqlType());
            }
        }
        ResultSet rs = stmt.executeQuery();
        rs.next();
        final int count = rs.getInt(1);
        rs.close();
        stmt.close();
        return new CountResponse() {
            @Override
            public int getCount() {
                return count;
            }
        };
    }
    @Override
    public UpdateResponse executeUpdate(Command queryList<SQLParameterparameters)  throws SQLException {
        String sql = query.toString();
        LogManager.logDetail(."Teiid-Query:"sql); //$NON-NLS-1$
        final PreparedStatementImpl stmt = getConnection().prepareStatement(sql,
                ..,
                .,
                .);
        if (!parameters.isEmpty()) {
            for (int i = 0; i < parameters.size(); i++) {
                stmt.setObject(i + 1, parameters.get(i).getValue(),
                        parameters.get(i).getSqlType());
            }
        }
        final int count = stmt.executeUpdate();
        final Map<StringObjectkeys = getGeneratedKeys(stmt.getGeneratedKeys());
        stmt.close();
        return new UpdateResponse() {
            @Override
            public Map<StringObjectgetGeneratedKeys() {
                return keys;
            }
            @Override
            public int getUpdateCount() {
                return count;
            }
        };
    }
    private Map<StringObjectgetGeneratedKeys(ResultSet result)
            throws SQLException {
        if (result == null) {
            return null;
        }
        HashMap<StringObjectkeys = new HashMap<StringObject>();
        ResultSetMetaData metadata = result.getMetaData();
        // now read the values
        while (result.next()) {
            for (int i = 0; i < metadata.getColumnCount(); i++) {
                String label = metadata.getColumnLabel(i + 1);
                keys.put(labelresult.getObject(i + 1));
            }
        }
        return keys;
    }
    @Override
    public String getProperty(String key) {
        return this..getProperty(key);
    }
    @Override
    public String startTransaction() throws SQLException {
        getConnection().setAutoCommit(false);
        return "anyid";
    }
    @Override
    public void commit(String txnIdthrows SQLException {
        getConnection().commit();
        getConnection().setAutoCommit(true);
    }
    @Override
    public void rollback(String txnId)  throws SQLException {
        getConnection().rollback();
        getConnection().setAutoCommit(true);
    }
New to GrepCode? Check out our FAQ X