pkb | Personal knowledge base

READ THE PYENV GUIDE CAREFULLY.

You didn't follow pyenv's README guide correctly. The guide tells you put PATH related operation in .bash_profile or .profile. But eval "$(pyenv init -)" in .bashrc.

Move pyenv init script from .bash_profile to .bashrc.

You have one close button for all modals:

Where to begin here?

B-trees are very intensely studied and developed data structures, so pointing to a single document that explains all aspects relevant to this question and SAP HANA is a bit difficult.

Maybe it helps to unpack the term first:

Compressed Prefix

This basically means, the B-tree index and leaf nodes do not contain the full strings for keys. Instead, the parts of the key-strings that are common among the keys (the prefixes) are stored separately. The leaf and index nodes then only contain

• the pointer to the prefix
• a sort of "delta" that contains the remaining key (this is where the partial key from the pkB-tree comes in)
• and a pointer to the data record (row id)

This technique is rather common in many DBMS, usually attached to a feature called "index compression" or something similar.

So, now we know that HANA uses compressed B-tree indexes (for row-store tables and for data that can be expressed as strings).

Why is this important for an in-memory database like HANA? In short: memory transfer effort between RAM and CPU. The smaller the index structure, the more of it can fit into the CPU caches. To traverse (go through) the index, fewer back-and-forth movements of data have to be performed.

It's a huge performance advantage.

This is complemented with specific "cache-conscious" index protocols (how the index structure is used by the HANA kernel) that try to minimize the RAM-CPU data transfers.

All this is an overly simplified explanation and I hope that it helps to make more sense nevertheless.

If you want to "dive deeper" and start reading academic papers around that topic then Cache-Conscious Concurrency Control of Main-Memory Indexes on Shared-Memory Multiprocessor Systems by Prof. Sang K. Cha. et al.
This is the same Sang K. Cha that created P*Time, an in-memory (row-store) DBMS in the early 2000s.

This P*Time has been, rather well-known, acquired by SAP (like so many other DBMS software products companies... Sybase... MaxDB... OrientDB...) and the technology has been used as a research base for what would become SAP HANA.

Nowadays, there is only a small part of P*Time still in SAP HANA and it is mostly reduced to the concepts and algorithms and not so much expressed in actual P*Time code.

All in all, for the user of HANA (developer, admin, data consumer) the specifics of this index implementation hardly matter as none of them can interact with the index structure directly.

What matters is that this index takes modern server systems (many cores, large CPU caches, lots of RAM) and extracts great performance from them, while still allowing for "high-speed" transactions.

I added an extended write-up of this answer to my blog: https://lbreddemann.org/what-is-cpb-tree-in-sap-hana/.

You can precompute the key pair obviously - actually if both sides are authenticated you must precompute the key pairs and establish trust in the public keys of the other party.

R_A can be generated in advance using your secure random number generator. U_A can be precomputed using ECC point addition as both R_A and the secret key SK_A are known by A(lice).

Possibly you could reformulate the K_1 calculation as K_1 = T_B * R_A - PK_B * R_A, although you'd still be left with a multiplication and point subtraction with the same complexity, so I don't think that makes all that much sense.

You can achieve this from your original query by grouping the results:

You get the "no default constructor exist" for the pair member of the FollowsQuery class, because the compiler tries to default-construct pair but the Pair class doesn't have a default constructor.

What happens in the FollowsQuery construction is basically this: