public virtual object Clone() { AbstractDbParameter other = (AbstractDbParameter)MemberwiseClone(); other._parent = null; return(other); }
void Validate(int index, object value) { ValidateType(value); AbstractDbParameter parameter = (AbstractDbParameter)value; if (parameter.Parent != null) { if (parameter.Parent.Equals(this)) { if (IndexOf(parameter) != index) { throw ExceptionHelper.CollectionAlreadyContains(ItemType, "ParameterName", parameter.ParameterName, this); } } else { // FIXME : The OleDbParameter with ParameterName 'MyParam2' is already contained by another OleDbParameterCollection. throw new ArgumentException(""); } } if (parameter.ParameterName == null || parameter.ParameterName == String.Empty) { int newIndex = 1; string parameterName; do { parameterName = "Parameter" + newIndex; newIndex++; }while(IndexOf(parameterName) != -1); parameter.ParameterName = parameterName; } }
private void RemoveIndex(int index) { OnSchemaChanging(); AbstractDbParameter oldItem = (AbstractDbParameter)_list [index]; oldItem.Parent = null; _list.RemoveAt(index); }
int PrepareSimpleQuery(StringBuilder sb, string query, IList userParametersList, int userParametersListStart) { int queryCurrentPosition = 0; int userParametersListPosition = userParametersListStart; if (userParametersList.Count > 0) { for (SimpleMatch m = ParameterRegExp.Match(query); m.Success;m = m.NextMatch()) { SimpleCapture parameterCapture = m; sb.Append(query,queryCurrentPosition,parameterCapture.Index - queryCurrentPosition); // advance in query queryCurrentPosition = parameterCapture.Index + parameterCapture.Length; AbstractDbParameter userParameter = GetUserParameter(parameterCapture.Value, userParametersList, userParametersListPosition); if (userParameter != null) { if (IsNullParameter(userParameter)) { sb.Append("null"); NullParametersInPrepare = true; } else { sb.Append('?'); InternalParameters.Add(userParameter); } // advance in user parameters userParametersListPosition++; } else { sb.Append(parameterCapture.Value); } } } sb.Append(query,queryCurrentPosition,query.Length - queryCurrentPosition); int userParamsConsumed = userParametersListPosition - userParametersListStart; if ((Behavior & CommandBehavior.KeyInfo) == 0) return userParamsConsumed; AbstractDBConnection connection = (AbstractDBConnection)Connection; if (connection == null) return userParamsConsumed; string dbname = connection.JdbcConnection.getMetaData().getDatabaseProductName(); if (dbname == "Microsoft SQL Server") { //must add "FOR BROWSE" for selects #if USE_DOTNET_REGEX if (!SqlStatementsHelper.ForBrowseStatementReqExp.IsMatch(query)) sb.Append(" FOR BROWSE"); #else if (!SqlStatementsHelper.ForBrowseStatementReqExp.matcher ((java.lang.CharSequence)(object)query).find ()) sb.Append (" FOR BROWSE"); #endif } return userParamsConsumed; }
protected virtual AbstractDbParameter GetReturnParameter (IList userParametersList) { AbstractDbParameter param = GetUserParameter ("?", userParametersList, 0); if (param != null && param.Direction == ParameterDirection.ReturnValue) return param; return null; }
protected virtual AbstractDbParameter GetUserParameter(string parameterName, IList userParametersList, int userParametersListPosition) { if (userParametersListPosition < userParametersList.Count) { AbstractDbParameter param = (AbstractDbParameter)userParametersList[userParametersListPosition]; if (param.Placeholder == parameterName) return param; } return null; }
private void Replace(int index, DbParameter value) { Validate(index, value); AbstractDbParameter oldItem = (AbstractDbParameter)this [index]; oldItem.Parent = null; ((AbstractDbParameter)value).Parent = this; _list [index] = value; }
private void FillOutputParameters() { if (!(_statement is CallableStatement)) { return; } for(int i = 0; i < InternalParameters.Count; i++) { AbstractDbParameter parameter = (AbstractDbParameter)InternalParameters[i]; ParameterDirection direction = parameter.Direction; if (((direction & ParameterDirection.Output) != 0) && !SkipParameter(parameter)) { FillOutputParameter(parameter, i); } // drop jdbc type of out parameter, since it possibly was updated in ExecuteReader parameter.IsJdbcTypeSet = false; } }
protected void BindParameters(ArrayList parameters) { for(int parameterIndex = 0; parameterIndex < parameters.Count; parameterIndex++) { AbstractDbParameter parameter = (AbstractDbParameter)parameters[parameterIndex]; switch (parameter.Direction) { case ParameterDirection.Input : BindInputParameter(parameter,parameterIndex); break; case ParameterDirection.InputOutput: BindInputParameter(parameter,parameterIndex); BindOutputParameter(parameter,parameterIndex); break; case ParameterDirection.Output : BindOutputParameter(parameter,parameterIndex); break; case ParameterDirection.ReturnValue : BindOutputParameter(parameter,parameterIndex); break; } } }
protected virtual void BindOutputParameter(AbstractDbParameter parameter, int parameterIndex) { parameter.Validate(); int jdbcType = (int)parameter.JdbcType; // java parameters are 1 based, while .net are 0 based parameterIndex++; CallableStatement callableStatement = ((CallableStatement)_statement); // the scale has a meening only in DECIMAL and NUMERIC parameters if (jdbcType == Types.DECIMAL || jdbcType == Types.NUMERIC) { if(parameter.DbType == DbType.Currency) { callableStatement.registerOutParameter(parameterIndex, jdbcType, 4); } else { callableStatement.registerOutParameter(parameterIndex, jdbcType, parameter.Scale); } } else { callableStatement.registerOutParameter(parameterIndex, jdbcType); } }
protected virtual void BindInputParameter(AbstractDbParameter parameter, int parameterIndex) { object value = parameter.ConvertedValue; // java parameters are 1 based, while .net are 0 based parameterIndex++; PreparedStatement preparedStatement = ((PreparedStatement)_statement); switch ((DbConvert.JavaSqlTypes)parameter.JdbcType) { case DbConvert.JavaSqlTypes.DATALINK: case DbConvert.JavaSqlTypes.DISTINCT: case DbConvert.JavaSqlTypes.JAVA_OBJECT: case DbConvert.JavaSqlTypes.OTHER: case DbConvert.JavaSqlTypes.REF: case DbConvert.JavaSqlTypes.STRUCT: { preparedStatement.setObject(parameterIndex, value, (int)parameter.JdbcType); return; } } if ((value is DBNull) || (value == null)) { preparedStatement.setNull(parameterIndex, (int)((AbstractDbParameter)parameter).JdbcType); } else if (value is long) { preparedStatement.setLong(parameterIndex, (long)value); } else if (value is byte[]) { if (((byte[])value).Length <= 4000) { preparedStatement.setBytes(parameterIndex, vmw.common.TypeUtils.ToSByteArray((byte[]) value)); } else { InputStream iStream=new ByteArrayInputStream(vmw.common.TypeUtils.ToSByteArray((byte[]) value)); preparedStatement.setBinaryStream(parameterIndex,iStream,((byte[])value).Length); } } else if (value is byte) { preparedStatement.setByte(parameterIndex, (sbyte)(byte)value); } else if (value is char[]) { Reader reader = new CharArrayReader((char[])value); preparedStatement.setCharacterStream(parameterIndex,reader,((char[])value).Length); } else if (value is bool) { preparedStatement.setBoolean(parameterIndex, (bool) value); } else if (value is char) { preparedStatement.setString(parameterIndex, ((char)value).ToString()); } else if (value is DateTime) { switch ((DbConvert.JavaSqlTypes)parameter.JdbcType) { default: case DbConvert.JavaSqlTypes.TIMESTAMP: preparedStatement.setTimestamp(parameterIndex,DbConvert.ClrTicksToJavaTimestamp(((DateTime)value).Ticks)); break; case DbConvert.JavaSqlTypes.TIME: preparedStatement.setTime(parameterIndex,DbConvert.ClrTicksToJavaTime(((DateTime)value).Ticks)); break; case DbConvert.JavaSqlTypes.DATE: preparedStatement.setDate(parameterIndex,DbConvert.ClrTicksToJavaDate(((DateTime)value).Ticks)); break; } } else if (value is TimeSpan) { if (parameter.JdbcType == (int)DbConvert.JavaSqlTypes.TIMESTAMP) preparedStatement.setTimestamp(parameterIndex,DbConvert.ClrTicksToJavaTimestamp(((TimeSpan)value).Ticks)); else preparedStatement.setTime(parameterIndex,DbConvert.ClrTicksToJavaTime(((TimeSpan)value).Ticks)); } else if (value is Decimal) { preparedStatement.setBigDecimal(parameterIndex, vmw.common.PrimitiveTypeUtils.DecimalToBigDecimal((Decimal) value)); } else if (value is double) { preparedStatement.setDouble(parameterIndex, (double)value); } else if (value is float) { preparedStatement.setFloat(parameterIndex, (float)value); } else if (value is int) { preparedStatement.setInt(parameterIndex, (int)value); } else if (value is string) { //can not be done for inout params, due to Oracle problem with FIXED_CHAR out param fetching if (parameter.Direction == ParameterDirection.Input && preparedStatement is Mainsoft.Data.Jdbc.Providers.IPreparedStatement && (DbConvert.JavaSqlTypes)parameter.JdbcType == DbConvert.JavaSqlTypes.CHAR) { ((Mainsoft.Data.Jdbc.Providers.IPreparedStatement)preparedStatement) .setChar(parameterIndex, (string)value); } else preparedStatement.setString(parameterIndex, (string)value); } else if (value is Guid) { preparedStatement.setString(parameterIndex, value.ToString()); } else if (value is short) { preparedStatement.setShort(parameterIndex, (short)value); } else if (value is sbyte) { preparedStatement.setByte(parameterIndex, (sbyte)value); } else { preparedStatement.setObject(parameterIndex, value); } }
private void PrepareInternal() { if ((Connection == null) || (Connection.State != ConnectionState.Open)) { throw ExceptionHelper.ConnectionNotOpened("Prepare",(Connection != null) ? Connection.State.ToString() : ""); } if (IsCommandPrepared) { // maybe we have to prepare the command again bool hasNullParameters = false; for(int i = 0; (i < Parameters.Count) && !hasNullParameters; i++) { AbstractDbParameter parameter = (AbstractDbParameter)Parameters[i]; if (IsNullParameter(parameter)) { // if we still have null parameters - have to prepare agail IsCommandPrepared = false; hasNullParameters = true; } } if (!NullParametersInPrepare && hasNullParameters) { // if we prepeared using null parameters and now there is no null parameters - need to prepare again IsCommandPrepared = false; } } if (!IsCommandPrepared) { _javaCommandText = PrepareCommandTextAndParameters(); java.sql.Connection jdbcCon = _connection.JdbcConnection; // For SchemaOnly we just prepare statement (for future use in GetSchemaTable) if (Behavior == CommandBehavior.SchemaOnly) { if (CommandType == CommandType.StoredProcedure) _statement = jdbcCon.prepareCall(_javaCommandText); else _statement = jdbcCon.prepareStatement(_javaCommandText); return; } if (CommandType == CommandType.StoredProcedure) _statement = jdbcCon.prepareCall(_javaCommandText); else { int internalParametersCount = InternalParameters.Count; if ( internalParametersCount > 0) { bool hasOnlyInputParameters = true; for(int i=0; i < internalParametersCount; i++) { AbstractDbParameter internalParameter = (AbstractDbParameter)InternalParameters[i]; if (IsNullParameter(internalParameter)) { NullParametersInPrepare = true; } if ((internalParameter.Direction & ParameterDirection.Output) != 0){ hasOnlyInputParameters = false; } } if (hasOnlyInputParameters) { _statement = jdbcCon.prepareStatement(_javaCommandText); } else { _statement = jdbcCon.prepareCall(_javaCommandText); } } else { if (_explicitPrepare) { _statement = jdbcCon.prepareStatement(_javaCommandText); } else { _statement = jdbcCon.createStatement(); } } } IsCommandPrepared = true; } }
int CreateStoredProcedureCommandText(StringBuilder sb, string sql, Matcher match, IDataParameterCollection userParams, int userParamsStartPosition) #endif { int curUserPos = userParamsStartPosition; #if USE_DOTNET_REGEX Group procNameGroup = null; for (Match procNameMatch = match; procNameMatch.Success; procNameMatch = procNameMatch.NextMatch()){ procNameGroup = match.Groups["PROCNAME"]; if (!procNameGroup.Success) { continue; } } if (procNameGroup == null || !procNameGroup.Success) throw new ArgumentException("Not a stored procedure call: '{0}'", sql); ArrayList derivedParameters = DeriveParameters(procNameGroup.Value, false); #else ArrayList derivedParameters = DeriveParameters(match.group(2).Trim(), false); #endif int curDerivedPos = 0; AbstractDbParameter retValderivedParameter = curDerivedPos < derivedParameters.Count ? (AbstractDbParameter)derivedParameters[curDerivedPos] : null; if (retValderivedParameter != null && retValderivedParameter.Direction == ParameterDirection.ReturnValue) curDerivedPos++; int queryCurrentPosition = 0; #if USE_DOTNET_REGEX for (Match retValMatch = match; retValMatch.Success; retValMatch = retValMatch.NextMatch()){ Group retval = retValMatch.Groups["RETVAL"]; if (!retval.Success) { continue; } int retvalIndex = retval.Index; string retvalValue = retval.Value; int retvalLength = retval.Length; #else int retvalIndex = match.start(1); for (;retvalIndex >= 0;) { string retvalValue = match.group(1); int retvalLength = retvalValue.Length; #endif sb.Append(sql, queryCurrentPosition, retvalIndex); AbstractDbParameter userParameter = GetUserParameter(retvalValue, userParams, curUserPos); if (userParameter != null) { sb.Append('?'); InternalParameters.Add(userParameter); if (retValderivedParameter != null && !userParameter.IsDbTypeSet) { userParameter.JdbcType = retValderivedParameter.JdbcType; } curUserPos++; } else { sb.Append(retvalValue); } queryCurrentPosition = (retvalIndex + retvalLength); break; } #if USE_DOTNET_REGEX sb.Append(sql, queryCurrentPosition, procNameGroup.Index + procNameGroup.Length - queryCurrentPosition); queryCurrentPosition = procNameGroup.Index + procNameGroup.Length; #else sb.Append(sql, queryCurrentPosition, match.end(2) - queryCurrentPosition); queryCurrentPosition = match.end(2); #endif bool hasUserParams = false; #if USE_DOTNET_REGEX must rewrite the regex to not parse params to have single code with java regex #else int paramsStart = match.start(3); if (paramsStart >= 0) { #endif hasUserParams = true; sb.Append(sql,queryCurrentPosition,paramsStart - queryCurrentPosition); queryCurrentPosition = paramsStart; for (SimpleMatch m = SqlStatementsHelper.ProcedureParameterSplitterReqExp.Match(match.group(3)); m.Success;m = m.NextMatch()) { SimpleCapture parameterCapture = m; sb.Append(sql,queryCurrentPosition,paramsStart + parameterCapture.Index - queryCurrentPosition); // advance in query queryCurrentPosition = paramsStart + parameterCapture.Index + parameterCapture.Length; AbstractDbParameter derivedParameter = curDerivedPos < derivedParameters.Count ? (AbstractDbParameter)derivedParameters[curDerivedPos++] : null; //check for special params while (derivedParameter != null && derivedParameter.IsSpecial) { // derived parameter is special - never appears in user parameters or user values InternalParameters.Add((AbstractDbParameter)derivedParameter.Clone()); sb.Append('?'); sb.Append(','); derivedParameter = curDerivedPos < derivedParameters.Count ? (AbstractDbParameter)derivedParameters[curDerivedPos++] : null; } AbstractDbParameter userParameter = GetUserParameter(parameterCapture.Value.Trim(), userParams, curUserPos); if (userParameter != null) { sb.Append('?'); InternalParameters.Add(userParameter); if (derivedParameter != null && !userParameter.IsDbTypeSet) { userParameter.JdbcType = derivedParameter.JdbcType; } // advance in user parameters curUserPos++; } else { sb.Append(parameterCapture.Value); } } } bool addedSpecialParams = false; for (int i = curDerivedPos; i < derivedParameters.Count;) { AbstractDbParameter derivedParameter = (AbstractDbParameter)derivedParameters[i++]; if (derivedParameter.IsSpecial) { // derived parameter is special - never appears in user parameters or user values if (!hasUserParams && !addedSpecialParams) { addedSpecialParams = true; curDerivedPos++; sb.Append('('); } for (;curDerivedPos < i;curDerivedPos++) sb.Append(','); InternalParameters.Add((AbstractDbParameter)derivedParameter.Clone()); sb.Append('?'); } } if (!hasUserParams && addedSpecialParams) sb.Append(')'); sb.Append(sql,queryCurrentPosition,sql.Length - queryCurrentPosition); return curUserPos - userParamsStartPosition; }
string CreateStoredProcedureCommandTextSimple(string procedureName, IDataParameterCollection userParams, IList derivedParams) { StringBuilder sb = new StringBuilder(); int curUserPos = 0; int curDerivedPos = 0; bool addParas = true; string trimedProcedureName = (procedureName != null) ? procedureName.TrimEnd() : String.Empty; if (trimedProcedureName.Length > 0 && trimedProcedureName[trimedProcedureName.Length-1] == ')') addParas = false; AbstractDbParameter derivedParam = (derivedParams.Count > 0) ? (AbstractDbParameter)derivedParams[curDerivedPos] : null; if (derivedParam != null) { if (derivedParam.Direction == ParameterDirection.ReturnValue) curDerivedPos++; else derivedParam = null; //play as if there is no retval parameter } AbstractDbParameter returnValueParameter = GetReturnParameter (userParams); if (returnValueParameter != null) { curUserPos++; InternalParameters.Add(returnValueParameter); sb.Append("{? = call "); if (derivedParam != null && !returnValueParameter.IsDbTypeSet) { returnValueParameter.JdbcType = derivedParam.JdbcType; } } else { sb.Append("{call "); } sb.Append(procedureName); if (addParas) sb.Append('('); bool needComma = false; for (int i = curDerivedPos; i < derivedParams.Count; i++) { AbstractDbParameter derivedParameter = (AbstractDbParameter)derivedParams[curDerivedPos++]; bool addParam = false; if (derivedParameter.IsSpecial) { // derived parameter is special - never appears in user parameters or user values InternalParameters.Add((AbstractDbParameter)derivedParameter.Clone()); addParam = true; } else { AbstractDbParameter userParameter = GetUserParameter(derivedParameter.Placeholder, userParams, curUserPos); if (userParameter != null) { curUserPos++; InternalParameters.Add(userParameter); addParam = true; if (derivedParameter != null && !userParameter.IsDbTypeSet) { userParameter.JdbcType = derivedParameter.JdbcType; } } } if (addParam) { if (needComma) sb.Append(','); else needComma = true; sb.Append('?'); } } for (int i = curUserPos; i < userParams.Count; i++) { if (needComma) sb.Append(','); else needComma = true; AbstractDbParameter userParameter = (AbstractDbParameter)userParams[curUserPos++]; InternalParameters.Add(userParameter); sb.Append('?'); } if (addParas) sb.Append(')'); sb.Append('}'); return sb.ToString(); }
protected virtual bool IsNullParameter(AbstractDbParameter parameter) { return ((parameter.Value == null || parameter.Value == DBNull.Value) && !parameter.IsDbTypeSet); }
protected override void BindOutputParameter(AbstractDbParameter parameter, int parameterIndex) { CallableStatement callableStatement = ((CallableStatement)Statement); if (((OleDbParameter)parameter).IsOracleRefCursor) { callableStatement.registerOutParameter(++parameterIndex, _oracleRefCursor); } else { base.BindOutputParameter(parameter, parameterIndex); } }
internal ArrayList GetProcedureColumns(String procedureString, AbstractDbCommand command) { ArrayList col = new ArrayList(); try { ObjectNameResolver[] nameResolvers = SyntaxPatterns; java.sql.ResultSet res = null; string catalog = null; string schema = null; string spname = null; java.sql.DatabaseMetaData metadata = JdbcConnection.getMetaData(); bool storesUpperCaseIdentifiers = false; bool storesLowerCaseIdentifiers = false; try { storesUpperCaseIdentifiers = metadata.storesUpperCaseIdentifiers(); storesLowerCaseIdentifiers = metadata.storesLowerCaseIdentifiers(); } catch (SQLException e) { // suppress } for (int i = 0; i < nameResolvers.Length; i++) { ObjectNameResolver nameResolver = nameResolvers[i]; Match match = nameResolver.Match(procedureString); if (match.Success) { spname = ObjectNameResolver.GetName(match); schema = ObjectNameResolver.GetSchema(match); catalog = ObjectNameResolver.GetCatalog(match); // make all identifiers uppercase or lowercase according to database metadata if (storesUpperCaseIdentifiers) { spname = (spname.Length > 0) ? spname.ToUpper() : null; schema = (schema.Length > 0) ? schema.ToUpper() : null; catalog = (catalog.Length > 0) ? catalog.ToUpper() : null; } else if (storesLowerCaseIdentifiers) { spname = (spname.Length > 0) ? spname.ToLower() : null; schema = (schema.Length > 0) ? schema.ToLower() : null; catalog = (catalog.Length > 0) ? catalog.ToLower() : null; } else { spname = (spname.Length > 0) ? spname : null; schema = (schema.Length > 0) ? schema : null; catalog = (catalog.Length > 0) ? catalog : null; } // catalog from db is always in correct caps if (catalog == null) { catalog = JdbcConnection.getCatalog(); } try { // always get the first procedure that db returns res = metadata.getProcedures(catalog, schema, spname); if (res.next()) { catalog = res.getString(1); schema = res.getString(2); spname = res.getString(3); break; } spname = null; } catch // suppress exception { return(null); } finally { if (res != null) { res.close(); } } } } if (spname == null || spname.Length == 0) { return(null); } try { // get procedure columns based o procedure metadata res = metadata.getProcedureColumns(catalog, schema, spname, null); while (res.next()) { // since there is still a possibility that some of the parameters to getProcedureColumn were nulls, // we need to filter the results with strict matching if ((res.getString(1) != catalog) || (res.getString(2) != schema) || (res.getString(3) != spname)) { continue; } AbstractDbParameter parameter = (AbstractDbParameter)command.CreateParameter(); parameter.SetParameterName(res); parameter.SetParameterDbType(res); parameter.SetSpecialFeatures(res); //get parameter direction short direction = res.getShort("COLUMN_TYPE"); if (direction == 1) //DatabaseMetaData.procedureColumnIn { parameter.Direction = ParameterDirection.Input; } else if (direction == 2) //DatabaseMetaData.procedureColumnInOut { parameter.Direction = ParameterDirection.InputOutput; } else if (direction == 4) //DatabaseMetaData.procedureColumnOut { parameter.Direction = ParameterDirection.Output; } else if (direction == 5) //DatabaseMetaData.procedureColumnReturn { parameter.Direction = ParameterDirection.ReturnValue; } //get parameter precision and scale parameter.SetParameterPrecisionAndScale(res); parameter.SetParameterSize(res); parameter.SetParameterIsNullable(res); col.Add(parameter); } } finally { if (res != null) { res.close(); } } } catch (Exception e) { //supress #if DEBUG Console.WriteLine("Exception catched at AbstractDBConnection.GetProcedureColumns() : {0}\n{1}\n{2}", e.GetType().FullName, e.Message, e.StackTrace); #endif } return(col); }