public Object GetParameterValue(SQLInputParameterContext inputParameterContext)
{
_paramContexts.Add(inputParameterContext);
if (inputParameterContext.ParameterValue is String)
{
return(int.Parse(inputParameterContext.ParameterValue.ToString().Substring(1)));
}
return(inputParameterContext.ParameterValue);
}
public void TestInputParameterConversion()
{
_epService.EPAdministrator.Configuration.AddVariable("myvariable", typeof(Object), "x10");
String[] fields = new String[] { "myint" };
String stmtText = "@Hook(Type=HookType.SQLCOL, Hook='" + typeof(SupportSQLColumnTypeConversion).FullName + "')" +
"select * from sql:MyDB ['select myint from mytesttable where myint = ${myvariable}']";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(stmtText);
_listener = new SupportUpdateListener();
stmt.Events += _listener.Update;
_epService.EPRuntime.SetVariableValue("myvariable", "x60"); // greater 50 turns true
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new Object[][] { new Object[] { true } });
SQLInputParameterContext param = SupportSQLColumnTypeConversion.ParamContexts[0];
Assert.AreEqual(1, param.ParameterNumber);
Assert.AreEqual("x60", param.ParameterValue);
}
private IList<EventBean> Execute(
DbDriverCommand driverCommand,
object lookupValuePerStream)
{
var hasLogging = _factory.IsEnableLogging && ADO_PERF_LOG.IsInfoEnabled;
using (var myDriverCommand = driverCommand.Clone()) {
var dbCommand = myDriverCommand.Command;
if (ExecutionPathDebugLog.IsDebugEnabled && Log.IsInfoEnabled) {
Log.Info(".execute Executing prepared statement '{0}'", dbCommand.CommandText);
}
DbParameter dbParam;
// set parameters
SQLInputParameterContext inputParameterContext = null;
if (_columnTypeConversionHook != null) {
inputParameterContext = new SQLInputParameterContext();
}
var mk = _factory.InputParameters.Length == 1 ? null : (HashableMultiKey) lookupValuePerStream;
for (var i = 0; i < _factory.InputParameters.Length; i++) {
try {
object parameter;
if (mk == null) {
parameter = lookupValuePerStream;
}
else {
parameter = mk.Keys[i];
}
if (ExecutionPathDebugLog.IsDebugEnabled && Log.IsInfoEnabled) {
Log.Info(
".Execute Setting parameter " +
" to " +
parameter +
" typed " +
((parameter == null) ? "null" : parameter.GetType().Name));
}
if (_columnTypeConversionHook != null) {
inputParameterContext.ParameterNumber = i + 1;
inputParameterContext.ParameterValue = parameter;
parameter = _columnTypeConversionHook.GetParameterValue(inputParameterContext);
}
dbParam = dbCommand.Parameters[i];
dbParam.Value = parameter ?? DBNull.Value;
}
catch (DbException ex) {
throw new EPException("Error setting parameter " + i, ex);
}
}
// execute
try {
// generate events for result set
IList<EventBean> rows = new List<EventBean>();
using (var dataReader = dbCommand.ExecuteReader()) {
try {
SQLColumnValueContext valueContext = null;
if (_columnTypeConversionHook != null) {
valueContext = new SQLColumnValueContext();
}
SQLOutputRowValueContext rowContext = null;
if (_outputRowConversionHook != null) {
rowContext = new SQLOutputRowValueContext();
}
var rowNum = 0;
if (dataReader.HasRows) {
// Determine how many fields we will be receiving
var fieldCount = dataReader.FieldCount;
// Allocate a buffer to hold the results of the row
var rawData = new object[fieldCount];
// Convert the names of columns into ordinal indices and prepare
// them so that we only have to incur this cost when we first notice
// the reader has rows.
if (_dbInfoList == null) {
_dbInfoList = new List<DbInfo>();
foreach (var entry in _outputTypes) {
var dbInfo = new DbInfo();
dbInfo.Name = entry.Key;
dbInfo.Ordinal = dataReader.GetOrdinal(dbInfo.Name);
dbInfo.OutputTypeDesc = entry.Value;
dbInfo.Binding = entry.Value.OptionalBinding;
_dbInfoList.Add(dbInfo);
}
}
var fieldNames = new string[fieldCount];
for (var ii = 0; ii < fieldCount; ii++) {
fieldNames[ii] = dataReader.GetName(ii);
}
// Anyone know if the ordinal will always be the same every time
// the query is executed; if so, we could certainly cache this
// dbInfoList so that we only have to do that once for the lifetime
// of the statement.
while (dataReader.Read()) {
var colNum = 1;
DataMap row = new Dictionary<string, object>();
// Get all of the values for the row in one shot
dataReader.GetValues(rawData);
// Convert the items into raw row objects
foreach (var dbInfo in _dbInfoList) {
var value = rawData[dbInfo.Ordinal];
if (value == DBNull.Value) {
value = null;
}
else if (dbInfo.Binding != null) {
value = dbInfo.Binding.GetValue(value, dbInfo.Name);
}
else if (value.GetType() != dbInfo.OutputTypeDesc.DataType) {
value = Convert.ChangeType(value, dbInfo.OutputTypeDesc.DataType);
}
if (_columnTypeConversionHook != null) {
valueContext.ColumnName = fieldNames[colNum - 1];
valueContext.ColumnNumber = colNum;
valueContext.ColumnValue = value;
value = _columnTypeConversionHook.GetColumnValue(valueContext);
}
row[dbInfo.Name] = value;
colNum++;
}
EventBean eventBeanRow = null;
if (_outputRowConversionHook == null) {
eventBeanRow = _agentInstanceContext.EventBeanTypedEventFactory
.AdapterForTypedMap(
row,
_factory.EventType);
}
else {
rowContext.Values = row;
rowContext.RowNum = rowNum;
var rowData = _outputRowConversionHook.GetOutputRow(rowContext);
if (rowData != null) {
eventBeanRow = _agentInstanceContext.EventBeanTypedEventFactory
.AdapterForTypedObject(
rowData,
(BeanEventType) _factory.EventType);
}
}
if (eventBeanRow != null) {
rows.Add(eventBeanRow);
rowNum++;
}
}
}
}
catch (DbException ex) {
throw new EPException(
"Error reading results for statement '" + _factory.PreparedStatementText + "'",
ex);
}
}
return rows;
}
catch (DbException ex) {
throw new EPException("Error executing statement '" + _factory.PreparedStatementText + "'", ex);
}
}
}
