Registers an output parameter into the statement.

@param key parameter key.
@param type parameter SQL type code.
@param struct parameter structured type name (optional).
@throws SQLException if error occurs while registering parameter.

@since v1.0
188743
public void out(Object key, int type, String struct) throws SQLException {
        if (key instanceof Integer) {
            if (struct == null) {
                base.registerOutParameter((Integer) key, type);
            } else {
                base.registerOutParameter((Integer) key, type, struct);
            }
        } else {
            if (struct == null) {
                base.registerOutParameter((String) key, type);
            } else {
                base.registerOutParameter((String) key, type, struct);
            }
        }
    }
1002817
@Override
    public void setParam(String key, INDArray val) {
        //Set params for MultiLayerNetwork sub layers.
        int idx = key.indexOf('_');
        if (idx == -1)
            throw new IllegalStateException("Invalid param key: not have layer separator: \"" + key + "\"");
        int layerIdx = Integer.parseInt(key.substring(0, idx));
        String newKey = key.substring(idx + 1);

        layers[layerIdx].setParam(newKey, val);
    }
1335460
public function bindParam($column, &$param, $type = null)
    {
        if ($type === null) :
            $this->_statement->bindParam($column, $param);
        else :
            $this->_statement->bindParam($column, $param, $type);
        endif;
    }
521154
public void setParameterType(String type) {
		String typeName;
		if (Strings.isEmpty(type)) {
			typeName = Object.class.getName();
		} else {
			typeName = type;
		}
		this.parameter.setParameterType(newTypeRef(this.context, typeName));
	}
863646
public void setNull(String parameterName, int sqlType) throws SQLException {
		checkClosed();
		try {
			this.internalCallableStatement.setNull(parameterName, sqlType);
			if (this.logStatementsEnabled){
				this.logParams.put(parameterName, PoolUtil.safePrint("[SQL NULL type ", sqlType, "]"));
			}
		} catch (SQLException e) {
			throw this.connectionHandle.markPossiblyBroken(e);
			
		}
	}
931794
public void register(String table, String column, Class<?> javaType) {
        register(table, column, javaTypeMapping.getType(javaType));
    }
43309
public void put(String key, Long value) {
		if (this.compiledStatement != null) {
			if (value == null) {
				this.compiledStatement.bindNull(compiledStatementBindIndex++);
			} else {
				compiledStatement.bindLong(compiledStatementBindIndex++, (long) value);
			}
		} else if (values != null) {
			values.put(key, value);
			return;
		}

		names.add(key);		
		args.add(value);
		valueType.add(ParamType.LONG);
	}
989286
private void writeODataType(StructuredType structuredType) throws IOException {
        if (entitySet != null) {
            String typeName = entitySet.getTypeName();
            String type = typeName.substring(typeName.lastIndexOf(".") + 1, typeName.length());

            if (!type.equals(structuredType.getName())) {
                jsonGenerator.writeStringField(TYPE, String.format("#%s.%s",
                        structuredType.getNamespace(), structuredType.getName()));
            } else {
                LOG.trace("{} has root level. {} won't be written here", entitySet.getName(), TYPE);
            }
        }
    }
620710
public void _serializeStruct(PageContext pc, Set test, Struct struct, StringBuilder sb, boolean serializeQueryByColumns, boolean addUDFs, Set<Object> done)
	    throws ConverterException {

	ApplicationContextSupport acs = (ApplicationContextSupport) pc.getApplicationContext();
	boolean preserveCase = acs.getSerializationSettings().getPreserveCaseForStructKey(); // preserve case by default for Struct

	// Component
	if (struct instanceof Component) {
	    String res = castToJson(pc, (Component) struct, NULL_STRING);
	    if (res != NULL_STRING) {
		sb.append(res);
		return;
	    }
	}

	sb.append(goIn());
	sb.append("{");

	Iterator<Entry<Key, Object>> it = struct.entryIterator();
	Entry<Key, Object> e;
	String k;
	Object value;
	boolean doIt = false;
	while (it.hasNext()) {

	    e = it.next();
	    k = e.getKey().getString();
	    if (!preserveCase) k = k.toUpperCase();
	    value = e.getValue();

	    if (!addUDFs && (value instanceof UDF || value == null)) continue;

	    if (doIt) sb.append(',');

	    doIt = true;
	    sb.append(StringUtil.escapeJS(k, '"', charsetEncoder));
	    sb.append(':');
	    _serialize(pc, test, value, sb, serializeQueryByColumns, done);
	}

	if (struct instanceof Component) {
	    Boolean remotingFetch;
	    Component comp = (Component) struct;
	    boolean isPeristent = false;
	    isPeristent = comp.isPersistent();

	    Property[] props = comp.getProperties(false, true, false, false);
	    ComponentScope scope = comp.getComponentScope();
	    for (int i = 0; i < props.length; i++) {
		if (!ignoreRemotingFetch) {
		    remotingFetch = Caster.toBoolean(props[i].getDynamicAttributes().get(REMOTING_FETCH, null), null);
		    if (remotingFetch == null) {
			if (isPeristent && ORMUtil.isRelated(props[i])) continue;
		    }
		    else if (!remotingFetch.booleanValue()) continue;

		}
		Key key = KeyImpl.getInstance(props[i].getName());
		value = scope.get(key, null);
		if (!addUDFs && (value instanceof UDF || value == null)) continue;
		if (doIt) sb.append(',');
		doIt = true;
		sb.append(StringUtil.escapeJS(key.getString(), '"', charsetEncoder));
		sb.append(':');
		_serialize(pc, test, value, sb, serializeQueryByColumns, done);
	    }
	}

	sb.append('}');
    }
696961
void registerExecutionVertex(final ExecutionVertex vertex) {

		if (this.vertexMap.put(vertex.getID(), vertex) != null) {
			throw new IllegalStateException("There is already an execution vertex with ID " + vertex.getID()
				+ " registered");
		}
	}
713307
public void put(String key, BigDecimal value) {
		if (this.compiledStatement != null) {
			if (value == null) {
				this.compiledStatement.bindNull(compiledStatementBindIndex++);
			} else {
				compiledStatement.bindString(compiledStatementBindIndex++, value.toPlainString());
			}
		} else if (values != null) {
			values.put(key, value.toPlainString());
			return;
		}

		names.add(key);
		// values.put(key, value);
		args.add(value);
		valueType.add(ParamType.INTEGER);
	}
743630
protected void writeTypeEntry(StringBuilder sb, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
        sb.append("Type:");
        sb.append(getStatementType(execInfo.getStatementType()));
        sb.append(", ");
    }
292289
public void put(String key, Character value) {
		if (this.compiledStatement != null) {
			if (value == null) {
				this.compiledStatement.bindNull(compiledStatementBindIndex++);
			} else {
				compiledStatement.bindLong(compiledStatementBindIndex++, Character.getNumericValue(value));
			}
		} else if (values != null) {
			values.put(key, Character.getNumericValue(value));
			return;
		}

		names.add(key);
		// values.put(key, value);
		args.add(value);
		valueType.add(ParamType.CHARACTER);
	}
471434
private function bind($key, $value, $bindDataType)
    {
        $this->sqlQuery->bindValue($key, $value, $bindDataType);
    }
1229692
public void put(String key, byte[] value) {
		if (this.compiledStatement != null) {
			if (value == null) {
				this.compiledStatement.bindNull(compiledStatementBindIndex++);
			} else {
				compiledStatement.bindBlob(compiledStatementBindIndex++, value);
			}
		} else if (values != null) {
			values.put(key, value);
			return;
		}

		names.add(key);
		// values.put(key, value);
		args.add(value);
		valueType.add(ParamType.BYTE_ARRAY);
	}
1289708
public void writeData(int l, Type[] types, Object[] data,
                          HashMappedList cols, int[] primaryKeys) {

        boolean hasPK = primaryKeys != null && primaryKeys.length != 0;
        int     limit = hasPK ? primaryKeys.length
                              : l;

        for (int i = 0; i < limit; i++) {
            int    j = hasPK ? primaryKeys[i]
                             : i;
            Object o = data[j];
            Type   t = types[j];

            if (cols != null) {
                ColumnSchema col = (ColumnSchema) cols.get(j);

                writeFieldPrefix();
                writeString(col.getName().statementName);
            }

            if (o == null) {
                writeNull(t);

                continue;
            }

            writeFieldType(t);

            switch (t.typeCode) {

                case Types.SQL_ALL_TYPES :
                    throw Error.runtimeError(
                        ErrorCode.U_S0500, "RowOutputBase");
                case Types.SQL_CHAR :
                case Types.SQL_VARCHAR :
                case Types.VARCHAR_IGNORECASE :
                    writeChar((String) o, t);
                    break;

                case Types.TINYINT :
                case Types.SQL_SMALLINT :
                    writeSmallint((Number) o);
                    break;

                case Types.SQL_INTEGER :
                    writeInteger((Number) o);
                    break;

                case Types.SQL_BIGINT :
                    writeBigint((Number) o);
                    break;

                case Types.SQL_REAL :
                case Types.SQL_FLOAT :
                case Types.SQL_DOUBLE :
                    writeReal((Double) o);
                    break;

                case Types.SQL_NUMERIC :
                case Types.SQL_DECIMAL :
                    writeDecimal((BigDecimal) o, t);
                    break;

                case Types.SQL_BOOLEAN :
                    writeBoolean((Boolean) o);
                    break;

                case Types.SQL_DATE :
                    writeDate((TimestampData) o, t);
                    break;

                case Types.SQL_TIME :
                case Types.SQL_TIME_WITH_TIME_ZONE :
                    writeTime((TimeData) o, t);
                    break;

                case Types.SQL_TIMESTAMP :
                case Types.SQL_TIMESTAMP_WITH_TIME_ZONE :
                    writeTimestamp((TimestampData) o, t);
                    break;

                case Types.SQL_INTERVAL_YEAR :
                case Types.SQL_INTERVAL_YEAR_TO_MONTH :
                case Types.SQL_INTERVAL_MONTH :
                    writeYearMonthInterval((IntervalMonthData) o, t);
                    break;

                case Types.SQL_INTERVAL_DAY :
                case Types.SQL_INTERVAL_DAY_TO_HOUR :
                case Types.SQL_INTERVAL_DAY_TO_MINUTE :
                case Types.SQL_INTERVAL_DAY_TO_SECOND :
                case Types.SQL_INTERVAL_HOUR :
                case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
                case Types.SQL_INTERVAL_HOUR_TO_SECOND :
                case Types.SQL_INTERVAL_MINUTE :
                case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
                case Types.SQL_INTERVAL_SECOND :
                    writeDaySecondInterval((IntervalSecondData) o, t);
                    break;

                case Types.OTHER :
                    writeOther((JavaObjectData) o);
                    break;

                case Types.SQL_BLOB :
                    writeBlob((BlobData) o, t);
                    break;

                case Types.SQL_CLOB :
                    writeClob((ClobData) o, t);
                    break;

                case Types.SQL_BINARY :
                case Types.SQL_VARBINARY :
                    writeBinary((BinaryData) o);
                    break;

                case Types.SQL_BIT :
                case Types.SQL_BIT_VARYING :
                    writeBit((BinaryData) o);
                    break;

                default :
                    throw Error.runtimeError(
                        ErrorCode.U_S0500,
                        t.getNameString());
            }
        }
    }
328216
private void registerMethod(Class<?> type, Method method) {
    Class<?> returnType = method.getReturnType();
    if (returnType == void.class || returnType == Void.class) {
      registerVoidMethod(type, method);
    } else {
      registerValueMethod(type, method);
    }
  }