/*--------------------------------------------------------------------------------------------*/
public static T Table <T>(this T pElem, out IWeaverVarAlias pAlias) where T : IWeaverElement
{
var t = new WeaverStepTable(pElem, out pAlias);
pElem.Path.AddItem(t);
return(pElem);
}
/*--------------------------------------------------------------------------------------------*/
private IWeaverPathPipeEnd MakePropertyKey <T>(string pElement, Expression <Func <T, object> > pProp,
IWeaverVarAlias pGroupVar = null) where T : IWeaverElement
{
WeaverPropPair wpp = WeaverUtil.GetPropertyAttribute(pProp);
WeaverTitanPropertyAttribute att = WeaverTitanUtil.GetAndVerifyTitanPropertyAttribute(wpp);
Type pt = wpp.Info.PropertyType;
AddCustom("makeType()");
AddCustom("dataType(" + WeaverTitanPropertyAttribute.GetTitanTypeName(pt) + ".class)");
AddCustom("name(" + Path.Query.AddParam(new WeaverQueryVal(att.DbName)) + ")");
AddCustom("unique(OUT)"); //WeaverConfig enforces unique property DbNames
if (pGroupVar != null)
{
AddCustom("group(" + pGroupVar.Name + ")");
}
if (att.TitanIndex)
{
AddCustom("indexed(" + pElement + ".class)");
}
if (att.TitanElasticIndex)
{
AddCustom("indexed('search'," + pElement + ".class)");
}
return(AddCustom("makePropertyKey()"));
}
/*--------------------------------------------------------------------------------------------*/
public IWeaverTransaction Finish(IWeaverVarAlias pFinalOutput = null)
{
EnsureUnfinished();
Script = "";
Params = new Dictionary <string, IWeaverQueryVal>();
const string end = @"(?=$|[^\d])";
foreach (IWeaverQuery wq in Queries)
{
string s = wq.Script + "";
Dictionary <string, IWeaverQueryVal> pars = wq.Params;
foreach (string key in pars.Keys)
{
string newKey = "_TP" + Params.Keys.Count;
s = Regex.Replace(s, key + end, newKey);
Params.Add(newKey, pars[key]);
}
Script += s;
}
if (pFinalOutput != null)
{
Script += pFinalOutput.Name + ";";
}
return(this);
}
/*--------------------------------------------------------------------------------------------*/
private static void AddEdge <TEdge>(ICreateOperationBuilder pCreCtx, IWeaverVarAlias pFromVar,
TEdge pEdge, IWeaverVarAlias pToVar) where TEdge : IWeaverEdge
{
IWeaverQuery q = Weave.Inst.Graph.AddEdge(pFromVar, pEdge, pToVar);
pCreCtx.AddQuery(q, true);
pCreCtx.SetupLatestCommand(true);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void AddVertex <T>(T pVertex, out IWeaverVarAlias <T> pNewVertexVar) where T : IVertex
{
IWeaverQuery q = Weave.Inst.Graph.AddVertex(pVertex);
q = WeaverQuery.StoreResultAsVar(GetNextVarName(), q, out pNewVertexVar);
Transaction.AddQuery(q);
RegisterVarWithTxBuilder(pNewVertexVar);
}
/*--------------------------------------------------------------------------------------------*/
private void VerifyVar(IWeaverVarAlias pVar)
{
if (pVar == null || !vVarHash.Contains(pVar.Name))
{
throw new Exception("No matching IWeaverVarAlias found with name '" +
(pVar == null ? "<NULL>" : pVar.Name) + "'.");
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private static void AddVertex <T>(ICreateOperationBuilder pCreCtx, T pVertex,
out IWeaverVarAlias <T> pAlias) where T : Vertex, new()
{
IWeaverQuery q = Weave.Inst.Graph.AddVertex(pVertex);
q = WeaverQuery.StoreResultAsVar(pCreCtx.GetNextAliasName(), q, out pAlias);
pCreCtx.AddQuery(q, true);
pCreCtx.SetupLatestCommand();
}
//Demonstrating some traversals shown here:
//https://github.com/thinkaurelius/titan/wiki/Getting-Started
//See unit tests in Weaver.Test.WeavExamples.TTraversal
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public static IWeaverQuery GetCharacterByName <T>(string pName, string pVarName,
out IWeaverVarAlias <T> pCharVar) where T : Character, new()
{
IWeaverQuery q = Weave.Inst.Graph
.V.ExactIndex <T>(x => x.Name, pName).Next()
.ToQuery();
return(WeaverQuery.StoreResultAsVar(pVarName, q, out pCharVar));
}
/*--------------------------------------------------------------------------------------------*/
public void GetVertexByDatabaseId <T>(T pVertex, out IWeaverVarAlias <T> pVertexVar,
string pVarName = null) where T : IVertex, new()
{
IWeaverQuery q = Weave.Inst.Graph.V.Id <T>(pVertex.Id).ToQuery();
string varName = (pVarName ?? GetNextVarName());
q = WeaverQuery.StoreResultAsVar(varName, q, out pVertexVar);
Transaction.AddQuery(q);
RegisterVarWithTxBuilder(pVertexVar);
}
/*--------------------------------------------------------------------------------------------*/
public void AddEdge <TEdge>(IWeaverVarAlias pFromVar, TEdge pEdge, IWeaverVarAlias pToVar)
where TEdge : IWeaverEdge, new()
{
VerifyVar(pFromVar);
VerifyVar(pToVar);
IWeaverQuery q = Weave.Inst.Graph.AddEdge(pFromVar, pEdge, pToVar);
Transaction.AddQuery(q);
}
/*--------------------------------------------------------------------------------------------*/
private void AddFactorEdges(IWeaverVarAlias <Factor> pAlias)
{
AddVertexEdges(new WeaverVarAlias <Vertex>(pAlias.Name));
Tasks.AddFactorCreatedByMember(Build, NewDom, NewCre, pAlias);
Tasks.AddFactorDescriptorRefinesPrimaryWithArtifact(Build, NewDom, NewCre, pAlias);
Tasks.AddFactorDescriptorRefinesRelatedWithArtifact(Build, NewDom, NewCre, pAlias);
Tasks.AddFactorDescriptorRefinesTypeWithArtifact(Build, NewDom, NewCre, pAlias);
Tasks.AddFactorUsesPrimaryArtifact(Build, NewDom, NewCre, pAlias);
Tasks.AddFactorUsesRelatedArtifact(Build, NewDom, NewCre, pAlias);
Tasks.AddFactorVectorUsesAxisArtifact(Build, NewDom, NewCre, pAlias);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private static IWeaverVarAlias <TTo> AddEdge <TFrom, TEdge, TTo>(ICreateOperationBuilder pCreCtx,
IWeaverVarAlias <TFrom> pFromVar, long pToVertexId)
where TFrom : IVertex, new()
where TTo : Vertex, new()
where TEdge : IWeaverEdge <TFrom, TTo>, new()
{
IWeaverVarAlias <TTo> toVar = VerifyVertex <TTo>(pCreCtx, pToVertexId);
AddEdge(pCreCtx, pFromVar, new TEdge(), toVar);
return(toVar);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void GetVertex <T>(long pVertexId, out IWeaverVarAlias <T> pVertexVar)
where T : Vertex, new()
{
IWeaverQuery q = Weave.Inst.Graph.V
.ExactIndex <T>((x => x.VertexId), pVertexId).Next()
.ToQuery();
q = WeaverQuery.StoreResultAsVar(GetNextVarName(), q, out pVertexVar);
Transaction.AddQuery(q);
RegisterVarWithTxBuilder(pVertexVar);
}
/*--------------------------------------------------------------------------------------------*/
private static void AddReverseEdge <TFrom, TEdge, TTo>(ICreateOperationBuilder pCreCtx,
IWeaverVarAlias <TFrom> pFromVar, TEdge pEdge, IWeaverVarAlias <TTo> pToVar)
where TFrom : IVertex, new()
where TTo : IVertex, new()
where TEdge : IWeaverEdge <TFrom, TTo>
{
if (pFromVar != null)
{
AddEdge(pCreCtx, pFromVar, pEdge, pToVar);
}
}
/*--------------------------------------------------------------------------------------------*/
public T FromVar <T>(IWeaverVarAlias <T> pAlias) where T : IWeaverElement, new()
{
var sc = new WeaverStepCustom(pAlias.Name);
var path = new WeaverPath(Config, new WeaverQuery());
path.AddItem(sc);
return(new T {
Path = path
});
}
/*--------------------------------------------------------------------------------------------*/
private static IWeaverVarAlias <TTo> AddEdge <TFrom, TEdge, TTo>(ICreateOperationBuilder pCreCtx,
IWeaverVarAlias <TFrom> pFromVar, long?pToVertexId)
where TFrom : IVertex, new()
where TTo : Vertex, new()
where TEdge : IWeaverEdge <TFrom, TTo>, new()
{
if (pToVertexId == null)
{
return(null);
}
return(AddEdge <TFrom, TEdge, TTo>(pCreCtx, pFromVar, (long)pToVertexId));
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public static IWeaverQuery InitListVar(string pName, IList <IWeaverVarAlias> pVars,
out IWeaverVarAlias pVar)
{
pVar = new WeaverVarAlias(pName);
string list = "";
foreach (IWeaverVarAlias var in pVars)
{
list += (list == "" ? "" : ",") + var.Name;
}
var q = new WeaverQuery();
q.FinalizeQuery(pVar.Name + "=[" + list + "]");
return(q);
}
/*--------------------------------------------------------------------------------------------*/
public IWeaverQuery AddEdgeVci <TEdge>(IWeaverVarAlias pOutVertexVar, TEdge pEdge,
IWeaverVarAlias pInVertexVar) where TEdge : IWeaverEdge
{
if (!pEdge.IsValidOutVertexType(pOutVertexVar.VarType))
{
throw new WeaverException("Invalid Out VarType: '" + pOutVertexVar.VarType.Name +
"', expected '" + pEdge.OutVertexType.Name + "'.");
}
if (!pEdge.IsValidInVertexType(pInVertexVar.VarType))
{
throw new WeaverException("Invalid In VarType: '" + pInVertexVar.VarType.Name +
"', expected '" + pEdge.InVertexType.Name + "'.");
}
return(FinishEdgeVci(pEdge, pOutVertexVar.Name, pInVertexVar.Name, ""));
}
/*--------------------------------------------------------------------------------------------*/
private static IWeaverQuery StoreResultInner(IWeaverQuery pQuery, IWeaverVarAlias pVarAlias)
{
if (!pQuery.IsFinalized)
{
throw new WeaverException("Query must be finalized.");
}
if (pQuery.ResultVar != null)
{
throw new WeaverException(
"Query result already stored as '" + pQuery.ResultVar.Name + "'.");
}
var s = pQuery.Script;
var q = new WeaverQuery();
q.ResultVar = pVarAlias;
q.Params = pQuery.Params;
q.FinalizeQuery(pVarAlias.Name + "=" + s.Substring(0, s.Length - 1));
return(q);
}
/*--------------------------------------------------------------------------------------------*/
private void AddEmailEdges(IWeaverVarAlias <Email> pAlias)
{
AddVertexEdges(new WeaverVarAlias <Vertex>(pAlias.Name));
Tasks.AddEmailUsedByArtifact(Build, NewDom, NewCre, pAlias);
}
/*--------------------------------------------------------------------------------------------*/
private void AddClassEdges(IWeaverVarAlias <Class> pAlias)
{
AddArtifactEdges(new WeaverVarAlias <Artifact>(pAlias.Name));
}
/*--------------------------------------------------------------------------------------------*/
protected override void AddVertex(out IWeaverVarAlias <Class> pAlias)
{
Tasks.AddClass(Build, NewDom, out pAlias);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
protected void AddArtifactEdges(IWeaverVarAlias <Artifact> pAlias)
{
AddVertexEdges(new WeaverVarAlias <Vertex>(pAlias.Name));
Tasks.AddArtifactCreatedByMember(Build, NewDom, NewCre, pAlias);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
protected void AddVertexEdges(IWeaverVarAlias <Vertex> pAlias)
{
}
/*--------------------------------------------------------------------------------------------*/
private void AddAppEdges(IWeaverVarAlias <App> pAlias)
{
AddArtifactEdges(new WeaverVarAlias <Artifact>(pAlias.Name));
}
/*--------------------------------------------------------------------------------------------*/
protected override void AddVertex(out IWeaverVarAlias <User> pAlias)
{
Tasks.AddUser(Build, NewDom, out pAlias);
}
/*--------------------------------------------------------------------------------------------*/
private void AddOauthAccessEdges(IWeaverVarAlias <OauthAccess> pAlias)
{
AddVertexEdges(new WeaverVarAlias <Vertex>(pAlias.Name));
Tasks.AddOauthAccessAuthenticatesMember(Build, NewDom, NewCre, pAlias);
}
/*--------------------------------------------------------------------------------------------*/
private void AddMemberEdges(IWeaverVarAlias <Member> pAlias)
{
AddVertexEdges(new WeaverVarAlias <Vertex>(pAlias.Name));
Tasks.AddMemberDefinedByApp(Build, NewDom, NewCre, pAlias);
Tasks.AddMemberDefinedByUser(Build, NewDom, NewCre, pAlias);
}
/*--------------------------------------------------------------------------------------------*/
private void AddInstanceEdges(IWeaverVarAlias <Instance> pAlias)
{
AddArtifactEdges(new WeaverVarAlias <Artifact>(pAlias.Name));
}
/*--------------------------------------------------------------------------------------------*/
protected override void AddVertex(out IWeaverVarAlias <Instance> pAlias)
{
Tasks.AddInstance(Build, NewDom, out pAlias);
}
