compare two tables in a query taking so long time - sybase

I have a a query where i compare 350 rows with other tables which are having 50000 rows it takes 5 minutes to give result.Any faster way to retrieve values get earlier.
select lower(rtrim(substring(rt_queue, 3, 6))) + " Ticor - " + convert(varchar(4), sort_grp_id) + " " + rtrim(batch_no) + ".prn" as FILENAME from tprt_queue where cycle_date >= (select CYCLE from tb_jpachi_cycle) and batch_no <> 'JOBCTR-' and rt_queue not like '%CN%' and status = 'TINTED' and lower(rtrim(substring(prt_queue, 3, 6))) + " Bicor - " + convert(varchar(4), sort_grp_id) + " " + rtrim(batch_no) + ".prn" not in (
select FILENAME from tb_jpachi_filesprocess ) order by rt_dt
This one contains 100000 rows : select FILENAME from tb_jpachi_filesprocess
Later it will increase day by day.
Here is query plan :
QUERY PLAN FOR STATEMENT 1 (at line 1).
STEP 1
The type of query is EXECUTE.
Executing a newly cached statement (SSQL_ID = 230588804).
QUERY PLAN FOR STATEMENT 1 (at line 0).
STEP 1
The type of query is DECLARE.
QUERY PLAN FOR STATEMENT 2 (at line 1).
Optimized using Serial Mode
STEP 1
The type of query is SELECT.
10 operator(s) under root
|ROOT:EMIT Operator (VA = 10)
|
| |RESTRICT Operator (VA = 9)(0)(0)(0)(0)(9)
| |
| | |SEQUENCER Operator (VA = 8) has 2 children.
| | |
| | | |SCALAR AGGREGATE Operator (VA = 1)
| | | | Evaluate Ungrouped ONCE AGGREGATE.
| | | |
| | | | |SCAN Operator (VA = 0)
| | | | | FROM TABLE
| | | | | tb_jpachi_cycle
| | | | | Table Scan.
| | | | | Forward Scan.
| | | | | Positioning at start of table.
| | | | | Using I/O Size 2 Kbytes for data pages.
| | | | | With LRU Buffer Replacement Strategy for data pages.
| | |
| | | |SQFILTER Operator (VA = 7) has 2 children.
| | | |
| | | | |RESTRICT Operator (VA = 3)(0)(0)(0)(6)(0)
| | | | |
| | | | | |SCAN Operator (VA = 2)
| | | | | | FROM TABLE
| | | | | | tprt_queue
| | | | | | Using Clustered Index.
| | | | | | Index : pk_tprt_queue
| | | | | | Forward Scan.
| | | | | | Positioning at index start.
| | | | | | Using I/O Size 16 Kbytes for index leaf pages.
| | | | | | With LRU Buffer Replacement Strategy for index leaf pages.
| | | | | | Using I/O Size 16 Kbytes for data pages.
| | | | | | With LRU Buffer Replacement Strategy for data pages.
| | | |
| | | | Run subquery 1 (at nesting level 1).
| | | |
| | | | QUERY PLAN FOR SUBQUERY 1 (at nesting level 1 and at line 2).
| | | |
| | | | Correlated Subquery.
| | | | Subquery under an IN predicate.
| | | |
| | | | |SCALAR AGGREGATE Operator (VA = 6)
| | | | | Evaluate Ungrouped ANY AGGREGATE.
| | | | | Scanning only up to the first qualifying row.
| | | | |
| | | | | |RESTRICT Operator (VA = 5)(9)(0)(0)(15)(0)
| | | | | |
| | | | | | |SCAN Operator (VA = 4)
| | | | | | | FROM TABLE
| | | | | | | tb_jpachi_filesprocess
| | | | | | | Table Scan.
| | | | | | | Forward Scan.
| | | | | | | Positioning at start of table.
| | | | | | | Using I/O Size 16 Kbytes for data pages.
| | | | | | | With LRU Buffer Replacement Strategy for data pages.
| | | |
| | | | END OF QUERY PLAN FOR SUBQUERY 1.

Related

How can I improve the response time of this query in Oracle

this query takes 24 seconds and returns 1891 results:
SELECT p.STATE, p.REFNUM, p.CODE, p.TYPE, i.STATE, pj.NAME, pj.DOCUMENT
TABLE p
inner join TABLE2 i on i.REFNUM = p.REFNUM
inner join TABLE3 pj on pj.NUMBER = i.NUMBER and p.OFIC_ID = pj.OFIC_ID and p.PUB_ID = pj.PUB_ID
inner join OFICE o on t.OFIC_ID = p.OFIC_ID and o.PUB_ID = p.PUB_ID
inner join GROUP glad on glad.GROUP_CODE=p.GROUP_CODE
WHERE glad.GROUP_TYPE ='3' AND i.STATE = '1'
AND p.PUB_ID IN ('05','11','12','09','08','13','04','02','01','06','10','03','07','14')
AND pj.NAME LIKE 'BANK%'
ORDER BY o.NAME,p.ID;
I have these indexes:
CREATE INDEX IND_TABLE1_REFNUM_ZONE ON TABLE1 (PUB_ID, OFIC_ID, REFNUM, ZONE_ID)
CREATE INDEX IND_TABLE1_REFNUMPUB ON TABLE1 (REFNUM, PUB_ID, OFIC_ID, GROUP_CODE );
CREATE INDEX IND_TABLE1_GROUP ON TABLE1 (PUB_ID, GROUP_CODE, REFNUM, OFIC_ID)
CREATE INDEX IND_TABLE2_REF ON TABLE2 (REFNUM, NUMBER, STATE);
CREATE INDEX IND_TABLE2_QUERY ON TABLE2 (NUMBER, TYPE, STATE, REFNUM, NUM, CODE);
CREATE INDEX IND_TABLE2_REFNUM ON TABLE2 (REFNUM)
CREATE INDEX IND_TABLE2_NUMBER ON TABLE2 (NUMBER)
CREATE INDEX IND_TABLE3_NUM ON TABLE3 (NUMBER, PUB_ID, OFIC_ID, NAME );
CREATE INDEX IND_TABLE3_NAME ON TABLE3 ( NAME );
CREATE INDEX IND_GROUP_COD ON GROUP (GROUP_CODE, GROUP_TYPE)
I made the following queries to see how many records are in each table:
SELECT count(*) FROM TABLE1 --> 18298458 results
SELECT count(*) FROM TABLE2 --> 60627924 results
SELECT count(*) FROM TABLE3 --> 18425913 results
SELECT count(*) FROM OFICE --> 65 results
SELECT count(*) FROM TABLE1 p INNER JOIN GROUP glad on glad.GROUP_CODE=p.GROUP_CODE where glad.GROUP_TYPE ='3' AND p.PUB_ID IN ('05','11','12','09','08','13','04','02','01','06','10','03','07','14') --> 1314077 results
SELECT count(*) FROM TABLE1 p INNER JOIN GROUP glad on glad.GROUP_CODE=p.GROUP_CODE where glad.GROUP_TYPE ='3' AND p.PUB_ID IN ('05') --> 53754 results
SELECT count(*) FROM TABLE3 WHERE NAME LIKE 'BANK%' --> 1922081 results
this is the plan generated by oracle:
-----------------------------------------------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost | Pstart| Pstop |
-----------------------------------------------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 291K| 38M| 384K| | |
| 1 | SORT ORDER BY | | 291K| 38M| 384K| | |
| 2 | HASH JOIN | | 291K| 38M| 375K| | |
| 3 | TABLE ACCESS FULL | OFICE | 64 | 960 | 3 | | |
| 4 | HASH JOIN | | 291K| 34M| 375K| | |
| 5 | INDEX SKIP SCAN | IND_GROUP_COD | 47 | 329 | 1 | | |
| 6 | HASH JOIN | | 452K| 50M| 375K| | |
| 7 | PART JOIN FILTER CREATE | :BF0000 | 452K| 50M| 375K| | |
| 8 | NESTED LOOPS | | 452K| 50M| 375K| | |
| 9 | NESTED LOOPS | | | | | | |
| 10 | STATISTICS COLLECTOR | | | | | | |
| 11 | HASH JOIN | | 2100K| 166M| 252K| | |
| 12 | NESTED LOOPS | | 2100K| 166M| 252K| | |
| 13 | STATISTICS COLLECTOR | | | | | | |
| 14 | PARTITION RANGE ALL | | 1681K| 89M| 82582 | 1 | 19 |
| 15 | PARTITION HASH ALL | | 1681K| 89M| 82582 | 1 | 32 |
| 16 | TABLE ACCESS FULL | TABLE3 | 1681K| 89M| 82582 | 1 | 608 |
| 17 | INDEX RANGE SCAN | IND_TABLE2_QUERY | 1 | 27 | 103K| | |
| 18 | INDEX FAST FULL SCAN | IND_TABLE2_QUERY | 32M| 845M| 103K| | |
| 19 | INDEX RANGE SCAN | IND_TABLE1_REFNUM_ZONE| | | | | |
| 20 | TABLE ACCESS BY GLOBAL INDEX ROWID| TABLE1 | 1 | 35 | 70380 | ROWID | ROWID |
| 21 | PARTITION RANGE ALL | | 19M| 650M| 70380 | 1 | 19 |
| 22 | PARTITION HASH JOIN-FILTER | | 19M| 650M| 70380 |:BF0000|:BF0000|
| 23 | TABLE ACCESS FULL | TABLE1 | 19M| 650M| 70380 | 1 | 608 |
-----------------------------------------------------------------------------------------------------------------
I think it takes time because this one is using TABLE ACCESS FULL for TABLE1 and TABLE3
if I perform the query filtering only PUB_ID='05' instead of all the numbers in the above query, the query returns 181 results and takes 8 seconds and in that case oracle generates this plan:
--------------------------------------------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost | Pstart| Pstop |
--------------------------------------------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 797 | 108K| 312K| | |
| 1 | SORT ORDER BY | | 797 | 108K| 312K| | |
| 2 | NESTED LOOPS | | 797 | 108K| 312K| | |
| 3 | HASH JOIN | | 1238 | 160K| 312K| | |
| 4 | TABLE ACCESS BY INDEX ROWID BATCHED| OFICE | 3 | 45 | 2 | | |
| 5 | INDEX RANGE SCAN | SYS_C0034405 | 3 | | 1 | | |
| 6 | HASH JOIN | | 2091 | 240K| 312K| | |
| 7 | PART JOIN FILTER CREATE | :BF0000 | 66316 | 5375K| 241K| | |
| 8 | NESTED LOOPS | | 66316 | 5375K| 241K| | |
| 9 | PARTITION RANGE ALL | | 53085 | 2903K| 82490 | 1 | 19 |
| 10 | PARTITION HASH ALL | | 53085 | 2903K| 82490 | 1 | 32 |
| 11 | TABLE ACCESS FULL | TABLE3 | 53085 | 2903K| 82490 | 1 | 608 |
| 12 | INDEX RANGE SCAN | IND_TABLE2_QUERY | 1 | 27 | 3 | | |
| 13 | PARTITION RANGE ALL | | 762K| 25M| 68657 | 1 | 19 |
| 14 | PARTITION HASH JOIN-FILTER | | 762K| 25M| 68657 |:BF0000|:BF0000|
| 15 | TABLE ACCESS FULL | TABLE1 | 762K| 25M| 68657 | 1 | 608 |
| 16 | INDEX RANGE SCAN | IND_GROUP_COD | 1 | 7 | 0 | | |
--------------------------------------------------------------------------------------------------------------
SYS_C0034405 is the primary key of OFFICE which contains these fields: (PUB_ID, REG_ID)
if in addition to filtering only PUB_ID='05' I remove the "order by", the query takes only 3.5 seconds but I definitely have to return the ordered data and I would prefer to be able to filter several PUB_IDs
I thought the query could be improved if I removed the "inner join" from GROUP and changed the filter "glad.GROUP_TYPE ='3'" to "p.GROUP_CODE in ('01','07','10','21 ')" (these are all type 3 codes), because now it should use the IND_TABLE1_GROUP index but instead of improving, it gets worse, it takes 13 seconds even filtering only PUB_ID='05'; This is the plan that oracle generates:
------------------------------------------------------------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost | Pstart| Pstop |
------------------------------------------------------------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 47 | 6251 | 172K| | |
| 1 | SORT ORDER BY | | 47 | 6251 | 172K| | |
| 2 | HASH JOIN | | 47 | 6251 | 172K| | |
| 3 | PARTITION RANGE ALL | | 47786 | 2613K| 82490 | 1 | 19 |
| 4 | PARTITION HASH ALL | | 47786 | 2613K| 82490 | 1 | 32 |
| 5 | TABLE ACCESS FULL | TABLE3 | 47786 | 2613K| 82490 | 1 | 608 |
| 6 | HASH JOIN | | 41945 | 3154K| 89633 | | |
| 7 | NESTED LOOPS | | 41945 | 3154K| 89633 | | |
| 8 | NESTED LOOPS | | 75740 | 3154K| 89633 | | |
| 9 | STATISTICS COLLECTOR | | | | | | |
| 10 | NESTED LOOPS | | 18935 | 924K| 15985 | | |
| 11 | TABLE ACCESS BY INDEX ROWID BATCHED | OFICE | 3 | 45 | 2 | | |
| 12 | INDEX RANGE SCAN | SYS_C0034405 | 3 | | 1 | | |
| 13 | INLIST ITERATOR | | | | | | |
| 14 | TABLE ACCESS BY GLOBAL INDEX ROWID BATCHED| TABLE1 | 6312 | 215K| 7039 | ROWID | ROWID |
| 15 | INDEX RANGE SCAN | IND_TABLE1_GROUP | 6828 | | 284 | | |
| 16 | INDEX RANGE SCAN | IND_TABLE2_REFNUM | 4 | | 2 | | |
| 17 | TABLE ACCESS BY INDEX ROWID | TABLE2 | 2 | 54 | 4 | | |
| 18 | INDEX FAST FULL SCAN | IND_TABLE2_QUERY | 2 | 54 | 2 | | |
------------------------------------------------------------------------------------------------------------------------------
And if I put all the PUB_IDs, Oracle generates this plan (it doesn't even use the IND_TABLE1_GROUP index anymore):
-------------------------------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost | Pstart| Pstop |
-------------------------------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 35661 | 4631K| 345K| | |
| 1 | SORT ORDER BY | | 35661 | 4631K| 345K| | |
| 2 | HASH JOIN | | 35661 | 4631K| 344K| | |
| 3 | TABLE ACCESS FULL | OFICE | 64 | 960 | 3 | | |
| 4 | HASH JOIN | | 35661 | 4109K| 344K| | |
| 5 | PARTITION RANGE ALL | | 1360K| 45M| 79580 | 1 | 19 |
| 6 | PARTITION HASH ALL | | 1360K| 45M| 79580 | 1 | 32 |
| 7 | TABLE ACCESS FULL | TABLE1 | 1360K| 45M| 79580 | 1 | 608 |
| 8 | HASH JOIN | | 2100K| 166M| 252K| | |
| 9 | NESTED LOOPS | | 2100K| 166M| 252K| | |
| 10 | STATISTICS COLLECTOR | | | | | | |
| 11 | PARTITION RANGE ALL | | 1681K| 89M| 82582 | 1 | 19 |
| 12 | PARTITION HASH ALL | | 1681K| 89M| 82582 | 1 | 32 |
| 13 | TABLE ACCESS FULL | TABLE3 | 1681K| 89M| 82582 | 1 | 608 |
| 14 | INDEX RANGE SCAN | IND_TABLE2_QUERY | 1 | 27 | 103K| | |
| 15 | INDEX FAST FULL SCAN | IND_TABLE2_QUERY | 32M| 845M| 103K| | |
-------------------------------------------------------------------------------------------------

How to place NULLs last in ascending order

I need to sort a table and I need to display the rows that include Nulls at the bottom. Whenever I run the below query
select * from t1
order by status, date;
Nulls show up in the first row which I don't want:
+--------+------------+--+
| Status | Date | |
+--------+------------+--+
| 1 | NULL | |
| 1 | 2011-12-01 | |
| 1 | 2011-12-21 | |
| 2 | NULL | |
| 2 | 2005-09-02 | |
| 3 | 2000-08-07 | |
| | | |
+--------+------------+--+
This is what I need:
+--------+------------+--+
| Status | Date | |
+--------+------------+--+
| 1 | 2011-12-01 | |
| 1 | 2011-12-21 | |
| 1 | NULL | |
| 2 | 2005-09-02 | |
| 2 | NULL | |
| 3 | 2000-08-07 | |
| | | |
+--------+------------+--+
How can I do it?
select * from t1
order by status,
date,
CASE WHEN date is NULL
THEN 1
ELSE 0
END;
Would this work: order by col asc nulls last?

Need to update "orderby" column

I have a table test
+----+--+------+--+--+----------+--+--------------+
| ID | | Name | | | orderby | | processgroup |
+----+--+------+--+--+----------+--+--------------+
| 1 | | ABC | | | 10 | | 1 |
| 10 | | DEF | | | 12 | | 1 |
| 15 | | LMN | | | 1 | | 1 |
| 44 | | JKL | | | 4 | | 1 |
| 42 | | XYZ | | | 3 | | 2 |
+----+--+------+--+--+----------+--+--------------+
I want to update the orderby column in the sequence, I am expecting output like
+----+--+------+--+--+----------+--+--------------+
| ID | | Name | | | orderby | | processgroup |
+----+--+------+--+--+----------+--+--------------+
| 1 | | ABC | | | 1 | | 1 |
| 10 | | DEF | | | 2 | | 1 |
| 15 | | LMN | | | 3 | | 1 |
| 44 | | JKL | | | 4 | | 1 |
| 42 | | XYZ | | | 5 | | 1 |
+----+--+------+--+--+----------+--+--------------+
Logic behind this is when we have procesgroup as 1, orderby column should update as 1,2,3,4 and when procesgroup is 2 then update orderby as 5.
This might help you
;WITH CTE AS (
SELECT ROW_NUMBER() OVER (ORDER BY processgroup, ID ) AS SNO, ID FROM TABLE1
)
UPDATE TABLE1 SET TABLE1.orderby= CTE.SNO FROM CTE WHERE TABLE1.ID = CTE.ID

SSRS 2008 R2 Row/Column Group Issues

I am using Row Group And Column Group in SSRS 2008 R2.
I have design the report contain two row groups(et.Pixel、Name) and one column group(et.Date).
Preview Report as bellow:
| Date1 | Date2 | Date2 |
Pixel | Name | Input | Ng | Name | Input | Ng | Name | Input | Ng |
| XXX1 | 1000 | 2 | | | | | | |
| | | | YYY1 | 2000 | 1 | | | |
2M | | | | YYY2 | 1000 | 2 | | | |
| | | | YYY3 | 3000 | 5 | | | |
| | | | | | | ZZZ1 | 800 | 2 |
| | | | | | | ZZZ2 | 500 | 3 |
|Total | 1000 | 2 |Total | 6000 | 8 |Total | 1300 | 5 |
My question is, How do I get the Preview Report don't show white space column in report.
For example:
| Date1 | Date2 | Date2 |
Pixel | Name | Input | Ng | Name | Input | Ng | Name | Input | Ng |
| XXX1 | 1000 | 2 | YYY1 | 2000 | 1 | ZZZ1 | 800 | 2 |
2M | | | | YYY2 | 1000 | 2 | ZZZ2 | 500 | 3 |
| | | | YYY3 | 3000 | 5 | | | |
|Total | 1000 | 2 |Total | 6000 | 8 |Total | 1300 | 5 |
It's the grouping by name which is causing the issue that you are having. Since the name is different they won't be on the same line.
On the plus side, you can probably work around this. If the data is like you display it, I would group on the numeric number in the name instead of the whole name.
=MID(Fields!Name.Value, 4, LEN(Fields!Name.Value) - 3)
Of course you couldn't have XXX and YYY data on the same date with this expression otherwise you would have multiple rows.

Memory Layout Choice of N-Dimensional Array

I've started writing a library for n-dimensional vectors.
There's a couple of design features that I would like to support in this
library:
The memory layout is continuous. This is so that sharing memory, sending over a network, and saving to file is only a matter of passing a pointer.
Different dimensions can support different element sizes (ie [0][0] may be 1 byte while [1][0] may be 2 bytes).
After drawing out some representations of what the memory layout
would look like for vectors of certain dimensions, I've realized that
there is two ways to layout the structure:
Here's the first way. Both representations are a visualization of
a [2][4][3] array.
---------------------------
| index | 0:0:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| index | 1:0:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| index | 0:0:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| index | 0:1:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| index | 0:2:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| index | 0:3:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| index | 1:0:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| index | 1:1:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| index | 1:2:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| index | 1:3:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| Index | 0:0:0 |
| Element | |
---------------------------
---------------------------
| Index | 0:0:1 |
| Element | |
---------------------------
---------------------------
| Index | 0:0:2 |
| Element | |
---------------------------
---------------------------
| Index | 0:1:0 |
| Element | |
---------------------------
---------------------------
| Index | 0:1:1 |
| Element | |
---------------------------
---------------------------
| Index | 0:1:2 |
| Element | |
---------------------------
---------------------------
| Index | 0:2:0 |
| Element | |
---------------------------
---------------------------
| Index | 0:2:1 |
| Element | |
---------------------------
---------------------------
| Index | 0:2:2 |
| Element | |
---------------------------
---------------------------
| Index | 0:3:0 |
| Element | |
---------------------------
---------------------------
| Index | 0:3:1 |
| Element | |
---------------------------
---------------------------
| Index | 0:3:2 |
| Element | |
---------------------------
---------------------------
| Index | 1:0:0 |
| Element | |
---------------------------
---------------------------
| Index | 1:0:1 |
| Element | |
---------------------------
---------------------------
| Index | 1:0:2 |
| Element | |
---------------------------
---------------------------
| Index | 1:1:0 |
| Element | |
---------------------------
---------------------------
| Index | 1:1:1 |
| Element | |
---------------------------
---------------------------
| Index | 1:1:2 |
| Element | |
---------------------------
---------------------------
| Index | 1:2:0 |
| Element | |
---------------------------
---------------------------
| Index | 1:2:1 |
| Element | |
---------------------------
---------------------------
| Index | 1:2:2 |
| Element | |
---------------------------
---------------------------
| Index | 1:3:0 |
| Element | |
---------------------------
---------------------------
| Index | 1:3:1 |
| Element | |
---------------------------
---------------------------
| Index | 1:3:2 |
| Element | |
---------------------------
Here's the second way.
---------------------------
| index | 0:0:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| index | 0:0:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| Index | 0:0:0 |
| Element | |
---------------------------
---------------------------
| Index | 0:0:1 |
| Element | |
---------------------------
---------------------------
| Index | 0:0:2 |
| Element | |
---------------------------
---------------------------
| index | 0:1:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| Index | 0:1:0 |
| Element | |
---------------------------
---------------------------
| Index | 0:1:1 |
| Element | |
---------------------------
---------------------------
| Index | 0:1:2 |
| Element | |
---------------------------
---------------------------
| index | 0:2:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| Index | 0:2:0 |
| Element | |
---------------------------
---------------------------
| Index | 0:2:1 |
| Element | |
---------------------------
---------------------------
| Index | 0:2:2 |
| Element | |
---------------------------
---------------------------
| index | 0:3:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| Index | 0:3:0 |
| Element | |
---------------------------
---------------------------
| Index | 0:3:1 |
| Element | |
---------------------------
---------------------------
| Index | 0:3:2 |
| Element | |
---------------------------
---------------------------
| index | 1:0:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| index | 1:0:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| Index | 1:0:0 |
| Element | |
---------------------------
---------------------------
| Index | 1:0:1 |
| Element | |
---------------------------
---------------------------
| Index | 1:0:2 |
| Element | |
---------------------------
---------------------------
| index | 1:1:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| Index | 1:1:0 |
| Element | |
---------------------------
---------------------------
| Index | 1:1:1 |
| Element | |
---------------------------
---------------------------
| Index | 1:1:2 |
| Element | |
---------------------------
---------------------------
| index | 1:2:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| Index | 1:2:0 |
| Element | |
---------------------------
---------------------------
| Index | 1:2:1 |
| Element | |
---------------------------
---------------------------
| Index | 1:2:2 |
| Element | |
---------------------------
---------------------------
| index | 1:3:0 |
| elementSize | |
| elementCount | |
| expansionBoundary | |
| slotCount | |
---------------------------
---------------------------
| Index | 1:3:0 |
| Element | |
---------------------------
---------------------------
| Index | 1:3:1 |
| Element | |
---------------------------
---------------------------
| Index | 1:3:2 |
| Element | |
---------------------------
Are there certain advantages/disadvantages in choosing one layout over the other?

Resources