/// <summary>
/// adds the table metadata to the internal list
/// </summary>
/// <param name="tableMetadata"></param>
public void Add(TableMetadata tableMetadata)
{
if (!_tables.ContainsKey(tableMetadata.name))
{
_tables.Add(tableMetadata.name, tableMetadata);
}
}
private ITableMetadata GetPrimaryTable(IForeignKeyColumnInfo[] iForeignKeyColumnInfo)
{
//we should have only one table as primary
ITableMetadata pname = null;
foreach (var s in iForeignKeyColumnInfo)
{
if (pname != null && s.PrimaryKeyTableName != pname.Name)
{
logger.Warn(string.Format("Inconsistent key definition. Set not created"));
return null;
}
pname = new TableMetadata(s.PrimaryKeyTableCatalog,s.PrimaryKeyTableSchema,s.PrimaryKeyTableName);
}
return pname;
}
public TableOnMergeViewChangeHandler(TableMetadata tableMetadata)
{
_tableMetadata = tableMetadata;
}
public AggSvcGroupByWTableRollupSingleKeyImpl(TableMetadata tableMetadata, TableColumnMethodPair[] methodPairs, AggregationAccessorSlotPair[] accessors, bool join, TableStateInstanceGrouped tableStateInstance, int[] targetStates, ExprNode[] accessStateExpr, AggregationAgent[] agents)
: base(tableMetadata, methodPairs, accessors, join, tableStateInstance, targetStates, accessStateExpr, agents)
{
}
public static void SchemaCheck(Table table)
{
var changes = TableMetadata.GetChanges(table.Partitions[0]);
ReportSchemaCheckChanges(changes);
}
private string GenerateFileName(TableMetadata tableMetadata)
{
return(string.IsNullOrWhiteSpace(tableMetadata.Schema.Database)
? $"{tableMetadata.Schema.Table}"
: $"{tableMetadata.Schema.Database}.{tableMetadata.Schema.Table}");
}
public static void BuildDataFromTable(IQueryHelper queryHelper, IDbTransaction transaction, Int16 serverId, string database, string schema, TableMetadata table, object[] dataRow)
{
if (table.ColumnsDefinition.Count != dataRow.Length)
{
throw new ArgumentException($"The number of columns defined in the cached table {table.Name} '{table.ColumnsDefinition.Count}' " +
"is different from the current row '{dataRow.Length}'.");
}
for (var i = 0; i < table.ColumnsDefinition.Count; i++)
{
var col = table.ColumnsDefinition[i];
dataRow[i] = BuildDataColumn(queryHelper, transaction, serverId, database, schema, table, col);
}
}
public AggregationAccessorMinMaxByTable(bool max, TableMetadata tableMetadata)
: base(max)
{
_tableMetadata = tableMetadata;
}
/// <summary>
/// Returns a random INSERT command
/// </summary>
public DbCommand GetInsertCommand(Random rnd, TableMetadata table, DataStressConnection conn)
{
DbCommand com = CreateCommand(rnd, conn);
StringBuilder cmdText = new StringBuilder();
cmdText.Append("INSERT INTO \"");
cmdText.Append(table.TableName);
cmdText.Append("\" (");
StringBuilder valuesText = new StringBuilder();
valuesText.Append(") VALUES (");
List<TableColumn> columns = table.Columns;
int numColumns = rnd.Next(2, columns.Count);
bool mostlyNull = rnd.NextBool(0.1); // 10% of rows have 90% chance of each column being null, in order to test nbcrow
for (int i = 0; i < numColumns; i++)
{
if (columns[i].ColumnName.ToUpper() == "PRIMARYKEY") continue;
if (i > 1)
{
cmdText.Append(", ");
valuesText.Append(", ");
}
cmdText.Append(columns[i].ColumnName);
if (columns[i].ColumnName.ToUpper() == "TIMESTAMP_FLD")
{
valuesText.Append("DEFAULT"); // Cannot insert an explicit value in a timestamp field
}
else if (mostlyNull && rnd.NextBool(0.9))
{
valuesText.Append("NULL");
}
else
{
DbParameter param = CreateRandomParameter(rnd, string.Format("P{0}", i + 1), columns[i]);
valuesText.Append(param.ParameterName);
com.Parameters.Add(param);
}
}
// To deal databases that do not support auto-incremented columns (Oracle?)
// if (!columns["PrimaryKey"].AutoIncrement)
if (PrimaryKeyValueIsRequired)
{
DbParameter param = CreateRandomParameter(rnd, "P0", table.GetColumn("PrimaryKey"));
cmdText.Append(", PrimaryKey");
valuesText.Append(", ");
valuesText.Append(param.ParameterName);
com.Parameters.Add(param);
}
valuesText.Append(")");
cmdText.Append(valuesText);
if (ShouldModifySession(rnd))
{
cmdText.Append(";").Append(GetRandomSessionModificationStatement(rnd));
}
com.CommandText = cmdText.ToString();
return com;
}
public static TableMetadata ReadMetadata(JsonData jObject)
{
var target = new TableMetadata();
if (jObject["table"] != null)
target.name = jObject["table"].ToString();
if (jObject["name"] != null)
target.name = jObject["name"].ToString();
if (jObject["creationDate"] != null)
target.creationDate = DateTime.FromFileTimeUtc((long)jObject["creationDate"]);
if (jObject["status"] != null)
target.status = (TableMetadata.Status)Enum.Parse(typeof(TableMetadata.Status), jObject["status"].ToString().ToUpper());
if (jObject["itemCount"] != null)
target.itemCount = (int)jObject["itemCount"];
if (jObject["key"] != null)
target.key = JsonMapper.ToObject<TableKey>(jObject["key"].ToJson());
if (jObject["size"] != null)
target.size = (int)jObject["size"];
if (jObject["throughput"] != null)
target.throughput = JsonMapper.ToObject<TableThroughput>(jObject["throughput"].ToJson());
//
if (jObject["provisionType"] != null)
{
var p1 = JsonMapper.ToObject<ProvisionMeta>(jObject["provisionType"].ToJson());
target.provisionType = (ProvisionType)p1.id;
}
if (jObject["provisionLoad"] != null)
{
var p2 = JsonMapper.ToObject<ProvisionMeta>(jObject["provisionLoad"].ToJson());
target.provisionLoad = (ProvisionLoad)p2.id;
}
return target;
}
public StatementAgentInstanceFactoryOnTriggerTable(StatementContext statementContext, StatementSpecCompiled statementSpec, EPServicesContext services, ViewableActivator activator, SubSelectStrategyCollection subSelectStrategyCollection, ResultSetProcessorFactoryDesc resultSetProcessorPrototype, ExprNode validatedJoin, TableOnViewFactory onExprFactory, EventType activatorResultEventType, TableMetadata tableMetadata, ResultSetProcessorFactoryDesc outputResultSetProcessorPrototype, OutputProcessViewFactory outputProcessViewFactory)
: base(statementContext, statementSpec, services, activator, subSelectStrategyCollection)
{
_resultSetProcessorPrototype = resultSetProcessorPrototype;
_onExprFactory = onExprFactory;
_outputResultSetProcessorPrototype = outputResultSetProcessorPrototype;
_outputProcessViewFactory = outputProcessViewFactory;
var pair = StatementAgentInstanceFactoryOnTriggerNamedWindow.GetIndexHintPair(statementContext, statementSpec);
var indexHint = pair.IndexHint;
var excludePlanHint = pair.ExcludePlanHint;
_queryPlanResult = SubordinateQueryPlanner.PlanOnExpression(
validatedJoin, activatorResultEventType, indexHint, true, -1, excludePlanHint,
false, tableMetadata.EventTableIndexMetadataRepo, tableMetadata.InternalEventType,
tableMetadata.UniqueKeyProps, true, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations);
if (_queryPlanResult.IndexDescs != null)
{
for (var i = 0; i < _queryPlanResult.IndexDescs.Length; i++)
{
tableMetadata.AddIndexReference(_queryPlanResult.IndexDescs[i].IndexName, statementContext.StatementName);
}
}
SubordinateQueryPlannerUtil.QueryPlanLogOnExpr(tableMetadata.IsQueryPlanLogging, TableServiceImpl.QueryPlanLog,
_queryPlanResult, statementContext.Annotations);
}
/// <summary>
/// Returns a random SELECT command
/// </summary>
public DbCommand GetSelectCommand(Random rnd, TableMetadata tableMetadata, DataStressConnection conn, bool isXml = false)
{
DbCommand com = CreateCommand(rnd, conn);
StringBuilder cmdText = new StringBuilder();
cmdText.Append(GetSelectCommandForMultipleRows(rnd, com, tableMetadata, isXml));
// 33% of the time, we also want to add another batch to the select command to allow for
// multiple result sets.
if ((!isXml) && (rnd.Next(0, 3) == 0))
{
cmdText.Append(";").Append(GetSelectCommandForScalarValue(com));
}
if ((!isXml) && ShouldModifySession(rnd))
{
cmdText.Append(";").Append(GetRandomSessionModificationStatement(rnd));
}
com.CommandText = cmdText.ToString();
return com;
}
private static bool MergeTable(TableModifierModel mergedTable,
List <TableModifier> userConfigTables,
TableMetadata defaultTable)
{
var hasChange = false;
var userConfigTable = userConfigTables.FirstOrDefault(t => t.Name == mergedTable.Name);
if (defaultTable == null)
{
hasChange = true;
}
//Add new
if (userConfigTable == null)
{
userConfigTable = new TableModifier {
Name = mergedTable.Name
};
userConfigTables.Add(userConfigTable);
}
userConfigTable.IsStatic = mergedTable.IsStatic;
userConfigTable.DerativeTables.GlobalAccess = mergedTable.DerativeTablesGlobalAccess;
userConfigTable.DerativeTables.GlobalCascade = mergedTable.DerativeTablesGlobalCascade;
if (mergedTable.IsStatic ||
mergedTable.DerativeTablesGlobalAccess != DerivativeTableAccess.NotSet ||
mergedTable.DerativeTablesGlobalCascade == true)
{
hasChange = true;
}
//Clear
userConfigTable.ForeignKeys.ForeignKeyAdd = new List <ForeignKeyAdd>();
userConfigTable.ForeignKeys.ForeignKeyRemove = new ForeignKeyRemove();
userConfigTable.DerativeTables.DerativeSubTables = new List <DerivativeSubTable>();
userConfigTable.DataBuilders = new List <DataBuilder>();
//Merge FK
for (int i = mergedTable.ForeignKeys.Count - 1; i >= 0; i--)
{
var mergedFk = mergedTable.ForeignKeys[i];
var defaultFk = defaultTable.ForeignKeys.FirstOrDefault(f => f.ServerIdTo.ToString() == mergedFk.ServerIdTo &&
f.DatabaseTo == mergedFk.DatabaseTo &&
f.SchemaTo == mergedFk.SchemaTo &&
f.TableTo == mergedFk.TableTo);
if (MergeForeignKey(mergedFk, mergedTable.ForeignKeys, userConfigTable.ForeignKeys, defaultFk, defaultTable.ColumnsDefinition))
{
hasChange = true;
}
}
//Merge derivative table
for (int i = mergedTable.DerivativeTables.Count - 1; i >= 0; i--)
{
var mergedDerivativeTable = mergedTable.DerivativeTables[i];
var defaultDt = defaultTable.DerivativeTables.FirstOrDefault(d => d.ServerId.ToString() == mergedDerivativeTable.ServerId &&
d.Database == mergedDerivativeTable.Database &&
d.Schema == mergedDerivativeTable.Schema &&
d.Table == mergedDerivativeTable.Table);
if (MergedDerivativeTable(mergedDerivativeTable, mergedTable.DerivativeTables, userConfigTable.DerativeTables, defaultDt))
{
hasChange = true;
}
}
//Merge data builders
foreach (var mergedDataBuilder in mergedTable.DataBuilders)
{
if (MergeDataBuilders(mergedDataBuilder, userConfigTable.DataBuilders))
{
hasChange = true;
}
}
//Cleaning
if (!userConfigTable.DataBuilders.Any())
{
userConfigTable.DataBuilders = null;
}
if (!userConfigTable.ForeignKeys.ForeignKeyAdd.Any())
{
userConfigTable.ForeignKeys.ForeignKeyAdd = null;
}
if (!userConfigTable.ForeignKeys.ForeignKeyRemove.Columns.Any())
{
userConfigTable.ForeignKeys.ForeignKeyRemove = null;
}
if (userConfigTable.ForeignKeys.ForeignKeyAdd == null &&
userConfigTable.ForeignKeys.ForeignKeyRemove == null)
{
userConfigTable.ForeignKeys = null;
}
if (mergedTable.DerativeTablesGlobalAccess == DerivativeTableAccess.NotSet &&
mergedTable.DerativeTablesGlobalCascade == false &&
!userConfigTable.DerativeTables.DerativeSubTables.Any())
{
userConfigTable.DerativeTables = null;
}
//If no change has been detected with the default config
if (!hasChange)
{
userConfigTables.Remove(userConfigTable);
}
return(hasChange);
}
IEnumerator TestRestTableAsync()
{
Terminal.LogImportant("TestRestTableAsync (This is really slow)");
// Make Table
var tableName = Strings.RandomString(10);
var meta1 = new TableMetadata
{
name = tableName,
provisionLoad = ProvisionLoad.Balanced,
provisionType = ProvisionType.Custom,
throughput = new TableThroughput(1, 1),
key = new TableKey(new Key("ID1", Key.DataType.STRING), new Key("ID2", Key.DataType.NUMBER)),
};
//CREATE
Terminal.Log("CREATE " + tableName);
var result1 = Repository.CreateTable(meta1);
yield return(StartCoroutine(result1.WaitRoutine()));
result1.ThrowIfFaulted();
if (result1.Result.hasError)
{
throw new Exception(result1.Result.error.message);
}
//wait...
var meta2 = WaitForTable(Repository, tableName);
yield return(StartCoroutine(meta2.WaitRoutine()));
meta2.ThrowIfFaulted();
//LIST
Terminal.Log("LIST");
var result4 = Repository.ListTables();
yield return(StartCoroutine(result4.WaitRoutine()));
result4.ThrowIfFaulted();
if (result4.Result.hasError)
{
throw new Exception(result4.Result.error.message);
}
Assert.IsTrue(result4.Result.data.tables.Any(), "request returned no results");
//UPDATE
Terminal.Log("UPDATE");
meta2.Result.throughput = new TableThroughput(2, 2);
meta2.Result.provisionType = ProvisionType.Custom;
var result3 = Repository.UpdateTable(meta2.Result);
yield return(StartCoroutine(result3.WaitRoutine()));
result3.ThrowIfFaulted();
if (result3.Result.hasError)
{
throw new Exception(result3.Result.error.message);
}
//wait...
var meta3 = WaitForTable(Repository, tableName, 5000);
yield return(StartCoroutine(meta3.WaitRoutine()));
meta3.ThrowIfFaulted();
//DELETE
Terminal.Log("DELETE");
var result5 = Repository.DeleteTable(tableName);
yield return(StartCoroutine(result5.WaitRoutine()));
result5.ThrowIfFaulted();
if (result5.Result.hasError)
{
throw new Exception(result5.Result.error.message);
}
Terminal.LogSuccess("Test Success");
}
public void checkPureMetadata(string TableName = null, string KeyspaceName = null, TableOptions tableOptions = null)
{
var columns = new Dictionary
<string, ColumnTypeCode>
{
{ "q0uuid", ColumnTypeCode.Uuid },
{ "q1timestamp", ColumnTypeCode.Timestamp },
{ "q2double", ColumnTypeCode.Double },
{ "q3int32", ColumnTypeCode.Int },
{ "q4int64", ColumnTypeCode.Bigint },
{ "q5float", ColumnTypeCode.Float },
{ "q6inet", ColumnTypeCode.Inet },
{ "q7boolean", ColumnTypeCode.Boolean },
{ "q8inet", ColumnTypeCode.Inet },
{ "q9blob", ColumnTypeCode.Blob },
{ "q10varint", ColumnTypeCode.Varint },
{ "q11decimal", ColumnTypeCode.Decimal },
{ "q12list", ColumnTypeCode.List },
{ "q13set", ColumnTypeCode.Set },
{ "q14map", ColumnTypeCode.Map }
//{"q12counter", Metadata.ColumnTypeCode.Counter}, A table that contains a counter can only contain counters
};
string tablename = TableName ?? "table" + Guid.NewGuid().ToString("N");
var sb = new StringBuilder(@"CREATE TABLE " + tablename + " (");
foreach (KeyValuePair <string, ColumnTypeCode> col in columns)
{
sb.Append(col.Key + " " + col.Value +
(((col.Value == ColumnTypeCode.List) ||
(col.Value == ColumnTypeCode.Set) ||
(col.Value == ColumnTypeCode.Map))
? "<int" + (col.Value == ColumnTypeCode.Map ? ",varchar>" : ">")
: "") + ", ");
}
sb.Append("PRIMARY KEY(");
int rowKeys = Randomm.Instance.Next(1, columns.Count - 3);
for (int i = 0; i < rowKeys; i++)
{
sb.Append(columns.Keys.First(key => key.StartsWith("q" + i.ToString(CultureInfo.InvariantCulture))) + ((i == rowKeys - 1) ? "" : ", "));
}
string opt = tableOptions != null ? " WITH " + tableOptions : "";
sb.Append("))" + opt + ";");
Session.WaitForSchemaAgreement(
QueryTools.ExecuteSyncNonQuery(Session, sb.ToString())
);
TableMetadata table = Cluster.Metadata.GetTable(KeyspaceName ?? Keyspace, tablename);
foreach (TableColumn metaCol in table.TableColumns)
{
Assert.True(columns.Keys.Contains(metaCol.Name));
Assert.True(metaCol.TypeCode == columns.First(tpc => tpc.Key == metaCol.Name).Value);
Assert.True(metaCol.Table == tablename);
Assert.True(metaCol.Keyspace == (KeyspaceName ?? Keyspace));
}
if (tableOptions != null)
{
Assert.True(tableOptions.Equals(table.Options));
}
}
public static OutputProcessViewFactory Make(StatementSpecCompiled statementSpec, InternalEventRouter internalEventRouter, StatementContext statementContext, EventType resultEventType, OutputProcessViewCallback optionalOutputProcessViewCallback, TableService tableService, ResultSetProcessorType resultSetProcessorType, ResultSetProcessorHelperFactory resultSetProcessorHelperFactory, StatementVariableRef statementVariableRef)
{
// determine direct-callback
if (optionalOutputProcessViewCallback != null)
{
return(new OutputProcessViewFactoryCallback(optionalOutputProcessViewCallback));
}
// determine routing
bool isRouted = false;
bool routeToFront = false;
if (statementSpec.InsertIntoDesc != null)
{
isRouted = true;
routeToFront = statementContext.NamedWindowMgmtService.IsNamedWindow(statementSpec.InsertIntoDesc.EventTypeName);
}
OutputStrategyPostProcessFactory outputStrategyPostProcessFactory = null;
if ((statementSpec.InsertIntoDesc != null) || (statementSpec.SelectStreamSelectorEnum == SelectClauseStreamSelectorEnum.RSTREAM_ONLY))
{
SelectClauseStreamSelectorEnum?insertIntoStreamSelector = null;
string tableName = null;
if (statementSpec.InsertIntoDesc != null)
{
insertIntoStreamSelector = statementSpec.InsertIntoDesc.StreamSelector;
TableMetadata tableMetadata = tableService.GetTableMetadata(statementSpec.InsertIntoDesc.EventTypeName);
if (tableMetadata != null)
{
tableName = tableMetadata.TableName;
EPLValidationUtil.ValidateContextName(true, tableName, tableMetadata.ContextName, statementSpec.OptionalContextName, true);
statementVariableRef.AddReferences(statementContext.StatementName, tableMetadata.TableName);
}
}
outputStrategyPostProcessFactory = new OutputStrategyPostProcessFactory(isRouted, insertIntoStreamSelector, statementSpec.SelectStreamSelectorEnum, internalEventRouter, statementContext.EpStatementHandle, routeToFront, tableService, tableName);
}
// Do we need to enforce an output policy?
int streamCount = statementSpec.StreamSpecs.Length;
OutputLimitSpec outputLimitSpec = statementSpec.OutputLimitSpec;
bool isDistinct = statementSpec.SelectClauseSpec.IsDistinct;
bool isGrouped = statementSpec.GroupByExpressions != null && statementSpec.GroupByExpressions.GroupByNodes.Length > 0;
OutputProcessViewFactory outputProcessViewFactory;
if (outputLimitSpec == null)
{
if (!isDistinct)
{
outputProcessViewFactory = new OutputProcessViewDirectFactory(statementContext, outputStrategyPostProcessFactory, resultSetProcessorHelperFactory);
}
else
{
outputProcessViewFactory = new OutputProcessViewDirectDistinctOrAfterFactory(statementContext, outputStrategyPostProcessFactory, resultSetProcessorHelperFactory, isDistinct, null, null, resultEventType);
}
}
else if (outputLimitSpec.RateType == OutputLimitRateType.AFTER)
{
outputProcessViewFactory = new OutputProcessViewDirectDistinctOrAfterFactory(statementContext, outputStrategyPostProcessFactory, resultSetProcessorHelperFactory, isDistinct, outputLimitSpec.AfterTimePeriodExpr, outputLimitSpec.AfterNumberOfEvents, resultEventType);
}
else
{
try {
bool isWithHavingClause = statementSpec.HavingExprRootNode != null;
bool isStartConditionOnCreation = HasOnlyTables(statementSpec.StreamSpecs);
OutputConditionFactory outputConditionFactory = OutputConditionFactoryFactory.CreateCondition(outputLimitSpec, statementContext, isGrouped, isWithHavingClause, isStartConditionOnCreation, resultSetProcessorHelperFactory);
bool hasOrderBy = statementSpec.OrderByList != null && statementSpec.OrderByList.Length > 0;
OutputProcessViewConditionFactory.ConditionType conditionType;
bool hasAfter = outputLimitSpec.AfterNumberOfEvents != null || outputLimitSpec.AfterTimePeriodExpr != null;
bool isUnaggregatedUngrouped = resultSetProcessorType == ResultSetProcessorType.HANDTHROUGH || resultSetProcessorType == ResultSetProcessorType.UNAGGREGATED_UNGROUPED;
// hint checking with order-by
bool hasOptHint = HintEnum.ENABLE_OUTPUTLIMIT_OPT.GetHint(statementSpec.Annotations) != null;
if (hasOptHint && hasOrderBy)
{
throw new ExprValidationException("The " + HintEnum.ENABLE_OUTPUTLIMIT_OPT + " hint is not supported with order-by");
}
if (outputLimitSpec.DisplayLimit == OutputLimitLimitType.SNAPSHOT)
{
conditionType = OutputProcessViewConditionFactory.ConditionType.SNAPSHOT;
}
// For FIRST without groups we are using a special logic that integrates the first-flag, in order to still conveniently use all sorts of output conditions.
// FIRST with group-by is handled by setting the output condition to null (OutputConditionNull) and letting the ResultSetProcessor handle first-per-group.
// Without having-clause there is no required order of processing, thus also use regular policy.
else if (outputLimitSpec.DisplayLimit == OutputLimitLimitType.FIRST && statementSpec.GroupByExpressions == null)
{
conditionType = OutputProcessViewConditionFactory.ConditionType.POLICY_FIRST;
}
else if (isUnaggregatedUngrouped && outputLimitSpec.DisplayLimit == OutputLimitLimitType.LAST)
{
conditionType = OutputProcessViewConditionFactory.ConditionType.POLICY_LASTALL_UNORDERED;
}
else if (hasOptHint && outputLimitSpec.DisplayLimit == OutputLimitLimitType.ALL && !hasOrderBy)
{
conditionType = OutputProcessViewConditionFactory.ConditionType.POLICY_LASTALL_UNORDERED;
}
else if (hasOptHint && outputLimitSpec.DisplayLimit == OutputLimitLimitType.LAST && !hasOrderBy)
{
conditionType = OutputProcessViewConditionFactory.ConditionType.POLICY_LASTALL_UNORDERED;
}
else
{
conditionType = OutputProcessViewConditionFactory.ConditionType.POLICY_NONFIRST;
}
SelectClauseStreamSelectorEnum selectClauseStreamSelectorEnum = statementSpec.SelectStreamSelectorEnum;
bool terminable = outputLimitSpec.RateType == OutputLimitRateType.TERM || outputLimitSpec.IsAndAfterTerminate;
outputProcessViewFactory = new OutputProcessViewConditionFactory(statementContext, outputStrategyPostProcessFactory, isDistinct, outputLimitSpec.AfterTimePeriodExpr, outputLimitSpec.AfterNumberOfEvents, resultEventType, outputConditionFactory, streamCount, conditionType, outputLimitSpec.DisplayLimit, terminable, hasAfter, isUnaggregatedUngrouped, selectClauseStreamSelectorEnum, resultSetProcessorHelperFactory);
}
catch (Exception ex) {
throw new ExprValidationException("Error in the output rate limiting clause: " + ex.Message, ex);
}
}
return(outputProcessViewFactory);
}
protected abstract void ValidateBindingInternal(ExprValidationContext validationContext, TableMetadata tableMetadata);
/// <summary>
/// Returns a random existing Primary Key value
/// </summary>
private int GetRandomPK(Random rnd, TableMetadata table)
{
using (DataStressConnection conn = CreateConnection())
{
conn.Open();
// This technique to get a random row comes from http://www.4guysfromrolla.com/webtech/042606-1.shtml
// When you set rowcount and then select into a scalar value, then the query is optimised so that
// just the last value is selected. So if n = ROWCOUNT then the query returns the n'th row.
int rowNumber = rnd.Next(Depth);
DbCommand com = conn.CreateCommand();
string cmdText = string.Format(
@"SET ROWCOUNT {0};
DECLARE @PK INT;
SELECT @PK = PrimaryKey FROM {1} WITH(NOLOCK)
SELECT @PK", rowNumber, table.TableName);
com.CommandText = cmdText;
object result = com.ExecuteScalarSyncOrAsync(CancellationToken.None, rnd).Result;
if (result == DBNull.Value)
{
throw DataStressErrors.TestError(string.Format("Table {0} returned DBNull for primary key", table.TableName));
}
else
{
int primaryKey = (int)result;
return primaryKey;
}
}
}
public EPStatementDestroyCallbackTableUpdStr(TableService tableService, TableMetadata tableMetadata, string statementName)
{
_tableService = tableService;
_tableMetadata = tableMetadata;
_statementName = statementName;
}
// method used to create stress tables in the database
protected void BuildUserTables(List<TableMetadata> TableMetadataList)
{
string CreateTable1 =
"CREATE TABLE stress_test_table_1 (PrimaryKey int identity(1,1) primary key, int_FLD int, smallint_FLD smallint, real_FLD real, float_FLD float, decimal_FLD decimal(28,4), " +
"smallmoney_FLD smallmoney, bit_FLD bit, tinyint_FLD tinyint, uniqueidentifier_FLD uniqueidentifier, varbinary_FLD varbinary(756), binary_FLD binary(756), " +
"image_FLD image, varbinarymax_FLD varbinary(max), timestamp_FLD timestamp, char_FLD char(756), text_FLD text, varcharmax_FLD varchar(max), " +
"varchar_FLD varchar(756), nchar_FLD nchar(756), ntext_FLD ntext, nvarcharmax_FLD nvarchar(max), nvarchar_FLD nvarchar(756), datetime_FLD datetime, " +
"smalldatetime_FLD smalldatetime);" +
"CREATE UNIQUE INDEX stress_test_table_1 on stress_test_table_1 ( PrimaryKey );" +
"insert into stress_test_table_1(int_FLD, smallint_FLD, real_FLD, float_FLD, decimal_FLD, " +
"smallmoney_FLD, bit_FLD, tinyint_FLD, uniqueidentifier_FLD, varbinary_FLD, binary_FLD, " +
"image_FLD, varbinarymax_FLD, char_FLD, text_FLD, varcharmax_FLD, " +
"varchar_FLD, nchar_FLD, ntext_FLD, nvarcharmax_FLD, nvarchar_FLD, datetime_FLD, " +
"smalldatetime_FLD) values ( 0, 0, 0, 0, 0, $0, 0, 0, '00000000-0000-0000-0000-000000000000', " +
"0x00, 0x00, 0x00, 0x00, '0', '0', '0', '0', N'0', N'0', N'0', N'0', '01/11/2000 12:54:01', '01/11/2000 12:54:00' );"
;
string CreateTable2 =
"CREATE TABLE stress_test_table_2 (PrimaryKey int identity(1,1) primary key, bigint_FLD bigint, money_FLD money, numeric_FLD numeric, " +
"time_FLD time, date_FLD date, datetimeoffset_FLD datetimeoffset, sql_variant_FLD sql_variant, " +
"datetime2_FLD datetime2, xml_FLD xml);" +
"CREATE UNIQUE INDEX stress_test_table_2 on stress_test_table_2 ( PrimaryKey );" +
"insert into stress_test_table_2(bigint_FLD, money_FLD, numeric_FLD, " +
"time_FLD, date_FLD, datetimeoffset_FLD, sql_variant_FLD, " +
"datetime2_FLD, xml_FLD) values ( 0, $0, 0, '01/11/2015 12:54:01', '01/11/2015 12:54:01', '01/11/2000 12:54:01 -08:00', 0, '01/11/2000 12:54:01', '0' );"
;
if (TableMetadataList == null)
{
TableMetadataList = new List<TableMetadata>();
}
List<TableColumn> tableColumns1 = new List<TableColumn>();
tableColumns1.Add(new TableColumn("PrimaryKey", -1));
tableColumns1.Add(new TableColumn("int_FLD", -1));
tableColumns1.Add(new TableColumn("smallint_FLD", -1));
tableColumns1.Add(new TableColumn("real_FLD", -1));
tableColumns1.Add(new TableColumn("float_FLD", -1));
tableColumns1.Add(new TableColumn("decimal_FLD", -1));
tableColumns1.Add(new TableColumn("smallmoney_FLD", -1));
tableColumns1.Add(new TableColumn("bit_FLD", -1));
tableColumns1.Add(new TableColumn("tinyint_FLD", -1));
tableColumns1.Add(new TableColumn("uniqueidentifier_FLD", -1));
tableColumns1.Add(new TableColumn("varbinary_FLD", 756));
tableColumns1.Add(new TableColumn("binary_FLD", 756));
tableColumns1.Add(new TableColumn("image_FLD", -1));
tableColumns1.Add(new TableColumn("varbinarymax_FLD", -1));
tableColumns1.Add(new TableColumn("timestamp_FLD", -1));
tableColumns1.Add(new TableColumn("char_FLD", -1));
tableColumns1.Add(new TableColumn("text_FLD", -1));
tableColumns1.Add(new TableColumn("varcharmax_FLD", -1));
tableColumns1.Add(new TableColumn("varchar_FLD", 756));
tableColumns1.Add(new TableColumn("nchar_FLD", 756));
tableColumns1.Add(new TableColumn("ntext_FLD", -1));
tableColumns1.Add(new TableColumn("nvarcharmax_FLD", -1));
tableColumns1.Add(new TableColumn("nvarchar_FLD", 756));
tableColumns1.Add(new TableColumn("datetime_FLD", -1));
tableColumns1.Add(new TableColumn("smalldatetime_FLD", -1));
TableMetadata tableMeta1 = new TableMetadata("stress_test_table_1", tableColumns1);
TableMetadataList.Add(tableMeta1);
List<TableColumn> tableColumns2 = new List<TableColumn>();
tableColumns2.Add(new TableColumn("PrimaryKey", -1));
tableColumns2.Add(new TableColumn("bigint_FLD", -1));
tableColumns2.Add(new TableColumn("money_FLD", -1));
tableColumns2.Add(new TableColumn("numeric_FLD", -1));
tableColumns2.Add(new TableColumn("time_FLD", -1));
tableColumns2.Add(new TableColumn("date_FLD", -1));
tableColumns2.Add(new TableColumn("datetimeoffset_FLD", -1));
tableColumns2.Add(new TableColumn("sql_variant_FLD", -1));
tableColumns2.Add(new TableColumn("datetime2_FLD", -1));
tableColumns2.Add(new TableColumn("xml_FLD", -1));
TableMetadata tableMeta2 = new TableMetadata("stress_test_table_2", tableColumns2);
TableMetadataList.Add(tableMeta2);
using (DataStressConnection conn = CreateConnection(null))
{
conn.Open();
using (DbCommand com = conn.CreateCommand())
{
try
{
com.CommandText = CreateTable1;
com.ExecuteNonQuery();
}
catch (DbException de)
{
// This can be improved by doing a Drop Table if exists.
if (de.Message.Contains("There is already an object named \'" + tableMeta1.TableName + "\' in the database."))
{
CleanupUserTables(tableMeta1);
com.ExecuteNonQuery();
}
else
{
throw de;
}
}
try
{
com.CommandText = CreateTable2;
com.ExecuteNonQuery();
}
catch (DbException de)
{
// This can be improved by doing a Drop Table if exists in the query itself.
if (de.Message.Contains("There is already an object named \'" + tableMeta2.TableName + "\' in the database."))
{
CleanupUserTables(tableMeta2);
com.ExecuteNonQuery();
}
else
{
throw de;
}
}
for (int i = 0; i < Depth; i++)
{
TrackedRandom randomInstance = new TrackedRandom();
randomInstance.Mark();
DbCommand comInsert1 = GetInsertCommand(randomInstance, tableMeta1, conn);
comInsert1.ExecuteNonQuery();
DbCommand comInsert2 = GetInsertCommand(randomInstance, tableMeta2, conn);
comInsert2.ExecuteNonQuery();
}
}
}
}
/// <summary>
/// 生成创建表的 SQL 语句
/// </summary>
/// <param name="tableMetadata">表元数据</param>
/// <returns>SQL 语句</returns>
protected virtual string GenerateCreateTableSql(TableMetadata tableMetadata)
{
var isAutoIncrementPrimary = tableMetadata.IsAutoIncrementPrimary;
var tableName = GetNameSql(tableMetadata.Schema.Table);
var database = GetNameSql(tableMetadata.Schema.Database);
var builder = string.IsNullOrWhiteSpace(database)
? new StringBuilder($"IF OBJECT_ID('{tableName}', 'U') IS NULL BEGIN CREATE table {tableName} (")
: new StringBuilder(
$"USE {database}; IF OBJECT_ID('{tableName}', 'U') IS NULL BEGIN CREATE table {tableName} (");
foreach (var column in tableMetadata.Columns)
{
var isPrimary = tableMetadata.IsPrimary(column.Key);
var columnSql = GenerateColumnSql(column.Value, isPrimary);
if (isAutoIncrementPrimary && isPrimary)
{
builder.Append($"{columnSql} IDENTITY(1,1), ");
}
else
{
builder.Append($"{columnSql}, ");
}
}
builder.Remove(builder.Length - 2, 2);
if (tableMetadata.HasPrimary)
{
var primaryKeys = string.Join(", ", tableMetadata.Primary.Select(c => $"[{GetNameSql(c)}]"));
builder.Append(
$", CONSTRAINT [PK_{tableName}] PRIMARY KEY CLUSTERED ({primaryKeys}) WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = ON , ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON[PRIMARY]) ON[PRIMARY];");
}
else
{
builder.Append(") ON [PRIMARY];");
}
if (tableMetadata.Indexes.Count > 0)
{
foreach (var index in tableMetadata.Indexes)
{
var name = index.Name;
var columnNames = string.Join(", ", index.Columns.Select(c => $"[{GetNameSql(c)}]"));
if (index.IsUnique)
{
builder.Append(
$"CREATE UNIQUE NONCLUSTERED INDEX [INDEX_{name}] ON {tableName} ({columnNames}) {(StorageType == StorageType.InsertIgnoreDuplicate ? "WITH (IGNORE_DUP_KEY = ON)" : "")};");
}
else
{
builder.Append(
$"CREATE NONCLUSTERED INDEX [INDEX_{name}] ON {tableName} ({columnNames});");
}
}
}
builder.AppendLine(" END");
var sql = builder.ToString();
return(sql);
}
/// <summary>
/// 获取数据文件路径
/// </summary>
/// <param name="dfc">数据上下文件</param>
/// <param name="tableMetadata">表元数据</param>
/// <param name="extension">文件扩展名</param>
/// <returns></returns>
protected virtual string GetDataFile(DataFlowContext dfc, TableMetadata tableMetadata, string extension)
{
return(Path.Combine(GetDataFolder(dfc.Response.Request.OwnerId),
$"{GenerateFileName(tableMetadata)}.{extension}"));
}
protected override string GenerateCreateDatabaseSql(TableMetadata tableMetadata)
{
return(string.IsNullOrWhiteSpace(tableMetadata.Schema.Database)
? ""
: $"CREATE DATABASE {Escape}{GetNameSql(tableMetadata.Schema.Database)}{Escape} with encoding 'UTF-8';");
}
public static object BuildDataColumn(IQueryHelper queryHelper, IDbTransaction transaction, Int16 serverId, string database, string schema, TableMetadata table, ColumnDefinition col)
{
IDataBuilder builder = null;
var mustGenerate = false;
if (!string.IsNullOrWhiteSpace(col.BuilderName))
{
mustGenerate = true;
if (!CachedBuilders.ContainsKey(col.BuilderName))
{
var t = Type.GetType(col.BuilderName);
builder = FastActivator.CreateInstance(t) as IDataBuilder;
CachedBuilders.Add(col.BuilderName, builder);
}
else
{
builder = CachedBuilders[col.BuilderName];
}
}
else if (((col.IsPrimary && !col.IsAutoIncrement) || col.IsUniqueKey) && !col.IsForeignKey)
{
mustGenerate = true;
switch (col.DbType)
{
case DbType.Date:
case DbType.DateTime:
case DbType.DateTime2:
return(DateTime.Now);
case DbType.Byte:
case DbType.Decimal:
case DbType.Double:
case DbType.SByte:
case DbType.Single:
case DbType.Int16:
case DbType.Int32:
case DbType.Int64:
case DbType.UInt16:
case DbType.UInt32:
case DbType.UInt64:
builder = CachedBuilders["AutoIncrementDataBuilder"];
break;
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
case DbType.Guid:
case DbType.String:
case DbType.StringFixedLength:
builder = CachedBuilders["StringDataBuilder"];
break;
default:
throw new NotSupportedException($"The generation of the key failed. Please specify a databuilder " +
"in the configuration for {database}.{table}.{col.Name}");
}
}
//Generate data
if (mustGenerate)
{
if (builder == null)
{
throw new NullReferenceException($"Builder '{col.BuilderName}' for column '{col.Name}' is not found. Watch configuration file.");
}
return(builder.BuildData(queryHelper.Connection, transaction, queryHelper.Engine, serverId, database, schema, table, col));
}
return(null);
}
public static EPStatementStartMethodSelectDesc Prepare(StatementSpecCompiled statementSpec,
EPServicesContext services,
StatementContext statementContext,
bool recoveringResilient,
AgentInstanceContext defaultAgentInstanceContext,
bool queryPlanLogging,
ViewableActivatorFactory optionalViewableActivatorFactory,
OutputProcessViewCallback optionalOutputProcessViewCallback,
SelectExprProcessorDeliveryCallback selectExprProcessorDeliveryCallback)
{
// define stop and destroy
List <StopCallback> stopCallbacks = new List <StopCallback>();
EPStatementDestroyCallbackList destroyCallbacks = new EPStatementDestroyCallbackList();
// determine context
var contextName = statementSpec.OptionalContextName;
var contextPropertyRegistry = (contextName != null) ? services.ContextManagementService.GetContextDescriptor(contextName).ContextPropertyRegistry : null;
// Determine stream names for each stream - some streams may not have a name given
var streamNames = EPStatementStartMethodHelperUtil.DetermineStreamNames(statementSpec.StreamSpecs);
var numStreams = streamNames.Length;
if (numStreams == 0)
{
throw new ExprValidationException("The from-clause is required but has not been specified");
}
var isJoin = statementSpec.StreamSpecs.Length > 1;
var hasContext = statementSpec.OptionalContextName != null;
// First we create streams for subselects, if there are any
var subSelectStreamDesc = EPStatementStartMethodHelperSubselect.CreateSubSelectActivation(services, statementSpec, statementContext, destroyCallbacks);
// Create streams and views
var eventStreamParentViewableActivators = new ViewableActivator[numStreams];
var unmaterializedViewChain = new ViewFactoryChain[numStreams];
var eventTypeNames = new String[numStreams];
var isNamedWindow = new bool[numStreams];
var historicalEventViewables = new HistoricalEventViewable[numStreams];
// verify for joins that required views are present
var joinAnalysisResult = VerifyJoinViews(statementSpec, statementContext.NamedWindowService, defaultAgentInstanceContext);
var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false);
for (var i = 0; i < statementSpec.StreamSpecs.Length; i++)
{
var streamSpec = statementSpec.StreamSpecs[i];
var isCanIterateUnbound = streamSpec.ViewSpecs.Length == 0 &&
(services.ConfigSnapshot.EngineDefaults.ViewResourcesConfig.IsIterableUnbound ||
AnnotationUtil.FindAttribute(statementSpec.Annotations, typeof(IterableUnboundAttribute)) != null);
// Create view factories and parent view based on a filter specification
if (streamSpec is FilterStreamSpecCompiled)
{
var filterStreamSpec = (FilterStreamSpecCompiled)streamSpec;
eventTypeNames[i] = filterStreamSpec.FilterSpec.FilterForEventTypeName;
// Since only for non-joins we get the existing stream's lock and try to reuse it's views
var filterSubselectSameStream = EPStatementStartMethodHelperUtil.DetermineSubquerySameStream(statementSpec, filterStreamSpec);
// create activator
ViewableActivator activatorDeactivator;
if (optionalViewableActivatorFactory != null)
{
activatorDeactivator = optionalViewableActivatorFactory.CreateActivatorSimple(filterStreamSpec);
if (activatorDeactivator == null)
{
throw new IllegalStateException("Viewable activate is null for " + filterStreamSpec.FilterSpec.FilterForEventType.Name);
}
}
else
{
if (!hasContext)
{
activatorDeactivator = services.ViewableActivatorFactory.CreateStreamReuseView(
services, statementContext, statementSpec, filterStreamSpec, isJoin,
evaluatorContextStmt, filterSubselectSameStream, i, isCanIterateUnbound);
}
else
{
InstrumentationAgent instrumentationAgentFilter = null;
if (InstrumentationHelper.ENABLED)
{
var eventTypeName = filterStreamSpec.FilterSpec.FilterForEventType.Name;
var streamNumber = i;
instrumentationAgentFilter = new ProxyInstrumentationAgent()
{
ProcIndicateQ = () => InstrumentationHelper.Get().QFilterActivationStream(eventTypeName, streamNumber),
ProcIndicateA = () => InstrumentationHelper.Get().AFilterActivationStream(),
};
}
activatorDeactivator = services.ViewableActivatorFactory.CreateFilterProxy(
services, filterStreamSpec.FilterSpec, statementSpec.Annotations, false,
instrumentationAgentFilter, isCanIterateUnbound);
}
}
eventStreamParentViewableActivators[i] = activatorDeactivator;
var resultEventType = filterStreamSpec.FilterSpec.ResultEventType;
unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, resultEventType, streamSpec.ViewSpecs, streamSpec.Options, statementContext);
}
// Create view factories and parent view based on a pattern expression
else if (streamSpec is PatternStreamSpecCompiled)
{
var patternStreamSpec = (PatternStreamSpecCompiled)streamSpec;
var usedByChildViews = streamSpec.ViewSpecs.Length > 0 || (statementSpec.InsertIntoDesc != null);
var patternTypeName = statementContext.StatementId + "_pattern_" + i;
var eventType = services.EventAdapterService.CreateSemiAnonymousMapType(patternTypeName, patternStreamSpec.TaggedEventTypes, patternStreamSpec.ArrayEventTypes, usedByChildViews);
unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, eventType, streamSpec.ViewSpecs, streamSpec.Options, statementContext);
var rootFactoryNode = services.PatternNodeFactory.MakeRootNode(patternStreamSpec.EvalFactoryNode);
var patternContext = statementContext.PatternContextFactory.CreateContext(statementContext, i, rootFactoryNode, patternStreamSpec.MatchedEventMapMeta, true);
// create activator
ViewableActivator patternActivator = services.ViewableActivatorFactory.CreatePattern(
patternContext, rootFactoryNode, eventType,
EPStatementStartMethodHelperUtil.IsConsumingFilters(patternStreamSpec.EvalFactoryNode),
patternStreamSpec.IsSuppressSameEventMatches, patternStreamSpec.IsDiscardPartialsOnMatch,
isCanIterateUnbound);
eventStreamParentViewableActivators[i] = patternActivator;
}
// Create view factories and parent view based on a database SQL statement
else if (streamSpec is DBStatementStreamSpec)
{
ValidateNoViews(streamSpec, "Historical data");
var sqlStreamSpec = (DBStatementStreamSpec)streamSpec;
var typeConversionHook = (SQLColumnTypeConversion)TypeHelper.GetAnnotationHook(statementSpec.Annotations, HookType.SQLCOL, typeof(SQLColumnTypeConversion), statementContext.MethodResolutionService);
var outputRowConversionHook = (SQLOutputRowConversion)TypeHelper.GetAnnotationHook(statementSpec.Annotations, HookType.SQLROW, typeof(SQLOutputRowConversion), statementContext.MethodResolutionService);
var epStatementAgentInstanceHandle = defaultAgentInstanceContext.EpStatementAgentInstanceHandle;
var historicalEventViewable = DatabasePollingViewableFactory.CreateDBStatementView(
statementContext.StatementId, i, sqlStreamSpec,
services.DatabaseRefService,
services.EventAdapterService,
epStatementAgentInstanceHandle,
statementContext.Annotations,
typeConversionHook,
outputRowConversionHook,
statementContext.ConfigSnapshot.EngineDefaults.LoggingConfig.IsEnableADO);
historicalEventViewables[i] = historicalEventViewable;
unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(historicalEventViewable.EventType);
eventStreamParentViewableActivators[i] = new ProxyViewableActivator(
(agentInstanceContext, isSubselect, isRecoveringResilient) => new ViewableActivationResult(historicalEventViewable, CollectionUtil.STOP_CALLBACK_NONE, null, null, null, false, false, null));
stopCallbacks.Add(historicalEventViewable.Stop);
}
else if (streamSpec is MethodStreamSpec)
{
ValidateNoViews(streamSpec, "Method data");
var methodStreamSpec = (MethodStreamSpec)streamSpec;
var epStatementAgentInstanceHandle = defaultAgentInstanceContext.EpStatementAgentInstanceHandle;
var historicalEventViewable = MethodPollingViewableFactory.CreatePollMethodView(i, methodStreamSpec, services.EventAdapterService, epStatementAgentInstanceHandle, statementContext.MethodResolutionService, services.EngineImportService, statementContext.SchedulingService, statementContext.ScheduleBucket, evaluatorContextStmt, statementContext.VariableService, statementContext.ContextName);
historicalEventViewables[i] = historicalEventViewable;
unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(historicalEventViewable.EventType);
eventStreamParentViewableActivators[i] = new ProxyViewableActivator(
(agentInstanceContext, isSubselect, isRecoveringResilient) => new ViewableActivationResult(historicalEventViewable, CollectionUtil.STOP_CALLBACK_NONE, null, null, null, false, false, null));
stopCallbacks.Add(historicalEventViewable.Stop);
}
else if (streamSpec is TableQueryStreamSpec)
{
ValidateNoViews(streamSpec, "Table data");
TableQueryStreamSpec tableStreamSpec = (TableQueryStreamSpec)streamSpec;
if (isJoin && tableStreamSpec.FilterExpressions.Count > 0)
{
throw new ExprValidationException("Joins with tables do not allow table filter expressions, please add table filters to the where-clause instead");
}
TableMetadata metadata = services.TableService.GetTableMetadata(tableStreamSpec.TableName);
ExprEvaluator[] tableFilterEvals = null;
if (tableStreamSpec.FilterExpressions.Count > 0)
{
tableFilterEvals = ExprNodeUtility.GetEvaluators(tableStreamSpec.FilterExpressions);
}
EPLValidationUtil.ValidateContextName(true, metadata.TableName, metadata.ContextName, statementSpec.OptionalContextName, false);
eventStreamParentViewableActivators[i] = new ViewableActivatorTable(metadata, tableFilterEvals);
unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(metadata.InternalEventType);
eventTypeNames[i] = tableStreamSpec.TableName;
joinAnalysisResult.SetTablesForStream(i, metadata);
if (tableStreamSpec.Options.IsUnidirectional)
{
throw new ExprValidationException("Tables cannot be marked as unidirectional");
}
if (tableStreamSpec.Options.IsRetainIntersection || tableStreamSpec.Options.IsRetainUnion)
{
throw new ExprValidationException("Tables cannot be marked with retain");
}
if (isJoin)
{
destroyCallbacks.AddCallback(EPStatementDestroyCallbackTableIdxRef.New(services.TableService, metadata, statementContext.StatementName));
}
}
else if (streamSpec is NamedWindowConsumerStreamSpec)
{
var namedSpec = (NamedWindowConsumerStreamSpec)streamSpec;
var processor = services.NamedWindowService.GetProcessor(namedSpec.WindowName);
var namedWindowType = processor.TailView.EventType;
if (namedSpec.OptPropertyEvaluator != null)
{
namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType;
}
eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.CreateNamedWindow(processor, namedSpec.FilterExpressions, namedSpec.OptPropertyEvaluator);
unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, namedWindowType, namedSpec.ViewSpecs, namedSpec.Options, statementContext);
joinAnalysisResult.SetNamedWindow(i);
eventTypeNames[i] = namedSpec.WindowName;
isNamedWindow[i] = true;
// Consumers to named windows cannot declare a data window view onto the named window to avoid duplicate remove streams
EPStatementStartMethodHelperValidate.ValidateNoDataWindowOnNamedWindow(unmaterializedViewChain[i].FactoryChain);
}
else
{
throw new ExprValidationException("Unknown stream specification type: " + streamSpec);
}
}
// handle match-recognize pattern
if (statementSpec.MatchRecognizeSpec != null)
{
if (isJoin)
{
throw new ExprValidationException("Joins are not allowed when using match-recognize");
}
if (joinAnalysisResult.TablesPerStream[0] != null)
{
throw new ExprValidationException("Tables cannot be used with match-recognize");
}
var isUnbound = (unmaterializedViewChain[0].FactoryChain.IsEmpty()) && (!(statementSpec.StreamSpecs[0] is NamedWindowConsumerStreamSpec));
var factory = services.RegexHandlerFactory.MakeViewFactory(unmaterializedViewChain[0], statementSpec.MatchRecognizeSpec, defaultAgentInstanceContext, isUnbound, statementSpec.Annotations, services.ConfigSnapshot.EngineDefaults.MatchRecognizeConfig);
unmaterializedViewChain[0].FactoryChain.Add(factory);
EPStatementStartMethodHelperAssignExpr.AssignAggregations(factory.AggregationService, factory.AggregationExpressions);
}
// Obtain event types from view factory chains
var streamEventTypes = new EventType[statementSpec.StreamSpecs.Length];
for (var i = 0; i < unmaterializedViewChain.Length; i++)
{
streamEventTypes[i] = unmaterializedViewChain[i].EventType;
}
// Add uniqueness information useful for joins
joinAnalysisResult.AddUniquenessInfo(unmaterializedViewChain, statementSpec.Annotations);
// Validate sub-select views
var subSelectStrategyCollection = EPStatementStartMethodHelperSubselect.PlanSubSelect(services, statementContext, queryPlanLogging, subSelectStreamDesc, streamNames, streamEventTypes, eventTypeNames, statementSpec.DeclaredExpressions, contextPropertyRegistry);
// Construct type information per stream
StreamTypeService typeService = new StreamTypeServiceImpl(streamEventTypes, streamNames, EPStatementStartMethodHelperUtil.GetHasIStreamOnly(isNamedWindow, unmaterializedViewChain), services.EngineURI, false);
var viewResourceDelegateUnverified = new ViewResourceDelegateUnverified();
// Validate views that require validation, specifically streams that don't have
// sub-views such as DB SQL joins
var historicalViewableDesc = new HistoricalViewableDesc(numStreams);
for (var stream = 0; stream < historicalEventViewables.Length; stream++)
{
var historicalEventViewable = historicalEventViewables[stream];
if (historicalEventViewable == null)
{
continue;
}
historicalEventViewable.Validate(
services.EngineImportService,
typeService,
statementContext.MethodResolutionService,
statementContext.TimeProvider,
statementContext.VariableService,
statementContext.TableService,
statementContext.ScriptingService,
evaluatorContextStmt,
services.ConfigSnapshot,
services.SchedulingService,
services.EngineURI,
statementSpec.SqlParameters,
statementContext.EventAdapterService,
statementContext.StatementName,
statementContext.StatementId,
statementContext.Annotations);
historicalViewableDesc.SetHistorical(stream, historicalEventViewable.RequiredStreams);
if (historicalEventViewable.RequiredStreams.Contains(stream))
{
throw new ExprValidationException("Parameters for historical stream " + stream + " indicate that the stream is subordinate to itself as stream parameters originate in the same stream");
}
}
// unidirectional is not supported with into-table
if (joinAnalysisResult.IsUnidirectional && statementSpec.IntoTableSpec != null)
{
throw new ExprValidationException("Into-table does not allow unidirectional joins");
}
// Construct a processor for results posted by views and joins, which takes care of aggregation if required.
// May return null if we don't need to post-process results posted by views or joins.
var resultSetProcessorPrototypeDesc = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
statementSpec, statementContext, typeService, viewResourceDelegateUnverified, joinAnalysisResult.UnidirectionalInd, true, contextPropertyRegistry, selectExprProcessorDeliveryCallback, services.ConfigSnapshot);
// Validate where-clause filter tree, outer join clause and output limit expression
EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, viewResourceDelegateUnverified);
// Handle 'prior' function nodes in terms of view requirements
var viewResourceDelegateVerified = EPStatementStartMethodHelperViewResources.VerifyPreviousAndPriorRequirements(unmaterializedViewChain, viewResourceDelegateUnverified);
// handle join
JoinSetComposerPrototype joinSetComposerPrototype = null;
if (numStreams > 1)
{
var selectsRemoveStream = statementSpec.SelectStreamSelectorEnum.IsSelectsRStream() ||
statementSpec.OutputLimitSpec != null;
var hasAggregations = !resultSetProcessorPrototypeDesc.AggregationServiceFactoryDesc.Expressions.IsEmpty();
joinSetComposerPrototype = JoinSetComposerPrototypeFactory.MakeComposerPrototype(
statementContext.StatementName,
statementContext.StatementId,
statementSpec.OuterJoinDescList,
statementSpec.FilterRootNode,
typeService.EventTypes, streamNames,
joinAnalysisResult, queryPlanLogging,
statementContext,
historicalViewableDesc,
defaultAgentInstanceContext,
selectsRemoveStream,
hasAggregations,
services.TableService,
false);
}
// obtain factory for output limiting
var outputViewFactory = OutputProcessViewFactoryFactory.Make(
statementSpec, services.InternalEventRouter,
statementContext,
resultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultEventType,
optionalOutputProcessViewCallback,
services.TableService,
resultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultSetProcessorType);
// Factory for statement-context instances
var factoryX = new StatementAgentInstanceFactorySelect(
numStreams, eventStreamParentViewableActivators,
statementContext, statementSpec, services,
typeService, unmaterializedViewChain, resultSetProcessorPrototypeDesc, joinAnalysisResult, recoveringResilient,
joinSetComposerPrototype, subSelectStrategyCollection, viewResourceDelegateVerified, outputViewFactory);
EPStatementStopMethod stopMethod = new EPStatementStopMethodImpl(statementContext, stopCallbacks).Stop;
return(new EPStatementStartMethodSelectDesc(factoryX, subSelectStrategyCollection, viewResourceDelegateUnverified, resultSetProcessorPrototypeDesc, stopMethod, destroyCallbacks));
}
public static void SchemaCheck(Partition partition)
{
var changes = TableMetadata.GetChanges(partition);
ReportSchemaCheckChanges(changes);
}
public BookPersistentObject(TableMetadata mainTable)
: base(mainTable)
{
}
public static void SchemaCheck(ProviderDataSource source)
{
var changes = TableMetadata.GetChanges(source);
ReportSchemaCheckChanges(changes);
}
public BookPersistentObject(DatabaseServer database, string connectionString, TableMetadata mainTable)
: base(database, connectionString, mainTable)
{
}
/// <summary>
/// Load the result of an Sql query into the metadatas object.
/// </summary>
/// <param name="reader">Result of an Sql query defined in <see cref="MetadataProvider.SqlGetColumns"/></param>
/// <param name="metadata">Metadatas container</param>
/// <param name="serverId">ServerId loaded from</param>
/// <param name="database">Database loaded from</param>
/// <param name="typeConverter">Classe performing type conversion between database and .NET.</param>
internal static void LoadColumns(IDataReader reader, Metadatas metadata, string serverId, string database, ISqlTypeConverter typeConverter)
{
var schemaMetadata = new SchemaMetadata();
var lstSchemaColumn = new List <ColumnDefinition>();
string currentSchema;
if (!reader.Read())
{
return;
}
//Init first row
var previousSchema = reader.GetString(0);
var previousTable = new TableMetadata(reader.GetString(1));
//Pour chaque ligne
do
{
currentSchema = reader.GetString(0);
var currentTable = reader.GetString(1);
//Si on change de table
if (currentSchema != previousSchema || currentTable != previousTable.Name)
{
previousTable.ColumnsDefinition = lstSchemaColumn;
schemaMetadata.Add(previousTable);
lstSchemaColumn = new List <ColumnDefinition>();
previousTable = new TableMetadata(currentTable);
}
//Si on change de schema
if (currentSchema != previousSchema)
{
metadata[serverId, database, currentSchema] = schemaMetadata;
schemaMetadata = new SchemaMetadata();
}
//Ajoute la colonne
var col = new ColumnDefinition
{
Name = reader.GetString(2),
SqlType = new SqlType
{
DataType = reader.GetString(3),
Precision = reader.GetInt32(4),
Scale = reader.GetInt32(5),
IsUnsigned = reader.GetBoolean(6)
},
IsPrimary = reader.GetBoolean(7),
IsAutoIncrement = reader.GetBoolean(8)
};
col.DbType = typeConverter.ConvertFromSql(col.SqlType);
lstSchemaColumn.Add(col);
} while (reader.Read());
//Ajoute la dernière table / schema
if (lstSchemaColumn.Count > 0)
{
previousTable.ColumnsDefinition = lstSchemaColumn;
schemaMetadata.Add(previousTable);
metadata[serverId, database, currentSchema] = schemaMetadata;
}
}
public void SetTablesForStream(int streamNum, TableMetadata metadata)
{
this._tablesPerStream[streamNum] = metadata;
}
private LinearAggregationFactoryDesc HandleNonIntoTable(ExprNode[] childNodes, AggregationStateType stateType, ExprValidationContext validationContext)
{
var streamTypeService = validationContext.StreamTypeService;
int streamNum;
Type resultType;
ExprEvaluator evaluator;
ExprNode evaluatorIndex = null;
bool istreamOnly;
EventType containedType;
Type scalarCollectionComponentType = null;
// validate wildcard use
var isWildcard = childNodes.Length == 0 || childNodes.Length > 0 && childNodes[0] is ExprWildcard;
if (isWildcard)
{
ExprAggMultiFunctionUtil.ValidateWildcardStreamNumbers(validationContext.StreamTypeService, stateType.ToString().ToLower());
streamNum = 0;
containedType = streamTypeService.EventTypes[0];
resultType = containedType.UnderlyingType;
TableMetadata tableMetadata = validationContext.TableService.GetTableMetadataFromEventType(containedType);
evaluator = ExprNodeUtility.MakeUnderlyingEvaluator(0, resultType, tableMetadata);
istreamOnly = GetIstreamOnly(streamTypeService, 0);
if ((stateType == AggregationStateType.WINDOW) && istreamOnly && !streamTypeService.IsOnDemandStreams)
{
throw MakeUnboundValidationEx(stateType);
}
}
// validate "stream.*"
else if (childNodes.Length > 0 && childNodes[0] is ExprStreamUnderlyingNode)
{
streamNum = ExprAggMultiFunctionUtil.ValidateStreamWildcardGetStreamNum(childNodes[0]);
istreamOnly = GetIstreamOnly(streamTypeService, streamNum);
if ((stateType == AggregationStateType.WINDOW) && istreamOnly && !streamTypeService.IsOnDemandStreams)
{
throw MakeUnboundValidationEx(stateType);
}
var type = streamTypeService.EventTypes[streamNum];
containedType = type;
resultType = type.UnderlyingType;
TableMetadata tableMetadata = validationContext.TableService.GetTableMetadataFromEventType(type);
evaluator = ExprNodeUtility.MakeUnderlyingEvaluator(streamNum, resultType, tableMetadata);
}
// validate when neither wildcard nor "stream.*"
else
{
var child = childNodes[0];
var streams = ExprNodeUtility.GetIdentStreamNumbers(child);
if ((streams.IsEmpty() || (streams.Count > 1)))
{
throw new ExprValidationException(GetErrorPrefix(stateType) + " requires that any child expressions evaluate properties of the same stream; Use 'firstever' or 'lastever' or 'nth' instead");
}
streamNum = streams.First();
istreamOnly = GetIstreamOnly(streamTypeService, streamNum);
if ((stateType == AggregationStateType.WINDOW) && istreamOnly && !streamTypeService.IsOnDemandStreams)
{
throw MakeUnboundValidationEx(stateType);
}
resultType = childNodes[0].ExprEvaluator.ReturnType;
evaluator = childNodes[0].ExprEvaluator;
if (streamNum >= streamTypeService.EventTypes.Length)
{
containedType = streamTypeService.EventTypes[0];
}
else
{
containedType = streamTypeService.EventTypes[streamNum];
}
scalarCollectionComponentType = resultType;
}
if (childNodes.Length > 1)
{
if (stateType == AggregationStateType.WINDOW)
{
throw new ExprValidationException(GetErrorPrefix(stateType) + " does not accept an index expression; Use 'first' or 'last' instead");
}
evaluatorIndex = childNodes[1];
if (evaluatorIndex.ExprEvaluator.ReturnType != typeof(int?))
{
throw new ExprValidationException(GetErrorPrefix(stateType) + " requires an index expression that returns an integer value");
}
}
// determine accessor
AggregationAccessor accessor;
if (evaluatorIndex != null)
{
var isFirst = stateType == AggregationStateType.FIRST;
var constant = -1;
if (evaluatorIndex.IsConstantResult)
{
constant = evaluatorIndex.ExprEvaluator.Evaluate(new EvaluateParams(null, true, null)).AsInt();
}
accessor = new AggregationAccessorFirstLastIndexWEval(streamNum, evaluator, evaluatorIndex.ExprEvaluator, constant, isFirst);
}
else
{
if (stateType == AggregationStateType.FIRST)
{
accessor = new AggregationAccessorFirstWEval(streamNum, evaluator);
}
else if (stateType == AggregationStateType.LAST)
{
accessor = new AggregationAccessorLastWEval(streamNum, evaluator);
}
else if (stateType == AggregationStateType.WINDOW)
{
accessor = new AggregationAccessorWindowWEval(streamNum, evaluator, resultType);
}
else
{
throw new IllegalStateException("Access type is undefined or not known as code '" + stateType + "'");
}
}
var accessorResultType = resultType;
if (stateType == AggregationStateType.WINDOW)
{
accessorResultType = TypeHelper.GetArrayType(resultType);
}
var isFafWindow = streamTypeService.IsOnDemandStreams && stateType == AggregationStateType.WINDOW;
TableMetadata tableMetadataX = validationContext.TableService.GetTableMetadataFromEventType(containedType);
if (tableMetadataX == null && !isFafWindow && (istreamOnly || streamTypeService.IsOnDemandStreams))
{
var factoryX = new ExprAggMultiFunctionLinearAccessNodeFactoryMethod(this, containedType, accessorResultType, streamNum);
return(new LinearAggregationFactoryDesc(factoryX, containedType, scalarCollectionComponentType));
}
var stateKey = new AggregationStateKeyWStream(streamNum, containedType, AggregationStateTypeWStream.DATAWINDOWACCESS_LINEAR, new ExprNode[0]);
ExprNode me = this;
var theStreamNum = streamNum;
AggregationStateFactory stateFactory = new ProxyAggregationStateFactory
{
ProcCreateAccess = (methodResolutionService, agentInstanceId, groupId, aggregationId, join, groupKey, passThru) =>
{
if (join)
{
return(methodResolutionService.MakeAccessAggLinearJoin(agentInstanceId, groupId, aggregationId, theStreamNum, passThru));
}
return(methodResolutionService.MakeAccessAggLinearNonJoin(agentInstanceId, groupId, aggregationId, theStreamNum, passThru));
},
ProcAggregationExpression = () => me
};
var factory = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess(this, accessor, accessorResultType, containedType,
stateKey, stateFactory, AggregationAgentDefault.INSTANCE);
var enumerationType = scalarCollectionComponentType == null ? containedType : null;
return(new LinearAggregationFactoryDesc(factory, enumerationType, scalarCollectionComponentType));
}
public TableOnUpdateView(SubordWMatchExprLookupStrategy lookupStrategy, TableStateInstance rootView, ExprEvaluatorContext exprEvaluatorContext, TableMetadata metadata, TableOnUpdateViewFactory parent)
: base(lookupStrategy, rootView, exprEvaluatorContext, metadata, true)
{
this.parent = parent;
}
/// <summary>
/// Returns a random command object
/// </summary>
public DbCommand GetCommand(Random rnd, TableMetadata table, DataStressConnection conn, bool query, bool isXml = false)
{
if (query)
{
return GetSelectCommand(rnd, table, conn, isXml);
}
else
{
// make sure arguments are correct
DataStressErrors.Assert(!isXml, "wrong usage of GetCommand: cannot create command with FOR XML that is not query");
int select = rnd.Next(4);
switch (select)
{
case 0:
return GetUpdateCommand(rnd, table, conn);
case 1:
return GetInsertCommand(rnd, table, conn);
case 2:
return GetDeleteCommand(rnd, table, conn);
default:
return GetSelectCommand(rnd, table, conn);
}
}
}
public OrderPersistentObject(Session session, TableMetadata mainTable) : base(session, mainTable)
{
}
/// <summary>
/// Returns a SELECT command that retrieves data from a table
/// </summary>
private String GetSelectCommandForMultipleRows(Random rnd, DbCommand com, TableMetadata inputTable, bool isXml)
{
int rowcount = rnd.Next(Depth);
StringBuilder cmdText = new StringBuilder();
cmdText.Append("SELECT TOP ");
cmdText.Append(rowcount); //Jonfo added this to prevent table scan of 75k row tables
cmdText.Append(" PrimaryKey");
List<TableColumn> columns = inputTable.Columns;
int colindex = rnd.Next(0, columns.Count);
for (int i = 0; i <= colindex; i++)
{
if (columns[i].ColumnName == "PrimaryKey") continue;
cmdText.Append(", ");
cmdText.Append(columns[i].ColumnName);
}
cmdText.Append(" FROM \"");
cmdText.Append(inputTable.TableName);
cmdText.Append("\" WITH(NOLOCK) WHERE PrimaryKey ");
// We randomly pick an operator from '>' or '=' to allow for randomization
// of possible rows returned by this query. This approach *may* help
// in reducing the likelihood of multiple threads accessing same rows.
// If multiple threads access same rows, there may be locking issues
// which may be avoided because of this randomization.
string op = rnd.NextBool() ? ">" : "=";
cmdText.Append(op).Append(" ");
string pName = GetParameterName("P0");
cmdText.Append(pName);
DbParameter param = DbFactory.CreateParameter();
param.ParameterName = pName;
param.Value = GetRandomPK(rnd, inputTable);
param.DbType = DbType.Int32;
com.Parameters.Add(param);
return cmdText.ToString();
}
public OrderPersistentObject(EDatabase database, string connectionString, TableMetadata mainTable) : base(database, connectionString, mainTable)
{
}
/// <summary>
/// Returns a random UPDATE command
/// </summary>
public DbCommand GetUpdateCommand(Random rnd, TableMetadata table, DataStressConnection conn)
{
DbCommand com = CreateCommand(rnd, conn);
StringBuilder cmdText = new StringBuilder();
cmdText.Append("UPDATE \"");
cmdText.Append(table.TableName);
cmdText.Append("\" SET ");
List<TableColumn> columns = table.Columns;
int numColumns = rnd.Next(2, columns.Count);
bool mostlyNull = rnd.NextBool(0.1); // 10% of rows have 90% chance of each column being null, in order to test nbcrow
for (int i = 0; i < numColumns; i++)
{
if (columns[i].ColumnName == "PrimaryKey") continue;
if (columns[i].ColumnName.ToUpper() == "TIMESTAMP_FLD") continue;
if (i > 1) cmdText.Append(", ");
cmdText.Append(columns[i].ColumnName);
cmdText.Append(" = ");
if (mostlyNull && rnd.NextBool(0.9))
{
cmdText.Append("NULL");
}
else
{
DbParameter param = CreateRandomParameter(rnd, string.Format("P{0}", (i + 1)), columns[i]);
cmdText.Append(param.ParameterName);
com.Parameters.Add(param);
}
}
cmdText.Append(" WHERE PrimaryKey = ");
string pName = GetParameterName("P0");
cmdText.Append(pName);
DbParameter keyParam = DbFactory.CreateParameter();
keyParam.ParameterName = pName;
keyParam.Value = GetRandomPK(rnd, table);
com.Parameters.Add(keyParam);
if (ShouldModifySession(rnd))
{
cmdText.Append(";").Append(GetRandomSessionModificationStatement(rnd));
}
com.CommandText = cmdText.ToString(); ;
return com;
}
protected virtual string GenerateCreateDatabaseSql(TableMetadata tableMetadata)
{
return(string.IsNullOrWhiteSpace(tableMetadata.Schema.Database)
? ""
: $"CREATE SCHEMA IF NOT EXISTS `{GetNameSql(tableMetadata.Schema.Database)}` DEFAULT CHARACTER SET utf8mb4;");
}
/// <summary>
/// Returns a random DELETE command
/// </summary>
public DbCommand GetDeleteCommand(Random rnd, TableMetadata table, DataStressConnection conn)
{
DbCommand com = CreateCommand(rnd, conn);
StringBuilder cmdText = new StringBuilder();
cmdText.Append("DELETE FROM \"");
List<TableColumn> columns = table.Columns;
string pName = GetParameterName("P0");
cmdText.Append(table.TableName);
cmdText.Append("\" WHERE PrimaryKey = ");
cmdText.Append(pName);
DbParameter param = DbFactory.CreateParameter();
param.ParameterName = pName;
param.Value = GetRandomPK(rnd, table);
com.Parameters.Add(param);
if (ShouldModifySession(rnd))
{
cmdText.Append(";").Append(GetRandomSessionModificationStatement(rnd));
}
com.CommandText = cmdText.ToString();
return com;
}
public SqlQuery From(TableMetadata table, string alias = null)
{
return(new SqlQuery(table, Transaction(TransactionType.NoTransaction), alias));
}
// method used to delete stress tables in the database
protected void CleanupUserTables(TableMetadata tableMetadata)
{
string DropTable = "drop TABLE " + tableMetadata.TableName + ";";
using (DataStressConnection conn = CreateConnection(null))
{
conn.Open();
using (DbCommand com = conn.CreateCommand())
{
try
{
com.CommandText = DropTable;
com.ExecuteNonQuery();
}
catch (Exception) { }
}
}
}
IEnumerator TestRestTableAsync()
{
Terminal.LogImportant("TestRestTableAsync (This is really slow)");
// Make Table
var tableName = Strings.RandomString(10);
var meta1 = new TableMetadata
{
name = tableName,
provisionLoad = ProvisionLoad.Balanced,
provisionType = ProvisionType.Custom,
throughput = new TableThroughput(1, 1),
key = new TableKey(new Key("ID1", Key.DataType.STRING), new Key("ID2", Key.DataType.NUMBER)),
};
//CREATE
Terminal.Log("CREATE " + tableName);
var result1 = Repository.CreateTable(meta1);
yield return StartCoroutine(result1.WaitRoutine());
result1.ThrowIfFaulted();
if (result1.Result.hasError)
throw new Exception(result1.Result.error.message);
//wait...
var meta2 = WaitForTable(Repository, tableName);
yield return StartCoroutine(meta2.WaitRoutine());
meta2.ThrowIfFaulted();
//LIST
Terminal.Log("LIST");
var result4 = Repository.ListTables();
yield return StartCoroutine(result4.WaitRoutine());
result4.ThrowIfFaulted();
if (result4.Result.hasError)
throw new Exception(result4.Result.error.message);
Assert.IsTrue(result4.Result.data.tables.Any(), "request returned no results");
//UPDATE
Terminal.Log("UPDATE");
meta2.Result.throughput = new TableThroughput(2, 2);
meta2.Result.provisionType = ProvisionType.Custom;
var result3 = Repository.UpdateTable(meta2.Result);
yield return StartCoroutine(result3.WaitRoutine());
result3.ThrowIfFaulted();
if (result3.Result.hasError)
throw new Exception(result3.Result.error.message);
//wait...
var meta3 = WaitForTable(Repository, tableName, 5000);
yield return StartCoroutine(meta3.WaitRoutine());
meta3.ThrowIfFaulted();
//DELETE
Terminal.Log("DELETE");
var result5 = Repository.DeleteTable(tableName);
yield return StartCoroutine(result5.WaitRoutine());
result5.ThrowIfFaulted();
if (result5.Result.hasError)
throw new Exception(result5.Result.error.message);
Terminal.LogSuccess("Test Success");
}