studyGroup | Gather together a group to skill-share co-work | Collaboration library

Here is one approach using aggregation:

What happens when you try ( i put DESC as the sort direction, you could also try ASC)

Something like this should work:

From the docs:

setup a cron task (or long running process) to execute the tasks

You have to setup cron or some other periodic runner to call that command because Django by itself will not be able to do this.

You can remove the StudyGroup objects that are no longer referenced by a Student with the following query:

The key concept behind a dimensional model is:

• Keep your fact tables in 3NF (third normal form);
• De-normalize your dimensions into 2NF (second normal form)

So ideally, the only joins you should have in your model are the joins between fact tables and relevant dimensions.

As part of this philosophy:

• Avoid "snow flake" designs, where dimensions contain keys to other dimensions. It's always possible to come up with a data model that allows the same functionality as the snow flakes, without violating 3NF/2NF rule;
• Never have any direct joins between 2 separate dimensions (i.e, department and study group) directly. All relations among dimensions must be resolved via fact tables;
• Never have any direct joins between 2 separate fact tables. Any relations among fact tables must be resolved via shared dimensions.

Finally, consider that dimensional design, besides optimization of the data for querying, serves a second important purpose: it's a semantic model of the business (or whatever else it represents). So, when making decisions about combining data elements into dimensions and facts, consider their "logical affinity" - they should make intuitive sense to the end users. If you have hard times explaining to a BI analyst the meaning of your dimension or fact table, most likely you've made a modeling mistake.

For example, in your case you should consider logical relations between universities, departments, study groups, etc. It's very likely that University/Department form a natural hierarchy. If so, they should belong to the same dimension. Study group, on the other hand, might not - let's assume, it's possible to form study groups across multiple universities and/or multiple departments. Such Many:Many relations are clear indication that they should be resolved via fact tables. In addition, relations between universities and departments are stable (rarely change), while study groups are formed and dissolved very often, and thus should be modeled separately.

In general, if you see 1:1 or 1:M relations between dimensional elements, it's often an indication that they should be de-normalized into the same table (again, only if their combination makes logical sense). If the relations are M:M, most likely they belong to different tables (you can force them into the same table, but often such tables look like Frankenstein creatures).

You can get much better help by making your question more specific - draw your dimensional model, post it, and ask for specific issues/challenges you have. For general concepts, books from Kimball and Inmon are your best friends.

The Two's complement rule (8.3.3) says that if the high bit of the first (lowest index) content byte is set that the number is negative.

02 01 80 has contents 0b1000_0000. Since the high bit is set, the number is negative.

Flip all the bits (0b0111_1111), then add one: 0b1000_0000; meaning that it represents negative 128.

For a less degenerate example, 0b1000_0001 => 0b0111_1110 => 0b0111_1111, showing that 0x81 is negative 127.

For the number (positive) 127, since the high bit isn't set, the number is interepreted as positive, so the contents are just 0b0111_1111 aka 0x7F, resulting in 02 01 7F

In addition to using characters (which BER/DER uses only for base=10) not bits, as commented by Kevin, and also doing them backwards which makes no sense at all, your errors are:

• the IEEE-then-ISO/IEC floating-point scheme used by Java (and most popular CPUs), like most others, has the implied binary/radix point at the left of the 'mantissa' (better, significand), not the right as for BER/DER, and also has a 'hidden' 1-bit to the left of that implied point

• DER (but not BER) requires normalizing the mantissa (except zero, which was already special-cased) so its least significant bit is 1; for base=2 this only requires adjusting the exponent, but 8 or 16 can require a scale factor as well

In addition, you don't need an ASN1OutputStream to encode integers, because Java's builtin BigInteger.toByteArray() already produces canonical big-endian two's-complement, and you don't actually need to handle exponent lengths greater than 2 octets because they will never occur for IEEE-ISO/IEC values. (They could be needed if you wanted BigDecimal values or similar.)

The following code produces the correct and expected value (excluding tag and length):

It seems you have ambiguous ASN.1 notation. The only way I can think of to deal with it would be explicit tagging.

If your ASN.1 module has the AUTOMATIC tagging clause in module definition, than your encoder should probably explicitly tag all untagged components in ASN.1 SEQUENCE, SET and CHOICE starting from tag value 0.

That automatic tagging should only be applied when you do not have tagged components already present in the constructed data structure definition you are trying to serialize.

Here is a possibly relevant answer.