private DynamicTransformerCompiler AddAndCompileTransform(TransformerDefinition transformerDefinition)
{
var transformer = new DynamicTransformerCompiler(transformerDefinition, configuration, extensions,
transformerDefinition.Name, path);
var generator = transformer.GenerateInstance();
transformCache.AddOrUpdate(transformerDefinition.TransfomerId, generator, (s, viewGenerator) => generator);
logger.Info("New transformer {0}:\r\n{1}\r\nCompiled to:\r\n{2}", transformer.Name,
transformer.CompiledQueryText,
transformer.CompiledQueryText);
return(transformer);
}
public static TransformerBase Compile(TransformerDefinition definition)
{
var cSharpSafeName = GetCSharpSafeName(definition.Name, isIndex: false);
var @class = CreateClass(cSharpSafeName, definition);
var compilationResult = CompileInternal(definition.Name, cSharpSafeName, @class, isIndex: false);
var type = compilationResult.Type;
var transformer = (TransformerBase)Activator.CreateInstance(type);
transformer.Source = compilationResult.Code;
return(transformer);
}
private string DetermineName(TransformerDefinition transformer)
{
if (UseGrouping.Value == false)
{
return("Transformers");
}
var name = transformer.Name;
if (name.Contains("/") == false)
{
return("No Group");
}
var groups = name.Split('/');
return(groups[0]);
}
public Get()
{
using (var store = new DocumentStore())
{
#region get_1_1
TransformerDefinition transformer = store
.DatabaseCommands
.GetTransformer("Order/Statistics"); // returns null if does not exist
#endregion
#region get_2_1
TransformerDefinition[] transformers = store
.DatabaseCommands
.GetTransformers(0, 128);
#endregion
}
}
private void ReplicateSingleTransformer(ReplicationStrategy destination, TransformerDefinition definition)
{
try
{
var clonedTransformer = definition.Clone();
clonedTransformer.TransfomerId = 0;
var url = destination.ConnectionStringOptions.Url + "/transformers/" + Uri.EscapeUriString(definition.Name) + "?" + GetDebugInformation();
var replicationRequest = HttpRavenRequestFactory.Create(url, HttpMethod.Put, destination.ConnectionStringOptions, Replication.GetRequestBuffering(destination));
replicationRequest.Write(RavenJObject.FromObject(clonedTransformer));
replicationRequest.ExecuteRequest();
}
catch (Exception e)
{
Replication.HandleRequestBufferingErrors(e, destination);
Log.WarnException("Could not replicate transformer " + definition.Name + " to " + destination.ConnectionStringOptions.Url, e);
}
}
public void CanSaveTransformerWithCastToDynamic()
{
using (var store = NewRemoteDocumentStore())
{
var t1 = new TransformerDefinition
{
Name = "T1",
TransformResults = "from people in results " +
" from child in (IEnumerable<dynamic>)people.Children " +
" from grandchild in (IEnumerable<dynamic>)child.Children " +
" from great in (IEnumerable<dynamic>)grandchild.Children " +
" select new " +
" { " +
" Name = child.Name " +
" }"
};
store.DatabaseCommands.PutTransformer("T1", t1);
}
}
public void CanSaveTransformerWithMultipleSelectMany()
{
using (var store = NewRemoteDocumentStore())
{
var t1 = new TransformerDefinition
{
Name = "T1",
TransformResults = "from people in results " +
" from child in people.Children " +
" from grandchild in child.Children " +
" from great in grandchild.Children " +
" select new " +
" { " +
" Name = child.Name " +
" }"
};
store.DatabaseCommands.PutTransformer("T1", t1);
}
}
public string PutTransform(string name, TransformerDefinition definition)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (definition == null)
{
throw new ArgumentNullException("definition");
}
name = name.Trim();
var existingDefinition = IndexDefinitionStorage.GetTransformerDefinition(name);
if (existingDefinition != null && existingDefinition.Equals(definition))
{
return(name); // no op for the same transformer
}
var generator = IndexDefinitionStorage.CompileTransform(definition);
if (existingDefinition != null)
{
IndexDefinitionStorage.RemoveTransformer(existingDefinition.TransfomerId);
}
TransactionalStorage.Batch(accessor =>
{
definition.TransfomerId = (int)Database.Documents.GetNextIdentityValueWithoutOverwritingOnExistingDocuments("TransformerId", accessor);
});
IndexDefinitionStorage.CreateAndPersistTransform(definition, generator);
IndexDefinitionStorage.AddTransform(definition.TransfomerId, definition);
TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() => Database.Notifications.RaiseNotifications(new TransformerChangeNotification()
{
Name = name,
Type = TransformerChangeTypes.TransformerAdded,
}));
return(name);
}
private static MemberDeclarationSyntax CreateClass(string name, TransformerDefinition definition)
{
var statements = new List <StatementSyntax>();
var methodDetector = new MethodDetectorRewriter();
statements.Add(HandleTransformResults(definition.TransformResults, methodDetector));
var methods = methodDetector.Methods;
if (methods.HasGroupBy)
{
statements.Add(RoslynHelper.This(nameof(TransformerBase.HasGroupBy)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement());
}
if (methods.HasLoadDocument)
{
statements.Add(RoslynHelper.This(nameof(TransformerBase.HasLoadDocument)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement());
}
if (methods.HasTransformWith)
{
statements.Add(RoslynHelper.This(nameof(TransformerBase.HasTransformWith)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement());
}
if (methods.HasInclude)
{
statements.Add(RoslynHelper.This(nameof(TransformerBase.HasInclude)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement());
}
var ctor = RoslynHelper.PublicCtor(name).AddBodyStatements(statements.ToArray());
return(RoslynHelper.PublicClass(name)
.WithBaseClass <TransformerBase>()
.WithMembers(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(ctor)));
}
public void AddTransform(string name, TransformerDefinition definition)
{
var fixedName = FixupIndexName(name);
transformDefinitions.AddOrUpdate(fixedName, definition, (s1, def) => definition);
}
public void AddTransform(string name, TransformerDefinition definition)
{
transformDefinitions.AddOrUpdate(name, definition, (s1, def) => definition);
}
public string PutTransformer(string name, TransformerDefinition transformerDef)
{
return(AsyncHelpers.RunSync(() => asyncServerClient.PutTransformerAsync(name, transformerDef)));
}
public PutTransformerCommand CreateRequest(DocumentConvention documentConvention, string transformerName, TransformerDefinition transformerDefinition)
{
var entityToBlittable = new EntityToBlittable(null);
var transformerDefinitionAsBlittable = entityToBlittable.ConvertEntityToBlittable(transformerDefinition,
documentConvention, _context);
return(new PutTransformerCommand()
{
TransformerDefinition = transformerDefinitionAsBlittable,
Context = _context,
TransformerName = transformerName
});
}
public Task WriteTransformerAsync(TransformerDefinition transformer, CancellationToken cancellationToken)
{
return(_store.AsyncDatabaseCommands.PutTransformerAsync(transformer.Name, transformer, cancellationToken));
}
public string CreateTransform(TransformerDefinition transformerDefinition, AbstractTransformer transformer)
{
transformCache.AddOrUpdate(transformerDefinition.TransfomerId, transformer, (s, viewGenerator) => transformer);
return(transformer.Name);
}
public DynamicTransformerCompiler(
TransformerDefinition transformerDefinition,
InMemoryRavenConfiguration configuration, OrderedPartCollection <AbstractDynamicCompilationExtension> extensions, string name, string basePath) : base(configuration, extensions, name, basePath)
{
this.transformerDefinition = transformerDefinition;
}
public bool Equals(TransformerDefinition other)
{
return string.Equals(TransformResults, other.TransformResults);
}
public string PutTransformer(string name, TransformerDefinition transformerDef)
{
return(asyncServerClient.PutTransformerAsync(name, transformerDef).ResultUnwrap());
}
public Task <string> PutTransformerAsync(string name, TransformerDefinition transformerDefinition)
{
return(new CompletedTask <string>(databaseCommands.PutTransformer(name, transformerDefinition)));
}
public string PutTransform(string name, TransformerDefinition definition)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (definition == null)
{
throw new ArgumentNullException("definition");
}
name = name.Trim();
var existingDefinition = IndexDefinitionStorage.GetTransformerDefinition(name);
if (existingDefinition != null)
{
switch (existingDefinition.LockMode)
{
case TransformerLockMode.Unlock:
if (existingDefinition.Equals(definition))
{
return(name); // no op for the same transformer
}
break;
case TransformerLockMode.LockedIgnore:
Log.Info("Transformer {0} not saved because it was lock (with ignore)", name);
return(name);
default:
throw new ArgumentOutOfRangeException();
}
}
var generator = IndexDefinitionStorage.CompileTransform(definition);
if (existingDefinition != null)
{
IndexDefinitionStorage.RemoveTransformer(existingDefinition.TransfomerId);
}
var temporary = definition.Temporary;
if (temporary)
{
definition.TransfomerId = Database.Transformers.GetNextTemporaryTransformerIndex();
IndexDefinitionStorage.CreateTransform(definition, generator);
IndexDefinitionStorage.AddTransform(definition.TransfomerId, definition);
}
else
{
TransactionalStorage.Batch(accessor =>
{
definition.TransfomerId = (int)Database.Documents.GetNextIdentityValueWithoutOverwritingOnExistingDocuments("TransformerId", accessor);
});
IndexDefinitionStorage.CreateTransform(definition, generator);
IndexDefinitionStorage.PersistTransform(definition);
IndexDefinitionStorage.AddTransform(definition.TransfomerId, definition);
TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() => Database.Notifications.RaiseNotifications(new TransformerChangeNotification()
{
Name = name,
Type = TransformerChangeTypes.TransformerAdded,
}));
}
return(name);
}
public Task WriteTransformerAsync(TransformerDefinition transformer, CancellationToken cancellationToken)
{
Count++;
return(new CompletedTask());
}
public TransformerDefinitionModel()
{
ModelUrl = "/transformers/";
Transformer = new TransformerDefinition();
Errors = new ObservableCollection <TransformerDefinitionError>();
}
private void UpdateFromTransformer(TransformerDefinition transformerDefinition)
{
Transformer = transformerDefinition;
OnEverythingChanged();
}
public string PutTransform(string name, TransformerDefinition definition, bool isReplication = false)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (definition == null)
{
throw new ArgumentNullException("definition");
}
name = name.Trim();
var existingDefinition = IndexDefinitionStorage.GetTransformerDefinition(name);
if (existingDefinition != null)
{
var newTransformerVersion = definition.TransformerVersion;
var currentTransformerVersion = existingDefinition.TransformerVersion;
// whether we update the transformer definition or not,
// we need to update the transformer version
existingDefinition.TransformerVersion = definition.TransformerVersion =
Math.Max(currentTransformerVersion ?? 0, newTransformerVersion ?? 0);
switch (isReplication)
{
case true:
if (newTransformerVersion != null && currentTransformerVersion != null &&
newTransformerVersion <= currentTransformerVersion)
{
//this new transformer is an older version of the current one
return(null);
}
// we need to update the lock mode only if it was updated by another server
existingDefinition.LockMode = definition.LockMode;
break;
default:
switch (existingDefinition.LockMode)
{
case TransformerLockMode.Unlock:
if (existingDefinition.Equals(definition))
{
return(name); // no op for the same transformer
}
definition.TransformerVersion++;
break;
case TransformerLockMode.LockedIgnore:
Log.Info("Transformer {0} not saved because it was lock (with ignore)", name);
return(name);
default:
throw new ArgumentOutOfRangeException();
}
break;
}
}
else if (isReplication == false)
{
// we're creating a new transformer,
// we need to take the transformer version of the deleted transformer (if exists)
definition.TransformerVersion = GetDeletedTransformerId(definition.Name);
definition.TransformerVersion = (definition.TransformerVersion ?? 0) + 1;
}
if (definition.TransformerVersion == null)
{
definition.TransformerVersion = 0;
}
var generator = IndexDefinitionStorage.CompileTransform(definition);
if (existingDefinition != null)
{
IndexDefinitionStorage.RemoveTransformer(existingDefinition.TransfomerId);
}
var temporary = definition.Temporary;
if (temporary)
{
definition.TransfomerId = Database.Transformers.GetNextTemporaryTransformerIndex();
IndexDefinitionStorage.CreateTransform(definition, generator);
IndexDefinitionStorage.AddTransform(definition.TransfomerId, definition);
}
else
{
TransactionalStorage.Batch(accessor =>
{
definition.TransfomerId = (int)Database.Documents.GetNextIdentityValueWithoutOverwritingOnExistingDocuments("TransformerId", accessor);
});
IndexDefinitionStorage.CreateTransform(definition, generator);
IndexDefinitionStorage.PersistTransform(definition);
IndexDefinitionStorage.AddTransform(definition.TransfomerId, definition);
TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() => Database.Notifications.RaiseNotifications(new TransformerChangeNotification()
{
Name = name,
Type = TransformerChangeTypes.TransformerAdded,
Version = definition.TransformerVersion
}));
}
return(name);
}
public bool Equals(TransformerDefinition other)
{
return(string.Equals(TransformResults, other.TransformResults));
}
public Task WriteTransformerAsync(TransformerDefinition transformer, CancellationToken cancellationToken)
{
_database.Transformers.PutTransform(transformer.Name, transformer);
return(new CompletedTask());
}
public void Init(TransformerDefinition def)
{
transformerDefinition = def;
}
public Task <HttpResponseMessage> Exploration()
{
var linq = GetQueryStringValue("linq");
var collection = GetQueryStringValue("collection");
int timeoutSeconds;
if (int.TryParse(GetQueryStringValue("timeoutSeconds"), out timeoutSeconds) == false)
{
timeoutSeconds = 60;
}
int pageSize;
if (int.TryParse(GetQueryStringValue("pageSize"), out pageSize) == false)
{
pageSize = 100000;
}
var hash = Encryptor.Current.Hash.Compute16(Encoding.UTF8.GetBytes(linq));
var sourceHashed = MonoHttpUtility.UrlEncode(Convert.ToBase64String(hash));
var transformerName = Constants.TemporaryTransformerPrefix + sourceHashed;
var transformerDefinition = Database.IndexDefinitionStorage.GetTransformerDefinition(transformerName);
if (transformerDefinition == null)
{
transformerDefinition = new TransformerDefinition
{
Name = transformerName,
Temporary = true,
TransformResults = linq
};
Database.Transformers.PutTransform(transformerName, transformerDefinition);
}
var msg = GetEmptyMessage();
using (var cts = new CancellationTokenSource())
{
var timeout = cts.TimeoutAfter(TimeSpan.FromSeconds(timeoutSeconds));
var indexQuery = new IndexQuery
{
PageSize = pageSize,
Start = 0,
Query = "Tag:" + collection,
ResultsTransformer = transformerName
};
var accessor = Database.TransactionalStorage.CreateAccessor(); //accessor will be disposed in the StreamQueryContent.SerializeToStreamAsync!
try
{
var queryOp = new QueryActions.DatabaseQueryOperation(Database, "Raven/DocumentsByEntityName", indexQuery, accessor, cts);
queryOp.Init();
msg.Content = new StreamQueryContent(InnerRequest, queryOp, accessor, timeout, mediaType => msg.Content.Headers.ContentType = new MediaTypeHeaderValue(mediaType)
{
CharSet = "utf-8"
},
o =>
{
if (o.Count == 2 &&
o.ContainsKey(Constants.DocumentIdFieldName) &&
o.ContainsKey(Constants.Metadata))
{
// this is the raw value out of the server, we don't want to get that
var doc = queryOp.DocRetriever.Load(o.Value <string>(Constants.DocumentIdFieldName));
var djo = doc as IDynamicJsonObject;
if (djo != null)
{
return(djo.Inner);
}
}
return(o);
});
msg.Headers.Add("Raven-Result-Etag", queryOp.Header.ResultEtag.ToString());
msg.Headers.Add("Raven-Index-Etag", queryOp.Header.IndexEtag.ToString());
msg.Headers.Add("Raven-Is-Stale", queryOp.Header.IsStale ? "true" : "false");
msg.Headers.Add("Raven-Index", queryOp.Header.Index);
msg.Headers.Add("Raven-Total-Results", queryOp.Header.TotalResults.ToString(CultureInfo.InvariantCulture));
msg.Headers.Add("Raven-Index-Timestamp", queryOp.Header.IndexTimestamp.GetDefaultRavenFormat());
if (IsCsvDownloadRequest(InnerRequest))
{
msg.Content.Headers.Add("Content-Disposition", "attachment; filename=export.csv");
}
}
catch (Exception)
{
accessor.Dispose();
throw;
}
return(new CompletedTask <HttpResponseMessage>(msg));
}
}
