> Given that almost all the modules are host-agnostic (kudos!), it should be possible to ađd a .vbp and a new view to allow the same codebase to be compiled as a standalone executable. Bonus points for adding CI with unit tests :-)
so I guess you could analogize it as interface => class while delegate => method
and because of that, you can hide the details behind the method's implementation (e.g. you don't need to know that it's defined in class Y to invoke it; you only need to be able to assign that method to the delegate, then forward the delegate to whoever else needs it.
struct is a kind of type that describes a value. class is a kind of type that describes an object. interface is a kind of type that describes.. er, well the interface of an object. delegate is a kind of type that describes a method's signature (whether that method is statically defined or compiled on-the-fly).
a delegate can be defined directly inside a namespace
^ that bit was a huge stumbling block for me and made me learn more about the function pointers to grok.
tbh, it's really nice to have a delegate type. In VBA, when you defined a callback procedure, you better have gotten the signature exactly right before you let the Win32 API call it back or you end up with a flaming poop bag
@this unrelated T-SQL quickie: I have table Foo with OtherFooId and Qty columns; I need to select foo1.Qty+foo2.Qty for bothfoo1 and foo2, but foo1.OtherFooId is foo2.Id and foo2.OtherFooId is null. Is that feasible with a single, incestuously spaghettish query?
ATM I'm able to get foo2 to correctly sum up the two quantities, but can't wrap my head around mapping foo1 back to foo2
i.e. I got the "links to ID" part easy, and now I need an easy way to figure out the "linked from ID" part of it (assuming 1 matching ID / level is fine)
@IvenBach I think part of the headache is that this bit of .net has seen constant change.... .c# 1 had delegates. .c# 2 added anonymous functions. C# 3 added lambdas and method groups. So you're trying to grok something that has been continuously improved over time... codemag.com/article/0809081/From-Delegate-to-Lambda
SELECT foo1.Id, SUM(foo1.Qty + foo2.Qty) OVER (PARTITION BY foo1.Id, foo1.OtherFooId ORDER BY foo1.Id) FROM Foo As foo1 LEFT JOIN Foo AS foo2 ON foo1.OtherFooId = foo2.Id
select f2.Qty + (select Qty from Foo2 f2 where f2.Id = f1.OtherId)
from Foo1 f1
select f1.Qty + f2.Qty
from Foo1 f1
inner join Foo2 f2 on f2.Id = f1.OtherId
There's your two queries. One with the non-null and a join, and the other with a nested query :)
I think what he wants is the result of
SELECT
foo1.Id,
foo1.Qty + f002.Qty
FROM FooTable AS foo1
INNER JOIN FooTable AS foo2
ON foo1.OtherId = foo2.Id
AND foo2.OtherId IS NULL
UNION ALL
SELECT
foo2.Id,
foo1.Qty + f002.Qty
FROM FooTable AS foo1
INNER JOIN FooTable AS foo2
ON foo1.OtherId = foo2.Id
AND foo2.OtherId IS NULL
but without the UNION
yeah no I have fabric inventory I'm pulling from one system, and I need to update another db's fabric inventory but counting "OtherId" inventory as one & the same, for both involved fabrics
SELECT *
INTO #foo
FROM (VALUES
(1, 2, 50),
(2, NULL, 1.5)
) AS t(Id, OtherId, Qty);
SELECT
f1.Id,
f1.OtherId,
SUM(f1.Qty + f2.Qty) OVER (PARTITION BY COALESCE(f1.OtherId, f1.Id)) AS CombinedQty,
f1.Qty AS Qty1,
f2.Qty AS Qty2
FROM #foo AS f1
LEFT JOIN #foo AS f2
ON f1.OtherId = f2.Id;
DROP TABLE #foo;
E.g. we make moduleAttributes mandatory in a lot of places in a module, but let is match an empty string. Instead we could make it optional and always match a non-empty string.
That is probably for optional moduleAttributes.
Oh, the implicit tokens are in the preprocessor.
I think it is still relying on some lexer rules that got removed.
That's also why Vogel was seeing so many warnings that we normally do not see in prior version - but I know from my past attempt of running Microsoft code analysis, we get several warning.
with flattened as (
select
[Master]=m.Id
,[External]=isnull(ext.Id,(select Id from rzra.Materials where ExternalClothId=m.Id))
from rzra.Materials m
left join rzra.Materials ext on m.ExternalClothId = ext.Id
where m.Id in(53612,52916,52985)
)
@IvenBach To understand what the parse tree, my suggestion from this morning (your yesterday night) to try to figure out what the parse tree for '@Folder("SomeFolder") looks like might still be a good idea. However, I you want to see a graphical solution, I can post an image of it.
I used t => t.startRule() because that's what I was assisted with. I'm trying with x => x.moduleDeclarations() and others just to try and figure out which one to use.
It's not the use of the delegate that's the problem currently. It's knowing what to use.
If it is hit, it contains the context for that subrule invocation.
If a subrule is potentially hit multiple times, the function will return an array of the contexts corresponding to the rule invocations in the order of invocation.
For any module remotely complicated, you really do not want to see the tree.
To oversimplify - for a statement If a = b Then, you have one node for the If statement, which contains 3 nodes; one for A, other for the =, and yet third for B
The 3 nodes contained in the If node are representations of the left-of-comparison-operator, comparison operator, and right-of-comparison-operator respectively?
I said nested sets primarily because of the fact all nodes will have an interval. You can tell how deep the node goes by the difference of the interval. (if that doesn't make sense, ignore me.)
It depends on how you look at it: if you look at it as part of the output structure, I would say node; if you look at it as part of the input, I would say interval.
whenever you see something that's camelCase in the grammar, it's referring to another parser rule... which refers to another parser rule... {which refers to...} ..until everything is ALL-CAPS lexer tokens. so a "block" in the sense of a "VBA code block" (if..then..end if / for..next / etc.) is really not any different than a variable declaration statement, or any other parser rule: it's a lego block made with smaller lego blocks, made with smaller lego blocks, made with..
expression & friends is special though, because it's one of the recursive rules: an expression can be made of smaller expressions stitched together
@M.Doerner agreed. For now it's enough to be aware that there are both specific and generalized rules, which may influence how your matching logic will work.
@M.Doerner fortunately, there aren't that many of them. Last time I did this, it was mainly changing the first letter's uppercase to lowercase, IIRC.
Generally, you want to define rules composed of multiple subrules or to go from more general to more specific.
However, there can be (techical) reasons why you have go from more specific to more general.
Btw, predicates are yet another concept not really relevant atm.
Looking at the parse tree visualization, I remember that there was some issue requesting to provide an export of the dependency structure of a project. I would really like to see that visualized for some of my projects.
module :
endOfStatement
moduleAttributes
moduleHeader?
moduleAttributes
moduleConfig?
moduleAttributes
moduleDeclarations
moduleAttributes
moduleBody
moduleAttributes
// A module can consist of WS as well as line continuations only.
whiteSpace?
;
I can do VBACodeStringParser.Parse(sourceText, t => t.startRule().module().moduleBody()); and the compiler allows me to do that since moduleBody is contained in module is contained in startRule.
VBA Rubberducking
VBA Rubberducking