Dapper.Oracle/src/Dapper.Oracle/OracleDynamicParameters.cs at main · DIPSAS/Dapper.Oracle · GitHub

Repository navigation

History

331 lines (283 loc) · 11.5 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

//// Based on Gist found here: https://gist.github.com/vijaysg/3096151

using System;

using System.Collections;

using System.Collections.Generic;

using System.Data;

using System.Linq;

using System.Runtime.InteropServices;

namespace Dapper.Oracle

{

/// <summary>

/// Parameter support for Oracle-specific types and functions. For use with Dapper.

/// Implements <see cref="SqlMapper.IDynamicParameters"/>.

/// </summary>

public partial class OracleDynamicParameters : SqlMapper.IDynamicParameters, IEnumerable

{

private static Dictionary<SqlMapper.Identity, Action<IDbCommand, object>> ParamReaderCache { get; } =

new Dictionary<SqlMapper.Identity, Action<IDbCommand, object>>();

private Dictionary<string, OracleParameterInfo> Parameters { get; } =

new Dictionary<string, OracleParameterInfo>();

private List<object> templates;

/// <summary>

/// construct a dynamic parameter bag

/// </summary>

public OracleDynamicParameters() { }

/// <summary>

/// construct a dynamic parameter bag

/// </summary>

/// <param name="template">can be an anonymous type or a DynamicParameters bag</param>

public OracleDynamicParameters(object template)

{

AddDynamicParams(template);

}

/// <summary>

/// Gets or sets the value for Oracle ArrayBindCount. Refer to Oracle documentation for how to use it.

/// </summary>

public int ArrayBindCount { get; set; }

/// <summary>

/// Gets or sets the value for InitialLOBFetchSize. Refer to Oracle documentation for how to use it.

/// </summary>

public int InitialLOBFetchSize { get; set; }

public bool BindByName { get; set; }

/// <summary>

/// Append a whole object full of params to the dynamic

/// EG: AddDynamicParams(new {A = 1, B = 2}) // will add property A and B to the dynamic

/// </summary>

/// <param name="param"></param>

public void AddDynamicParams(dynamic param)

{

if (param is object obj)

{

if (!(obj is OracleDynamicParameters subDynamic))

{

if (!(obj is IEnumerable<KeyValuePair<string, object>> dictionary))

{

templates = templates ?? new List<object>();

templates.Add(obj);

}

else

{

foreach (var kvp in dictionary)

{

Add(kvp.Key, kvp.Value);

}

else

{

if (subDynamic.Parameters != null)

{

foreach (var kvp in subDynamic.Parameters)

{

Parameters.Add(kvp.Key, kvp.Value);

}

if (subDynamic.templates != null)

{

templates = templates ?? new List<object>();

foreach (var t in subDynamic.templates)

{

templates.Add(t);

}

/// <summary>

/// Add a parameter to this dynamic parameter list

/// </summary>

/// <param name="name">Parameter name. If it starts with @,: or ? it is stripped before adding it to the parameter list.</param>

/// <param name="value">Value of parameter.</param>

/// <param name="dbType">Parameter type</param>

/// <param name="direction">Parameter direction</param>

/// <param name="size"></param>

/// <param name="isNullable"></param>

/// <param name="precision"></param>

/// <param name="scale"></param>

/// <param name="sourceColumn"></param>

/// <param name="sourceVersion"></param>

/// <param name="collectionType"></param>

public void Add(

string name,

object value = null,

OracleMappingType? dbType = null,

ParameterDirection? direction = null,

int? size = null,

bool? isNullable = null,

byte? precision = null,

byte? scale = null,

string sourceColumn = null,

DataRowVersion? sourceVersion = null,

OracleMappingCollectionType? collectionType = null,

int[] arrayBindSize = null)

{

Parameters[Clean(name)] = new OracleParameterInfo()

{

Name = Clean(name),

Value = value,

ParameterDirection = direction ?? ParameterDirection.Input,

DbType = dbType,

Size = size,

IsNullable = isNullable ?? false,

Precision = precision,

Scale = scale,

SourceColumn = sourceColumn,

SourceVersion = sourceVersion ?? DataRowVersion.Current,

CollectionType = collectionType ?? OracleMappingCollectionType.None,

ArrayBindSize = arrayBindSize

};

}

/// <summary>

/// All the names of the param in the bag, use Get to yank them out

/// </summary>

public IEnumerable<string> ParameterNames

{

get { return Parameters.Select(p => p.Key); }

}

/// <summary>

/// Get the value of a parameter

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="name"></param>

/// <returns>The value, note DBNull.Value is not returned, instead the value is returned as null</returns>

public T Get<T>(string name)

{

var paramInfo = GetParameter(name);

var attachedParam = paramInfo.AttachedParam;

object val = attachedParam == null ? paramInfo.Value : attachedParam.Value;

if (val == DBNull.Value)

{

if (default(T) != null)

{

throw new ApplicationException("Attempting to cast a DBNull to a non nullable type! Note that out/return parameters will not have updated values until the data stream completes (after the 'foreach' for Query(..., buffered: false), or after the GridReader has been disposed for QueryMultiple)");

}

return default(T);

}

return OracleValueConverter.Convert<T>(val);

}

public OracleParameterInfo GetParameter(string name)

{

return Parameters[Clean(name)];

}

void SqlMapper.IDynamicParameters.AddParameters(IDbCommand command, SqlMapper.Identity identity)

{

AddParameters(command, identity);

}

/// <summary>

/// Add all the parameters needed to the command just before it executes

/// </summary>

/// <param name="command">The raw command prior to execution</param>

/// <param name="identity">Information about the query</param>

protected virtual void AddParameters(IDbCommand command, SqlMapper.Identity identity)

{

if (ArrayBindCount > 0)

{

OracleMethodHelper.SetArrayBindCount(command, ArrayBindCount);

}

if (InitialLOBFetchSize > 0)

{

OracleMethodHelper.SetInitialLOBFetchSize(command, InitialLOBFetchSize);

}

if (BindByName)

{

OracleMethodHelper.SetBindByName(command, BindByName);

}

if (templates != null)

{

foreach (var template in templates)

{

var newIdent = identity.ForDynamicParameters(template.GetType());

Action<IDbCommand, object> appender;

lock (ParamReaderCache)

{

if (!ParamReaderCache.TryGetValue(newIdent, out appender))

{

appender = SqlMapper.CreateParamInfoGenerator(newIdent, false, false);

ParamReaderCache[newIdent] = appender;

}

appender(command, template);

}

foreach (var param in Parameters.Values)

{

var name = Clean(param.Name);

var add = !command.Parameters.Contains(name);

IDbDataParameter p;

if (add)

{

p = command.CreateParameter();

p.ParameterName = name;

}

else

{

p = (IDbDataParameter) command.Parameters[name];

}

OracleMethodHelper.SetOracleParameters(p, param);

p.Direction = param.ParameterDirection;

var val = param.Value;

if (val != null && OracleTypeMapper.HasTypeHandler(val.GetType(), out var handler))

{

handler.SetValue(p,val);

}

else

{

p.Value = val ?? DBNull.Value;

var s = val as string;

if (s?.Length <= 4000)

{

p.Size = 4000;

}

if (param.Size != null)

{

p.Size = param.Size.Value;

}

if (add)

{

command.Parameters.Add(p);

param.AttachedParam = p;

}

private static string Clean(string name)

{

if (!string.IsNullOrEmpty(name))

{

switch (name[0])

{

case '@':

case ':':

case '?':

return name.Substring(1);

}

return name;

}

/// <summary>

/// Class used to pass parameter information to and from the OracleCommand object

/// </summary>

public class OracleParameterInfo

{

public string Name { get; set; }

public object Value { get; set; }

public ParameterDirection ParameterDirection { get; set; }

public OracleMappingType? DbType { get; set; }

public int? Size { get; set; }

public bool? IsNullable { get; set; }

public byte? Precision { get; set; }

public byte? Scale { get; set; }

public string SourceColumn { get; set; } = string.Empty;

public DataRowVersion SourceVersion { get; set; }

public OracleMappingCollectionType CollectionType { get; set; } = OracleMappingCollectionType.None;

public int[] ArrayBindSize { get; set; } = null;

public OracleParameterMappingStatus Status { get; set; }

public IDbDataParameter AttachedParam { get; set; }

}

/// <summary>

/// Returns an enumerator that iterates through the parameters

/// </summary>

/// <returns></returns>

public IEnumerator GetEnumerator() => Parameters.GetEnumerator();

}

Dapper.Oracle/src/Dapper.Oracle/OracleDynamicParameters.cs at main · DIPSAS/Dapper.Oracle · GitHub

Repository navigation

Expand file tree

Breadcrumbs

OracleDynamicParameters.cs

Latest commit

History

Breadcrumbs

OracleDynamicParameters.cs

File metadata and controls