Sets the designated parameter to the given java.sql.Blob object.
433984
@Override
    public void setBlob(String parameterName, Blob x) throws SQLException
    {
        checkClosed();
        throw SQLError.noSupport();
    }
908959
@Override
    public void updateBlob(String columnLabel, InputStream inputStream,
            long length) throws SQLException {
        throw SQLError.noSupport();
    }
1304010
public void setDBModified(int mode) {

        String value = MODIFIED_NO;

        if (mode == FILES_MODIFIED) {
            value = MODIFIED_YES;
        } else if (mode == FILES_NEW) {
            value = MODIFIED_NEW;
        }

        setProperty(db_modified, value);
        save();
    }
89740
@Override
    public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException
    {
        checkClosed();
        throw SQLError.noSupport();
    }
1133935
@Override
    public void setNClob(String parameterName, Reader reader) throws SQLException
    {
        checkClosed();
        throw SQLError.noSupport();
    }
809874
private void setParameter(PreparedStatement preparedStatement, int param, Object value) throws SQLException {
		if (value instanceof Enum<?>) {
			Enum<?> e = (Enum<?>) value;
			value = e.ordinal();
		} else if (value instanceof LocalDate) {
			value = java.sql.Date.valueOf((LocalDate) value);
		} else if (value instanceof LocalTime) {
			value = java.sql.Time.valueOf((LocalTime) value);
		} else if (value instanceof LocalDateTime) {
			value = java.sql.Timestamp.valueOf((LocalDateTime) value);
		}
		preparedStatement.setObject(param, value);
	}
931710
public void set(Object data, int iOpenMode) throws DBException, RemoteException
    {
        if (m_objCurrentKey == null)
            throw new DBException(Constants.INVALID_RECORD);
        Object key = this.getKey(data);
        if (!key.equals(m_objCurrentKey))
            m_mDataMap.remove(key);
        m_mDataMap.put(key, data);      // Replace the data at this position
        m_objCurrentKey = null;
    }
1118720
@Override
    public void setClob(int parameterIndex, Clob x) throws SQLException {
        internalStmt.setClob(parameterIndex, x);
    }
628225
@Override
	public SqlContext inOutParamIfAbsent(final String parameterName, final Object value, final int sqlType) {
		if (!hasParam(parameterName)) {
			inOutParam(parameterName, value, sqlType);
		}
		return this;
	}
696092
@Override
    public void setBytes(int parameterIndex, byte[] x) throws SQLException
    {
        checkParameterBounds(parameterIndex);
        this.parameters[parameterIndex-1] = x;
    }
96899
public void set(Object data, int iOpenMode) throws DBException, RemoteException
    {
        BaseTransport transport = this.createProxyTransport(SET);
        transport.addParam(DATA, data);
        transport.addParam(OPEN_MODE, iOpenMode);
        Object strReturn = transport.sendMessageAndGetReply();
        Object objReturn = transport.convertReturnObject(strReturn);
        this.checkDBException(objReturn);
    }
182110
@Override
    public Blob loadForID(String id) throws SQLException {
        Connection c = dataSource.getConnection();
        PreparedStatement preparedStatement = c.prepareStatement(loadStatement());
        preparedStatement.setString(1, id);
        ResultSet r = preparedStatement.executeQuery();
        if (r.wasNull() || !r.next()) {
            return null;
        } else {
            Blob first = r.getBlob(2);
            return first;
        }


    }
76169
@Override
	public void updateBlob(final int columnIndex, final Blob x) throws SQLException {
		wrapped.updateBlob(columnIndex, x);
	}
71725
@Override
    public void setClob(int parameterIndex, Reader reader) throws SQLException {
        internalStmt.setClob(parameterIndex, reader);
    }
465122
void setValue(int parameterIndex, PreparedStatement preparedStatement,
			Class<?> fieldType, Object fieldValue) throws Exception {

		try {

			if (fieldType == String.class) {
				preparedStatement
						.setString(parameterIndex, (String) fieldValue);
			} else if (fieldType == java.sql.Timestamp.class) {
				preparedStatement.setTimestamp(parameterIndex,
						(java.sql.Timestamp) fieldValue);
			} else if (fieldType == java.sql.Date.class) {
				preparedStatement.setDate(parameterIndex,
						(java.sql.Date) fieldValue);
			} else if (fieldType == java.sql.Time.class) {
				preparedStatement.setTime(parameterIndex,
						(java.sql.Time) fieldValue);
			} else if (fieldType == boolean.class || fieldType == Boolean.class) {

				if (fieldValue != null) {
					boolean boolValue = (boolean) (Boolean) fieldValue;
					preparedStatement.setInt(parameterIndex,
							(boolValue ? 1 : 0));
				} else {
					preparedStatement.setInt(parameterIndex, 0);

				}
			} else if (fieldType == int.class || fieldType == Integer.class) {

				if (fieldValue != null) {
					preparedStatement.setInt(parameterIndex,
							(int) (Integer) fieldValue);
				} else {
					preparedStatement.setNull(parameterIndex,
							java.sql.Types.INTEGER);
				}
			} else if (fieldType == long.class || fieldType == Long.class) {

				if (fieldValue != null) {
					preparedStatement.setLong(parameterIndex,
							(long) (Long) fieldValue);
				} else {
					preparedStatement.setNull(parameterIndex,
							java.sql.Types.INTEGER);
				}
			} else if (fieldType == float.class || fieldType == Float.class) {

				if (fieldValue != null) {
					preparedStatement.setFloat(parameterIndex,
							(float) (Float) fieldValue);
				} else {
					preparedStatement.setNull(parameterIndex,
							java.sql.Types.FLOAT);
				}

			} else if (fieldType == double.class || fieldType == Double.class) {

				if (fieldValue != null) {
					preparedStatement.setDouble(parameterIndex,
							(double) (Double) fieldValue);
				} else {
					preparedStatement.setNull(parameterIndex,
							java.sql.Types.DOUBLE);
				}

			} else {
				final String msg = "Unknown data type. type=" + fieldType
						+ " value=" + fieldValue;
				loge(msg);
				throw new RuntimeException(msg);
			}
		} catch (Exception e) {
			loge("#setValue", e);
			throw e;
		}

	}
109160
@Override
    public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException
    {
        checkParameterBounds(parameterIndex);
        switch(targetSqlType)
        {
            case Types.TINYINT:
                setByte(parameterIndex, ((Byte)x).byteValue());
                break;
            case Types.SMALLINT:
                setShort(parameterIndex, ((Short)x).shortValue());
                break;
            case Types.INTEGER:
                setInt(parameterIndex, ((Integer)x).intValue());
                break;
            case Types.BIGINT:
                setLong(parameterIndex, ((Long)x).longValue());
                break;
            case Types.DOUBLE:
                setDouble(parameterIndex, ((Double)x).doubleValue());
                break;
            case Types.DECIMAL:
                setBigDecimal(parameterIndex, (BigDecimal)x);
                break;
            case Types.TIMESTAMP:
                setTimestamp(parameterIndex, (Timestamp)x);
                break;
            case Types.VARBINARY:
            case Types.VARCHAR:
            case Types.NVARCHAR:
                setString(parameterIndex, (String)x);
                break;
            case Types.OTHER:
                setObject(parameterIndex, x);
                break;
            default:
                throw SQLError.get(SQLError.ILLEGAL_ARGUMENT);
        }
    }
533460
@Override
    public void setNClob(int parameterIndex, NClob value) throws SQLException
    {
        checkParameterBounds(parameterIndex);
        throw SQLError.noSupport();
    }