putNoOverwrite taints a secondary index

Similar Questions

• Add a secondary index to store existing data (json).

  I want to store json using BDB messages. We use the json as a key object property and the rest of the object (bytes) json as a data. later if we want to add secondary index targeting property of the json for the existing data store object, I can not do that because the data is to stay as a bytes.is their all recommend how do this .i am very new to BDB.

  In BDB, the land used for a secondary index is from primary registration data (byte []) by using the code that you write.  You can convert bytes of data from the primary registration in JSON, pull on the property you want, and then convert this byte property (since all the keys of the BDB are bytes more).

  See:

  SecondaryKeyCreator (Oracle - Berkeley DB Java Edition API)

  And to make it easy convert the property in bytes:

  com Sleepycat.bind.Tuple (Oracle - Java Edition Berkeley DB API)

  The collections API tutorial is good to learn how it works, even if you do not use the collections API:

  Berkeley DB Java Edition Collections tutorial

  -mark

• One of the secondary index is not complete

  Hello

  I had an entity having 18847 record.  It contains a primary key and secondary keys several.  Since the next release to check, we see it, all indexes are complete except ProductId.  What should I do to fix this error?

  Verification of data persist #gdlogs #test. TableWhProductStorageCard

  Tree control to persist #gdlogs #test. TableWhProductStorageCard

  BTree: Composition of the btree, types and number of nodes.

  binCount = 149

  binEntriesHistogram = [40-49%: 1; 80 to 89%: 1, 90-99%: 147]

  binsByLevel = [level 1: count = 149]

  deletedLNCount = 0

  inCount = 3

  insByLevel = [level 2: number = 2; level 3: count = 1]

  lnCount = 18, 847

  mainTreeMaxDepth = 3

  BTree: Composition of the btree, types and number of nodes.

  Verification of data persist #gdlogs #test. TableWhProductStorageCard #BatchNo

  Tree control to persist #gdlogs #test. TableWhProductStorageCard #BatchNo

  BTree: Composition of the btree, types and number of nodes.

  binCount = 243

  binEntriesHistogram = [% 40-49: 43; 50 to 59%: 121, 60-69%: 30; 70-79%: 23; 80 to 89%: 17; 90-99%: 9]

  binsByLevel = [level 1: count = 243]

  deletedLNCount = 0

  inCount = 4

  insByLevel = [level 2: number = 3; level 3: count = 1]

  lnCount = 18, 847

  mainTreeMaxDepth = 3

  BTree: Composition of the btree, types and number of nodes.

  This secondary index is correct. (the lnCount is the same as the primary index)

  
  

  Verification of data persist #gdlogs #test. TableWhProductStorageCard #ProductId

  Tree control to persist #gdlogs #test. TableWhProductStorageCard #ProductId

  BTree: Composition of the btree, types and number of nodes.

  binCount = 168

  binEntriesHistogram = [% 40-49: 16; 50 to 59%: 47; 60 to 69%: 39; 70-79%: 26; 80 to 89%: 26; 90-99%: 14]

  binsByLevel = [level 1: count = 168]

  deletedLNCount = 0

  inCount = 3

  insByLevel = [level 2: number = 2; level 3: count = 1]

  lnCount = 14: 731

  mainTreeMaxDepth = 3

  BTree: Composition of the btree, types and number of nodes.

  This index is not complete. (lnCount is less than the primary index)  Then when use this index to iterate through the lines, only the first record 14731 is returned.

  
  

  Apparently, somehow your secondary index DB became not synchronized with your primary.  Normally, this is caused by not using is not a transactional store (EntityStore.setTransactional).  But whatever the cause, I will describe how to correct the situation by rebuilding the index.

  (1) take your application offline so that no other operations occur.

  (2) make a backup in case a problem occurs during this procedure.

  (3) do not open the EntityStore yet.

  (4) delete the database index that is out of sync (persist #gdlogs #test. TableWhProductStorageCard #ProductId) by calling the Environment.removeDatabase with this name.

  (5) rebuild the index database simply by opening the EntityStore.  It will take more time than usual, since the index will be rebuilt before the return of the EntityStore constructor.

  (6) confirm that the index is rebuilt correctly.

  (7) bring your online return request.

  -mark

• PCT_DIRECT_ACCESS of secondary indexes of the IOT

  Facing a performance problem to DELETE statement due to ignorance of a secondary index on ITO by the optimizer.
  
  Version: 11.1.0.7.0
  
  We did the "update block references" for secondary indexes, here's what we tested.
  

  SQL> select owner,index_name,PCT_DIRECT_ACCESS  from dba_indexes where index_name in ('XYZ1');
  
  OWNER                          INDEX_NAME                     PCT_DIRECT_ACCESS
  ------------------------------ ------------------------------ -----------------
  DLF5                           XYZ1                                          91
  DLF7                           XYZ1                                          87
  DLF4                           XYZ1                                          90
  DLF0                           XYZ1                                          92
  DLF3                           XYZ1                                          85
  DLF1                           XYZ1                                          97
  DLF6                           XYZ1                                          93
  DLF2                           XYZ1                                          91
  
  SQL> delete FROM DLF0.LOCATE D WHERE GUID = 'Iwfegjie2jgigqwwuenbqw' AND C_ID = 30918 AND ((S_ID < 8672) OR (S_ID <= 8672 AND DELETE_FLAG = 'Y'));
  
  0 rows deleted.
  
  SQL> select PLAN_TABLE_OUTPUT  from table(dbms_xplan.display_cursor(null,null,'RUNSTATS_LAST'));
  
  PLAN_TABLE_OUTPUT
  ------------------------------------------------------------------------------------------------------------------------------------
  SQL_ID  7qxyur0npcpvh, child number 0
  -------------------------------------
  delete FROM DLF0.LOCATE D WHERE GUID = :"SYS_B_0" AND C_ID
  = :"SYS_B_1" AND ((S_ID < :"SYS_B_2") OR (S_ID <= :"SYS_B_3"
  AND DELETE_FLAG = :"SYS_B_4"))
  
  Plan hash value: 310264634
  
  -------------------------------------------------------------------------------------------
  | Id  | Operation          | Name       | Starts | E-Rows | A-Rows |   A-Time   | Buffers |
  -------------------------------------------------------------------------------------------
  |   0 | DELETE STATEMENT   |            |      1 |        |      0 |00:00:00.01 |    1260 |
  |   1 |  DELETE            | LOCATE     |      1 |        |      0 |00:00:00.01 |    1260 |
  |   2 |   CONCATENATION    |            |      1 |        |      0 |00:00:00.01 |    1260 |
  |*  3 |    INDEX RANGE SCAN| DLF0PK     |      1 |      1 |      0 |00:00:00.01 |     630 |
  |*  4 |    INDEX RANGE SCAN| DLF0PK     |      1 |      1 |      0 |00:00:00.01 |     630 |
  -------------------------------------------------------------------------------------------
  
  Predicate Information (identified by operation id):
  ---------------------------------------------------
  
     3 - access("C_ID"=:SYS_B_1 AND "GUID"=:SYS_B_0 AND
                "DELETE_FLAG"=:SYS_B_4 AND "S_ID"<=:SYS_B_3)
         filter(("GUID"=:SYS_B_0 AND "DELETE_FLAG"=:SYS_B_4))
     4 - access("C_ID"=:SYS_B_1 AND "GUID"=:SYS_B_0 AND "S_ID"<:SYS_B_2)
         filter(("GUID"=:SYS_B_0 AND (LNNVL("S_ID"<=:SYS_B_3) OR
                LNNVL("DELETE_FLAG"=:SYS_B_4))))
  
  
  28 rows selected.
  
  SQL> rollback;
  
  Rollback complete.

  At this point, we have updated the block reference and gathered stats.
  

  SQL> select owner,index_name,PCT_DIRECT_ACCESS  from dba_indexes where index_name in ('XYZ1');
  
  OWNER                          INDEX_NAME                     PCT_DIRECT_ACCESS
  ------------------------------ ------------------------------ -----------------
  DLF0                           XYZ1                                         100
  DLF1                           XYZ1                                         100
  DLF2                           XYZ1                                         100
  DLF3                           XYZ1                                         100
  DLF4                           XYZ1                                         100
  DLF5                           XYZ1                                         100
  DLF6                           XYZ1                                         100
  DLF7                           XYZ1                                         100
  
  8 rows selected.
  
  SQL> delete  FROM DLF0.LOCATE D WHERE GUID = 'Iwfegjie2jgigqwwuenbqw' AND C_ID = 30918 AND ((S_ID < 8672) OR (S_ID <= 8672 AND DELETE_FLAG = 'Y'));
  
  0 rows deleted.
  
  Elapsed: 00:00:00.03
  SQL> select PLAN_TABLE_OUTPUT  from table(dbms_xplan.display_cursor(null,null,'RUNSTATS_LAST'));
  
  PLAN_TABLE_OUTPUT
  ------------------------------------------------------------------------------------------------------------------------------------
  SQL_ID  fmrp501t70s66, child number 0
  -------------------------------------
  delete  FROM DLF0.LOCATE D WHERE GUID = :"SYS_B_0" AND
  C_ID = :"SYS_B_1" AND ((S_ID < :"SYS_B_2") OR (S_ID <=
  :"SYS_B_3" AND DELETE_FLAG = :"SYS_B_4"))
  
  Plan hash value: 310264634
  
  -------------------------------------------------------------------------------------------
  | Id  | Operation          | Name       | Starts | E-Rows | A-Rows |   A-Time   | Buffers |
  -------------------------------------------------------------------------------------------
  |   0 | DELETE STATEMENT   |            |      1 |        |      0 |00:00:00.02 |    1260 |
  |   1 |  DELETE            | LOCATE     |      1 |        |      0 |00:00:00.02 |    1260 |
  |   2 |   CONCATENATION    |            |      1 |        |      0 |00:00:00.02 |    1260 |
  |*  3 |    INDEX RANGE SCAN| DLF0PK     |      1 |      1 |      0 |00:00:00.01 |     630 |
  |*  4 |    INDEX RANGE SCAN| DLF0PK     |      1 |      1 |      0 |00:00:00.02 |     630 |
  -------------------------------------------------------------------------------------------
  
  Predicate Information (identified by operation id):
  ---------------------------------------------------
  
     3 - access("C_ID"=:SYS_B_1 AND "GUID"=:SYS_B_0 AND
                "DELETE_FLAG"=:SYS_B_4 AND "S_ID"<=:SYS_B_3)
         filter(("GUID"=:SYS_B_0 AND "DELETE_FLAG"=:SYS_B_4))
     4 - access("C_ID"=:SYS_B_1 AND "GUID"=:SYS_B_0 AND "S_ID"<:SYS_B_2)
         filter(("GUID"=:SYS_B_0 AND (LNNVL("S_ID"<=:SYS_B_3) OR
                LNNVL("DELETE_FLAG"=:SYS_B_4))))
  
  
  28 rows selected.
  
  Elapsed: 00:00:00.01
  SQL> rollback;
  
  Rollback complete.
  
  Elapsed: 00:00:00.00

  So it made no difference.
  With the help of suspicion is much better.
  

  SQL> delete /*+ index(D XYZ1) */  FROM DLF0.LOCATE D WHERE GUID = 'Iwfegjie2jgigqwwuenbqw' AND C_ID = 30918 AND ((S_ID < 8672) OR (S_ID <= 8672 AND DELETE_FLAG = 'Y'));
  
  0 rows deleted.
  
  Elapsed: 00:00:00.00
  SQL> select PLAN_TABLE_OUTPUT  from table(dbms_xplan.display_cursor(null,null,'RUNSTATS_LAST'));
  
  PLAN_TABLE_OUTPUT
  ------------------------------------------------------------------------------------------------------------------------------------
  SQL_ID  0cf13mwxuksht, child number 0
  -------------------------------------
  delete /*+ index(D XYZ1) */  FROM DLF0.LOCATE D WHERE GUID =
  :"SYS_B_0" AND C_ID = :"SYS_B_1" AND ((S_ID < :"SYS_B_2")
  OR (S_ID <= :"SYS_B_3" AND DELETE_FLAG = :"SYS_B_4"))
  
  Plan hash value: 2359760181
  
  ------------------------------------------------------------------------------------------
  | Id  | Operation         | Name       | Starts | E-Rows | A-Rows |   A-Time   | Buffers |
  ------------------------------------------------------------------------------------------
  |   0 | DELETE STATEMENT  |            |      1 |        |      0 |00:00:00.01 |       3 |
  |   1 |  DELETE           | LOCATE     |      1 |        |      0 |00:00:00.01 |       3 |
  |*  2 |   INDEX RANGE SCAN| XYZ1       |      1 |      1 |      0 |00:00:00.01 |       3 |
  ------------------------------------------------------------------------------------------
  
  Predicate Information (identified by operation id):
  ---------------------------------------------------
  
     2 - access("GUID"=:SYS_B_0)
         filter(("C_ID"=:SYS_B_1 AND ("S_ID"<:SYS_B_2 OR
                ("S_ID"<=:SYS_B_3 AND "DELETE_FLAG"=:SYS_B_4))))
  
  
  23 rows selected.
  
  Elapsed: 00:00:00.01
  
  SQL> rollback;
  
  Rollback complete.

  Could someone please help us to get the cause for the ignorance of a secondary by the optimizer index when secondary Index is to have 100% PCT_DIRECT_ACCESS.
  
  It seems to be processing problem with predicate of GOLD... but could not connect as I don't know many with ITO.
  
  -Yasser
  
  Published by: Yasu on 23 April 2012 16:39

  Its no different then any other optimizer choice, why did - it go one way rather than the other, its because he thought that less expensive.

  If you really want to prove, suggest a with and without suspicion 10053 trace, read both and see the costing. the wonderful Mr. lewis has a note on this thing with the GSIS ignored with IOT, it seems that the work is already done for you

  http://jonathanlewis.WordPress.com/2008/02/25/iots-and-10053/

• Question on UniqueConstraintException and secondary indexes.

  Hello
  
  We use the BDB DPL package for loading and reading data.
  
  We have created ONE_TO_MANY secondary Index on for example ID-> Account_NOs
  
  During the loading of data, using for example. primaryIndex.put(id,account_nos); -UniqueConstraintException is thrown when there are duplicate account numbers existing id
  
  But although UniqueConstraintException is thrown, the secondary key duplicate data are still load in BDB. I think that the data should not get charged if an Exception is thrown. Can I know if I am missing something here?
  
  for example.
  
  ID = 101-> accounts = 12345, 34567 - loading successfully of the key = 101
  ID = 201-> accounts = 77788, 12345 - throw an Exception but data is still to take key = 201.

  Your store is transactional? If this isn't the case, it is what explains and I suggest you do your transactional shop. A non-transactional store with secondary clues ask trouble, and you are responsible for the manual correction of errors of integrity if the primary and the secondary to be out of sync.

  See 'Special Considerations for the use of secondary databases with or without Transactions' here:
  http://download.Oracle.com/docs/CD/E17277_02/HTML/Java/COM/Sleepycat/je/SecondaryDatabase.html

  -mark

• Partial insertion with secondary index

  I would like to use partial inserts (DB_DBT_PARTIAL).
  However, I also need secondary indexes. Now when I insert partial data, the secondary index function is called immediately, but again, I don't have enough data to calculate the secondary key. I tried to provide some app_data is the DBT, but it does not reach the secondary index function.
  Is it possible that I can use partial inserts as well as secondary indexes?

  Hello

  Your secondary index callback function detects when there is not enough data to generate the secondary key? If so, you can return your callback function DB_DONOTINDEX.

  For more information about DB_DONOTINDEX, see the db-> documentation here: http://download.oracle.com/docs/cd/E17076_02/html/api_reference/C/dbassociate.html

  DB_DONOTINDEX basically tells the library is not to create a secondary key for this record. Subsequent updates to the data structure (that do contain the data that you need) can then return the value of secondary key appropriate to the callback function.

  Kind regards

  Dave

• Question about the use of secondary indexes in application

  Hi, I'm a newbie to Berkeley DB. We use Berkeley DB for our application that has tables in the following structure.
  
  Key to value1 value2
  ------- --------- ----------
  1) E_ID-> E_Attr, A_ID - where A_ID is String for example. A_ID = A1; A2; A3
  -where E_ID is unique but for example A1 or A2 may be part of multiple F_VITA say E1, E3, E5 etc.
  
  
  So my question is that it is possible to create secondary indexes on individual items of Value2 (e.g., A1, A2 or A3)?
  
  
  Another question, lets say we have two tables
  
  Key to value1 value2
  ------- --------- ----------
  2) X_ID-> X_Attr, E_ID
  
  E_ID-> E_Attr, A_ID - where A_ID is String for example. A_ID = A1; A2; A3
  
  In this case, can create us E_ID as a secondary Index but with primary Table-> E_Attr, A_ID E_ID?
  
  While X_ID given, we can get the chronogram, E_ID-> E_Attr, table allocation A_ID?
  
  Don't know if its possible.
  
  Thanks for reading.

  (1) when talking about data & Index, I was referring to READ ONLY BDB with no. UPDATES where you download entire files allows for example on a weekly basis. In this case, I believe that the data will be stored directly in the tree. It will not be stored in the transaction as such logs. This hypothesis is correct?

  # Storage I is nothing other than a transaction log. Read the white paper, that I mentioned.

  (2) and about the Garbage Collection operation, I meant BDB 'Cache éviction' algorithms. Sorry I have not communicated before.

  I use an LRU algorithm. What do you need exactly to know, that you can not get the doc?

  -mark

• Difference between the foreign key index and secondary index

  Hello
  
  Suppose we have two primary databases,
  
  Employee (id, company_id)
  
  Company (id, name)
  
  (where: the employee of the company is one to many, and I use the collections API)
  
  If we want to perform a join between the employee and the company based on the ID of the company. I want to know the difference between the following two options:
  
  1 - construction of a secondary index on the Employee (company_id). call this index index1. Then, we use the following code:
  
  For each company c
  index1.get (c.ID)
  
  2 - construction of a foreign key on Employee (company_id) index where the database of foreign key was undertaken. call this index index2. Then, we use the following code:
  
  For each company c
  index2.get (c.ID)
  
  I have two questions:
  
  1 - What is the difference between these two options in terms of performance?
  
  2. I know that one of the benefits of the foreign key are the application of integrity constraints (CASCADE, CANCEL, etc. to DELETE). That declare a foreign key to give me any advantage when I want to do a join? (for example a quick method, or a single statement to a join)
  
  Thank you
  Wait.

  It doesn't matter what the example, the only advantage of a foreign key index (above, the benefits of a secondary index) is that it imposes of foreign key constraints. There is no other advantage to a foreign key index.

  -mark

• Berkeley DB C++ application on floating index

  IM using Berkeley DB C++ API 6.0 on OSX. My application creates a database with the following tables:

  Primary table: (int, myStruct)-> myStruct is a buffer.

  Secondary index: (float, myStruct)-> float key is information that I collect in a buffer with the following reminder myStruct.

  int meanExtractor(Db *sdbp, const Dbt *pkey, const Dbt *pdata, Dbt *skey) { Dbt data = *pdata; feature<float> f; restoreDescriptor(f, data); void* mean = malloc( sizeof(float) ); memcpy( mean, &f.mean, sizeof(float) ); skey->set_data(mean); skey->set_size(sizeof(float)); skey->set_flags( DB_DBT_APPMALLOC ); return 0; } 

  When I iterate over the secondary index and the print key/data pairs, the float keys are well stored. My problem is that I can not query this table. I would like to run this SQL query for example:

  SELECT * FROM secondary index WHERE keys > 1.5 && keys < 3.4 

  My table is filled with 50000 keys between 0.001 and 49,999. The thing is when I use this method, for example:

  I assume the Db and the table are already opened float i = 0.05; Dbt key = Dbt(&i, sizeof(float)); Dbc* dbc; db->cursor( txn, &dbc, 0 ); int ret; ret = dbc->get( key, &vald, DB_SET_RANGE)); 

  Its retrieved this key: 0,275. It must recover 0.05 (because if there is) or at least 0.051. And for any other float value in the key of Dbt, it gives me some stupid values. If I set the DB_SET flag, he finds no key. My idea was to set the cursor to the most touch is greater than or equal to my key, then iterate with the indicator DB_NEXT until I reach the end of my stove.

  It must come from the BerkeleyDB search algorithm, but I've seen some (useful but not enough) examples to do exactly what I need, but with the Java API, so this proves that it's possible to do...

  I'm pretty stuck with this one, so if anyone has had this problem before, thx for helping me. I put my code elsewhere if necessary.

  Hello

  Because the default byte comparison does not reflect the sort order of float numbers, you have the bt_compare function for your secondary database? According to your description, your query relies on the correct number of float sort order, so I think you must define a custom function bt_compare.

  Also, as you do not exact search and just go search, DBC-> get (DB_SET) does not work for you. I think you should use the DB_SET_RANGE flag to get the point nearest(just >=).  You can see the documentation of DBC (or CBD in C++) for more information.

  Kind regards

  Winter, Oracle Berkeley DB

• Questions of detail on the index?

  We try to reduce the consumption of lots of index consistency in our application using the partitioned cache (we use close but it's partitioned back layer that contains the indexes) and therefore better understandand some details (we are now using version 3.6 but eventually will rise to 3.7 so if response are different for both please indivcate only) :
  
  1 are you all indexes (or part of them) maintained by score (would I think since it is possible to apply effectively the PartitionFilter) or are they all by node?
  2. is part of the index in binary form or are the keys and values in the form of "java objects?
  
  Best regards
  Magnus

  Hello.

  1 are you all indexes (or part of them) maintained by score (would I think since it is possible to apply effectively the PartitionFilter) or are they all by node?

  Secondary indexes are one per node, but consistency maintains in-house 'key index' which especially used for partition based filtering AFAIK. (I did the presentation on one of the SIGs consistency, this is drag bridge http://blog.ragozin.info/2011/11/coherence-sig-advanced-usage-of-indexes.html).

  2. is part of the index in binary form or are the keys and values in the form of "java objects?

  Indexed attributes are stored as java objects in the heap, but the keys are binary, shared with support card (e.i. index doesn't create additional copy of the key).

  A few year ago, I did an analysis of index piles footprint you can find it here http://blog.griddynamics.com/2009/10/coherence-memory-usage-indexes.html but they relevant to 3.5. As far as I know, there are some improvements in point 3.6. General index may also depend on selectivity.

  Kind regards
  Alexey

• Secondary databases in the Berkeley DB

  Please, can you help me with the following situations?
  
  
  
  I loaded about 18,500,000 records into a single primary database and approximately 12 500 000 records in another. It took about 6 hours to load the data and write data files: is this normal?
  
  
  Now, I need to define the secondary databases during these two primary databases: what I have to load all the data again or I can build the secondary databases on the loaded data?
  
  Thanks in advance for your answers!

  Hello

  >

  I loaded about 18,500,000 records into a single primary database and approximately 12 500 000 records in another. It took about 6 hours to load the data and write data files: is this normal?

  It may be normal. If you do not need guarantees of sustainability during the loading phase, you can try to load the data without the use of transactions (and logging); Thus, you avoid the necessary I/o to write the records of the newspaper in the logs files and the slight overhead of initialization and complete transactions. In addition, you can benefit from bulk write data: bulk updates
  At the end of the loading phase, you will need to stop and close environment, make sure that the databases are compatible via db_verify running and make a backup for them. When you restart the environment for regular use (non-charge ops) you will initialize the logging subsystems and transactional (DB_INIT_LOG, DB_INIT_TXN).
  Also, you can improve the performance of writing in pre-sorting of data before loading (according to the order of the function of the key comparison that you defined for the database, or lexicographical order if you have not defined a - applies to Btree and hash access methods).
  Additional pointers on how to deal with the load, in both cases, when you make this transactional mode or not, can be extracted from here:
  Writing to the database records
  The Page size setting
  Selection of the size of Cache
  Tuning to access method
  Setting of the transaction

  Now, I need to define the secondary databases during these two primary databases: what I have to load all the data again or I can build the secondary databases on the loaded data?

  You can create secondary from scratch, without the need to load the data all over again. See the DB_CREATE flag for the Db::associate() method.
  Note that in a transactional environment, the creation of the secondary index is executed in a single transaction. It is therefore likely that you might meet ENOMEM as errors. In this case try opening the environment without initializing the transaction subsystem (DB_INIT_TXN), wait for the creation of secondary to fill, data bases close environment, as well as restarting it with on transaction.

  Kind regards
  Andrei

• Index organized Tables

  What is logical rowid in IOT? are they kept physically somwhere like physical rowId
  
  What are secondary indexes?
  
  what he meant by leaves block splits? When and how it happens?
  
  and the primary key for a table in index constraint cannot be abandoned, delayed or off, is this true, if yes then Y
  
  How overflow works? how the two clauses are implemented PCTTHRESHOLD and INCLUDING.how they work?
  
  Published by: Juhi on October 22, 2008 13:09

  I'm sort of tempted to simply point you in the direction of the official documentation (concepts guide would be a start. See http://download.oracle.com/docs/cd/B28359_01/server.111/b28318/schema.htm#sthref759)

  But I would say one or two other things.

  First, physical ROWID not is not physically stored. I don't know why you would think they were. Certainly the ROWID data type can store a rowid if you choose to do, but if you do something like "select rowid from scott.emp", for example, you will see the ROWID that are generated on the fly. ROWID is a pseudo-column, not physically stored anywhere, but calculated each time as needed.

  The difference between a physical rowid and logic used with IOT boils down to a bit of relational database theory. It is a rule in melting of relational databases that a line, once inserted into a table, must never move. In other words, the identifier that is assigned at the time of his first insertion, must be the rowid he "keeps" for ever and ever. If you ever want to change the assigned lines in an ordinary table ROWID, you must export them, truncate the table, and then reinsert them: Insert charges, fees rowid. (Oracle bend this rule for various purposes of maintenance and management, according to which 'allow the movement of line"allows lines without a table, but the general case is still valid for most).

  This rule is obviously hopeless for the index structures. It was true, an index entry for "Bob" which is updated to "Robert" would find next to the entries for 'Adam' and 'Charlie', even though she now has a value of 'R '. Effectively, 'line' a 'b' in an index must be allowed to "move" a sort of 'r' of the block if it's the kind of update that takes place. (In practice, an update to an index entry consists of performing a delete followed by a re - insert, but the physicalities do not change the principle: 'lines' in an index must be allowed to move if their value is changed; rows of a table do not move, no matter what happens to their values)

  An IOT is, at the end of the day, simply an index with columns much more in it that a 'normal' index would - he, too, has thus allow its entires (his 'rows', if you like) to move. Therefore, an IOT cannot use a standard ROWID, which is assigned only once and forever. Instead, one must use something that takes into account that its lines may wander. It's the logical rowid. It is not more 'physical' as a physical rowid - or are physically stored anywhere. But a 'physical' rowid is invariable; a logic is not. Logic, it is actually built in part of the primary key of the ITO - and this is the main reason why you can never get rid of the primary key on the IOT constraint. Be allowed to do would be to you to destroy an organizing principle for its content which has an IOT.

  (See the section called "The virtual ROWID" and continued on this page: http://download.oracle.com/docs/cd/B28359_01/server.111/b28318/datatype.htm#CNCPT1845)

  IOT so their data stored inside in the primary key order. But they only contain the primary key, but all the other columns in the definition of 'table' too. Therefore, just as with an ordinary table, you might sometimes find data on columns that are NOT part of the first key - and in this case, you might well these columns non-primary keys are indexed. Therefore, you create ordinary index on those columns - at this point, you create an index in an index, really, but it's a secondary question, too! These additional indices are called 'secondary index', simply because they are "subsidiary clues" in the main proceedings, which is the 'picture' himself laid out in the primary key order.

  Finally, a split block of sheets is simply what happens when you have to make room for the new data in an index block which is already filled to overflowing with the existing data. Imagine an index block may not contain four entries, for example. Fill you with entries for Adam, Bob, Charlie, David. Now, you insert a new record of 'Brian '. If it's a table, you can take Brian to a new block you like: data from a table have no positional sense. But the entries of an index MUST have positional significance: you can't just throw MC Bean and Brian in the middle of a lot of Roberts, bristling. Brian DOIT pass between the existing entries for Bob and Charlie. Still you can not just put him in the middle of these two, because then you'd have five entries in a block, not four, which we imagined for the moment to be maximally allowed. So what to do? What you do is: get an empty block. Move Charlie and David entries in the new block. Now you have two blocks: Adam-Bob and Charlie David. Each has only two entries, so each has two 'spaces' to accept new entries. Now you have room to add in the entry for Brian... and if you end up with Adam-Bob-Brian and Charlie David.

  The process of moving the index entries in a single block in a new one so that there is room to allow new entries to be inserted in the middle of existing ones is called a split of block. They occur for other reasons too, so it's just a brilliant of them treatment, but they give you the basic idea. It's because of splits of block that indexes (and thus IOT) see their 'lines' move: Charlie and David started in a single block and ended up in a completely different block due to a new (and completely foreign to them) Insert.

  Very well, infinity is simply a means of segregation of data in a separate table segment that would not reasonably be stored in the main segment of the ITO himself. Suppose that you are creating an IOT containing four columns: one, a digital sequence number; two, a varchar2 (10); three, a varchar2 (15); and four, a BLOB. Column 1 is the primary key.

  The first three columns are small and relatively compact. The fourth column is a blob of data type - so it could be stored whole, multi-gigabyte-size monsters DVD movies. Do you really want your index segment (because that's what an IOT really is) to ball to the huge dimensions, every time that you add a new line? Probably not. You probably want 1 to 3 columns, stored in the IOT, but column 4 can be struck off the coast to a segment on its own (the overflow segment, actually) and a link (in fact, a physical rowid pointer) can bind to the other. Left to himself, an IOT will cut each column after the a primary key when a record that threatens to consume more than 50% of a block is inserted. However, to keep the main IOT small and compact and yet still contain data of non-primary key, you can change these default settings. INCLUDE, for example, to specify what last non-primary key column should be the point where a record is split between "keep in IOT" and "out to overflow segment." You could say "INCLUDE COL3" in the previous example, so that COL1, COL2 and COL3 remain in the IOT and only COL4 overflows. And PCTTHRESHOLD can be set at, say, 5 or 10 so that you try to assure an IOT block always contains 10 to 20 saves - instead of the 2 you would end up with default if 50% of kicks.

• Writing the records using a secondary slider

  Hello
  
  If I open my database using DB_INIT_LOCK environment, then call DB-> put () on a table which has a cursor open on a secondary index (associated with the same table) is blocked. If I want to do that when you cross the table itself, I just call DBcursor-> put instead, and all is well. However, I can not obviously calling DBcursor-> put on the secondary slider since it is not allowed. It is important I can call put () when you cross the secondary index because I can't always afford to read carefully the entire table, and I don't want to save the keys to update until after the cursor is closed because I don't know how many there will be, and I don't want to store them in memory. I found that specifying a transaction at the opening of the table makes the problem disappears, but is there a better way to do it if I don't want to use transactions?

  Transactions are the right answer for transactional environments. You can open the cursor secondary in the transaction with the isolation of DB_READ_COMMITTED if you do not want to maintain the read locks until the transaction is committed.

  If you use Berkeley DB concurrent mode store data instead, you can use DB_ENV-> cdsgroup_begin for the same purpose.

  The underlying issue here is the update on the primary must have the same 'locker ID' as the cursor secondary to avoid conflicts. Both in the same opening transaction is the easiest way to achieve this.

  Kind regards
  Michael Cahill, Oracle Berkeley DB.

• Cursors closed no problem

  Hi, I ran into a problem while closing an environment. When closing a store of the entity, I get java.lang.IllegalStateException, there's open cursors. I use not all cursors with store of this entity, only indexes of a secondary index like this feature:
  
  EntityIndex < IndexClass, DataClass > subindex = cookieIndex.subIndex (currentIndexItem);
  
  I also insert elements by calling primaryKey.putNoOverwrite () and that's it.
  
  Always during the call to EntityStore.close (), the result is the following:
  
  java.lang.IllegalStateException: database always has 6 all open cursors in trying to close.
  at com.sleepycat.je.Database.closeInternal(Database.java:503)
  at com.sleepycat.je.Database.close(Database.java:348)
  at com.sleepycat.je.SecondaryDatabase.close(SecondaryDatabase.java:333)
  at com.sleepycat.persist.impl.Store.closeDb(Store.java:1540)
  at com.sleepycat.persist.impl.Store.close(Store.java:1133)
  at com.sleepycat.persist.EntityStore.close(EntityStore.java:656)
  ...
  
  Any thoughts?

  Hello

  Are you sure that you not call methods that open cursors, such as entities() or keys() methods?

  You are not always aware that these methods open a cursor, which must be closed.

  -mark

• How to create the constructor function for a pl/sql table?

  I created a PL/SQL type as table below:

  create or replace type typ_tbl_des_text is table of the typ_tof_des_text

  OK so far, but I would like to have a constructor function which would be subject to validations and raise_application_error when a validation condition is not met.

  How to do this?

  The typ_tof_des_text that I created with a constructor function, so that the record-level validation are performed in the constructor. And I think the postings between several records shall be made in a constructor for typ_tbl_des_tex, but cannot figure out how to create such a constructor.

  BEDE wrote:

  So, if I have understood correctly, to a plsql table type, I can't have a member procedure. Or can I? I mean, just as for a type of failure I can have one or more constructors and possibly several procedures of Member.

  For the standard tables in PL/SQL, you will need to create your own API (using procedures and functions) to handle beyond the basics provided by the language. No constructors and methods as it is no o - o.

  After thinking a little deeper, I reformulate what I said earlier and actually wants to have a member procedure called add_item, who would be first to check if an item with a key value exists and, if so, it would be up-to-date and so not only extend the plsql table.

  Two options.

  As we already mentioned, an associative array can be considered - note however that this structure of table has name-value pairs.

  Another method is to use a TWG (global temporary table). You define the structure of the once initial table. When a session uses the structure of the table, private copying is instantiated for this session. When the session ends, this copy is destroyed. The table is a temporary structure for this session only.

  It can include indexes and so on – which means you can use the constraints of primary keys, unique indexes, secondary indexes and so on.

  TWG scales are much better than collections or arrays that require a PGA (expensive private server) memory. In addition, SQL can be used natively against a GTT - unlike the arrays and collections.