private void ExecuteExpressionCommand()
{
SQLExpression expression;
bool editExpression = InSQLExpression(out expression);
string expressionText = editExpression ? '=' + expression.ExpressionText : String.Empty;
IExpression modifiedValue;
if (designerContext.EditExpression(expressionText, out modifiedValue))
{
string wrappedExpression = string.Empty;
if (!modifiedValue.IsEmpty)
{
wrappedExpression = SqlStringHandler.CreateSqlExpression(modifiedValue.GetExpression());
}
if (editExpression)
{
Regex replaceRegex = new Regex(SqlStringHandler.expressionPattern);
SQL = replaceRegex.Replace(SQL, wrappedExpression, 1, expression.StartIndex);
}
else
{
SQL = SQL.Insert(SQLIndex, wrappedExpression);
}
}
}
private void RefreshExpressionParameters(string expressionName, string propertyName)
{
for (int i = 0; Properties.ContainsId(expressionName + i); i++)
{
Properties.Remove(expressionName + i);
}
if (!Properties.Contains(propertyName))
{
return;
}
var property = Properties[propertyName];
var expressionText = property.Value as string ?? string.Empty;
if (!string.IsNullOrEmpty(expressionText))
{
var index = 0;
SqlStringHandler.GetSqlStringHandler(expressionText).Expressions.ForEach(
expression =>
Properties.Add(new Property(expressionName + (index++), typeof(object), ValueUseOption.RuntimeRead, Context.CreateExpression(expression.ExpressionText))
{
IsVisible = false
}));
}
}
private void ExecuteExpressionCommand()
{
LinxExpression expression;
bool editExpression = InLinxExpression(out expression);
string expressionText = (editExpression) ? "=" + expression.ExpressionText : string.Empty;
IExpression modifiedValue;
if (designerContext.EditExpression(expressionText, out modifiedValue))
{
string wrappedExpression = string.Empty;
if (!modifiedValue.IsEmpty)
{
wrappedExpression = SqlStringHandler.CreateSqlExpression(modifiedValue.GetExpression());
}
if (editExpression)
{
SegmentedDocument.Replace(expression.StartIndex, expression.EndIndex - expression.StartIndex + 1,
wrappedExpression);
}
else
{
SegmentedDocument.Replace(CaretIndex, 0, wrappedExpression);
}
}
}
public void Drop(IDropInfo dropInfo)
{
TextEditor editor = dropInfo.VisualTarget as TextEditor;
string dragText = string.Empty;
if (dropInfo.Data is NodeViewModel)
{
var draggedModel = dropInfo.Data as NodeViewModel;
dragText = (string.IsNullOrEmpty(editor.Text.Trim())) ? draggedModel.GetExtendedDragText() : draggedModel.GetSimpleDragText();
}
else if (dropInfo.Data is string)
{
dragText = dropInfo.Data as string;
if (dragText == VariablesEditor.ExpressionEditorText)
{
ExecuteExpressionCommand();
dragText = string.Empty;
}
else
{
SQLExpression expression;
if (!InSQLExpression(out expression))
{
dragText = SqlStringHandler.CreateSqlExpression(dragText);
}
}
}
var caretIndex = editor.CaretOffset;
editor.Text = editor.Text.Insert(caretIndex, dragText);
editor.CaretOffset = caretIndex + dragText.Length;
}
public static void CompileExpression(IFunctionBuilder functionBuilder, IFunctionData data, string parameterName, string expressionName)
{
var propertyValue = data.Properties[parameterName].Value;
var expressionString = (propertyValue is string) ? propertyValue as string : string.Empty;
SqlStringHandler stringHandler = SqlStringHandler.GetSqlStringHandler(expressionString);
var parameterValues = new string[stringHandler.Expressions.Count];
for (int i = 0; i < parameterValues.Length; i++)
{
parameterValues[i] = functionBuilder.GetParamName(expressionName + i) + ".ToString()";
}
if (parameterValues.Length > 0)
{
functionBuilder.AddCode(string.Format(@"{0} = Twenty57.Linx.Components.Database.Mongo.MongoStringHandler.GetExecutableQuery(
{0},
{1},
new [] {{ {2} }});" ,
functionBuilder.GetParamName(parameterName),
CSharpUtilities.ArrayAsString(stringHandler.Expressions.Select(x => x.MatchText)),
parameterValues.Aggregate((a, b) => a + ",\n" + b)
));
}
}
public override IFunctionData GetFunctionData()
{
FunctionData functionData = new FunctionData {
Version = FunctionUpdater.Instance.CurrentVersion
};
foreach (var nextProperty in Properties)
{
if (!nextProperty.Name.StartsWith(ExecuteSQLShared.SqlValuePropertyPrefix))
{
functionData.Properties.Add(nextProperty);
}
}
if (!string.IsNullOrEmpty(ResolvedSqlStatementValue))
{
int i = 1;
SqlStringHandler.GetSqlStringHandler(ResolvedSqlStatementValue).Expressions.ForEach(
ex => functionData.Properties.Add(new Property(ExecuteSQLShared.SqlValuePropertyPrefix + (i++), typeof(object), ValueUseOption.RuntimeRead,
Context.CreateExpression(ex.ExpressionText))
{
IsVisible = false
}));
}
functionData.ExecutionPaths.AddRange(ExecutionPaths);
functionData.Output = Output;
return(functionData);
}
private void BuildResultType()
{
if (!string.IsNullOrEmpty(ResolvedConnectionString) && !string.IsNullOrEmpty(ResolvedSqlStatementValue))
{
string designTimeSql = SqlStringHandler.GetSqlStringHandler(ResolvedSqlStatementValue).GetExecutableDesignTimeSql();
DataTable schema = null;
try
{
schema = DatabaseHelpers.RetrieveSchema(ConnectionType, ResolvedConnectionString, designTimeSql);
}
catch { }
if (schema != null)
{
var resultFields = ResultTypeValue.Fields;
ResultTypeFields newResults = BuildResultType(schema, resultFields);
resultFields.Clear();
foreach (ResultTypeField nextField in newResults)
{
resultFields.Add(nextField);
}
}
}
BuildDataOut();
BuildExecutionPaths();
}
private ExecuteSQLX(int timeout, string[] outputNames, string[] columnNames, string sqlToExecute, string[] sqlIdentifiers, object[] sqlValues)
{
if (outputNames.Length != columnNames.Length)
{
throw new Exception("The output name count must match the column name count.");
}
this.timeout = timeout;
this.outputNames = outputNames;
this.columnNames = columnNames;
this.sql = SqlStringHandler.GetParameterizedSql(sqlToExecute, sqlIdentifiers);
this.sqlValues = sqlValues;
}
private void CreateFromSQL()
{
try
{
var connectionType = executeSQLDesigner.ResolvedConnectionType;
string connectionString = executeSQLDesigner.ResolvedConnectionString;
DataTable schemaTable = DatabaseHelpers.RetrieveSchema(connectionType, connectionString,
SqlStringHandler.GetSqlStringHandler(this.executeSQLDesigner.ResolvedSqlStatementValue ?? string.Empty).GetExecutableDesignTimeSql());
var newResults = new List <ResultFieldModel>();
foreach (DataColumn dataColumn in schemaTable.Columns)
{
var oldModel = ResultFields.FirstOrDefault(x => x.ColumnName == dataColumn.ColumnName);
if (oldModel != null)
{
newResults.Add(oldModel);
continue;
}
ResultFieldModel newModel = new ResultFieldModel(this);
newModel.IsDefault = false;
newModel.ColumnName = dataColumn.ColumnName;
newModel.Name = DatabaseHelpers.GetValidName(dataColumn.ColumnName);
newModel.SetTypeReferenceValues(dataColumn.DataType);
newModel.NameChanged += ModelNameChanged;
newModel.ColumnNameChanged += ModelColumnNameChanged;
newResults.Add(newModel);
}
ResultFields.Where(x => !newResults.Contains(x)).ToList().ForEach(x =>
{
x.NameChanged -= ModelNameChanged;
x.ColumnNameChanged -= ModelColumnNameChanged;
});
ResultFields.Clear();
newResults.ForEach(x => ResultFields.Add(x));
AddDefaultChild();
}
catch (Exception exception)
{
MessageBox.Show(exception.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private DataView ExecuteSQL()
{
string[] expressionNames = this.sqlStringHandler.ExpressionTexts.Select(et => SqlStringHandler.CreateSqlExpression(et)).ToArray();
string[] expressionValues = this.sqlStringHandler.ExpressionTexts.Select(et => SQLParameters.First(sp => sp.Name == et).Value).ToArray();
string parameterizedSql = SqlStringHandler.GetParameterizedSql(this.sqlStringHandler.SqlString, expressionNames);
using (var adapter = GetAdapter(this.connectionType, this.connectionString, parameterizedSql, expressionValues))
{
DataTable dataTable = new DataTable();
adapter.Fill(0, MaxTestResultCount + 1, dataTable);
if ((MoreResults = dataTable.Rows.Count == MaxTestResultCount + 1))
{
dataTable.Rows.RemoveAt(dataTable.Rows.Count - 1);
}
return(dataTable.DefaultView);
}
}
public SQLViewModel(ExecuteSQLDesigner executeSQLDesigner)
{
this.connectionType = executeSQLDesigner.ResolvedConnectionType;
this.connectionString = executeSQLDesigner.ResolvedConnectionString;
this.sqlStringHandler = new SqlStringHandler();
this.sqlStringHandler.SqlString = executeSQLDesigner.ResolvedSqlStatementValue ?? string.Empty;
this.sqlIndex = 0;
this.designerContext = executeSQLDesigner.Context;
Designer = executeSQLDesigner;
this.queryResults = null;
this.queryError = String.Empty;
DatabaseObjects = new ObservableCollection <NodeViewModel>();
this.refreshIsRunning = false;
this.executeSQLIsRunning = false;
}
public void Drop(IDropInfo dropInfo)
{
var draggedModel = dropInfo.Data as TemplateTreeItemViewModel;
bool isStringDraggedModel = dropInfo.Data is string;
if (draggedModel == null && !isStringDraggedModel)
{
return;
}
if (!isStringDraggedModel && draggedModel.Template == null)
{
return;
}
if (dropInfo.Data is string)
{
string dragText = dropInfo.Data as string;
if (dragText == VariablesEditor.ExpressionEditorText)
{
ExecuteExpressionCommand();
dragText = string.Empty;
}
else
{
if (!this.CaretInExpression)
{
dragText = SqlStringHandler.CreateSqlExpression(dragText);
}
var editor = dropInfo.VisualTarget as TextEditor;
var caretIndex = editor.CaretOffset;
editor.Text = editor.Text.Insert(caretIndex, dragText);
editor.CaretOffset = caretIndex + dragText.Length;
}
}
else
{
InsertTemplate(draggedModel.Template);
}
}
public override void GenerateCode(IFunctionBuilder functionBuilder)
{
ExecuteSQL_Gen generator = new ExecuteSQL_Gen();
generator.Session = new Dictionary <string, object>();
generator.Session.Add("FunctionContextProperty", functionBuilder.ContextParamName);
generator.Session.Add("GetParamName", new Func <string, string>(functionBuilder.GetParamName));
// Function properties
generator.Session.Add("Timeout", FunctionData.Properties[ExecuteSQLShared.TimeoutPropertyName].GetValue <int>());
ConnectionTypeSelection connectionType = FunctionData.Properties[DbShared.ConnectionTypePropertyName].GetValue <ConnectionTypeSelection>();
bool useTransaction = connectionType == ConnectionTypeSelection.UseTransaction;
generator.Session.Add("UseTransaction", useTransaction);
if (useTransaction)
{
generator.Session.Add("TransactionProperty", functionBuilder.GetParamName(DbShared.TransactionPropertyName));
}
else
{
generator.Session.Add("ConnectionType", connectionType.ToConnectionType());
generator.Session.Add("ConnectionStringProperty", functionBuilder.GetParamName(DbShared.ConnectionStringPropertyName));
}
generator.Session.Add("Sql", functionBuilder.GetParamName(ExecuteSQLShared.SqlStatementPropertyName));
ExecuteSQLShared.ReturnModeType returnMode = FunctionData.Properties[ExecuteSQLShared.ReturnOptionsPropertyName].GetValue <ExecuteSQLShared.ReturnModeType>();
generator.Session.Add("ReturnMode", returnMode);
// SQL placeholders
SqlStringHandler sqlStringHandler = SqlStringHandler.GetSqlStringHandler(StaticSqlStatementValue);
generator.Session.Add("SqlIdentifiers", CSharpUtilities.ArrayAsString(sqlStringHandler.Expressions.Select(ex => SqlStringHandler.CreateSqlExpression(ex.ExpressionText))));
int parameterIndex = 0;
generator.Session.Add("SqlValues", "new object[] { " + string.Join(", ", sqlStringHandler.Expressions.Select(ex => functionBuilder.GetParamName(ExecuteSQLShared.SqlValuePropertyPrefix + (++parameterIndex)))) + " }");
// Output columns
var resultType = FunctionData.Properties[ExecuteSQLShared.ResultTypePropertyName].GetValue <ResultType>();
generator.Session.Add("ResultTypeFields", resultType.Fields);
ITypeReference rowTypeReference = null;
if (resultType.Fields.Count != 0)
{
switch (returnMode)
{
case ExecuteSQLShared.ReturnModeType.RowByRow:
rowTypeReference = FunctionData.ExecutionPaths[ExecuteSQLShared.ExecutionPathName].Output;
break;
case ExecuteSQLShared.ReturnModeType.ListOfRows:
rowTypeReference = FunctionData.Output.GetEnumerableContentType();
break;
case ExecuteSQLShared.ReturnModeType.FirstRow:
case ExecuteSQLShared.ReturnModeType.FirstRowElseEmptyRow:
rowTypeReference = FunctionData.Output;
break;
}
}
generator.Session.Add("RowTypeName", rowTypeReference == null ? null : functionBuilder.GetTypeName(rowTypeReference));
generator.Session.Add("RowType", rowTypeReference);
generator.Session.Add("ExecutionPathName", ExecuteSQLShared.ExecutionPathName);
generator.Session.Add("ExecutionPathOutputName", functionBuilder.ExecutionPathOutParamName);
generator.Initialize();
functionBuilder.AddCode(generator.TransformText());
functionBuilder.AddAssemblyReference(typeof(ExecuteSQL));
functionBuilder.AddAssemblyReference(typeof(System.Data.IDataReader));
}