Java ARRAY类代码示例

import oracle.sql.ARRAY; //导入依赖的package包/类
/** write statement call to log
 *
 * @param userid
 * @param localId
 * @param roles
 * @param newArray
 */
private void debugStatement(String userid, final String localId, final Object[] roles, final ARRAY newArray) {
    StringBuffer buf = new StringBuffer("call jaffa_sec.set_userid(?,?,?) with arg1='")
    .append(userid)
    .append("', arg2='")
    .append(newArray)
    .append("'");
    if (roles != null) {
        buf.append(". Arg2 has the roles: ");
        for (int i = 0; i < roles.length; i++) {
            if (i > 0)
                buf.append(',');
            buf.append(roles[i]);
        }
    }
    buf.append(", arg3='");
    buf.append(localId);
    buf.append("'");

    log.debug(buf.toString());
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
/** 
* Essa funcao serve para converer um array em Um aray SQL
* @param array O array a ser convertido para o array de base de dados
* @param connect A conexao que sera usada
* @param arrayTypeDataBase nome do aray na base de dados que ira receber o aray
*       CASO for nulo sera mapeado para o TB_ARRAY_STRING
* @return 
*/
public static Array createSQLArrayVarchar (Object [] array, Connection connect, String arrayTypeDataBase)
{
    try 
    {
        arrayTypeDataBase = (arrayTypeDataBase == null)? "TB_ARRAY_STRING": arrayTypeDataBase;
        ArrayDescriptor arryDesc = ArrayDescriptor.createDescriptor(arrayTypeDataBase, connect);
        Array oracleArray = new ARRAY(arryDesc, connect, array);
        OracleConnection oc = (OracleConnection) connect;
        return  oracleArray;
    } catch (SQLException ex) {
        ex.printStackTrace();
        
    }
    return null;
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
/**
 * Tratar o retorno vido do java
 * @param result
 * @param returnType
 * @return 
 */
@SuppressWarnings("CallToPrintStackTrace")
private static Object treatReturn (Object result, int returnType)
{
    Object currectObject = result;
    try
    {
        if (returnType == ARRAY && result instanceof Array)
        {
            Array r = (Array) result;
            currectObject = new ArrayList<> (Arrays.asList((Object [])r.getArray()));
        }
        else if (Types.STRUCT == returnType)
        {
            System.out.println("dbdkj");
            currectObject = ((Struct) result).getAttributes();
        }
    }catch(Exception ex)
    {
        ex.printStackTrace();
    }
    if(currectObject != null)
        
        System.out.println("RETURN = class{"+currectObject.getClass().getName()+"} | toString = "+currectObject.toString()+"\n");
    return currectObject;
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
/**
 * delegated back to DBDriver to take care of driver related issues between
 * Oracle and standard SQL
 *
 * @param con
 * @param values
 * @param dbArrayType
 *            as defined in the RDBMS
 * @return object that is suitable to be assigned to an array parameter
 * @throws SQLException
 */
public static Array createArray(Connection con, Value[] values,
		String dbArrayType) throws SQLException {
	Object[] data = new Object[values.length];
	for (int i = 0; i < values.length; i++) {
		Value val = values[i];
		if (val != null) {
			data[i] = val.toObject();
		}
	}
	if (dbVendor == DbVendor.ORACLE) {
		OracleConnection ocon = toOracleConnection(con);
		ArrayDescriptor ad = ArrayDescriptor.createDescriptor(dbArrayType,
				ocon);
		return new ARRAY(ad, ocon, data);
	}
	return con.createArrayOf(dbArrayType, data);
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
@Override
public void setNonNullParameter(PreparedStatement ps, int i, List<String> parameter, JdbcType jdbcType) throws SQLException {
	Connection c = ps.getConnection();
	if (c instanceof DelegatingConnection) {
		Connection pooledConnection = c;
		c = ((DelegatingConnection<?>)c).getInnermostDelegate();
		if (c == null) {
			throw new RuntimeException("Database resource pool configuration error: " + pooledConnection.getClass().getName());
		}
	}

	//drsteini - added to support junit testing
	if (c.isWrapperFor(oracle.jdbc.OracleConnection.class)) {
		c = c.unwrap(oracle.jdbc.OracleConnection.class);
	}

	ArrayDescriptor descriptor = ArrayDescriptor.createDescriptor("TYP_VCTBL", c);
	Array array = new ARRAY(descriptor, c, parameter.toArray());
	ps.setArray(i, array);
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
private void registerOutput(Connection conn, CallableStatement callStmt, CallArgument argument,
        List<Out> outputs) throws SQLException {
    if (argument == null) {
        return;
    }
    AdapterMapping outputAdapter = getOutputAdapter(argument, outputs);
    int argumentIndex = argument.getSequence();
    int argumentType = argument.getSqlType();
    String argumentTypeName = getArgumentTypeName(outputAdapter, argument.getTypeName());
    if (isStructType(argument)) {
        argumentType = Types.STRUCT;
        callStmt.registerOutParameter(argumentIndex, argumentType, argumentTypeName);
    } else if (isArrayOfStructType(argument)) {
        argumentType = Types.ARRAY;
        callStmt.registerOutParameter(argumentIndex, argumentType, argumentTypeName);
    } else {
        callStmt.registerOutParameter(argumentIndex, argumentType);
    }
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
@Before
public void setUp() throws SQLException, IOException, MjdbcException {
    MockitoAnnotations.initMocks(this);

    when(stmt.getConnection()).thenReturn(conn);
    when(conn.createARRAY(any(String.class), any(Object[].class))).thenReturn(array);

    when(blob.setBinaryStream(1)).thenReturn(output);
    when(clob.setAsciiStream(1)).thenReturn(output);

    when(input.read(any(byte[].class))).thenReturn(-1);
    when(input.read(any(byte[].class), any(int.class), any(int.class))).thenReturn(-1);

    when(blob.getBinaryStream()).thenReturn(input);
    when(clob.getAsciiStream()).thenReturn(input);

    params = new QueryParameters();

    params.set("array_list", Arrays.asList("Superman"), MjdbcTypes.ARRAY);
    params.set("blob_byte", "Batman", MjdbcTypes.BLOB);
    params.set("clob_byte", "Wolverine", MjdbcTypes.CLOB);

    params.set("array", array, MjdbcTypes.ARRAY);
    params.set("blob", blob, MjdbcTypes.BLOB);
    params.set("clob", clob, MjdbcTypes.CLOB);
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
public static void createAndEvaluateReport(final String statement, final String methodName, final BLOB template, final ARRAY arguments, final ARRAY[] result) throws SQLException, IOException {
	final Report report;
	boolean isStatementBased = statement != null && statement.trim().length() != 0;
	boolean isFunctionBased = methodName != null && methodName.trim().length() != 0;
	final InputStream $template = template == null ? null : template.getBinaryStream();
	if(isStatementBased && !isFunctionBased)
		report = reportEngine.createReportFromStatement(statement, $template);
	else if(isFunctionBased && !isStatementBased)
		report = reportEngine.createReport(methodName, $template, extractVargs(arguments));
	else {
		if($template != null)
			$template.close();
		throw new RuntimeException("A report must either be statement or function based!");
	}
	
	result[0] = convertListOfCellsToOracleArray(report.evaluateWorkbook());
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
public List<O2MSyncEventLog> readData(Array oraArray) throws SQLException {
	List<O2MSyncEventLog> eventLogList = null;
	Object[] eventLogArr = (Object[]) oraArray.getArray();
	if (eventLogArr != null && eventLogArr.length > 0) {
		eventLogList = new ArrayList<O2MSyncEventLog>();
		O2MSyncEventLog eventLog = null;
		for (int i = 0; i < eventLogArr.length; i++) {
			eventLog = new O2MSyncEventLog();
			STRUCT attrArrStruct = (STRUCT) eventLogArr[i];
			Object [] attrArr = attrArrStruct.getAttributes();
			eventLog.setLogId(new ObjectId());
			eventLog.setEventId(String.valueOf(attrArr[0]).trim());
			eventLog.setOperation(String.valueOf(attrArr[1]));
			java.sql.Timestamp crOn = (java.sql.Timestamp) attrArr[2];
			if (crOn != null) {
				eventLog.setCrOn(new Date(crOn.getTime()));
			} else {
				eventLog.setCrOn(new Date());
			}
			ARRAY oraFilters = (ARRAY) attrArr[6];
			Object[] filterStructArr = (Object[]) oraFilters.getOracleArray();
			if (filterStructArr != null && filterStructArr.length > 0) {
				List<O2MSyncEventInfo> filterList = new ArrayList<O2MSyncEventInfo>();
				O2MSyncEventInfo filter = null;
				for (int j = 0 ; j < filterStructArr.length; j++) {
					STRUCT filterAttrArrStruct = (STRUCT) filterStructArr[j];
					Object[] filterAttrArr = filterAttrArrStruct.getAttributes();
					filter = new O2MSyncEventInfo();
					filter.setTableName(String.valueOf(filterAttrArr[0]).trim());
					filter.setColumnName(String.valueOf(filterAttrArr[1]).trim());
					filter.setColumnValue(String.valueOf(filterAttrArr[2]));
					filterList.add(filter);
				}
				eventLog.setEventFilters(filterList);
			}
			eventLogList.add(eventLog);
		}
	}
	return eventLogList;
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
protected void executeStoredProcedure(final Connection pooledConnection, final String userid) throws java.sql.SQLException {
    CallableStatement cs = null;

    final String localId = (String) ContextManagerFactory.instance().getProperty(LOCAL_ID);
    Object[] roles = getUserRoles(userid).toArray();
    ARRAY newArray = null;

    Connection connection = null;
    try {
        // Extract the actual oracle connection
        connection = pooledConnection.unwrap(oracle.jdbc.OracleConnection.class);
        if (!(connection instanceof oracle.jdbc.OracleConnection)) {
        	throw new Exception(String.format("Not an Oracle Connection : %s",connection.getClass().getName()));
        }

        cs = connection.prepareCall(CALL_JAFFA_SEC_SET_USERID);
        cs.setString(1,userid);

        newArray = ((oracle.jdbc.OracleConnection)connection).createARRAY(ROLE,roles);
        cs.setArray(2,newArray);
        cs.setString(3,localId);

        if (log.isDebugEnabled()) {
            // Log the call to the stored procedure
            debugStatement(userid, localId, roles, newArray);
        }

        if(log.isDebugEnabled()) log.debug("Calling the Stored Procedure to Set the Context");
        cs.execute();
        connection.commit();
    }
    catch (Exception exception) {
    	final String message = String.format(String.format(SET_THE_CONTEXT_ERROR_MESSAGE,exception.getMessage()));
        log.error(message, exception);
        if (connection != null)
        	connection.rollback();
        throw new UOWSecurityException(message, exception);
    }
    finally {
        roles = null;
        if (newArray != null)
            newArray.free();
        if (cs != null) {
            cs.clearParameters();
            cs.close();
            cs = null;
        }
    }
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
/**
 * Funcao para   invocara as funcaoe simples da base de dado
 * Serve para invocar as funcoes que se deve usar o {? = call ...}
 * @param functionName O nome da funcao em base de dados que se quer chamar
 * @param returnType O que sera retornado por ela
 * @param parans Os parametros de entrada na funcao {Atencao que a ordem dos parametros deve ser igual a sua ordem na base de dados}
 * @return O retorno sera um objecto do tipo definido
 */
@SuppressWarnings("CallToPrintStackTrace")
public static Object callSampleFunction (String functionName, int returnType, Object ... parans)
{
    if(!EstadoConnexao.isValid) return null;
    try 
    {
        CallableStatement call;
        Object result;
        // Criar as interoganocoes necessaria para a invocacao da funcao ex (?, ?, ?, ...) || nada
        try (Connection con = new Conexao().getCon()) 
        {
            if(con==null)
            {
                return null;
            }
            // Criar as interoganocoes necessaria para a invocacao da funcao ex (?, ?, ?, ...) || nada
            String interogations = (parans != null && parans.length>0)? createInterogation(parans.length): "";
            //Associa ao call e o nome da funcao
            String sql = "{? = call "+functionName+interogations+"}";
            //Mapear e setar os parametros no call
            call = mapParamsType(con, sql, 2, parans);
            if (returnType == Call.ARRAY) call.registerOutParameter(1, ARRAY, "TB_ARRAY_STRING");
            else if(returnType == Types.STRUCT) 
                call.registerOutParameter(1,returnType, "TP_OBJECT");
            else 
                call.registerOutParameter(1, returnType);
            call.execute();
            result = Call.treatReturn(call.getObject(1), returnType);
            
        }call.close();
        return  result;
            
    } catch (Exception e) {
        e.printStackTrace();
    }
    return  null;
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
private TypeDescriptor getTypeDescriptor(Connection nativeConn, int dataType, String dataTypeName)
        throws SQLException {
    if (dataType == Types.STRUCT) {
        StructDescriptor structDescriptor = StructDescriptor.createDescriptor(dataTypeName, nativeConn);
        return structDescriptor;
    }
    if (dataType == Types.ARRAY) {
        ArrayDescriptor arrayDescriptor = ArrayDescriptor.createDescriptor(dataTypeName, nativeConn);
        return arrayDescriptor;
    }
    return null;
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
@Before
public void setUp() throws SQLException, IOException, MjdbcException {
    MockitoAnnotations.initMocks(this);

    when(stmt.getConnection()).thenReturn(conn);
    when(conn.createARRAY(any(String.class), any(Object[].class))).thenReturn(array);
    when(MappingUtils.invokeFunction(conn, "createBlob", new Class[]{}, new Object[]{})).thenReturn(blob);
    when(MappingUtils.invokeFunction(conn, "createClob", new Class[]{}, new Object[]{})).thenReturn(clob);

    when(blob.setBinaryStream(1)).thenReturn(output);
    when(clob.setAsciiStream(1)).thenReturn(output);

    when(input.read(any(byte[].class))).thenReturn(-1);
    when(input.read(any(byte[].class), any(int.class), any(int.class))).thenReturn(-1);

    when(blob.getBinaryStream()).thenReturn(input);
    when(clob.getAsciiStream()).thenReturn(input);

    params = new QueryParameters();

    params.set("array_list", Arrays.asList("Superman"), MjdbcTypes.ARRAY);
    params.set("blob_byte", "Batman", MjdbcTypes.BLOB);
    params.set("clob_byte", "Wolverine", MjdbcTypes.CLOB);

    params.set("array", array, MjdbcTypes.ARRAY);
    params.set("blob", blob, MjdbcTypes.BLOB);
    params.set("clob", clob, MjdbcTypes.CLOB);
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
private static String[] extractVargs(final ARRAY arguments) throws SQLException {
	final String[] $arguments;
	if(arguments == null)
		$arguments = new String[0];
	else {
		$arguments = new String[arguments.length()];
		final ResultSet hlp = arguments.getResultSet();
		int i = 0;
		while(hlp.next()) {
			// The actual data resides at index 2
			$arguments[i++] = hlp.getString(2);
		}
	}
	return $arguments;
}
 

import oracle.sql.ARRAY; //导入依赖的package包/类
private static ARRAY convertListOfCellsToOracleArray(final List<CellDefinition> cellDefinitions) throws SQLException {
	final StructDescriptor resultStruct = StructDescriptor.createDescriptor("T_ER_CELL_DEFINITION", connection);
	final ArrayDescriptor  arrayDesc = ArrayDescriptor.createDescriptor("TABLE_OF_ER_CELL_DEFINITIONS", connection);
	
	final STRUCT[] rv = new STRUCT[cellDefinitions.size()];						
	int i=0;
	for(CellDefinition cellDefinition : cellDefinitions)
		rv[i++] = new STRUCT(resultStruct, connection, cellDefinition.toSQLStructObject());		
	return new ARRAY(arrayDesc, connection, rv);
}