I'm looking for some advice with a query I'm trying to write. I would like to count the occurrence (number of rows) of a column based on whose shift (6-2, 2-10 & 10-6) it falls into. The trouble is the shifts rotate every two weeks, e.g. if I just started on the 6-2 in two weeks time I would be on the 10-6. I have a query that will count said occurrence depending on the shift but I cannot get my head around how to make it count based on whos shift it happened on.
Any advice would be very helpful!
Thanks in advance.
Edit:
Table headings
Serial Number | Date & Time | Part Number | Type | Result
Edit 2 (a bit more detail):
I would like to count how many instances of unknown occur in part number for each our shifts. The part number column contains various numbers (always length 8) identifying the product running through the machine. If the machine for whatever reason doesn't see or read the part number correctly it writes unknown to the table.
e.g.
Week 13: Tom is on 6-2 shift / Alex is on 2-10 shift / Cam is on 10-6
Week 15: Alex is on 6-2 shift / Cam is on 2-10 / Tom is on 10-6 shift
Week 17: Cam is on 6-2 / Tom is on 2-10 shift / Alex is on 10-6 shift.
This pattern continues indefinitely and I want to some the number of unknowns in part number for Cam's shift, Tom's shift and Alex's shift. So I should end up with three numbers. I hope this helps.
OK, so we can get the week number in MySQL. For instance:
WEEK(<Date & Time colum>, 1)
have a look at the link above to decide which mode you need.
There are three shifts and three workers. I'll give them numbers:
Tom = 0
Alex = 1
Cam = 2
6-2 = 0
2-10 = 1
10-6 = 2
I then get this pattern:
week
shift
worker
rotation
0
0
0
0
0
1
1
0
0
2
2
0
1
0
1
1
1
1
2
1
1
2
0
1
2
0
2
2
2
1
0
2
2
2
1
2
3
0
0
3
3
1
1
3
3
2
2
3
4
0
0
0
Now we need to try and compute the 'shift' and 'worker' numbers from the 'week' number. Let's start with the 'shift'. There is no way to get it from week, we just have to define it:
SET shift0 = 0
SET shift1 = 1
SET shift2 = 2
This seems pointless, but bear with me. Now we need to compute the workers. How would we do this, given the 'week' and 'shift'? Here we have to use modulo 3:
SET worker0 = MOD('week' + 'shift0', 3)
SET worker1 = MOD('week' + 'shift1', 3)
SET worker2 = MOD('week' + 'shift2', 3)
Written full out with the WEEK() function:
SET worker0 = MOD(WEEK(<Date & Time colum>, 1) + 0, 3)
SET worker1 = MOD(WEEK(<Date & Time colum>, 1) + 1, 3)
SET worker2 = MOD(WEEK(<Date & Time colum>, 1) + 2, 3)
This is as far as I am willing to take it.
I would try to reconstruct the missing information using the above and store it in the database. Create tables to hold the workers and the shifts. Otherwise you'll have to write very complicated queries, which is not what you want.
Related
This is not connected to any particular programming language, I'm trying to look for the most efficient way to store a binary grid (It will look like this...)
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
Into an int with a limit of 9,999,999
So each "1" Have a Boolean of true/false a.k.a "1" or "0" state so it can be displayed as also
1 0 0 1 1
1 1 0 1 1
1 1 1 1 1
All this is expected to be stored in an int so it can be transformed binary into digits.
So at the end of the day, I should be able to first set a binary grid then turn the binary grid into digits where I can store them into a variable, And then be able to extract them after from the variable back to the binary grid.
And also to answer any question related to why I just don't simply use an array or anything in relation, Well basically this is the only way the engine lets me store things to then extract them later.
Things I try: I already know I can store things within the digit system, What I lack is getting the most out of it, right now I can store 23 Bits which means that I got to get a binary grid that looks like this
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1
And remember this is having the limit of 9,999,999
I found out the system can have it from -9,999,999 to 9,999,999.
Another thing is that the limit of 9,999,999 is all-around any function so adding 9,999,999 + 9,999,999 is out of the question for that limitation.
So I'm going to add all the relevant details:
I can only use digits to store data in a variable.
The limit of the digits go only to 9,999,999
If I were to use floats it will have to be < 999,999.00 note that the limit on the float is 2 decimal points (0.00)
If I want, I can use multiple variables in terms that have more capacity
What I'm looking for is to try to get the most amount of bits out of the digits limit in the variable.
I am struggling with calculating 5- and 10-day moving averages. I have these fields in my table: Sno, date, and price. Based on these I will get the 5- and 10-day moving averages. Below is the table.
(Please note that I am using an older version of MySQL, in which window functions are not supported.)
2 day average: it will be calculated at row no 3 as (row1+row2)/2, row 4 will be (row2+row3)/2 and so on..
4 day average: it will be calculated at row no 5 as (row1+row2+..+row4)/4, row 6 will be row2+row3+..+row5/4 and so on..
Final: Final is based on the below formula
IF(AND(D5>E5,D4<E4),"BUY",IF(AND(D5<E5,D4>E4),"SELL","HOLD"))
Example data:
Sno(A) Date(B) Close Price(C) 2 D_AVG(D) 4 D_AVG(E) Final(F)
1 01-01-13 2316.525 0 0
2 02-01-13 2304.89 0 0
3 05-01-13 2292.1825 2310.7075 0
4 06-01-13 2279.67 2298.53625 0
5 07-01-13 2267.8325 2285.92625 2298.316875 SELL
6 08-01-13 2254.735 2273.75125 2286.14375 HOLD
7 09-01-13 2129.906 2261.28375 2273.605 HOLD
8 12-01-13 2124.264 2192.3205 2233.035875 HOLD
9 13-01-13 2119.432 2127.085 2194.184375 HOLD
10 14-01-13 2114.34 2121.848 2157.08425 HOLD
I have a data set with orders of tickets. Tickets can be bought in packs of 5, or 3, as well as individually. I need to group the data using the quantity of tickets sold per order, to determine if it was a 5 pack (divisible by five), then 3 pack, or else/then individually (1 or 2 qty). So if I have a quantity of 27, I know that order consisted of five "5 packs", and 2 individual tickets.
SUM(CASE WHEN (id % 5) = 0 THEN 1 ELSE 0 END) fivepack
I have this in my query, but stringing these together for fivepack, and threepack, doesn't eliminate the starting number from the total quantity on the next operation. So a quantity of 27, would yield a result of 5 "five packs" and 9 "three packs", and then 27 "individuals".
So given a quantity, how would you first divide by a large factor, get the remainder and divide by the smaller, then finally handle the remainder?
Edit:
The sample packs provide a discount of the purchase price(not relevant to the technical issue), so the first maximum division needs to occur first. So as Gordon Linoff asked below, in the case of 27 tickets quantity, you would take the maximum number of 5 divisions first, then pass the remainder to try to divide by 3, and then return the final remainder as individuals.
The issue is passing the value of one operation in SQL to the next operation, so so on. So I can do Math1, pass Answer1 to Math2, and then pass Answer2 to Math3.
I don't fully understand why 27 would be 5 five packs and 2 individuals rather than any of the following:
27 individuals
9 3-packs
4 5-packs, 2 3-packs, 1-individual
8 3-packs and 3 individuals
and so on.
But, if you want a greedy approach, you can use the following arithmetic:
select floor(num / 5) as five_packs,
floor( (num - 5 * floor(num / 5)) / 3) as three_packs,
num - 5 * floor(num / 5) - 3 * floor( (num - 5 * floor(num / 5)) / 3) as singles
Here is a SQL Fiddle illustrating the logic.
I've got a specific problem. My data (map) in mysql is as follows
id table_row table_col tile_type
1 1 1 0
2 2 1 0
3 3 1 0
... ... ... 0
512 512 1 0
513 1 2 0
514 2 2 0
515 3 2 0
... ... ... 0
... 512 2 0
... 1 3 0
... 2 3 0
... 3 3 0
... ... ... 0
... 512 3 0
... 1 4 0
Map is 512*512. I need to come up with an algorithm that selects tiles from the centre(or near centre 256*256) point. So it should look something like
256*256 first - once selected we can update tile_type to 1
255*256 second - update tile_type to 1
256*255 third - update tile_type to 1
257*256 fourth - update tile_type to 1
256*257 fifth - update tile_type to 1
etc. or similar, but it has to start filling in tiles from centre outwards in all directions (can be random). Any ideas appreciated
Your question lacks a few details, but I am assuming you are asking a means of generating an id that is close to the center of your 512x512 grid.
It appears your grid is enumerated in a particular manner: each column is enumerated in increasing order of table_row values, and the enumeration of columns is done in increasing order of table_col values.
Consequently, we can already know the id of the cell for which the table_row and table_col values are 256: it is 255 x 512 + 256. That is correct, because there are 255 full columns that were enumerated before enumeration started for table_col value 256, and each of those columns had 512 rows in them. Finally, within this column, we are interested in row #256.
A more generalized version of this would look like below.
((num_cols + 1) / 2 - 1) * num_rows + (num_rows + 1) / 2
You don't need to care all that much about the +1s and -1s: they are just a numerical hack to handle odd num_rows and num_cols values.
Anyways, to introduce a proximity measure, you can just use two random variables. A random variable P can represent the distance to the center in terms of colums. (i.e. how far the table_col of the point with the generated id will be from the table_col value of the center of the grid) Another random variable Q can represent the distance to the center in terms of rows.
((num_cols + 1) / 2 - 1 + P) * num_rows + ((num_rows + 1) / 2 + Q)
Then you can just generate values for P and Q based on your needs, and get the id of a cell that is P colums and Q rows away from the center of the grid.
Try Below query.
SELECT (MAX(t.`row`+1)/2), (MAX(t.`column`+1)/2) INTO #max_row, #max_col
FROM tiles t;
SELECT t.`row`, t.`column`, ceil(IF(ABS(#max_row - t.`row`) < ABS(#max_col - t.`column`), ABS(#max_col - t.`column`), ABS(#max_row - t.`row`))) as tbl_order
FROM tiles t
ORDER BY 3
So in binary to find the largest number you can represent given N amount of bits, you would use:
2^N - 1
But why the -1. To try understand it i created a 3 Bit systems and tried some examples:
2^1 = (2) - 1
0 0 1 --> 1
2^2 = (4) - 1
0 1 0 --> 2
0 1 1 --> 3
2^3 = (8) - 1
1 0 0 --> 4
1 0 1 --> 5
1 1 0 --> 6
1 1 1 --> 7
So it all works out as planned, but why the -1. This probably sounds like a stupid question but as you can see above i have done a fair amount of research.
Because you can represent 0 which always takes up one spot in all the permutations.
The research shown should reveal the answer already, but you have forgotten about the zero.
Three bits are able to represent 2^3 different values. The smallest value is zero, so the largest must be 2^3-1.
Note that if you use a different system (such as signed binary), the smallest and largest value may change, but the count of values does not.