/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer">The materializer.</param>
/// <returns>ExecutionToken<TCommand>.</returns>
public override CommandExecutionToken <OleDbCommand, OleDbParameter> Prepare(Materializer <OleDbCommand, OleDbParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyArgumentValue(DataSource, ArgumentValue, m_Options);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
var availableColumns = sqlBuilder.GetParameterizedColumns().ToList();
var sql = new StringBuilder($"MERGE INTO {Table.Name.ToQuotedString()} target USING ");
sql.Append("(VALUES (" + string.Join(", ", availableColumns.Select(c => "?")) + ")) AS source (" + string.Join(", ", availableColumns.Select(c => c.QuotedSqlName)) + ")");
sql.Append(" ON ");
sql.Append(string.Join(" AND ", sqlBuilder.GetKeyColumns().ToList().Select(c => $"target.{c.QuotedSqlName} = source.{c.QuotedSqlName}")));
sql.Append(" WHEN MATCHED THEN UPDATE SET ");
sql.Append(string.Join(", ", sqlBuilder.GetUpdateColumns().Select(x => $"{x.QuotedSqlName} = source.{x.QuotedSqlName}")));
var insertColumns = sqlBuilder.GetInsertColumns();
sql.Append(" WHEN NOT MATCHED THEN INSERT (");
sql.Append(string.Join(", ", insertColumns.Select(x => x.QuotedSqlName)));
sql.Append(") VALUES (");
sql.Append(string.Join(", ", insertColumns.Select(x => "source." + x.QuotedSqlName)));
sql.Append(" )");
sqlBuilder.BuildSelectClause(sql, " OUTPUT ", "Inserted.", null);
sql.Append(";");
return(new OleDbCommandExecutionToken(DataSource, "Insert or update " + Table.Name, sql.ToString(), sqlBuilder.GetParameters()));
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer">The materializer.</param>
/// <returns>ExecutionToken<TCommand>.</returns>
public override CommandExecutionToken <SqlCommand, SqlParameter> Prepare(Materializer <SqlCommand, SqlParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyArgumentValue(DataSource, ArgumentValue, m_Options);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
var prefix = m_Options.HasFlag(UpdateOptions.ReturnOldValues) ? "Deleted." : "Inserted.";
var sql = new StringBuilder();
string header;
string intoClause;
string footer;
sqlBuilder.UseTableVariable(Table, out header, out intoClause, out footer);
sql.Append(header);
sql.Append($"UPDATE {Table.Name.ToQuotedString()}");
sqlBuilder.BuildSetClause(sql, " SET ", null, null);
sqlBuilder.BuildSelectClause(sql, " OUTPUT ", prefix, intoClause);
sqlBuilder.BuildWhereClause(sql, " WHERE ", null);
sql.Append(";");
sql.Append(footer);
return(new SqlServerCommandExecutionToken(DataSource, "Update " + Table.Name, sql.ToString(), sqlBuilder.GetParameters()).CheckUpdateRowCount(m_Options));
}
public override CommandExecutionToken <SqlCommand, SqlParameter> Prepare(Materializer <SqlCommand, SqlParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = m_Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyTableType(DataSource, OperationTypes.Insert, m_TableType.Columns);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
var sql = new StringBuilder();
sqlBuilder.BuildInsertClause(sql, $"INSERT INTO {m_Table.Name.ToQuotedString()} (", null, ")");
sqlBuilder.BuildSelectClause(sql, " OUTPUT ", "Inserted.", null);
sqlBuilder.BuildSelectTvpForInsertClause(sql, " SELECT ", null, " FROM @ValuesParameter ");
sql.Append(";");
var parameters = sqlBuilder.GetParameters();
parameters.Add(new SqlParameter()
{
ParameterName = "@ValuesParameter",
Value = m_Source,
SqlDbType = SqlDbType.Structured,
TypeName = m_TableType.Name.ToQuotedString()
});
return(new SqlServerCommandExecutionToken(DataSource, "Insert batch into " + m_Table.Name, sql.ToString(), parameters));
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer"></param>
/// <returns><see cref="MySqlCommandExecutionToken" /></returns>
public override CommandExecutionToken <MySqlCommand, MySqlParameter> Prepare(Materializer <MySqlCommand, MySqlParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyArgumentValue(DataSource, ArgumentValue, m_Options);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
var sql = new StringBuilder();
if (m_Options.HasFlag(UpdateOptions.ReturnOldValues))
{
sqlBuilder.BuildSelectByKeyStatement(sql, Table.Name.ToQuotedString(), ";");
sql.AppendLine();
}
sqlBuilder.BuildUpdateByKeyStatement(sql, Table.Name.ToQuotedString(), ";");
if (!m_Options.HasFlag(UpdateOptions.ReturnOldValues))
{
sql.AppendLine();
sqlBuilder.BuildSelectByKeyStatement(sql, Table.Name.ToQuotedString(), ";");
}
return(new MySqlCommandExecutionToken(DataSource, "Update " + Table.Name, sql.ToString(), sqlBuilder.GetParameters()).CheckUpdateRowCount(m_Options));
}
public override IEnumerable <T> ExecuteQuery <T>(List <SqlStatement> statements, List <KeyValuePair <string, object> > constants)
{
using (var selectCommand = Connection.CreateCommand())
{
var sql = GetSql(statements);
selectCommand.CommandText = sql;
foreach (var parameter in constants)
{
selectCommand.Parameters.AddWithValue(parameter.Key, parameter.Value);
}
IDataReader reader;
try
{
reader = selectCommand.ExecuteReader();
}
catch (Exception e)
{
throw new InvalidOperationException(sql, e);
}
try
{
foreach (var record in Materializer.ReadTypedReader <T>(reader, LastSelectMembers))
{
yield return(record);
}
}
finally
{
reader.Dispose();
}
}
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer">The materializer.</param>
/// <returns>ExecutionToken<TCommand>.</returns>
public override CommandExecutionToken <OleDbCommand, OleDbParameter> Prepare(Materializer <OleDbCommand, OleDbParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyArgumentValue(DataSource, ArgumentValue, m_Options);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
var sql = new StringBuilder();
string header;
string intoClause;
string footer;
sqlBuilder.UseTableVariable(Table, out header, out intoClause, out footer);
sql.Append(header);
sql.Append("DELETE FROM " + Table.Name.ToQuotedString());
sqlBuilder.BuildSelectClause(sql, " OUTPUT ", "Deleted.", intoClause);
sqlBuilder.BuildAnonymousWhereClause(sql, " WHERE ", null, true);
sql.Append(";");
sql.Append(footer);
return(new OleDbCommandExecutionToken(DataSource, "Delete from " + Table.Name, sql.ToString(), sqlBuilder.GetParameters()));
}
public override CommandExecutionToken <SqlCommand, SqlParameter> Prepare(Materializer <SqlCommand, SqlParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = m_Function.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyRulesForSelect(DataSource);
if (m_FunctionArgumentValue != null)
{
sqlBuilder.ApplyArgumentValue(DataSource, OperationTypes.None, m_FunctionArgumentValue);
}
var sql = new StringBuilder();
sqlBuilder.BuildFromFunctionClause(sql, $"SELECT {m_Function.Name.ToQuotedString()} (", " )");
sql.Append(";");
List <SqlParameter> parameters;
parameters = sqlBuilder.GetParameters();
return(new SqlServerCommandExecutionToken(DataSource, "Query Function " + m_Function.Name, sql.ToString(), parameters));
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer">The materializer.</param>
/// <returns>ExecutionToken<TCommand>.</returns>
public override CommandExecutionToken <SqlCommand, SqlParameter> Prepare(Materializer <SqlCommand, SqlParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyArgumentValue(DataSource, ArgumentValue, m_Options);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
var sql = new StringBuilder();
string header;
string intoClause;
string footer;
sqlBuilder.UseTableVariable(Table, out header, out intoClause, out footer);
sql.Append(header);
sqlBuilder.BuildInsertClause(sql, $"INSERT INTO {Table.Name.ToQuotedString()} (", null, ")");
sqlBuilder.BuildSelectClause(sql, " OUTPUT ", "Inserted.", intoClause);
sqlBuilder.BuildValuesClause(sql, " VALUES (", ")");
sql.Append(";");
sql.Append(footer);
return(new SqlServerCommandExecutionToken(DataSource, "Insert into " + Table.Name, sql.ToString(), sqlBuilder.GetParameters()));
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer">The materializer.</param>
/// <returns>ExecutionToken<TCommand>.</returns>
public override CommandExecutionToken <OleDbCommand, OleDbParameter> Prepare(Materializer <OleDbCommand, OleDbParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = m_Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyArgumentValue(DataSource, m_NewValues, m_Options);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
var prefix = m_Options.HasFlag(UpdateOptions.ReturnOldValues) ? "Deleted." : "Inserted.";
var sql = new StringBuilder($"UPDATE {m_Table.Name.ToQuotedString()}");
sqlBuilder.BuildAnonymousSetClause(sql, " SET ", null, null);
sqlBuilder.BuildSelectClause(sql, " OUTPUT ", prefix, null);
sql.Append(" WHERE " + m_WhereClause);
sql.Append(";");
var parameters = sqlBuilder.GetParameters();
parameters.AddRange(m_Parameters);
return(new OleDbCommandExecutionToken(DataSource, "Update " + m_Table.Name, sql.ToString(), parameters).CheckUpdateRowCount(m_Options, m_ExpectedRowCount));
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer">The materializer.</param>
/// <returns>ExecutionToken<TCommand>.</returns>
public override CommandExecutionToken <SqlCommand, SqlParameter> Prepare(Materializer <SqlCommand, SqlParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyArgumentValue(DataSource, ArgumentValue, m_Options);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
if (KeyColumns.Count > 0)
{
sqlBuilder.OverrideKeys(KeyColumns);
}
var sql = new StringBuilder();
string?header;
string?intoClause;
string?footer;
sqlBuilder.UseTableVariable(Table, out header, out intoClause, out footer);
sql.Append(header);
sql.Append("DELETE FROM " + Table.Name.ToQuotedString());
sqlBuilder.BuildSelectClause(sql, " OUTPUT ", "Deleted.", intoClause);
sqlBuilder.BuildWhereClause(sql, " WHERE ", null);
sql.Append(";");
sql.Append(footer);
return(new SqlServerCommandExecutionToken(DataSource, "Delete from " + Table.Name, sql.ToString(), sqlBuilder.GetParameters()).CheckDeleteRowCount(m_Options));
}
public void ThenEachCategoryContainsData()
{
// Build
SqlConnection connection = (SqlConnection)DbConnectionFactory.Get().CreateIfNotExists("name=DefaultConnection");
SqlCommand command = connection.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "dbo.GetAllCategories";
// Operator
connection.OpenIfNot();
IDataReader queryResult = command.ExecuteReader();
Materializer <Category> categoryMaterializer = new Materializer <Category>(queryResult);
List <Category> categories = new List <Category>();
while (queryResult.Read())
{
categories.Add(categoryMaterializer.Materialize(queryResult));
}
// Check
foreach (Category cat in categories)
{
AssertPropertiesAreNotNull(cat.GetType(), cat);
}
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer"></param>
/// <returns><see cref="MySqlCommandExecutionToken" /></returns>
public override CommandExecutionToken <MySqlCommand, MySqlParameter> Prepare(Materializer <MySqlCommand, MySqlParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = Table.CreateSqlBuilder(StrictMode);
var desiredColumns = materializer.DesiredColumns();
sqlBuilder.ApplyArgumentValue(DataSource, ArgumentValue, m_Options, desiredColumns == Materializer.NoColumns);
sqlBuilder.ApplyDesiredColumns(desiredColumns);
if (KeyColumns.Count > 0)
{
sqlBuilder.OverrideKeys(KeyColumns);
}
var sql = new StringBuilder();
sqlBuilder.BuildSelectByKeyStatement(sql, Table.Name.ToQuotedString(), ";");
sql.AppendLine();
sqlBuilder.BuildDeleteStatement(sql, Table.Name.ToQuotedString(), ";");
return(new MySqlCommandExecutionToken(DataSource, "Delete from " + Table.Name, sql.ToString(), sqlBuilder.GetParameters()).CheckDeleteRowCount(m_Options));
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer"></param>
/// <returns><see cref="AccessCommandExecutionToken" /></returns>
public override CommandExecutionToken <OleDbCommand, OleDbParameter> Prepare(Materializer <OleDbCommand, OleDbParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = Table.CreateSqlBuilder(StrictMode);
var desiredColumns = materializer.DesiredColumns();
sqlBuilder.ApplyArgumentValue(DataSource, ArgumentValue, m_Options, desiredColumns == Materializer.NoColumns);
sqlBuilder.ApplyDesiredColumns(desiredColumns);
if (KeyColumns.Count > 0)
{
sqlBuilder.OverrideKeys(KeyColumns);
}
var sql = new StringBuilder();
sql.Append("DELETE FROM " + Table.Name.ToQuotedString());
sqlBuilder.BuildWhereClause(sql, " WHERE ", null);
sql.Append(";");
return(new AccessCommandExecutionToken(DataSource, "Delete from " + Table.Name, sql.ToString(), sqlBuilder.GetParameters(DataSource)).CheckDeleteRowCount(m_Options));
}
void UpdateGoalMaterial()
{
if (_goalLife <= 0)
{
Material newMaterial = Materializer.GetMaterial("Dead Goal");
gameObject.GetComponent <Renderer>().material = newMaterial;
}
}
private void Start()
{
rb = GetComponent <Rigidbody>();
materializer = GetComponent <Materializer>();
player = FindObjectOfType <Character>();
fader = GetComponent <FadeObject>();
stuckSpears = new List <Spear>();
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer">The materializer.</param>
/// <returns>ExecutionToken<TCommand>.</returns>
public override CommandExecutionToken <SqlCommand, SqlParameter> Prepare(Materializer <SqlCommand, SqlParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyArgumentValue(DataSource, ArgumentValue, m_Options);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
if (KeyColumns.Count > 0)
{
sqlBuilder.OverrideKeys(KeyColumns);
}
var availableColumns = sqlBuilder.GetParameterizedColumns().ToList();
var sql = new StringBuilder();
sqlBuilder.UseTableVariable(Table, out var header, out var intoClause, out var footer);
sql.Append(header);
var identityInsert = m_Options.HasFlag(UpsertOptions.IdentityInsert);
if (identityInsert)
{
sql.AppendLine($"SET IDENTITY_INSERT {Table.Name.ToQuotedString()} ON;");
}
sql.Append($"MERGE INTO {Table.Name.ToQuotedString()} WITH ( UPDLOCK, SERIALIZABLE ) target USING "); sql.Append("(VALUES (" + string.Join(", ", availableColumns.Select(c => c.SqlVariableName)) + ")) AS source (" + string.Join(", ", availableColumns.Select(c => c.QuotedSqlName)) + ")");
sql.Append(" ON ");
sql.Append(string.Join(" AND ", sqlBuilder.GetKeyColumns().ToList().Select(c => $"target.{c.QuotedSqlName} = source.{c.QuotedSqlName}")));
sql.Append(" WHEN MATCHED THEN UPDATE SET ");
sql.Append(string.Join(", ", sqlBuilder.GetUpdateColumns().Select(x => $"{x.QuotedSqlName} = source.{x.QuotedSqlName}")));
var insertColumns = sqlBuilder.GetInsertColumns(m_Options.HasFlag(UpsertOptions.IdentityInsert));
sql.Append(" WHEN NOT MATCHED THEN INSERT (");
sql.Append(string.Join(", ", insertColumns.Select(x => x.QuotedSqlName)));
sql.Append(") VALUES (");
sql.Append(string.Join(", ", insertColumns.Select(x => "source." + x.QuotedSqlName)));
sql.Append(" )");
sqlBuilder.BuildSelectClause(sql, " OUTPUT ", "Inserted.", intoClause);
sql.Append(";");
sql.Append(footer);
if (identityInsert)
{
sql.AppendLine($"SET IDENTITY_INSERT {Table.Name.ToQuotedString()} OFF;");
}
return(new SqlServerCommandExecutionToken(DataSource, "Insert or update " + Table.Name, sql.ToString(), sqlBuilder.GetParameters()));
}
void Awake()
{
rb = GetComponent <Rigidbody>();
materializer = GetComponent <Materializer>();
recovery = GetComponentInChildren <ToolRecovery>();
recovery.SetColliderActive(false);
damageText.enabled = false;
bodyCollider.enabled = false;
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer"></param>
/// <returns><see cref="AccessCommandExecutionToken" /></returns>
public override CommandExecutionToken <OleDbCommand, OleDbParameter> Prepare(Materializer <OleDbCommand, OleDbParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
if (!Table.IsTable)
{
throw new MappingException($"Cannot perform an update operation on the view {Table.Name}.");
}
if (!Table.HasPrimaryKey && !m_Options.HasFlag(UpdateOptions.UseKeyAttribute) && KeyColumns.Count == 0)
{
throw new MappingException($"Cannot perform an update operation on {Table.Name} unless UpdateOptions.UseKeyAttribute or .WithKeys() is specified.");
}
var sqlBuilder = Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyArgumentValue(DataSource, ArgumentValue, m_Options);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
if (KeyColumns.Count > 0)
{
sqlBuilder.OverrideKeys(KeyColumns);
}
var sql = new StringBuilder($"UPDATE {Table.Name.ToQuotedString()}");
sqlBuilder.BuildSetClause(sql, " SET ", null, null);
sqlBuilder.BuildWhereClause(sql, " WHERE ", null);
sql.Append(";");
var updateCommand = new AccessCommandExecutionToken(DataSource, "Update " + Table.Name, sql.ToString(), sqlBuilder.GetParametersKeysLast()).CheckUpdateRowCount(m_Options);
updateCommand.ExecutionMode = AccessCommandExecutionMode.NonQuery;
var desiredColumns = materializer.DesiredColumns();
if (desiredColumns == Materializer.NoColumns)
{
return(updateCommand);
}
if (m_Options.HasFlag(UpdateOptions.ReturnOldValues))
{
var result = PrepareRead(desiredColumns, "before");
result.NextCommand = updateCommand;
return(result);
}
else
{
updateCommand.NextCommand = PrepareRead(desiredColumns, "after");
return(updateCommand);
}
}
public override CommandExecutionToken <OleDbCommand, OleDbParameter> Prepare(Materializer <OleDbCommand, OleDbParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = m_Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
List <OleDbParameter> parameters;
var sql = new StringBuilder();
sql.Append("DELETE FROM " + m_Table.Name.ToQuotedString());
if (m_FilterValue != null)
{
sql.Append(" WHERE " + sqlBuilder.ApplyFilterValue(m_FilterValue, m_FilterOptions));
parameters = sqlBuilder.GetParameters();
}
else if (!string.IsNullOrWhiteSpace(m_WhereClause))
{
sql.Append(" WHERE " + m_WhereClause);
parameters = SqlBuilder.GetParameters <OleDbParameter>(m_ArgumentValue);
parameters.AddRange(sqlBuilder.GetParameters());
}
else
{
parameters = sqlBuilder.GetParameters();
}
sql.Append(";");
if (m_Parameters != null)
{
parameters.AddRange(m_Parameters);
}
var deleteCommand = new AccessCommandExecutionToken(DataSource, "Delete from " + m_Table.Name, sql.ToString(), parameters);
var desiredColumns = materializer.DesiredColumns();
if (desiredColumns == Materializer.NoColumns)
{
return(deleteCommand);
}
var result = PrepareRead(desiredColumns);
result.NextCommand = deleteCommand;
return(result);
//var sqlBuilder2
// sqlBuilder.BuildSelectClause(sql, "SELECT ", null, " FROM " + m_Table.Name.ToQuotedString());
// sql.AppendLine(" WHERE " + m_WhereClause + ";");
}
/// <summary>
/// Initializes a new instance of this class.
/// </summary>
/// <param name="dataSource">The data source.</param>
/// <param name="materializer">The materializer.</param>
/// <param name="resultAccessMethod">The value describing how it is supposed to access query result.</param>
/// <param name="tupleParameterBindings">The tuple parameter bindings.</param>
/// <param name="tupleParameters">The tuple parameters.</param>
public TranslatedQuery(ExecutableProvider dataSource,
Materializer materializer,
ResultAccessMethod resultAccessMethod,
Dictionary <Parameter <Tuple>, Tuple> tupleParameterBindings, IEnumerable <Parameter <Tuple> > tupleParameters)
{
DataSource = dataSource;
Materializer = materializer;
ResultAccessMethod = resultAccessMethod;
TupleParameterBindings = new Dictionary <Parameter <Tuple>, Tuple>(tupleParameterBindings);
TupleParameters = tupleParameters.ToList();
}
public override CommandExecutionToken <SqlCommand, SqlParameter> Prepare(Materializer <SqlCommand, SqlParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = m_Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
//This sets up the sqlBuilder. We're not actually going to build the parameters now
sqlBuilder.ApplyArgumentValue(DataSource, m_SourceList[0], m_Options);
var sql = new StringBuilder();
bool identityInsert = m_Options.HasFlag(InsertOptions.IdentityInsert);
if (identityInsert)
{
sql.AppendLine($"SET IDENTITY_INSERT {m_Table.Name.ToQuotedString()} ON;");
}
sqlBuilder.BuildInsertClause(sql, $"INSERT INTO {m_Table.Name.ToQuotedString()} (", null, ")", identityInsert);
sqlBuilder.BuildSelectClause(sql, " OUTPUT ", "Inserted.", null);
sql.AppendLine("VALUES");
var parameters = new List <SqlParameter>();
for (var i = 0; i < m_SourceList.Count; i++)
{
var parameterSuffix = "_" + i;
var footer = (i == m_SourceList.Count - 1) ? ");" : "),";
sqlBuilder.OverrideArgumentValue(DataSource, AuditRules.OperationTypes.Insert, m_SourceList[i]);
sqlBuilder.BuildValuesClause(sql, "(", footer, identityInsert, parameterSuffix, parameters, Utilities.ParameterBuilderCallback);
}
var maxParams = DataSource.DatabaseMetadata.MaxParameters !.Value;
if (parameters.Count > maxParams)
{
var parametersPerRow = parameters.Count / m_SourceList.Count;
var maxRows = maxParams / parametersPerRow;
throw new InvalidOperationException($"Batch insert exceeds SQL Server's parameter limit of {DataSource.DatabaseMetadata.MaxParameters}. Supply a table type, break the call into batches of {maxRows}, use InsertMultipleBatch, or use BulkInsert");
}
if (identityInsert)
{
sql.AppendLine($"SET IDENTITY_INSERT {m_Table.Name.ToQuotedString()} OFF;");
}
return(new SqlServerCommandExecutionToken(DataSource, "Insert batch into " + m_Table.Name, sql.ToString(), parameters));
}
internal static M Get(Identity id)
{
if (InstanceStore.HasCollection(id))
{
return(InstanceStore.GetInstance(id));
}
else
{
return(InstanceStore.AddInstanceFromStorage(id, Materializer.Read(Definitions.GetIdentities(id), Settings).ToList()).GetInstance());
}
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer"></param>
/// <returns><see cref="MySqlCommandExecutionToken" /></returns>
public override CommandExecutionToken <MySqlCommand, MySqlParameter> Prepare(Materializer <MySqlCommand, MySqlParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyArgumentValue(DataSource, ArgumentValue, m_Options);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
var identityInsert = m_Options.HasFlag(UpsertOptions.IdentityInsert);
var sql = new StringBuilder();
List <MySqlParameter> keyParameters;
var isPrimaryKeyIdentity = sqlBuilder.PrimaryKeyIsIdentity(out keyParameters);
if (isPrimaryKeyIdentity && !identityInsert)
{
var areKeysNull = keyParameters.Any(c => c.Value == DBNull.Value || c.Value == null) ? true : false;
if (areKeysNull)
{
sqlBuilder.BuildInsertStatement(sql, Table.Name.ToString(), null);
}
else
{
sqlBuilder.BuildUpdateByKeyStatement(sql, Table.Name.ToString(), null);
}
sql.Append(";");
}
else
{
sqlBuilder.BuildInsertClause(sql, $"INSERT INTO {Table.Name.ToString()} (", null, ")", identityInsert);
sqlBuilder.BuildValuesClause(sql, " VALUES (", ")", identityInsert);
sqlBuilder.BuildSetClause(sql, $" ON DUPLICATE KEY UPDATE ", null, null);
sql.Append(";");
}
if (sqlBuilder.HasReadFields)
{
var keys = sqlBuilder.GetKeyColumns().ToList();
if (keys.Count != 1)
{
throw new NotSupportedException("Cannot return data from a MySQL Upsert unless there is a single primary key.");
}
var key = keys[0];
sqlBuilder.BuildSelectClause(sql, "SELECT ", null, $" FROM {Table.Name.ToQuotedString()} WHERE {key.QuotedSqlName} = CASE WHEN {key.SqlVariableName} IS NULL OR {key.SqlVariableName} = 0 THEN LAST_INSERT_ID() ELSE {key.SqlVariableName} END;");
}
return(new MySqlCommandExecutionToken(DataSource, "Insert or update " + Table.Name, sql.ToString(), sqlBuilder.GetParameters()));
}
/// <summary>
/// Executes the provided <paramref name="command"/>
/// against the provided data source and returns the result.
/// </summary>
/// <param name="context">Provides the current operation context.</param>
/// <param name="command">The command instance to execute.</param>
protected override TEntity ExecuteCommand(DbOperationContext context,
DbCommandDescriptor command)
{
return(context.Provider.Execute(command).AsDataReader <TEntity>(reader => {
if (reader.Read())
{
return Materializer.Materialize(reader);
}
return default(TEntity);
}));
}
public override CommandExecutionToken <MySqlCommand, MySqlParameter> Prepare(Materializer <MySqlCommand, MySqlParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = m_Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
List <MySqlParameter> parameters;
var sql = new StringBuilder();
if (sqlBuilder.HasReadFields)
{
sqlBuilder.BuildSelectClause(sql, "SELECT ", null, " FROM " + m_Table.Name.ToQuotedString());
if (m_FilterValue != null)
{
sql.Append(" WHERE " + sqlBuilder.ApplyFilterValue(m_FilterValue, m_FilterOptions));
}
else if (!string.IsNullOrWhiteSpace(m_WhereClause))
{
sql.Append(" WHERE " + m_WhereClause);
}
sql.AppendLine(";");
}
sql.Append("DELETE FROM " + m_Table.Name.ToQuotedString());
if (m_FilterValue != null)
{
sql.Append(" WHERE " + sqlBuilder.ApplyFilterValue(m_FilterValue, m_FilterOptions));
parameters = sqlBuilder.GetParameters();
}
else if (!string.IsNullOrWhiteSpace(m_WhereClause))
{
sql.Append(" WHERE " + m_WhereClause);
parameters = SqlBuilder.GetParameters <MySqlParameter>(m_ArgumentValue);
parameters.AddRange(sqlBuilder.GetParameters());
}
else
{
parameters = sqlBuilder.GetParameters();
}
sql.Append(";");
if (m_Parameters != null)
{
parameters.AddRange(m_Parameters);
}
return(new MySqlCommandExecutionToken(DataSource, "Delete from " + m_Table.Name, sql.ToString(), parameters));
}
/// <summary>
/// Executes the provided <paramref name="command"/>
/// against the provided data source and returns the result.
/// </summary>
/// <param name="context">Provides the current operation context.</param>
/// <param name="command">The command instance to execute.</param>
protected override IEnumerable <TEntity> ExecuteCommand(DbOperationContext context,
DbCommandDescriptor command)
{
return(context.Provider.Execute(command).AsDataReader(reader => {
List <TEntity> collection = new List <TEntity>(BufferSize);
while (reader.Read())
{
collection.Add(Materializer.Materialize(reader));
}
return collection;
}));
}
public JournalSequenceActor(IReadJournalDAO readJournalDao,
JournalSequenceRetrievalConfig config)
{
_mat =
Materializer.CreateSystemMaterializer((ExtendedActorSystem)Context.System,
ActorMaterializerSettings.Create(Context.System),
"linq2db-query");
_readJournalDao = readJournalDao;
_config = config;
queryDelay = config.QueryDelay;
maxTries = config.MaxTries;
_log = Context.GetLogger();
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer"></param>
/// <returns><see cref="MySqlCommandExecutionToken" /></returns>
public override CommandExecutionToken <MySqlCommand, MySqlParameter> Prepare(Materializer <MySqlCommand, MySqlParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var identityInsert = m_Options.HasFlag(InsertOptions.IdentityInsert);
var sqlBuilder = Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyArgumentValue(DataSource, ArgumentValue, m_Options);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
if (KeyColumns.Count > 0)
{
sqlBuilder.OverrideKeys(KeyColumns);
}
var sql = new StringBuilder();
sqlBuilder.BuildInsertClause(sql, $"INSERT INTO {Table.Name.ToString()} (", null, ")", identityInsert);
sqlBuilder.BuildValuesClause(sql, " VALUES (", ");", identityInsert);
if (sqlBuilder.HasReadFields)
{
var identityColumn = Table.Columns.Where(c => c.IsIdentity).SingleOrDefault();
if (!identityInsert && identityColumn != null)
{
sqlBuilder.BuildSelectClause(sql, "SELECT ", null, null);
sql.Append(" FROM " + Table.Name.ToQuotedString());
sql.Append(" WHERE " + identityColumn.QuotedSqlName + " = LAST_INSERT_ID()");
sql.Append(";");
}
else
{
var primaryKeys = Table.PrimaryKeyColumns;
if (primaryKeys.Count == 0)
{
throw new MappingException($"Insert operation cannot return any values for { Table.Name} because it doesn't have a primary key.");
}
sqlBuilder.BuildSelectClause(sql, "SELECT ", null, null);
sql.Append(" FROM " + Table.Name.ToQuotedString());
sqlBuilder.BuildWhereClause(sql, " WHERE ", null);
sql.Append(";");
}
}
return(new MySqlCommandExecutionToken(DataSource, "Insert into " + Table.Name, sql.ToString(), sqlBuilder.GetParameters()));
}
/// <summary>
/// Prepares the command for execution by generating any necessary SQL.
/// </summary>
/// <param name="materializer"></param>
/// <returns><see cref="AccessCommandExecutionToken" /></returns>
public override CommandExecutionToken <OleDbCommand, OleDbParameter> Prepare(Materializer <OleDbCommand, OleDbParameter> materializer)
{
if (materializer == null)
{
throw new ArgumentNullException(nameof(materializer), $"{nameof(materializer)} is null.");
}
var sqlBuilder = m_Table.CreateSqlBuilder(StrictMode);
sqlBuilder.ApplyArgumentValue(DataSource, m_NewValues, m_Options);
sqlBuilder.ApplyDesiredColumns(materializer.DesiredColumns());
var sql = new StringBuilder($"UPDATE {m_Table.Name.ToQuotedString()}");
sqlBuilder.BuildSetClause(sql, " SET ", null, null);
sql.Append(" WHERE " + m_WhereClause);
sql.Append(";");
var parameters = sqlBuilder.GetParameters();
if (m_Parameters != null)
{
parameters.AddRange(m_Parameters);
}
var updateCommand = new AccessCommandExecutionToken(DataSource, "Update " + m_Table.Name, sql.ToString(), parameters).CheckUpdateRowCount(m_Options, m_ExpectedRowCount);
updateCommand.ExecutionMode = AccessCommandExecutionMode.NonQuery;
var desiredColumns = materializer.DesiredColumns();
if (desiredColumns == Materializer.NoColumns)
{
return(updateCommand);
}
if (m_Options.HasFlag(UpdateOptions.ReturnOldValues))
{
var result = PrepareRead(desiredColumns);
result.NextCommand = updateCommand;
return(result);
}
else
{
updateCommand.NextCommand = PrepareRead(desiredColumns);
return(updateCommand);
}
}
public void OnDownstreamFinish()
{
// Do Nothing until `timeout` to try and intercept completion as downstream,
// but cancel stream after timeout if inlet is not closed to prevent deadlock.
Materializer.ScheduleOnce(_timeout, () =>
{
var cb = GetAsyncCallback(() =>
{
if (!IsClosed(_nextElem))
{
FailStage(new InvalidOperationException($"unfoldFlow source's inner flow canceled only upstream, while downstream remain available for {_timeout}"));
}
});
cb();
});
}
public void ThenCategoryShaperIsCreated()
{
// Build
IDbConnection connection = DbConnectionFactory.Get().CreateIfNotExists("name=DefaultConnection");
IDbCommand command = connection.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "dbo.GetAllCategories";
// Operator
connection.OpenIfNot();
IDataReader queryResult = command.ExecuteReader();
Materializer<Category> categoryMaterializer = new Materializer<Category>(queryResult);
// Check
Assert.IsInstanceOfType(categoryMaterializer, typeof(Materializer<Category>));
}
public void ThenCollectionOfCategoriesReturned()
{
// Build
SqlConnection connection = (SqlConnection)DbConnectionFactory.Get().CreateIfNotExists("name=DefaultConnection");
SqlCommand command = connection.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "dbo.GetAllCategories";
// Operator
connection.OpenIfNot();
IDataReader queryResult = command.ExecuteReader();
Materializer<Category> categoryMaterializer = new Materializer<Category>(queryResult);
List<Category> categories = new List<Category>();
while (queryResult.Read())
{
categories.Add(categoryMaterializer.Materialize(queryResult));
}
// Check
Assert.IsTrue(categories.Any());
}
public void ThenEmptyCategoryCollectionIsReturned()
{
// Build
SqlConnection connection = (SqlConnection)DbConnectionFactory.Get().CreateIfNotExists("name=DefaultConnection");
SqlCommand command = connection.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "dbo.GetCategory";
command.Parameters.AddWithValue("Id", SomeCategoryId);
// Operator
connection.OpenIfNot();
IDataReader queryResult = command.ExecuteReader();
Materializer<Category> categoryMaterializer = new Materializer<Category>(queryResult);
List<Category> categories = new List<Category>();
while (queryResult.Read())
{
categories.Add(categoryMaterializer.Materialize(queryResult));
}
// Check
Assert.IsTrue(categories.Count() == 0);
}
public void ThenEachCategoryContainsData()
{
// Build
SqlConnection connection = (SqlConnection)DbConnectionFactory.Get().CreateIfNotExists("name=DefaultConnection");
SqlCommand command = connection.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "dbo.GetAllCategories";
// Operator
connection.OpenIfNot();
IDataReader queryResult = command.ExecuteReader();
Materializer<Category> categoryMaterializer = new Materializer<Category>(queryResult);
List<Category> categories = new List<Category>();
while (queryResult.Read())
{
categories.Add(categoryMaterializer.Materialize(queryResult));
}
// Check
foreach (Category cat in categories)
{
AssertPropertiesAreNotNull(cat.GetType(), cat);
}
}
