public PollExecStrategyDBQuery(
HistoricalEventViewableDatabaseFactory factory,
AgentInstanceContext agentInstanceContext,
ConnectionCache connectionCache)
{
_factory = factory;
_agentInstanceContext = agentInstanceContext;
_connectionCache = connectionCache;
_dbInfoList = null;
_outputTypes = factory.OutputTypes;
_columnTypeConversionHook = factory.ColumnTypeConversionHook;
_outputRowConversionHook = factory.OutputRowConversionHook;
}
/// <summary>Ctor. </summary>
/// <param name="eventAdapterService">for generating event beans</param>
/// <param name="eventType">is the event type that this poll generates</param>
/// <param name="connectionCache">caches Connection and PreparedStatement</param>
/// <param name="preparedStatementText">is the SQL to use for polling</param>
/// <param name="outputTypes">describe columns selected by the SQL</param>
/// <param name="outputRowConversionHook">hook to convert rows, if any hook is registered</param>
/// <param name="columnTypeConversionHook">hook to convert columns, if any hook is registered</param>
public PollExecStrategyDBQuery(EventAdapterService eventAdapterService,
EventType eventType,
ConnectionCache connectionCache,
String preparedStatementText,
IDictionary <String, DBOutputTypeDesc> outputTypes,
SQLColumnTypeConversion columnTypeConversionHook,
SQLOutputRowConversion outputRowConversionHook)
{
_eventAdapterService = eventAdapterService;
_eventType = eventType;
_connectionCache = connectionCache;
_preparedStatementText = preparedStatementText;
_outputTypes = outputTypes;
_columnTypeConversionHook = columnTypeConversionHook;
_outputRowConversionHook = outputRowConversionHook;
}
/// <summary>
/// Creates the viewable for polling via database SQL query.
/// </summary>
/// <param name="statementId">The statement id.</param>
/// <param name="streamNumber">is the stream number of the view</param>
/// <param name="databaseStreamSpec">provides the SQL statement, database name and additional info</param>
/// <param name="databaseConfigService">for getting database connection and settings</param>
/// <param name="eventAdapterService">for generating event beans from database information</param>
/// <param name="epStatementAgentInstanceHandle">The ep statement agent instance handle.</param>
/// <param name="contextAttributes">The db attributes.</param>
/// <param name="columnTypeConversionHook">The column type conversion hook.</param>
/// <param name="outputRowConversionHook">The output row conversion hook.</param>
/// <param name="enableAdoLogging">if set to <c>true</c> [enable JDBC logging].</param>
/// <param name="dataCacheFactory">The data cache factory.</param>
/// <param name="statementContext">The statement context.</param>
/// <returns>
/// viewable providing poll functionality
/// </returns>
/// <exception cref="ExprValidationException">the validation failed</exception>
public static HistoricalEventViewable CreateDBStatementView(
int statementId,
int streamNumber,
DBStatementStreamSpec databaseStreamSpec,
DatabaseConfigService databaseConfigService,
EventAdapterService eventAdapterService,
EPStatementAgentInstanceHandle epStatementAgentInstanceHandle,
IEnumerable <Attribute> contextAttributes,
SQLColumnTypeConversion columnTypeConversionHook,
SQLOutputRowConversion outputRowConversionHook,
bool enableAdoLogging,
DataCacheFactory dataCacheFactory,
StatementContext statementContext)
{
// Parse the SQL for placeholders and text fragments
var sqlFragments = GetSqlFragments(databaseStreamSpec);
IList <String> invocationInputParameters = new List <string>();
foreach (var fragment in sqlFragments)
{
if ((fragment.IsParameter) && (fragment.Value != SAMPLE_WHERECLAUSE_PLACEHOLDER))
{
invocationInputParameters.Add(fragment.Value);
}
}
// Get the database information
var databaseName = databaseStreamSpec.DatabaseName;
var dbDriver = GetDatabaseConnectionFactory(databaseConfigService, databaseName).Driver;
var dbCommand = dbDriver.CreateCommand(
sqlFragments,
GetMetaDataSettings(databaseConfigService, databaseName),
contextAttributes);
if (Log.IsDebugEnabled)
{
Log.Debug(".CreateDBStatementView dbCommand=" + dbCommand);
}
var queryMetaData = GetQueryMetaData(
databaseStreamSpec,
databaseConfigService,
dbCommand,
contextAttributes);
Func <SQLColumnTypeContext, Type> columnTypeConversionFunc = null;
if (columnTypeConversionHook != null)
{
columnTypeConversionFunc = columnTypeConversionHook.GetColumnType;
}
Func <SQLOutputRowTypeContext, Type> outputRowConversionFunc = null;
if (outputRowConversionHook != null)
{
outputRowConversionFunc = outputRowConversionHook.GetOutputRowType;
}
// Construct an event type from SQL query result metadata
var eventType = CreateEventType(
statementId,
streamNumber,
queryMetaData,
eventAdapterService,
databaseStreamSpec,
columnTypeConversionFunc,
outputRowConversionFunc);
// Get a proper connection and data cache
ConnectionCache connectionCache;
DataCache dataCache;
try
{
connectionCache = databaseConfigService.GetConnectionCache(
databaseName, dbCommand.PseudoText, contextAttributes);
dataCache = databaseConfigService.GetDataCache(
databaseName, statementContext, epStatementAgentInstanceHandle, dataCacheFactory, streamNumber);
}
catch (DatabaseConfigException e)
{
const string text = "Error obtaining cache configuration";
Log.Error(text, e);
throw new ExprValidationException(text + ", reason: " + e.Message, e);
}
var dbPollStrategy = new PollExecStrategyDBQuery(
eventAdapterService,
eventType,
connectionCache,
dbCommand.CommandText,
queryMetaData.OutputParameters,
columnTypeConversionHook,
outputRowConversionHook);
return(new DatabasePollingViewable(
streamNumber,
invocationInputParameters,
dbPollStrategy,
dataCache,
eventType));
}
public static HistoricalEventViewableDatabaseForge CreateDBStatementView(
int streamNum,
DBStatementStreamSpec databaseStreamSpec,
SQLColumnTypeConversion columnTypeConversionHook,
SQLOutputRowConversion outputRowConversionHook,
StatementBaseInfo statementBaseInfo,
StatementCompileTimeServices services,
IEnumerable<Attribute> contextAttributes)
{
// Parse the SQL for placeholders and text fragments
var sqlFragments = GetSqlFragments(databaseStreamSpec);
var invocationInputParameters = new List<string>();
foreach (var fragment in sqlFragments) {
if ((fragment.IsParameter) && (fragment.Value != SAMPLE_WHERECLAUSE_PLACEHOLDER)) {
invocationInputParameters.Add(fragment.Value);
}
}
// Assemble a PreparedStatement and parameter list
var preparedStatementText = CreatePreparedStatement(sqlFragments);
var parameterDesc = GetParameters(sqlFragments);
if (Log.IsDebugEnabled) {
Log.Debug(
".CreateDBStatementView preparedStatementText=" +
preparedStatementText +
" parameterDesc=" +
parameterDesc);
}
// Get a database connection
var databaseName = databaseStreamSpec.DatabaseName;
var dbDriver = services.DatabaseConfigServiceCompileTime
.GetConnectionFactory(databaseName)
.Driver;
var dbCommand = dbDriver.CreateCommand(
sqlFragments,
GetMetaDataSettings(services, databaseName),
contextAttributes);
if (Log.IsDebugEnabled) {
Log.Debug(".CreateDBStatementView dbCommand=" + dbCommand);
}
var queryMetaData = GetQueryMetaData(
databaseStreamSpec,
services,
dbCommand,
parameterDesc,
contextAttributes);
Func<SQLColumnTypeContext, Type> columnTypeConversionFunc =
columnTypeConversionHook != null
? columnTypeConversionHook.GetColumnType
: (Func<SQLColumnTypeContext, Type>) null;
Func<SQLOutputRowTypeContext, Type> outputRowConversionFunc =
outputRowConversionHook != null
? outputRowConversionHook.GetOutputRowType
: (Func<SQLOutputRowTypeContext, Type>) null;
// Construct an event type from SQL query result metadata
var eventType = CreateEventType(
streamNum,
queryMetaData,
services,
databaseStreamSpec,
columnTypeConversionHook,
outputRowConversionHook,
statementBaseInfo);
services.EventTypeCompileTimeRegistry.NewType(eventType);
return new HistoricalEventViewableDatabaseForge(
streamNum,
eventType,
databaseName,
queryMetaData.InputParameters.ToArray(),
preparedStatementText,
queryMetaData.OutputParameters);
}
/// <summary>
/// Creates an event type from the query meta data.
/// </summary>
/// <param name="streamNum"></param>
/// <param name="queryMetaData">The query meta data.</param>
/// <param name="services"></param>
/// <param name="databaseStreamSpec">The database stream spec.</param>
/// <param name="columnTypeConversionHook">The column type conversion hook.</param>
/// <param name="outputRowConversionHook">The output row conversion hook.</param>
/// <param name="base"></param>
private static EventType CreateEventType(
int streamNum,
QueryMetaData queryMetaData,
StatementCompileTimeServices services,
DBStatementStreamSpec databaseStreamSpec,
SQLColumnTypeConversion columnTypeConversionHook,
SQLOutputRowConversion outputRowConversionHook,
StatementBaseInfo @base)
{
var eventTypeFields = CreateEventTypeFields(
databaseStreamSpec,
columnTypeConversionHook,
queryMetaData);
var eventTypeName = services.EventTypeNameGeneratorStatement.GetAnonymousDBHistorical(streamNum);
EventType eventType;
Func<EventTypeApplicationType, EventTypeMetadata> metadata = appType => new EventTypeMetadata(
eventTypeName,
@base.ModuleName,
EventTypeTypeClass.DBDERIVED,
appType,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
if (outputRowConversionHook == null) {
eventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata.Invoke(EventTypeApplicationType.MAP),
eventTypeFields,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
else {
var carrierClass = outputRowConversionHook.GetOutputRowType(
new SQLOutputRowTypeContext(
databaseStreamSpec.DatabaseName,
databaseStreamSpec.SqlWithSubsParams,
eventTypeFields));
if (carrierClass == null) {
throw new ExprValidationException("Output row conversion hook returned no type");
}
var stem = services.BeanEventTypeStemService.GetCreateStem(carrierClass, null);
eventType = new BeanEventType(
services.Container,
stem,
metadata.Invoke(EventTypeApplicationType.CLASS),
services.BeanEventTypeFactoryPrivate,
null,
null,
null,
null);
}
return eventType;
}
