public ISet<TargetRelativePath> Run(IBuildContext context)
{
var targetDir = targetRoot.CreateDirectory(project.RelativeTargetPath);
if (targetDir == null)
targetDir = targetRoot.CreateDirectory(project.RelativeTargetPath);
var sourceSet = project.GetSourceSet("scr");
var result = new HashSet<TargetRelativePath>();
foreach (var file in sourceSet.Files)
{
log.DebugFormat("Processing {0}", file);
using (var reader = suiteRoot.ReadTextFile(file))
{
var contents = reader.ReadToEnd();
var msg = String.Format("Hello {0}!!!", contents);
var fileName = Path.GetFileName(file);
using (var writer = targetDir.CreateTextFile(fileName + ".txt"))
writer.WriteLine(msg);
result.Add(new TargetRelativePath(project.RelativeTargetPath, fileName + ".txt"));
}
}
return result;
}
public override void Generate(IBuildContext context, IProject project)
{
var host = GetHost(context, project);
foreach (var fileName in context.FileSystem.GetFiles(context.ProjectDirectory, "*.project.tt", SearchOption.AllDirectories))
{
if (Ignore(fileName))
{
continue;
}
context.Trace.TraceInformation(Msg.G1008, Texts.Generating_code, PathHelper.UnmapPath(context.ProjectDirectory, fileName));
try
{
if (!host.ProcessTemplate(fileName, fileName.Left(fileName.Length - 11)))
{
TraceErrors(context, host, fileName);
}
}
catch (Exception ex)
{
context.Trace.TraceError(Msg.G1007, ex.Message, fileName, TextSpan.Empty);
}
}
}
public EnumerableImpl(object key, Type type, Type resultType, IBuildContext firstBuildCtx, ICRegILGen firstReg)
{
_key = key;
_type = type;
_resultType = resultType;
_list.Add(new KeyValuePair<IBuildContext, ICRegILGen>(firstBuildCtx, firstReg));
}
public override void Run(IBuildContext context)
{
context.Trace.TraceInformation(Msg.S1000, Texts.SynchronizingWebsite);
var url = MakeWebApiUrl(context, "SynchronizeWebsite");
var targetFileName = Path.GetTempFileName();
if (!DownloadFile(context, url, targetFileName))
{
return;
}
context.Trace.TraceInformation(Msg.S1001, Texts.Updating_resources___);
using (var zip = ZipFile.OpenRead(targetFileName))
{
foreach (var entry in zip.Entries)
{
context.Trace.TraceInformation(Msg.S1002, entry.FullName);
entry.ExtractToFile(Path.Combine(context.ProjectDirectory, entry.FullName), true);
}
}
context.FileSystem.DeleteFile(targetFileName);
}
public override void Run(IBuildContext context)
{
if (context.Project.HasErrors)
{
context.Trace.TraceInformation(Msg.D1017, Texts.Package_contains_errors_and_will_not_be_deployed);
context.IsAborted = true;
return;
}
context.Trace.TraceInformation(Msg.D1023, Texts.Creating_npm_module___);
var npmFileName = Path.Combine(context.ProjectDirectory, "package.json");
if (!context.FileSystem.FileExists(npmFileName))
{
context.Trace.TraceInformation(Msg.D1024, Texts._package_json__file_not_found__Skipping_);
return;
}
var process = new Process();
process.StartInfo.FileName = "npm";
process.StartInfo.Arguments = "pack";
process.StartInfo.WorkingDirectory = context.ProjectDirectory;
process.StartInfo.UseShellExecute = true;
process.StartInfo.CreateNoWindow = true;
process.Start();
process.WaitForExit();
var outputFileName = GetOutputFileName(context, npmFileName);
if (!string.IsNullOrEmpty(outputFileName) && context.FileSystem.FileExists(outputFileName))
{
context.OutputFiles.Add(outputFileName);
}
}
static void BuildSkip(ExpressionBuilder builder, IBuildContext sequence, ISqlExpression prevSkipValue, ISqlExpression expr)
{
var sql = sequence.SqlQuery;
builder.SqlProvider.SqlQuery = sql;
sql.Select.Skip(expr);
builder.SqlProvider.SqlQuery = sql;
if (sql.Select.TakeValue != null)
{
if (builder.DataContextInfo.SqlProviderFlags.GetIsSkipSupportedFlag(sql) ||
!builder.DataContextInfo.SqlProviderFlags.IsTakeSupported)
sql.Select.Take(builder.Convert(
sequence,
new SqlBinaryExpression(typeof(int), sql.Select.TakeValue, "-", sql.Select.SkipValue, Precedence.Additive)));
if (prevSkipValue != null)
sql.Select.Skip(builder.Convert(
sequence,
new SqlBinaryExpression(typeof(int), prevSkipValue, "+", sql.Select.SkipValue, Precedence.Additive)));
}
if (!builder.DataContextInfo.SqlProviderFlags.GetAcceptsTakeAsParameterFlag(sql))
{
var p = sql.Select.SkipValue as SqlParameter;
if (p != null)
p.IsQueryParameter = false;
}
}
public override void Run(IBuildContext context)
{
context.Trace.TraceInformation(Msg.D1000, Texts.Copying_dependencies___);
var sourceDirectory = context.Configuration.Get(Constants.Configuration.CopyDependenciesSourceDirectory);
sourceDirectory = Path.Combine(context.ProjectDirectory, sourceDirectory);
if (!context.FileSystem.DirectoryExists(sourceDirectory))
{
context.Trace.TraceInformation(Msg.D1003, Texts.Dependencies_directory_not_found__Skipping, sourceDirectory);
return;
}
foreach (var pair in context.Configuration.GetSubKeys("copy-package"))
{
var key = "copy-package:" + pair.Key;
var destinationDirectory = context.Configuration.GetString(key + ":copy-to-directory");
if (string.IsNullOrEmpty(destinationDirectory))
{
context.Trace.TraceError(Msg.D1001, Texts.Destination_directory_not_found, key + ":copy-to-directory");
continue;
}
destinationDirectory = PathHelper.NormalizeFilePath(destinationDirectory).TrimStart('\\');
destinationDirectory = PathHelper.Combine(context.Configuration.Get(Constants.Configuration.DataFolderDirectory), destinationDirectory);
context.FileSystem.CreateDirectory(destinationDirectory);
CopyNuGetPackages(context, sourceDirectory, destinationDirectory);
}
}
public override void Run(IBuildContext context)
{
Context = context;
Context.IsAborted = true;
var include = context.Configuration.GetString(Constants.Configuration.WatchProjectInclude, "**");
var exclude = context.Configuration.GetString(Constants.Configuration.WatchProjectExclude, "**");
_pathMatcher = new PathMatcher(include, exclude);
_publishDatabase = context.Configuration.GetBool(Constants.Configuration.WatchProjectPublishDatabase, true);
_fileWatcher = new FileSystemWatcher(context.ProjectDirectory)
{
IncludeSubdirectories = true,
NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName
};
_fileWatcher.Changed += FileChanged;
_fileWatcher.Deleted += FileChanged;
_fileWatcher.Renamed += FileChanged;
_fileWatcher.Created += FileChanged;
_fileWatcher.Created += FileChanged;
_fileWatcher.EnableRaisingEvents = true;
Console.WriteLine(Texts.Type__q__to_quit___);
string input;
do
{
input = Console.ReadLine();
}
while (!string.Equals(input, "q", StringComparison.OrdinalIgnoreCase));
}
public string GetPath (IBuildContext ctxt) {
if (dir == null)
return null;
string p = ctxt.PathTo (dir);
return Path.Combine (p, name);
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context"> </param>
/// <returns>Returns a set of generated files, in suite relative paths</returns>
public ISet<TargetRelativePath> Run(IBuildContext context)
{
var currentFingerprint = wrappedBuilder.Dependencies.CreateFingerprint();
var buildKey = new BuildKey(wrappedBuilder.GetType(), wrappedBuilder.Uid);
cache.LockForBuilder(buildKey);
try
{
if (cache.Contains(buildKey, currentFingerprint))
{
log.DebugFormat("Restoring cached build outputs for {0}", buildKey);
return cache.Restore(buildKey, targetDir);
}
else
{
log.DebugFormat("Running builder {0}", buildKey);
var files = wrappedBuilder.Run(context);
log.DebugFormat("Storing build outputs of {0}", buildKey);
cache.Store(buildKey, currentFingerprint, files, targetDir);
return files;
}
}
finally
{
cache.UnlockForBuilder(buildKey);
}
}
public override void Run(IBuildContext context)
{
if (context.Project.HasErrors)
{
context.Trace.TraceInformation(Msg.D1012, Texts.Package_contains_errors_and_will_not_be_deployed);
context.IsAborted = true;
return;
}
context.Trace.TraceInformation(Msg.D1016, Texts.Publishing___);
if (string.Equals(context.Project.Options.DatabaseName, "core", StringComparison.OrdinalIgnoreCase))
{
context.Trace.TraceInformation(Msg.D1013, Texts.Database_is__core___Skipping_);
return;
}
context.Trace.TraceInformation(Msg.D1014, Texts.Database, context.Project.Options.DatabaseName);
var queryStringParameters = new Dictionary<string, string>
{
["m"] = "i",
["db"] = context.Project.Options.DatabaseName
};
var url = MakeUrl(context, context.Configuration.GetString(Constants.Configuration.PublishUrl), queryStringParameters);
Request(context, url);
}
/// <summary>
/// The on perpare.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
public override void OnPerpare(IBuildContext context)
{
if (context.Target != null) return;
context.ErrorTracer.Phase = "Reciving Construtor Informations for " + context.Metadata;
IImportInterceptor interceptor;
context.Policys.Add(
new ConstructorPolicy
{
Constructor =
context.UseInternalInstantiation()
? Helper.WriteDefaultCreation(context)
: context.Metadata.Export.ExternalInfo.Create,
Generator =
_service.Generate(context.Metadata, context.Metadata.Export.ImportMetadata.ToArray(),
out interceptor)
});
if (interceptor == null) return;
var pol = context.Policys.Get<ExternalImportInterceptorPolicy>();
if (pol != null) pol.Interceptors.Add(interceptor);
else
{
pol = new ExternalImportInterceptorPolicy();
pol.Interceptors.Add(interceptor);
context.Policys.Add(pol);
}
}
public override void Run(IBuildContext context)
{
if (context.Project.HasErrors)
{
return;
}
context.Trace.TraceInformation(Msg.D1015, Texts.Writing_package_exports___);
var fileName = PathHelper.Combine(context.ProjectDirectory, context.Configuration.GetString(Constants.Configuration.WriteExportsFileName));
var fieldToWrite = context.Configuration.GetString(Constants.Configuration.WriteExportsFieldsToWrite).Split(Constants.Comma, StringSplitOptions.RemoveEmptyEntries).Select(f => f.Trim()).ToList();
using (var writer = new StreamWriter(fileName))
{
using (var output = new XmlTextWriter(writer))
{
output.Formatting = Formatting.Indented;
output.WriteStartElement("Exports");
foreach (var template in context.Project.ProjectItems.OfType<Template>().Where(template => !template.IsImport))
{
template.WriteAsExportXml(output);
}
foreach (var item in context.Project.ProjectItems.OfType<Item>().Where(item => !item.IsImport))
{
item.WriteAsExportXml(output, fieldToWrite);
}
output.WriteEndElement();
}
}
}
public override void Run(IBuildContext context)
{
if (context.Project.HasErrors)
{
context.Trace.TraceInformation(Msg.D1004, Texts.Package_contains_errors_and_will_not_be_deployed);
context.IsAborted = true;
return;
}
context.Trace.TraceInformation(Msg.D1005, Texts.Copying_package_to_website___);
foreach (var pair in context.Configuration.GetSubKeys("copy-package"))
{
var key = "copy-package:" + pair.Key;
var destinationDirectory = context.Configuration.GetString(key + ":copy-to-directory");
if (string.IsNullOrEmpty(destinationDirectory))
{
context.Trace.TraceError(Msg.D1006, Texts.Destination_directory_not_found, key + ":copy-to-directory");
continue;
}
destinationDirectory = PathHelper.NormalizeFilePath(destinationDirectory).TrimStart('\\');
destinationDirectory = PathHelper.Combine(context.Configuration.Get(Constants.Configuration.DataFolderDirectory), destinationDirectory);
context.FileSystem.CreateDirectory(destinationDirectory);
foreach (var fileName in context.OutputFiles)
{
var destinationFileName = PathHelper.Combine(destinationDirectory, Path.GetFileName(fileName));
context.FileSystem.Copy(fileName, destinationFileName);
}
}
}
public override void Run(IBuildContext context)
{
context.IsAborted = true;
context.Trace.TraceInformation(Msg.M1012, Texts.Writing_website_exports___);
var url = MakeWebApiUrl(context, "WriteWebsiteExports");
var targetFileName = Path.GetTempFileName();
if (!DownloadFile(context, url, targetFileName))
{
return;
}
using (var zip = ZipFile.OpenRead(targetFileName))
{
foreach (var entry in zip.Entries)
{
context.Trace.TraceInformation(Msg.M1013, entry.FullName);
var fileName = Path.Combine(context.ProjectDirectory, entry.FullName);
context.FileSystem.CreateDirectory(Path.GetDirectoryName(fileName) ?? string.Empty);
entry.ExtractToFile(fileName, true);
}
}
context.FileSystem.DeleteFile(targetFileName);
}
/// <summary>
/// Adds the builders (<see cref="IBuilder"/>) to the given build context which process
/// the given set of projects (<see cref="Project"/>)
/// </summary>
/// <param name="context">Current build context</param>
/// <param name="projects">Projects to be built</param>
public IBuilder AddToContext(IBuildContext context, IEnumerable<Project> projects)
{
Contract.Requires(context != null);
Contract.Requires(projects != null);
return null; // dummy value
}
public override Result Build (IBuildContext ctxt)
{
// A more orthodox subclass might call Rule.CreateResultObject
// and do some value.CopyValueTo (result), but this is simpler.
return (Result) value.Clone ();
}
public override void Run(IBuildContext context)
{
context.DisplayDoneMessage = false;
var qualifiedName = context.Configuration.GetCommandLineArg(1).Trim();
if (string.IsNullOrEmpty(qualifiedName))
{
qualifiedName = context.Configuration.GetString("name").Trim();
}
if (string.IsNullOrEmpty(qualifiedName))
{
context.Trace.WriteLine(Texts.You_must_specific_the___name_argument);
return;
}
var newShortName = context.Configuration.GetCommandLineArg(2).Trim();
if (string.IsNullOrEmpty(newShortName))
{
newShortName = context.Configuration.GetString("to").Trim();
}
if (string.IsNullOrEmpty(newShortName))
{
context.Trace.WriteLine(Texts.You_must_specific_the___to_argument);
return;
}
var projectItem = context.Project.FindQualifiedItem(qualifiedName);
if (projectItem == null)
{
context.Trace.WriteLine(Texts.Item_not_found, qualifiedName);
return;
}
var value = projectItem.QualifiedName;
var n = value.LastIndexOf('/');
value = n < 0 ? newShortName : value.Left(n + 1) + newShortName;
var queryService = context.CompositionService.Resolve<IQueryService>();
var references = queryService.FindUsages(context.Project, qualifiedName).ToList();
foreach (var reference in references)
{
reference.SourceProperty.SetValue(value);
}
var changedFileNames = context.Project.ProjectItems.SelectMany(i => i.Snapshots).Where(s => s.IsModified).Select(s => s.SourceFile.AbsoluteFileName).ToList();
projectItem.Rename(newShortName);
context.Project.SaveChanges();
foreach (var fileName in changedFileNames)
{
context.Trace.TraceInformation(Msg.M1017, PathHelper.UnmapPath(context.ProjectDirectory, fileName));
}
context.Trace.TraceInformation(Msg.M1018, $"Changed files: {changedFileNames.Count}");
}
public override void UpdateWebsiteFiles(IBuildContext context)
{
CopyToolsFileToWebsiteBinDirectory(context, "Sitecore.Pathfinder.Unicorn.dll");
CopyToolsFileToWebsiteBinDirectory(context, "Unicorn.dll");
CopyToolsFileToWebsiteBinDirectory(context, "Rainbow.Storage.Sc.dll");
CopyToolsFileToWebsiteBinDirectory(context, "Rainbow.Storage.Yaml.dll");
CopyToolsFileToWebsiteBinDirectory(context, "Rainbow.dll");
}
public override void Run(IBuildContext context)
{
context.Trace.WriteLine("Project Metrics");
context.Trace.WriteLine("---------------");
context.Trace.WriteLine("Items", context.Project.ProjectItems.OfType<Item>().Count().ToString());
context.Trace.WriteLine("Templates", context.Project.ProjectItems.OfType<Template>().Count().ToString());
context.Trace.WriteLine("Files", context.Project.ProjectItems.OfType<Projects.Files.File>().Count().ToString());
}
public override void Run(IBuildContext context)
{
context.Trace.TraceInformation(Msg.G1012, Texts.Importing_website___);
var url = MakeWebApiUrl(context, "ImportWebsite");
Request(context, url);
}
public override void RemoveWebsiteFiles(IBuildContext context)
{
RemoveWebsiteAssembly(context, "Sitecore.Pathfinder.Unicorn.dll");
RemoveWebsiteAssembly(context, "Unicorn.dll");
RemoveWebsiteAssembly(context, "Rainbow.Storage.Sc.dll");
RemoveWebsiteAssembly(context, "Rainbow.Storage.Yaml.dll");
RemoveWebsiteAssembly(context, "Rainbow.dll");
}
public override void Run(IBuildContext context)
{
context.Trace.TraceInformation(Msg.M1009, Texts.Resetting_website___);
var url = MakeWebApiUrl(context, "ResetWebsite");
Request(context, url);
}
public override void Run(IBuildContext context)
{
context.Trace.TraceInformation(Msg.M1009, "Updating the project/website mappings on the website...");
var url = MakeWebApiUrl(context, "UpdateProjectWebsiteMappings");
Request(context, url);
}
public override void Run(IBuildContext context)
{
context.Trace.TraceInformation(Msg.G1010, Texts.Troubleshooting___);
var url = MakeWebApiUrl(context, "TroubleshootWebsite");
Request(context, url);
}
/// <summary>
/// The on post build.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
public override void OnPostBuild(IBuildContext context)
{
var notify = context.Target as INotifyBuildCompled;
if (notify == null) return;
context.ErrorTracer.Phase = "Notify Build Compled for " + context.Metadata;
notify.BuildCompled();
}
public override bool UpdateWebsiteFiles(IBuildContext context)
{
var updated = false;
updated |= CopyToolsFileToWebsiteBinDirectory(context, "Sitecore.Pathfinder.NuGet.dll");
updated |= CopyToolsFileToWebsiteBinDirectory(context, "NuGet.Core.dll");
return updated;
}
public static ExternalBinaryInfo ParseFromUnixStyle (string command, IBuildContext ctxt)
{
ExternalBinaryInfo info = new ExternalBinaryInfo ();
if (info.SetFromUnixStyle (command, ctxt))
return null;
return info;
}
/// <summary>
/// The on create instance.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
public override void OnCreateInstance(IBuildContext context)
{
var policy = context.Policys.Get<ConstructorPolicy>();
if (policy == null) return;
context.ErrorTracer.Phase = "Contruct Object for " + context.Metadata;
context.Target = policy.Constructor.Invoke(context, policy.Generator); //(context, policy.Generator);
}
protected bool MoveToFinal (MBFile output, MBFile tempdest, IBuildContext ctxt) {
// We should probably move away the file before clobbering it ...
if (output.Exists (ctxt))
output.Delete (ctxt);
tempdest.MoveTo (output, ctxt);
return false;
}
public DropContext(IBuildContext?parent, IBuildContext sequence)
: base(parent, sequence, null)
{
}
static Expression GetMultipleQueryExpressionLazy(IBuildContext context, MappingSchema mappingSchema, Expression expression, HashSet <ParameterExpression> parameters)
{
expression.Visit(e =>
{
if (e.NodeType == ExpressionType.Lambda)
{
foreach (var p in ((LambdaExpression)e).Parameters)
{
parameters.Add(p);
}
}
});
// Convert associations.
//
return(expression.Transform(e =>
{
switch (e.NodeType)
{
case ExpressionType.MemberAccess :
{
var root = context.Builder.GetRootObject(e);
if (root != null &&
root.NodeType == ExpressionType.Parameter &&
!parameters.Contains((ParameterExpression)root))
{
var res = context.IsExpression(e, 0, RequestFor.Association);
if (res.Result)
{
var associationContext = (AssociationContext)res.Context !;
if (associationContext.Descriptor.IsList)
{
var me = (MemberExpression)e;
var parentType = me.Expression.Type;
var childType = me.Type;
var queryMethod = AssociationHelper.CreateAssociationQueryLambda(context.Builder,
new AccessorMember(me), associationContext.Descriptor, parentType, parentType, childType, false,
false, null, out _);
var dcConst = Expression.Constant(context.Builder.DataContext.Clone(true));
var expr = queryMethod.GetBody(me.Expression, dcConst);
if (e == expression)
{
expr = Expression.Call(
Methods.Enumerable.ToList.MakeGenericMethod(childType),
expr);
}
return expr;
}
}
}
break;
}
}
return e;
}));
}
public override string DescribeAction(Result other, IBuildContext ctxt)
{
return(String.Format("Copy {0} to {1} and make it executable",
((MBFile)other).GetPath(ctxt), DestDir));
}
// check that the result is valid. Return true if it is.
// only meaningful for a result that is associated with
// a resource stored external to the result cache; eg
// an MBFile, etc.
public virtual bool Check(IBuildContext ctxt)
{
return(true);
}
// clone the result to the 'dist' directory,
// using the DistPath function in ctxt. Again, a noop
// unless the result is stored external to the result
// cache. Return true if anything was done.
public virtual bool DistClone(IBuildContext ctxt)
{
return(false);
}
public ISqlExpression GetSubQuery(IBuildContext context)
{
return(null);
}
public BuildInfo(IBuildContext parent, Expression expression, SelectQuery selectQuery)
{
Parent = parent;
Expression = expression;
SelectQuery = selectQuery;
}
Expression CorrectConditional(IBuildContext context, Expression expr, bool enforceServerSide, string?alias)
{
if (expr.NodeType != ExpressionType.Conditional)
{
return(BuildExpression(context, expr, enforceServerSide, alias));
}
var cond = (ConditionalExpression)expr;
if (cond.Test.NodeType == ExpressionType.Equal || cond.Test.NodeType == ExpressionType.NotEqual)
{
var b = (BinaryExpression)cond.Test;
Expression?cnt = null;
Expression?obj = null;
if (IsNullConstant(b.Left))
{
cnt = b.Left;
obj = b.Right;
}
else if (IsNullConstant(b.Right))
{
cnt = b.Right;
obj = b.Left;
}
if (cnt != null)
{
var objContext = GetContext(context, obj);
if (objContext != null && objContext.IsExpression(obj, 0, RequestFor.Object).Result)
{
var sql = objContext.ConvertToSql(obj, 0, ConvertFlags.Key);
if (sql.Length == 0)
{
sql = objContext.ConvertToSql(obj, 0, ConvertFlags.All);
}
if (sql.Length > 0)
{
Expression?predicate = null;
foreach (var f in sql)
{
if (f.Sql is SqlField field && field.Table !.All == field)
{
continue;
}
var valueType = f.Sql.SystemType !;
if (!valueType.IsNullable() && valueType.IsValueType)
{
valueType = typeof(Nullable <>).MakeGenericType(valueType);
}
var reader = BuildSql(context, f.Sql, valueType, null);
var comparison = Expression.MakeBinary(cond.Test.NodeType,
Expression.Default(valueType), reader);
predicate = predicate == null
? comparison
: Expression.MakeBinary(
cond.Test.NodeType == ExpressionType.Equal
? ExpressionType.AndAlso
: ExpressionType.OrElse, predicate, comparison);
}
if (predicate != null)
{
cond = cond.Update(predicate,
CorrectConditional(context, cond.IfTrue, enforceServerSide, alias),
CorrectConditional(context, cond.IfFalse, enforceServerSide, alias));
}
}
}
}
}
if (cond == expr)
{
expr = BuildExpression(context, expr, enforceServerSide, alias);
}
else
{
expr = cond;
}
return(expr);
}
TransformInfo TransformExpression(IBuildContext context, Expression expr, bool enforceServerSide)
{
if (_skippedExpressions.Contains(expr))
{
return(new TransformInfo(expr, true));
}
if (expr.Find(IsNoneSqlMember) != null)
{
return(new TransformInfo(expr));
}
switch (expr.NodeType)
{
case ExpressionType.Convert:
case ExpressionType.ConvertChecked:
{
if (expr.Type == typeof(object))
{
break;
}
var cex = (UnaryExpression)expr;
_convertedExpressions.Add(cex.Operand, cex);
var nex = BuildExpression(context, cex.Operand, enforceServerSide);
if (nex.Type != cex.Type)
{
nex = cex.Update(nex);
}
var ret = new TransformInfo(nex, true);
_convertedExpressions.Remove(cex.Operand);
return(ret);
}
case ExpressionType.MemberAccess:
{
if (IsServerSideOnly(expr) || PreferServerSide(expr, enforceServerSide))
{
return(new TransformInfo(BuildSql(context, expr)));
}
var ma = (MemberExpression)expr;
var l = Expressions.ConvertMember(MappingSchema, ma.Expression == null ? null : ma.Expression.Type, ma.Member);
if (l != null)
{
// In Grouping KeyContext we have to perform calculation on server side
if (Contexts.Any(c => c is GroupByBuilder.KeyContext))
{
return(new TransformInfo(BuildSql(context, expr)));
}
break;
}
if (ma.Member.IsNullableValueMember())
{
break;
}
if (ma.Member.IsNullableHasValueMember())
{
Expression e = Expression.NotEqual(
ma.Expression, Expression.Constant(null, ma.Expression.Type));
return(new TransformInfo(
BuildExpression(
context,
ma.Expression.Type.IsPrimitiveEx() ?
Expression.Call(
MemberHelper.MethodOf(() => Sql.AsSql(true)),
e) :
e, enforceServerSide),
true));
}
var ctx = GetContext(context, ma);
if (ctx != null)
{
if (ma.Type.IsGenericTypeEx() && typeof(IEnumerable <>).IsSameOrParentOf(ma.Type))
{
var res = ctx.IsExpression(ma, 0, RequestFor.Association);
if (res.Result)
{
var table = (TableBuilder.AssociatedTableContext)res.Context;
if (table.IsList)
{
var mexpr = GetMultipleQueryExpression(context, MappingSchema, ma, new HashSet <ParameterExpression>());
return(new TransformInfo(BuildExpression(context, mexpr, enforceServerSide)));
}
}
}
return(new TransformInfo(ctx.BuildExpression(ma, 0, enforceServerSide)));
}
var ex = ma.Expression;
while (ex is MemberExpression)
{
ex = ((MemberExpression)ex).Expression;
}
if (ex is MethodCallExpression)
{
var ce = (MethodCallExpression)ex;
if (IsSubQuery(context, ce))
{
if (!IsMultipleQuery(ce))
{
var info = GetSubQueryContext(context, ce);
var par = Expression.Parameter(ex.Type);
var bex = info.Context.BuildExpression(ma.Transform(e => e == ex ? par : e), 0, enforceServerSide);
if (bex != null)
{
return(new TransformInfo(bex));
}
}
}
}
ex = ma.Expression;
if (ex != null && ex.NodeType == ExpressionType.Constant)
{
// field = localVariable
//
var c = _expressionAccessors[ex];
return(new TransformInfo(Expression.MakeMemberAccess(Expression.Convert(c, ex.Type), ma.Member)));
}
break;
}
case ExpressionType.Parameter:
{
if (expr == ParametersParam)
{
break;
}
var ctx = GetContext(context, expr);
if (ctx != null)
{
return(new TransformInfo(ctx.BuildExpression(expr, 0, enforceServerSide)));
}
break;
}
case ExpressionType.Constant:
{
if (expr.Type.IsConstantable())
{
break;
}
if (_expressionAccessors.ContainsKey(expr))
{
return(new TransformInfo(Expression.Convert(_expressionAccessors[expr], expr.Type)));
}
break;
}
case ExpressionType.Coalesce:
if (expr.Type == typeof(string) && MappingSchema.GetDefaultValue(typeof(string)) != null)
{
return(new TransformInfo(BuildSql(context, expr)));
}
if (CanBeTranslatedToSql(context, ConvertExpression(expr), true))
{
return(new TransformInfo(BuildSql(context, expr)));
}
break;
case ExpressionType.Conditional:
if (CanBeTranslatedToSql(context, ConvertExpression(expr), true))
{
return(new TransformInfo(BuildSql(context, expr)));
}
break;
case ExpressionType.Call:
{
var ce = (MethodCallExpression)expr;
if (IsGroupJoinSource(context, ce))
{
foreach (var arg in ce.Arguments.Skip(1))
{
if (!_skippedExpressions.Contains(arg))
{
_skippedExpressions.Add(arg);
}
}
if (IsSubQuery(context, ce))
{
if (ce.IsQueryable())
//if (!typeof(IEnumerable).IsSameOrParentOf(expr.Type) || expr.Type == typeof(string) || expr.Type.IsArray)
{
var ctx = GetContext(context, expr);
if (ctx != null)
{
return(new TransformInfo(ctx.BuildExpression(expr, 0, enforceServerSide)));
}
}
}
break;
}
if (ce.IsAssociation(MappingSchema))
{
var ctx = GetContext(context, ce);
if (ctx == null)
{
throw new InvalidOperationException();
}
return(new TransformInfo(ctx.BuildExpression(ce, 0, enforceServerSide)));
}
if ((_buildMultipleQueryExpressions == null || !_buildMultipleQueryExpressions.Contains(ce)) && IsSubQuery(context, ce))
{
if (IsMultipleQuery(ce))
{
return(new TransformInfo(BuildMultipleQuery(context, ce, enforceServerSide)));
}
return(new TransformInfo(GetSubQueryExpression(context, ce, enforceServerSide)));
}
if (IsServerSideOnly(expr) || PreferServerSide(expr, enforceServerSide) || ce.Method.IsSqlPropertyMethodEx())
{
return(new TransformInfo(BuildSql(context, expr)));
}
}
break;
}
if (EnforceServerSide(context))
{
switch (expr.NodeType)
{
case ExpressionType.MemberInit:
case ExpressionType.New:
case ExpressionType.Convert:
break;
default:
if (CanBeCompiled(expr))
{
break;
}
return(new TransformInfo(BuildSql(context, expr)));
}
}
return(new TransformInfo(expr));
}
public Expression GetSubQueryExpression(IBuildContext context, MethodCallExpression expr, bool enforceServerSide)
{
var info = GetSubQueryContext(context, expr);
return(info.Expression ?? (info.Expression = info.Context.BuildExpression(null, 0, enforceServerSide)));
}
static bool EnforceServerSide(IBuildContext context)
{
return(context.SelectQuery.Select.IsDistinct);
}
public override int ConvertToParentIndex(int index, IBuildContext context)
{
var idx = GetIndex(context.Select.Select.Columns[index]);
return(Parent == null ? idx : Parent.ConvertToParentIndex(idx, this));
}
public KeyContext(IBuildContext parent, LambdaExpression lambda, params IBuildContext[] sequences)
: base(parent, lambda, sequences)
{
}
public SelectManyContext(IBuildContext parent, LambdaExpression lambda, IBuildContext sequence)
: base(parent, lambda, sequence)
{
}
public Expression BuildExpression(IBuildContext context, Expression expression, bool enforceServerSide)
{
var newExpr = expression.Transform(expr => TransformExpression(context, expr, enforceServerSide));
return(newExpr);
}
public AllAnyContext(IBuildContext parent, MethodCallExpression methodCall, IBuildContext sequence)
: base(parent, sequence, null)
{
_methodCall = methodCall;
}
TransformInfo TransformExpression(IBuildContext context, Expression expr, bool enforceServerSide, string?alias)
{
if (_skippedExpressions.Contains(expr))
{
return(new TransformInfo(expr, true));
}
alias ??= _optimizationContext.GetExpressionAlias(expr);
switch (expr.NodeType)
{
case ExpressionType.Convert:
case ExpressionType.ConvertChecked:
{
if (expr.Type == typeof(object))
{
break;
}
var cex = (UnaryExpression)expr;
_convertedExpressions.Add(cex.Operand, cex);
var newOperand = BuildExpression(context, cex.Operand, enforceServerSide);
if (newOperand.Type != cex.Type)
{
if (cex.Type.IsNullable() && newOperand is ConvertFromDataReaderExpression readerExpression)
{
newOperand = readerExpression.MakeNullable();
}
newOperand = cex.Update(newOperand);
}
var ret = new TransformInfo(newOperand, true);
RemoveConvertedExpression(cex.Operand);
return(ret);
}
case ExpressionType.MemberAccess:
{
var ma = (MemberExpression)expr;
if (IsServerSideOnly(ma) || PreferServerSide(ma, enforceServerSide) && !HasNoneSqlMember(ma))
{
return(new TransformInfo(BuildSql(context, expr, alias)));
}
var l = Expressions.ConvertMember(MappingSchema, ma.Expression?.Type, ma.Member);
if (l != null)
{
// In Grouping KeyContext we have to perform calculation on server side
if (Contexts.Any(c => c is GroupByBuilder.KeyContext))
{
return(new TransformInfo(BuildSql(context, expr, alias)));
}
break;
}
if (ma.Member.IsNullableValueMember())
{
break;
}
var ctx = GetContext(context, ma);
if (ctx != null)
{
var prevCount = ctx.SelectQuery.Select.Columns.Count;
var expression = ctx.BuildExpression(ma, 0, enforceServerSide);
if (expression.NodeType == ExpressionType.Extension && expression is DefaultValueExpression &&
ma.Expression?.NodeType == ExpressionType.Parameter)
{
var objExpression = BuildExpression(ctx, ma.Expression, enforceServerSide, alias);
var varTempVar = objExpression.NodeType == ExpressionType.Parameter
? objExpression
: BuildVariable(objExpression, ((ParameterExpression)ma.Expression).Name);
var condition = Expression.Condition(
Expression.Equal(varTempVar,
new DefaultValueExpression(MappingSchema, ma.Expression.Type)), expression,
Expression.MakeMemberAccess(varTempVar, ma.Member));
expression = condition;
}
else if (!alias.IsNullOrEmpty() && (ctx.SelectQuery.Select.Columns.Count - prevCount) == 1)
{
ctx.SelectQuery.Select.Columns[ctx.SelectQuery.Select.Columns.Count - 1].Alias = alias;
}
return(new TransformInfo(expression));
}
var ex = ma.Expression;
while (ex is MemberExpression memberExpression)
{
ex = memberExpression.Expression;
}
if (ex is MethodCallExpression ce)
{
if (IsSubQuery(context, ce))
{
if (!IsMultipleQuery(ce, context.Builder.MappingSchema))
{
var info = GetSubQueryContext(context, ce);
if (alias != null)
{
info.Context.SetAlias(alias);
}
var par = Expression.Parameter(ex.Type);
var bex = info.Context.BuildExpression(ma.Transform(e => e == ex ? par : e), 0, enforceServerSide);
if (bex != null)
{
return(new TransformInfo(bex));
}
}
}
}
ex = ma.Expression;
if (ex != null && ex.NodeType == ExpressionType.Constant)
{
// field = localVariable
//
if (!_expressionAccessors.TryGetValue(ex, out var c))
{
return(new TransformInfo(ma));
}
return(new TransformInfo(Expression.MakeMemberAccess(Expression.Convert(c, ex.Type), ma.Member)));
}
break;
}
case ExpressionType.Parameter:
{
if (expr == ParametersParam || expr == PreambleParam)
{
break;
}
var ctx = GetContext(context, expr);
if (ctx != null)
{
var buildExpr = ctx.BuildExpression(expr, 0, enforceServerSide);
if (buildExpr.Type != expr.Type)
{
buildExpr = Expression.Convert(buildExpr, expr.Type);
}
return(new TransformInfo(buildExpr));
}
break;
}
case ExpressionType.Constant:
{
if (expr.Type.IsConstantable(true))
{
break;
}
if ((_buildMultipleQueryExpressions == null || !_buildMultipleQueryExpressions.Contains(expr)) && IsSequence(new BuildInfo(context, expr, new SelectQuery())))
{
return(new TransformInfo(BuildMultipleQuery(context, expr, enforceServerSide)));
}
if (_expressionAccessors.TryGetValue(expr, out var accessor))
{
return(new TransformInfo(Expression.Convert(accessor, expr.Type)));
}
break;
}
case ExpressionType.Coalesce:
if (expr.Type == typeof(string) && MappingSchema.GetDefaultValue(typeof(string)) != null)
{
return(new TransformInfo(BuildSql(context, expr, alias)));
}
if (CanBeTranslatedToSql(context, ConvertExpression(expr), true))
{
return(new TransformInfo(BuildSql(context, expr, alias)));
}
break;
case ExpressionType.Call:
{
var ce = (MethodCallExpression)expr;
if (IsGroupJoinSource(context, ce))
{
foreach (var arg in ce.Arguments.Skip(1))
{
if (!_skippedExpressions.Contains(arg))
{
_skippedExpressions.Add(arg);
}
}
if (IsSubQuery(context, ce))
{
if (ce.IsQueryable())
//if (!typeof(IEnumerable).IsSameOrParentOf(expr.Type) || expr.Type == typeof(string) || expr.Type.IsArray)
{
var ctx = GetContext(context, expr);
if (ctx != null)
{
return(new TransformInfo(ctx.BuildExpression(expr, 0, enforceServerSide)));
}
}
}
break;
}
if (ce.IsAssociation(MappingSchema))
{
var ctx = GetContext(context, ce);
if (ctx == null)
{
throw new InvalidOperationException();
}
return(new TransformInfo(ctx.BuildExpression(ce, 0, enforceServerSide)));
}
if ((_buildMultipleQueryExpressions == null || !_buildMultipleQueryExpressions.Contains(ce)) && IsSubQuery(context, ce))
{
if (IsMultipleQuery(ce, MappingSchema))
{
return(new TransformInfo(BuildMultipleQuery(context, ce, enforceServerSide)));
}
return(new TransformInfo(GetSubQueryExpression(context, ce, enforceServerSide, alias)));
}
if (IsServerSideOnly(expr) || PreferServerSide(expr, enforceServerSide) || ce.Method.IsSqlPropertyMethodEx())
{
return(new TransformInfo(BuildSql(context, expr, alias)));
}
}
break;
case ExpressionType.New:
{
var ne = (NewExpression)expr;
List <Expression>?arguments = null;
for (var i = 0; i < ne.Arguments.Count; i++)
{
var argument = ne.Arguments[i];
var memberAlias = ne.Members?[i].Name;
var newArgument = ConvertAssignmentArgument(context, argument, ne.Members?[i], enforceServerSide, memberAlias);
if (newArgument != argument)
{
if (arguments == null)
{
arguments = ne.Arguments.Take(i).ToList();
}
}
arguments?.Add(newArgument);
}
if (arguments != null)
{
ne = ne.Update(arguments);
}
return(new TransformInfo(ne, true));
}
case ExpressionType.MemberInit:
{
var mi = (MemberInitExpression)expr;
var newPart = (NewExpression)BuildExpression(context, mi.NewExpression, enforceServerSide);
List <MemberBinding>?bindings = null;
for (var i = 0; i < mi.Bindings.Count; i++)
{
var binding = mi.Bindings[i];
var newBinding = binding;
if (binding is MemberAssignment assignment)
{
var argument = ConvertAssignmentArgument(context, assignment.Expression,
assignment.Member, enforceServerSide, assignment.Member.Name);
if (argument != assignment.Expression)
{
newBinding = Expression.Bind(assignment.Member, argument);
}
}
if (newBinding != binding)
{
if (bindings == null)
{
bindings = mi.Bindings.Take(i).ToList();
}
}
bindings?.Add(newBinding);
}
if (mi.NewExpression != newPart || bindings != null)
{
mi = mi.Update(newPart, bindings ?? mi.Bindings.AsEnumerable());
}
return(new TransformInfo(mi, true));
}
}
if (enforceServerSide || EnforceServerSide(context))
{
switch (expr.NodeType)
{
case ExpressionType.MemberInit:
case ExpressionType.Convert:
break;
default:
if (!enforceServerSide && CanBeCompiled(expr))
{
break;
}
return(new TransformInfo(BuildSql(context, expr, alias)));
}
}
return(new TransformInfo(expr));
}
// Fingerprinting -- an MD5 of the result's data.
// Cached is a cached value of the fingerprint; the
// result implementation may compare some saved hints
// and return the cached value if deemed appropriate.
//
// It is acceptable if ctxt or cached is null. If cached
// is null, the cache comparison should be skipped.
//
// If the result class needs a context to evaluate the fingerprint,
// and ctxt is null, and the fingerprint is not cached,
// throw an exception.
public abstract Fingerprint GetFingerprint(IBuildContext ctxt, Fingerprint cached);
public override IQueryExpression GetSubQuery(IBuildContext context)
{
return(null);
}
public int ConvertToParentIndex(int index, IBuildContext context)
{
return(Parent == null ? index : Parent.ConvertToParentIndex(index, this));
}
public InsertOrUpdateContext(IBuildContext parent, IBuildContext sequence)
: base(parent, sequence, null)
{
}
internal abstract void Init(IBuildContext parseContext, List <ParameterAccessor> sqlParameters);
// remove any external data associated with the Result.
// returns true if any action was taken.
public virtual bool Clean(IBuildContext ctxt)
{
return(false);
}
public CountContext(IBuildContext parent, IBuildContext sequence, Type returnType)
: base(parent, sequence, null)
{
_returnType = returnType;
}
public static Expression?CorrectExpression(Expression?expression, IBuildContext current, IBuildContext underlying)
{
if (expression != null)
{
var root = current.Builder.GetRootObject(expression);
if (root is ContextRefExpression refExpression)
{
if (refExpression.BuildContext == current)
{
expression = expression.Replace(root, new ContextRefExpression(root.Type, underlying), EqualityComparer <Expression> .Default);
}
}
}
return(expression);
}
public BuildContext(IBuildContext parentContext)
{
ParentContext = parentContext ?? throw new ArgumentNullException(nameof(parentContext));
BuildTarget = parentContext.BuildTarget;
}
public SubQueryContext(IBuildContext subQuery, bool addToSql = true)
: this(subQuery, new SelectQuery {
ParentSelect = subQuery.Select.ParentSelect
}, addToSql)
{
}
public Expression Build(Expression expression, IBuildContext buildContext) => // Add the Singleton lifetime for any instances buildContext.AddLifetime(expression, new Lifetimes.SingletonLifetime());
public OfTypeContext(IBuildContext context, MethodCallExpression methodCall)
: base(context)
{
_methodCall = methodCall;
}
static Expression GetMultipleQueryExpression(IBuildContext context, MappingSchema mappingSchema, Expression expression, HashSet <ParameterExpression> parameters)
{
if (!Common.Configuration.Linq.AllowMultipleQuery)
{
throw new LinqException("Multiple queries are not allowed. Set the 'LinqToDB.Common.Configuration.Linq.AllowMultipleQuery' flag to 'true' to allow multiple queries.");
}
expression.Visit(e =>
{
if (e.NodeType == ExpressionType.Lambda)
{
foreach (var p in ((LambdaExpression)e).Parameters)
{
parameters.Add(p);
}
}
});
// Convert associations.
//
return(expression.Transform(e =>
{
switch (e.NodeType)
{
case ExpressionType.MemberAccess:
{
var root = e.GetRootObject(mappingSchema);
if (root != null &&
root.NodeType == ExpressionType.Parameter &&
!parameters.Contains((ParameterExpression)root))
{
var res = context.IsExpression(e, 0, RequestFor.Association);
if (res.Result)
{
var table = (TableBuilder.AssociatedTableContext)res.Context;
if (table.IsList)
{
var ttype = typeof(Table <>).MakeGenericType(table.ObjectType);
var tbl = Activator.CreateInstance(ttype, context.Builder.DataContext);
var method = e == expression ?
MemberHelper.MethodOf <IEnumerable <bool> >(n => n.Where(a => a)).GetGenericMethodDefinition().MakeGenericMethod(table.ObjectType) :
_whereMethodInfo.MakeGenericMethod(e.Type, table.ObjectType, ttype);
var me = (MemberExpression)e;
var op = Expression.Parameter(table.ObjectType, "t");
parameters.Add(op);
Expression ex = null;
for (var i = 0; i < table.Association.ThisKey.Length; i++)
{
var field1 = table.ParentAssociation.SqlTable.Fields[table.Association.ThisKey [i]];
var field2 = table.SqlTable.Fields[table.Association.OtherKey[i]];
var ma1 = Expression.MakeMemberAccess(op, field2.ColumnDescriptor.MemberInfo);
var ma2 = Expression.MakeMemberAccess(me.Expression, field1.ColumnDescriptor.MemberInfo);
var ee = Equal(mappingSchema, ma1, ma2);
ex = ex == null ? ee : Expression.AndAlso(ex, ee);
}
var expr = Expression.Call(null, method, Expression.Constant(tbl), Expression.Lambda(ex, op));
if (e == expression)
{
expr = Expression.Call(
MemberHelper.MethodOf <IEnumerable <int> >(n => n.ToList()).GetGenericMethodDefinition().MakeGenericMethod(table.ObjectType),
expr);
}
return expr;
}
}
}
break;
}
}
return e;
}));
}
