lorri | Your project ’ s nix-env

For the pubDate :

In the Xml that is parsed with BS, the balise pubDate become pubdate or in your code you are looking for pubDate

Maybe you can try this.

Your design is awkward; you create an instance of CTS run; and never use it.

Assuming that you do your calculations right, you need to know at what index you found min. If you store the iterator returned by min_element(), you can get an index by subtracting vTrips.begin() from it. Then the corresponding elements in your vCost, vLorry and vVan vectors will contain the data you want.

However, it would be easier if you define a struct containing your pre-calculated values, and push that into some vector. In that case, all related data is kept together.

This looks like a overkill to me but it does the job.

So to answer the question I had my logic wrong:

We will create a recursive function that walks a global capacities array left to right and tries to load cargo into the various vehicle types. We keep track of how much we still have to load and pass that on to any recursive call. If we reach the end of the array, we produce a solution only if the remaining cargo is zero.

I suppose you are not doing JOINS or some other heavy transformations in your insert overwrite query and skew is really happened during insert. Because if you do then question should be not about insert.

Try to add distribute by batch_id to your insert query and re-run. If still running with skew then check your data. There are too many data for some particular batch_id or maybe you have a lot of nulls. There are different approaches of how to deal with skewed data. One of them is to filter out skewed keys and load them separately. Check long running reducer logs on job tracker, it will give you more information about where is a problem.

You're super close Lily, literally.

If you print the values of destination and location you'll notice they're getting super close, however, due to the increments they never "meet". The values never match (aren't equal).

You could easily swap your equals conditions for a more practical threshold distance condition (e.g. if the distance between the destination and location are smaller than 1px):

This kind of problem surfaces over and over again in data modeling. It is called "generalization/specialization" in ER modeling, and "superclass/subclass" in object modeling.

An object modeler uses the inheritance features built into the object model to solve the problem quite easily. The subclasses simply extend the superclass. The relational modeler is faced with a problem. how to design the tables so as to emulate the benefits that one would get from inheritance? That is the question you raised.

The simplest technique is called single table inheritance. Data about all subclasses are grouped into a single table for the superclass. There is a column, object_type, that groups together all the objects of a single type. No object can belong to more than one type. If a column is irrelevant to one of the subclasses, it will be left NULL in the rows that pertain to that subclass.

This simple solution works well for the smaller and simpler cases. The presence of a lot of NULLs adds a tiny bit to storage overhead, and a little bit to retrieval overhead. The developer may have to learn SQL three-valued logic if boolean tests are done on nullable columns. This can be baffling at first, but one gets used to it.

There is another technique, called class table inheritance. In this design, there are separate tables for each of the specialized subclasses, in addition to a combined table for all of them. When you want all of the data about a specific kind of object, you join the general table with the appropriate specialized table. There are fewer NULLs in this design, but you do more joining. This technique works better in the larger and more complex cases.

There is a third technique called shared primary key. This technique is often used in conjunction with class table inheritance. The specialized tables for the subclasses have, as their primary key, a copy of the primary key of the corresponding entry in the general table. This id column can be declared to be both the primary key and a foreign key.

This involves a little extra programming when new objects are to be added, but it makes the joins simple, easy, and fast.

Superclasses and subclasses happen all the time in the real world. Make your design simple and sound. Test your initial design for performance. Then tweak it if you need to.