lzo | Unofficial mirror of LZO | Natural Language Processing library

There are several ways that table space can be reclaimed.

First is compression (encoding) which you are looking at. Best advice is to compress everything especially data columns. There are only a few cases where storing raw data on disk is a win (sort key - usually second or third keys). Run ANALYZE COMPRESSION and get a report of what compression will be the best for your data. As one commenter noted a surrogate integer may be best and that is one of the compression (encoding) modes that may be recommended. This report will also give you some idea about how much space could be saved. Changing the data type from float to some decimal representation will likely not save much space ONCE they are compressed. I'd used the data type that is best for the work and leave the space savings up to compression.

Second I'd want to make sure that there isn't a lot of "dead space" in the table. Redshift uses 1MB blocks to store data. Once a block is written it is not updated, only replaced. If you have a process that adds data incrementally to the table the last block is likely partially full but the next write will start a new block. This can lead to a lot of dead space in the table. "VACUUM " will compact the table to remove this dead space (or "VACUUM DELETE ONLY " if you are worried about the sorting time of the table). Redshift should do this automatically now but it can be disabled and happens when there is low activity on the cluster which for some clusters is never.

Additional thing to check is if the table is well distributed as being poorly distributed can increase dead space as well as impact your query performance.

That's about it. Redshift is all about packing in large data but you need to use its systems well.

As you can see in strace, the execve command executes as: execve("/bin//nc", ["/bin//nc", "/bin//nc-e //bin/bash -nvlp 4455"], NULL) = 0 It seems to be taking the whole /bin//nc-e //bin/bash -nvlp 4455 as a single argument and thus thinks it's a hostname. In order to get around that, the three argv[] needed for execve() is pushed seperately. argv[]=["/bin/nc", "-e/bin/bash", "-nvlp4455"] These arguments are each pushed into edx, ecx, and ebx. since ebx needs to be /bin/nc, which was already done in the original code. we just needed to push 2nd and 3rd argv[] into ecx and edx and push it into stack. After that we just copy the whole stack into ecx, and then xor edx,edx to set edx as NULL.

Here is the correct solution:

This is a link error, not a compile error so I'd guess you are missing at least the reference to library gtk-3 in your link library dependencies (takes care of the gtk_application_window_new reference). There might be others missing too.

You might take a look here: https://docs.gtk.org/gtk3/compiling.html for a example of what you might need.

Looking at the log, there's not much info, but I can assume from it that you were using WSL or something similar on Windows, not using an actual Ubuntu device. The reason why buildozer doesn't work, I don't know, the log doesn't go far back enough for me to find out, but it is very likely that is because WSL is not a full-fledged Linux distribution

The solution for me was to use an online virtual machine called Google Colaboratory

Press cancel to the popup to open a new notebook

Initialize the VM by pressing Connect in the top-right part of the page

Then add a new Code Cell by pressing +Code

To set up buildozer and other commands, paste into the cell and press the play icon

Build tags in you environment.yml are quite strict requirements to satisfy and most often not needed. In your case, changing the yml file to

There are a number of things to check as Redshift has a number of systems in this area. First, how old was the console recommendation? Also does the table have "Automatic Table Optimization" enabled?

Analyze compression just looks as the size the column can be reduced to if the compression is changes. So just about size and as you rightly point out IO bandwidth. The reason that the improvement could be 0% is likely due to how the data falls into 1MB blocks and no blocks are saved by making the data smaller (at least at the current size of the table).

The console recommendation is a "smarter" algorithm - it looks at more than data size and tries to make "safe" recommendations or change. The major reason that improving a compression can reduced performance is by making the block metadata less effective. So if a column is often used as a WHERE clause Redshift will shy away from recommending additional compression. I've yet to see it be smart enough to look through metadata impacts and compare them correctly with IO bandwidth improvements. So it just gets shy when it isn't sure.

In the case of these other columns where analyze compression says large amounts of size savings are possible it is possible Redshift is being "shy". Are these columns used as WHERE clauses? Especially simple WHERE clauses (col = value) where metadata comparisons are enabled. Just because Redshift didn't recommend these changes to encodings doesn't mean that these are bad to do (or good, or neutral). It just doesn't know enough / isn't smart enough. There are ways to analyze the metadata for these columns and see what the different encodings will do to it but this takes some effort. ENCODE RAW for common, simple WHERE clause columns is a good guess but to know for sure takes work.

Here is a minimal example of a pod with OpenVPN client. I used kylemanna/openvpn as a server and to generate a basic client config. I only added two routes to the generated config to make it working. See below:

Flutter plugins follow a very specific format, and the tooling requires core elements of that format to exist. That includes the public header file with the correct path, as you have discovered, and also the plugin registration, which is the second issues you have (it sounds like you have restored the declaration, but not the implementation).

If your goal is to build your own FFI library code by piggy-backing on the plugin template, you need to leave those core elements in place. Your registration method doesn't need to do anything, but it must exist because the flutter tool will generate a call to it.

It's likely that in the future there will be tooling support for FFI-specific builds, but until then you need to make your library follow the required elements of the plugin structure.

Looking at