protected void Execute <T>(InsertQuery <T> query, InsertExecutor <T> executor)
where T : DataRecord
{
var item = query.CreateWork(executor);
Client.EnqueueWork(item);
}
public async Task <bool> ParseInsert(InsertQuery query, IQueryParsingContext context)
{
if (query.TableName != "smart_scripts")
{
return(false);
}
var entry = query.Columns.IndexOfIgnoreCase("entryorguid");
var scriptSourceType = query.Columns.IndexOfIgnoreCase("source_type");
if (entry == -1 || scriptSourceType == -1)
{
return(false);
}
HashSet <(int, SmartScriptType)> pairs = new();
foreach (var insert in query.Inserts)
{
if (insert[entry] is long entryValue &&
insert[scriptSourceType] is long scriptSourceTypeValue)
{
pairs.Add(((int)entryValue, (SmartScriptType)scriptSourceTypeValue));
}
}
foreach (var pair in pairs)
{
context.ProduceItem(new SmartScriptSolutionItem(pair.Item1, pair.Item2));
}
return(true);
}
public void GenerateDeclarations()
{
var Mappings = new MappingSource(new IMapping[] {
new BaseClass1Mapping(),
new ConcreteClass1Mapping(),
new ConcreteClass2Mapping(),
new ConcreteClass3Mapping(),
new IInterface1Mapping(),
new IInterface2Mapping()
},
new MockDatabaseMapping(),
new QueryProviderManager(new[] { new SQLServerQueryProvider(Configuration, ObjectPool) }, Logger),
Canister.Builder.Bootstrapper.Resolve <ILogger>(),
ObjectPool);
var TestObject = new InsertQuery <ConcreteClass1>(Mappings, ObjectPool);
var Result = TestObject.GenerateDeclarations();
Assert.Equal(CommandType.Text, Result[0].DatabaseCommandType);
Assert.Empty(Result[0].Parameters);
Assert.Equal("DECLARE @IInterface1_ID_Temp AS INT;", Result[2].QueryString);
Assert.Equal(QueryType.Insert, Result[0].QueryType);
Assert.Equal(CommandType.Text, Result[1].DatabaseCommandType);
Assert.Empty(Result[1].Parameters);
Assert.Equal("DECLARE @BaseClass1_ID_Temp AS BIGINT;", Result[1].QueryString);
Assert.Equal(QueryType.Insert, Result[1].QueryType);
Assert.Equal(CommandType.Text, Result[2].DatabaseCommandType);
Assert.Empty(Result[2].Parameters);
Assert.Equal("DECLARE @ConcreteClass1_ID_Temp AS BIGINT;", Result[0].QueryString);
Assert.Equal(QueryType.Insert, Result[2].QueryType);
}
/// <summary>
/// parses <see cref="InsertQuery"/> having <paramref name="tableName"/> from
/// <paramref name="rowDataXmlNode"/>.
/// </summary>
/// <param name="rowDataXmlNode"></param>
/// <param name="tableName"></param>
/// <returns>
/// <see cref="InsertQuery"/> having <paramref name="tableName"/> parsed from
/// <paramref name="rowDataXmlNode"/>
/// </returns>
/// <exception cref="InsertQueryParseException">
/// thrown if <see cref="InsertQuery"/> parse failed
/// </exception>
public static InsertQuery Parse(XmlNode rowDataXmlNode, string tableName)
{
try
{
// get ValuedColumns
XmlNodeList valuedColumnsXmlNodeList = rowDataXmlNode.GetNodes("column");
// number of specified columns might be zero (?)
ValuedColumn[] valuedColumns = new ValuedColumn[valuedColumnsXmlNodeList.Count];
for (int i = 0; i < valuedColumnsXmlNodeList.Count; i++)
{
XmlNode valuedColumnXmlNode = valuedColumnsXmlNodeList[0];
valuedColumns[i] = ValuedColumn.Parse(valuedColumnXmlNode);
}
InsertQuery insertQuery = new InsertQuery(tableName, valuedColumns);
return(insertQuery);
}
catch (XmlNodeMissingAttributeException xmlNodeMissingAttributeException)
{
throw new InsertQueryParseException(xmlNodeMissingAttributeException);
}
}
/// Dictionary Mode
public InsertQuery GetInsertQueryDict(Dictionary <string, object> data, List <string> columns)
{
InsertQuery QData = new InsertQuery();
if (columns == null || data == null)
{
return(QData);
}
DynamicParameters dp = new DynamicParameters();
StringBuilder values = new StringBuilder();
StringBuilder cols = new StringBuilder();
foreach (var kp in data)
{
if (!columns.Exists(p => kp.Key == p))
{
continue;
}
string kpt = tableUtils.GenUniqParam(kp.Key);
cols.Append(kp.Key + ",");
values.Append("@" + kpt + ",");
dp.Add("@" + kpt, kp.Value);
}
values.Remove(values.Length - 1, 1);
cols.Remove(cols.Length - 1, 1);
tableUtils.ResetUniqParam();
QData.Values = values.ToString();
QData.Param = dp;
QData.Columns = cols.ToString();
return(QData);
}
/// <summary>
/// Inserts the item into the connection.
/// </summary>
/// <returns>The insert.</returns>
/// <param name="connection">Connection.</param>
/// <param name="item">Item.</param>
/// <param name="cancellationToken">Cancellation token.</param>
public async Task ExecuteInsert(Connection connection, T item, CancellationToken cancellationToken)
{
var columns = new List <QueryColumn>();
foreach (var mapping in TableMappings)
{
var column = Table.Columns[mapping.Position];
if (column.DeltaType != TableColumn.EDeltaType.AutoIncrement)
{
var value = TryParse(column.DataType, mapping.PropertyInfo.GetValue(item));
var queryColumn = new QueryColumn(column, value);
columns.Add(queryColumn);
}
}
var insertQuery = new InsertQuery(Table.Name, columns);
var insertResult = await connection.ExecuteInsert(Table, new List <InsertQuery>() { insertQuery }, cancellationToken);
if (AutoIncrementProperty != null)
{
AutoIncrementProperty.SetValue(item, insertResult);
}
}
public void SqlServerInsertQuery_ShouldGenQuery()
{
// Arrange
var command = new System.Data.SqlClient.SqlCommand();
var db = MockRepository.GenerateStub <IDataMapper>();
db.Expect(d => d.Command).Return(command);
ColumnMapCollection columns = MapRepository.Instance.GetColumns(typeof(Person));
MappingHelper mappingHelper = new MappingHelper(db);
Person person = new Person();
person.ID = 1;
person.Name = "Jordan";
person.Age = 33;
person.IsHappy = true;
person.BirthDate = new DateTime(1977, 1, 22);
mappingHelper.CreateParameters <Person>(person, columns, true);
IQuery query = new InsertQuery(new SqlServerDialect(), columns, command, "dbo.People");
// Act
string queryText = query.Generate();
// Assert
Assert.IsNotNull(queryText);
Assert.IsTrue(queryText.Contains("INSERT INTO [dbo].[People]"));
Assert.IsFalse(queryText.Contains("@ID"), "Should not contain ID column since it is marked as AutoIncrement");
Assert.IsTrue(queryText.Contains("[Name]"), "Should contain the name column");
}
public void WhenColumnNameDiffersFromProperty_InsertQueryShouldUseColumnName()
{
// Arrange
Person2 person = new Person2 {
Name = "Bob", Age = 40, BirthDate = DateTime.Now
};
Dialect dialect = new SqlServerDialect();
ColumnMapCollection mappings = MapRepository.Instance.GetColumns(typeof(Person2));
var command = new System.Data.SqlClient.SqlCommand();
var db = MockRepository.GenerateStub <IDataMapper>();
db.Expect(d => d.Command).Return(command);
var mappingHelper = new MappingHelper(db);
mappingHelper.CreateParameters <Person2>(person, mappings, true);
string targetTable = "PersonTable";
InsertQuery query = new InsertQuery(dialect, mappings, command, targetTable);
// Act
string queryText = query.Generate();
// Assert
Assert.IsTrue(queryText.Contains("[PersonName]"), "Query should contain column name");
Assert.IsTrue(queryText.Contains("[PersonAge]"), "Query should contain column name");
Assert.IsTrue(queryText.Contains("[BirthDate]"), "Query should contain property name");
Assert.IsTrue(queryText.Contains("[IsHappy]"), "Query should contain property name");
}
public bool Insert(T t)
{
try
{
IDbCommand cmd = connection.CreateCommand();
cmd.Parameters.Clear();
var iq = new InsertQuery(Entity);
cmd.CommandType = CommandType.Text;
cmd.CommandText = iq.GetQuerywithParameter(t);
iq.SetParameter(ref cmd, t);
var result = (Int32)cmd.ExecuteNonQuery();
if (result > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (MySqlException ex)
{
throw new System.Exception(Helpers.ErrorHandle(ex));
}
}
protected void RenderInsert(InsertQuery query)
{
string sql = Renderer.RenderInsert(query);
Console.WriteLine(sql);
RunSql(sql);
}
public void GenerateQuery()
{
var Mappings = new MappingSource(new IMapping[] {
new BaseClass1Mapping(),
new ConcreteClass1Mapping(),
new ConcreteClass2Mapping(),
new ConcreteClass3Mapping(),
new IInterface1Mapping(),
new IInterface2Mapping()
},
new MockDatabaseMapping(),
new QueryProviderManager(new[] { new SQLServerQueryProvider(Configuration, ObjectPool) }, Logger),
Canister.Builder.Bootstrapper.Resolve <ILogger>(),
ObjectPool);
var TestObject = new InsertQuery <ConcreteClass1>(Mappings, ObjectPool);
var Result = TestObject.GenerateQueries(new ConcreteClass1 {
ID = 10, BaseClassValue1 = 1, Value1 = 2
})[0];
Assert.Equal(CommandType.Text, Result.DatabaseCommandType);
Assert.Equal(3, Result.Parameters.Length);
Assert.Equal(10, Result.Parameters[0].InternalValue);
Assert.Equal("ID", Result.Parameters[0].ID);
Assert.Equal(1, Result.Parameters[2].InternalValue);
Assert.Equal("BaseClassValue1", Result.Parameters[2].ID);
Assert.Equal(2, Result.Parameters[1].InternalValue);
Assert.Equal("Value1", Result.Parameters[1].ID);
Assert.Equal("INSERT INTO [dbo].[IInterface1_] DEFAULT VALUES;\r\nSET @IInterface1_ID_Temp=SCOPE_IDENTITY();\r\nSELECT @IInterface1_ID_Temp AS [ID];\r\n\r\nINSERT INTO [dbo].[BaseClass1_]([dbo].[BaseClass1_].[BaseClassValue1_],[dbo].[BaseClass1_].[IInterface1_ID_]) VALUES (@BaseClassValue1,@IInterface1_ID_Temp);\r\nSET @BaseClass1_ID_Temp=SCOPE_IDENTITY();\r\n\r\nINSERT INTO [dbo].[ConcreteClass1_]([dbo].[ConcreteClass1_].[Value1_],[dbo].[ConcreteClass1_].[BaseClass1_ID_]) VALUES (@Value1,@BaseClass1_ID_Temp);\r\n", Result.QueryString);
Assert.Equal(QueryType.Insert, Result.QueryType);
}
//[ExpectedException(typeof(InvalidQueryException))]
public void InvalidInsert2()
{
InsertQuery query = new InsertQuery("products");
//RenderInsert(query);
Assert.Throws <InvalidQueryException>(() => RenderInsert(query));
}
public void GenerateQueryWithMapPropertiesWithValue()
{
var Mappings = new MappingSource(new IMapping[] {
new AllReferencesAndIDMappingWithDatabase(),
new MapPropertiesMapping()
},
new MockDatabaseMapping(),
new QueryProviderManager(new[] { new SQLServerQueryProvider(Configuration, ObjectPool) }, Logger),
Canister.Builder.Bootstrapper.Resolve <ILogger>(),
ObjectPool);
Mappings.Mappings[typeof(MapProperties)].MapProperties.First().Setup(Mappings);
var TestObject = new InsertQuery <MapProperties>(Mappings, ObjectPool);
var Result = TestObject.GenerateQueries(new MapProperties {
ID = 10, BoolValue = true, MappedClass = new AllReferencesAndID {
ID = 1
}
})[0];
Assert.Equal(CommandType.Text, Result.DatabaseCommandType);
Assert.Equal(2, Result.Parameters.Length);
Assert.Equal(10, Result.Parameters[0].InternalValue);
Assert.Equal("ID", Result.Parameters[0].ID);
Assert.True((bool)Result.Parameters[1].InternalValue);
Assert.Equal("BoolValue", Result.Parameters[1].ID);
Assert.Equal("INSERT INTO [dbo].[MapProperties_]([dbo].[MapProperties_].[BoolValue_]) VALUES (@BoolValue);\r\nSET @MapProperties_ID_Temp=SCOPE_IDENTITY();\r\nSELECT @MapProperties_ID_Temp AS [ID];\r\n", Result.QueryString);
Assert.Equal(QueryType.Insert, Result.QueryType);
}
internal InsertQuery CreateSingleInsertQuery(ReflectionTable reflectionTable,
Object viewModel,
Dictionary <string, string> joinPropTable,
bool storeIdInTempTable,
ref int lastParamId)
{
var cols = reflectionTable.Cols
.Where(q => q.Name != reflectionTable.PrimaryKey.Name)
.ToArray();
var result = new InsertQuery()
{
Params = new List <SqlParameter>()
};
var outPut = "";
var varSet = "";
if (storeIdInTempTable)
{
result.TempTableName = reflectionTable.TableName + lastParamId;
result.Pre = $@"declare @{result.TempTableName}Scalar {reflectionTable.PrimaryKey.Type.ToString()}
create table #{result.TempTableName} ([{reflectionTable.PrimaryKey.Name}] {reflectionTable.PrimaryKey.Type.ToString()}){Environment.NewLine}";
outPut += $@"output inserted.[{reflectionTable.PrimaryKey.Name}] into #{result.TempTableName}{Environment.NewLine}";
varSet = $@"SELECT @{result.TempTableName}Scalar = [{reflectionTable.PrimaryKey.Name}] from #{result.TempTableName}
drop table #{result.TempTableName}{Environment.NewLine}";
}
string query = $@"insert into [{reflectionTable.TableName}] ";
string queryVars = string.Join(",", cols.Select(q => q.Name));
string queryValues = "";
foreach (var col in cols)
{
if (joinPropTable.ContainsKey(col.Name))
{
queryValues += "@" + joinPropTable[col.Name] + "Scalar,";
}
else
{
lastParamId++;
var parname = "Param" + lastParamId;
queryValues += "@" + parname + ",";
var paraval = PropertyReflectionHelper.GetPropValue(viewModel, col.Name);
var sqlParam = new SqlParameter(parname, paraval);
if (paraval == null)
{
sqlParam.SqlValue = DBNull.Value;
}
result.Params.Add(sqlParam);
}
}
queryValues = queryValues.Substring(0, queryValues.Length - 1);
query += $@"({queryVars})
{outPut}
values ({queryValues})
{varSet}{Environment.NewLine}";
result.Main = query;
return(result);
}
private static async Task CreateInsertTeamsSql()
{
const string InsertQuery = @"
INSERT INTO livematches.Teams(Code, Name)
VALUES ({{Code}}, {{Name}});
";
var path = "Teams/teams.txt";
var contents = await File.ReadAllLinesAsync(path);
var teamCodeLine = 21;
var teamCodes = contents[teamCodeLine].Split('\t');
var builder = new StringBuilder();
for (var i = 0; i < 20; i++)
{
var insert = InsertQuery.Replace("{{Code}}", $"'{teamCodes[i]}'").Replace("{{Name}}", $"'{contents[i]}'");
builder.AppendLine(insert);
}
var sql = builder.ToString();
}
public bool InsertItem <T>(string tableName, T data, List <string> cols)
{
InsertQuery QData = GetInsertQueryData <T>(data, cols);
string sql = string.Format("INSERT INTO {0} ( {1} ) VALUES ( {2} );", tableName, QData.Columns, QData.Values);
return(conn.Execute(sql, QData.Param, transaction) > 0);
}
public void ToString_NullTableName()
{
//Arrange
InsertQuery q = new InsertQuery();
//Act
q.ToString();
}
private void Dispose(bool disposing)
{
AccessSemaphore?.Dispose();
InsertQuery?.Dispose();
UpdateQuery?.Dispose();
DeleteQuery?.Dispose();
SelectHashQuery?.Dispose();
}
public string SiteQuery()
{
InsertQuery query = new InsertQuery(packet.TerminalId);
query.AddField(new Field(nameof(ReceivedOn), packet.ReceivedOn));
query.AddFieldRange(packet.FilterFields);
query.AddFieldRange(packet.Fields);
return(query.ToQuery());
}
public string RealTimeInsertQuery()
{
InsertQuery query = new InsertQuery(RealTimeData);
query.AddField(new Field(nameof(ReceivedOn), packet.ReceivedOn));
query.AddFieldRange(packet.FilterFields);
query.AddFieldRange(packet.Fields);
return(query.ToQuery());
}
public IQueryable <T> Includ(IQueryable <T> query, Expression <Func <T, dynamic> > expression)
{
var job = new CollectPropertyFromExpression().Translate(expression);
foreach (T Item in query)
{
foreach (PropertyInfo propertyJOb in job)
{
EntityInfo entityChild = null;
if (propertyJOb.PropertyType.GenericTypeArguments.Count() > 0)
{
entityChild = new EntityInfo(propertyJOb.PropertyType.GenericTypeArguments[0]);
string vsql = new InsertQuery(Entity).GetChildInsertQuery(propertyJOb, Item, entityChild);
if (vsql != string.Empty)
{
IDataReader dr = null;
try
{
IDbCommand cmd = connection.CreateCommand();
cmd.CommandType = CommandType.Text;
cmd.CommandText = vsql;
dr = cmd.ExecuteReader();
var propertyproduct = Entity.GetPropertyByPropertyName(propertyJOb.Name);
IList list = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(entityChild.GetEntityType()));
var map = new MappingColumn(Entity);
var resultMapping = (IList)map.MappingWithoutInclud(dr, entityChild.GetEntityType());
foreach (var item in resultMapping)
{
list.Add(item);
}
propertyproduct.SetValue(Item, list, null);
}
catch (Exception ex)
{
throw new System.Exception(ex.Message);
}
finally
{
if (dr != null)
{
dr.Close();
}
}
}
}
else
{
entityChild = new EntityInfo(propertyJOb.ReflectedType);
}
}
}
return(query);
}
public virtual ParameterizedQuery ParseInsertQuery(InsertQuery query)
{
Builder = Builder ?? Db.ServiceProvider.GetService <IParameterizedQueryBuilder>();
ParseInsertIntoClause(query.Into);
ParseInsertColumnsClause(query.Columns);
ParseInsertValues(query.Values);
return(Builder.BuildQuery(new DbQueryConfigures()));
}
public virtual ParameterizedQuery ParseInsertQuery(InsertQuery query)
{
Builder = Builder ?? Db.DbContext.GetParameterizedQueryBuilder();
ParseInsertIntoClause(query.Into);
ParseInsertColumnsClause(query.Columns);
ParseInsertValues(query.Values);
return(Builder.BuildQuery(new DbQueryConfigures()));
}
async Task Reschedule(ScheduledEvent sched, DateTime next)
{
InsertQuery query = new InsertQuery("scheduled_events");
query.Value("event_id", sched.Event.ID)
.Value("next_time", next)
.Value("recurrence", sched.SetReccurence);
await Program.MySql().ExecuteNonQuery(query);
}
public virtual ParameterizedQuery ParseInsertQuery(InsertQuery query)
{
builder = QueryService.CreateQueryBuild();
ParseInsertIntoClause(query.Into);
ParseInsertColumnsClause(query.Columns);
ParseInsertValues(query.Values);
return(builder.BuildQuery(new DbQueryConfigures()));
}
public void Insert()
{
InsertQuery query = new InsertQuery("products");
query.Terms.Add(new UpdateTerm("productId", SqlExpression.Number(999)));
query.Terms.Add(new UpdateTerm("name", SqlExpression.String("Temporary Test Product")));
query.Terms.Add(new UpdateTerm("price", SqlExpression.Number(123.45)));
query.Terms.Add(new UpdateTerm("quantaty", SqlExpression.Number(97)));
RenderInsert(query);
}
public async Task InsertPosts(IEnumerable <Post> posts)
{
using (var rentedConnection = await ConnectionPool.RentConnectionAsync())
using (var clonedCommand = (MySqlCommand)InsertQuery.Clone())
using (var transaction = await rentedConnection.Object.BeginTransactionAsync())
using (var clonedSet = postDataTable.Clone())
using (var adapter = new MySqlDataAdapter($"SELECT * FROM {Board} WHERE 1 = 0", rentedConnection.Object))
{
clonedCommand.Connection = rentedConnection;
clonedCommand.Transaction = transaction;
clonedCommand.UpdatedRowSource = UpdateRowSource.None;
foreach (var post in posts)
{
var row = clonedSet.NewRow();
row["num"] = post.PostNumber;
row["thread_num"] = post.ReplyPostNumber != 0 ? post.ReplyPostNumber : post.PostNumber;
row["op"] = post.ReplyPostNumber == 0 ? 1 : 0;
row["timestamp"] = post.UnixTimestamp;
row["timestamp_expired"] = 0;
row["preview_orig"] = post.TimestampedFilename.HasValue ? $"{post.TimestampedFilename}s.jpg" : null;
row["preview_w"] = post.ThumbnailWidth ?? 0;
row["preview_h"] = post.ThumbnailHeight ?? 0;
row["media_filename"] = post.OriginalFilenameFull;
row["media_w"] = post.ImageWidth ?? 0;
row["media_h"] = post.ImageHeight ?? 0;
row["media_size"] = post.FileSize ?? 0;
row["media_hash"] = post.FileMd5;
row["media_orig"] = post.TimestampedFilenameFull;
row["spoiler"] = post.SpoilerImage == true ? 1 : 0;
row["deleted"] = 0;
row["capcode"] = post.Capcode?.Substring(0, 1).ToUpperInvariant() ?? "N";
row["email"] = null; // 4chan api doesn't supply this????
row["name"] = HttpUtility.HtmlDecode(post.Name);
row["trip"] = post.Trip;
row["title"] = HttpUtility.HtmlDecode(post.Subject);
row["comment"] = post.Comment;
row["sticky"] = post.Sticky == true ? 1 : 0;
row["locked"] = post.Closed == true ? 1 : 0;
row["poster_hash"] = post.PosterID == "Developer" ? "Dev" : post.PosterID;
row["poster_country"] = post.CountryCode;
clonedSet.Rows.Add(row);
}
adapter.InsertCommand = clonedCommand;
adapter.UpdateBatchSize = 100;
await adapter.UpdateAsync(clonedSet);
transaction.Commit();
}
}
/// <summary>
/// returns the <see cref="InsertQuery"/> performed on the instance of
/// <paramref name="auditTableSchema"/> corresponding to <paramref name="auditedTableSchema"/>,
/// when audit is triggered by query of <paramref name="queryType"/>, performed on
/// <paramref name="auditedTableSchema"/>.
/// </summary>
/// <param name="auditedTableSchema"></param>
/// <param name="auditTableSchema"></param>
/// <param name="queryType"></param>
/// <returns>
/// <see cref="InsertQuery"/> performed on the instance of
/// <paramref name="auditTableSchema"/> corresponding to <paramref name="auditedTableSchema"/>,
/// when audit is triggered by query of <paramref name="queryType"/>, performed on
/// <paramref name="auditedTableSchema"/>
/// </returns>
private static InsertQuery getOnTriggerAuditInsertQuery(
TableSchema auditedTableSchema,
TableSchema auditTableSchema,
Query.eQueryType queryType)
{
InsertQuery onTriggerAuditInsertQuery;
// init trigger InsertQuery ValuedColumn list with:
// 0. ID corresponding to a query of type queryType,
// which was performed on triggeredTableSchema and triggered the audit
// 1. ID of row which was triggered
List <ValuedColumn> triggerInsertQueryValuedColumns = new List <ValuedColumn>()
{
new ValuedColumn(
auditTableSchema.ColumnSchemas[1].Name,
getQueryTypeIdSelectQuery(queryType)),
getAuditedTableTriggeredRowIdValuedColumn(
auditedTableSchema,
auditTableSchema,
queryType)
};
// add values of rest of ValuedColumns of row which was triggered in
// auditedTable
// convert each (non-primary key) ValuedColumn (key, value) of triggered row in
// auditedTable,
// into a TriggerValuedColumn (key, [TriggerValuedColumn.eTime].key)
// in the auditTable InsertQuery
// (note that column names in auditTable starting from index 3 match column names in
// auditedTable starting from index 1)
TriggerValuedColumn.ValueExpression.eTime triggerValuedColumnTime =
queryType == Query.eQueryType.Insert
? TriggerValuedColumn.ValueExpression.eTime.New
: TriggerValuedColumn.ValueExpression.eTime.Old;
TriggerValuedColumn[] auditTableTriggerValueColumns =
auditedTableSchema.ColumnSchemas.Subarray(1).Select(
columnSchema => new TriggerValuedColumn(
columnSchema.Name,
columnSchema.Name,
triggerValuedColumnTime)
).ToArray();
// add ValuedColumns to ValuedColumn list
triggerInsertQueryValuedColumns.AddRange(auditTableTriggerValueColumns);
// init InsertQuery
onTriggerAuditInsertQuery = new InsertQuery(
auditTableSchema.Name,
triggerInsertQueryValuedColumns.ToArray()
);
return(onTriggerAuditInsertQuery);
}
public void Insert(StudentStatusDo studentStatus)
{
if (studentStatus == null)
{
throw new Exception("An insert with null value can't be made!");
}
var query = InsertQuery.Create("studentStatuses", studentStatus);
database.Execute(query);
}
public void ToString_EmptyTableName()
{
//Arrange
InsertQuery q = new InsertQuery()
{
TableName = ""
};
//Act
q.ToString();
}
Tuple<bool, int> InsertObject(InsertQuery insertQuery)
{
AskObject obj = insertQuery.askObject;
float[] coord = obj.position;
lock (engaged) {
try {
KdTreeNode<float, int>[] neighbors = KDTree.RadialSearch (coord, 2 * maxRadius, 100);
if (neighbors.Length >= 1) {
return new Tuple<bool, int> (false, -1);
}
obj.objectId = maxObjectId + 1;
bool ifadd = KDTree.Add (obj.position, obj.objectId);
if (!ifadd) {
Console.WriteLine ("Object already present.");
return new Tuple<bool, int> (false, -3);
}
idMap.Add (obj.objectId, obj);
maxObjectId++;
} catch (Exception e) {
Console.WriteLine (e.Message);
return new Tuple<bool, int> (false, -2);
}
}
//KdTreeNode<float, int>[] myNeigh = KDTree.RadialSearch (new float[2] { 0.0f, 0.0f }, 1000000, 100);
//Console.WriteLine ("Tree has " + myNeigh.Length.ToString () + " Children");
return new Tuple<bool, int> (true, insertQuery.askObject.objectId);
}
