Re: Ie Could Not Create Temporary File For Processing
Nelson Suggs
There is something that I don't know on how the temporary output layers are managed since the current version of QGIS? I encountered this issue using QGIS 2.18, but I don't exclude that it could be started from previous versions of the software.
The layer with the URL starting 'polygon:' is a memory layer (or 'scratch' layer). You can create one yourself using Add layer > New temporary scratch layer. As it's in memory, it's not written off to disk (unless you decide to do this manually using save as..) and will vanish once you close QGIS.
Keyword that creates a temporary table that is visible only within the current session. The table is automatically dropped at the end of the session in which it is created. The temporary table can have the same name as a permanent table. The temporary table is created in a separate, session-specific schema. (You can't specify a name for this schema.) This temporary schema becomes the first schema in the search path, so the temporary table takes precedence over the permanent table unless you qualify the table name with the schema name to access the permanent table. For more information about schemas and precedence, see search_path.
By default, database users have permission to create temporary tables by their automatic membership in the PUBLIC group. To deny this privilege to a user, revoke the TEMP privilege from the PUBLIC group, and then explicitly grant the TEMP privilege only to specific users or groups of users.
The maximum length for the table name is 127 bytes; longer names are truncated to 127 bytes. You can use UTF-8 multibyte characters up to a maximum of four bytes. Amazon Redshift enforces a quota of the number of tables per cluster by node type, including user-defined temporary tables and temporary tables created by Amazon Redshift during query processing or system maintenance. Optionally, the table name can be qualified with the database and schema name. In the following example, the database name is tickit, the schema name is public, and the table name is test.
If a schema name is given, the new table is created in that schema (assuming the creator has access to the schema). The table name must be a unique name for that schema. If no schema is specified, the table is created by using the current database schema. If you are creating a temporary table, you can't specify a schema name, because temporary tables exist in a special schema.
Multiple temporary tables with the same name can exist at the same time in the same database if they are created in separate sessions because the tables are assigned to different schemas. For more information about valid names, see Names and identifiers.
You might be able to create a very wide table but be unable to perform query processing, such as INSERT or SELECT statements, on the table. The maximum width of a table with fixed width columns, such as CHAR, is 64KB - 1 (or 65535 bytes). If a table includes VARCHAR columns, the table can have a larger declared width without returning an error because VARCHARS columns don't contribute their full declared width to the calculated query-processing limit. The effective query-processing limit with VARCHAR columns will vary based on a number of factors.
I am trying to find the proper solution to delete the temporary file that I used to get the result of SELECT query of sqlplus using bash. As I can not create the desired output file as per the format, I first store the result in a file and then process it and append it to the target file. How should I name the temp file inorder to delete the exact file of the current bash process? I even named the temp file by appending the process id name, but the processes are so many that the same process id file can be created at the same time.
Continuing from the comment, in addition to creating the temporary file and setting a trap to remove the temp file on termination, interrupt or exit, you should validate each step along the way. You should validate mktemp provides a zero exit code. You should validate that the temp file is in fact created. Then you can use the temp file with confidence that no intervening error took place.
The problem with a high number or infinite queues is that you need to manage them. To ensure sequential consistency you would need to spawn a separate thread to monitor each queue and receive messages. If each queue is likely to recieve messages in high frequency, this might be justified, but as soon as you introduce locks to ensure that a receiving thread was the only one processing messages for a given sender, then there is no reason that any idle thread couldn't process any message.
If you really need more than 100 partitions, we simply create another level of partitioning by splitting customers between multiple partitioned queues. 10 named queues could service 1000 partitions. If you really needed to service 10000 customers and ensure that no customer is waiting for another customer's message processing then you would need 100 named queues. This at least is more manageable than 10000 queues.
When dealing with paying customers, you might consider that some customers could pay a premium for dedicated resources or for access to environments with a lower number of concurrent customers. For this you might even go so far as to deploying a separate service bus and limit the number of customers who send messages to it, or you might just create a separate queue, again limiting the number of customers who send messages to that queue.
Another oddity of the local temporary table (and the local temporary stored procedure) is that it has a different name in the metadata to the one you give it in your routine or batch. If the same routine is executed simultaneously by several processes, the Database Engine needs to be able to distinguish between the identically-named local temporary tables created by the different processes. It does this by adding a numeric string to each local temporary table name left-padded by underscore characters. Although you specify the short name such as #MyTempTable, what is actually stored in TempDB is made up of the table name specified in the CREATE TABLE statement and the suffix. Because of this suffix, local temporary table names must be 116 characters or less.
With Local temporary table (names that begin with #), what goes on under the hood is surprisingly similar to table variables. As with Table Variables, Local Temporary tables are private to the process that created it. They cannot therefore be used in views and you cannot associate triggers with them.
You cannot easily tell which session or procedure has created these tables. This is because, if the same stored procedure is executed simultaneously by several processes, the Database Engine needs to be able to distinguish the same tables created by the different processes. The Database Engine does this by internally appending a left-padded numeric suffix to each local temporary table name. The full name of a temporary table as stored in the sys.objects view in TempDB is made up of the table name specified in the CREATE TABLE statement and the system-generated numeric suffix. To allow for the suffix, the table name specified for a local temporary name must be less than 116 characters.
You can associate rules, defaults, and indexes with temporary tables, but you cannot create views on temporary tables or associate triggers with them. You can use a user-defined datatype when creating a temporary table only if the datatype exists in TempDB
Stored procedures can reference temporary tables that are created during the current session. Within a stored procedure, you cannot create a temporary table, drop it, and then create a new temporary table with the same name.
dbplyr creates temporary tables when copy = TRUE is coded when joining tables together with inner_join or similar dplyr functions using a local tibble as the "right" table. A message like this is shown in the console:
How can I control what these temporary table names are? When running multiple sessions processing different data I see error messages that a particular temporary table already exists. I don't think I would have that problem if I could make sure the tables have different names in the different sessions. A high-precision time stamp as part of the temporary name would help.
The "copy = TRUE" causes a temporary table to be created with the message shown above. But when multiple concurrent R sessions are run using the same code on different data with the same database (I believe) there's a race condition and the first session gets to create a temporary table, but the second session errors out with a duplicate temporary name.
You can also use temporary tables to improve performance. For example,if you find that, multiple times during a run the program accesses a smallsubset of rows from a much larger table, you can insert the necessary rowsinto a temporary table as an initialization task. Then the program accessesthe data residing in the smaller temporary table rather than the large applicationtable. This technique is similar to reading the data into an array in memory,except that the data never leaves the database, which is an important considerationwhen the program employs a set-based processing algorithm.
To use parallel processing, partition the data between multiple concurrentruns of a program, each with its own dedicated version of a temporary table(for example, PS_MYAPPLTMP). If you have a payroll batch process, you coulddivide the employee data by last name. For example, employees with last namesbeginning with A through M are inserted into PS_MYAPPLTMP1; employees withlast names beginning with N through Z are inserted into PS_MYAPPLTMP2.
This global setting is separate from the instance count setting fora particular program. To use a temporary table with a specific program, youassign the table to the program and set the number of instances created whena particular program is run.
aa06259810