Oracle buffer

Similar Questions

• Changing data in the undo tablespace or db Oracle buffer cache

  Hello
  
  I have serious doubt in the feature of oracle architecture, when a user issues an update statement, the data blocks are transported to the db buffer cache and where the data changes are made? Made a copy data block is stored in the cache db pads and the changes are made to the block in the buffer cache? or the copy of the data block is stored in the undo tablespace and changes are made to the blocks in the undo tablespace?
  
  In singles, the changes to the data blocks are make to the db or undo tablespace buffer cache?
  
  
  Thanks in advance
  
  Kind regards
  007

  Did you have a look to the Internet for the answer?

  In short, if a trial Oracle wants to update a record in the table, it does:

  -Read the record to be changed in the buffercache
  -Audits (the record already locked, is the update allowed)
  -Put the folder (called image before) in a rollback in the UNDO tablespace segment
  -Writing redo information about this change in the UNDO tablespace
  -Lock the record
  -Write the change in registration in the buffer cache
  -Put the change also in the redo buffer
  S ' sit and wait... (for a commit or a rollback)

  When are committed:
  -Release the lock
  -Empty folder of restoration since the UNDO tablespace
  -Write a record of this change forward in the UNDO tablespace

  When rollback:
  -Release the lock
  -Rinse the record changed the buffercache
  -Read the original value
  -Empty folder of restoration since the UNDO tablespace
  -Write a record of this change forward in the UNDO tablespace

  It of here, some more specific complexity when a checkpoint occurs between the change and the commit / rollback or redo buffer has been emptied for redo files

  Please any other s/n, correct me if I'm wrong...

  See you soon
  FJFranken

• UNIX buffer cache vs oracle database buffer cache

  1. What is the difference between the operating system buffer cache and the oracle buffer cache?
  2. in what cases, oracle uses oracle buffer cache? in this case, oracle does not use buffer cache instead of use the OS buffer cache.
  
  I'm confused about this concept.
  
  Appreciate any help.
  
  S.

  Database instance does not use the OS buffer cache in 2 cases:

  1 FILESYSTEMIO_OPTIONS is set to ARM or SETALL (see http://download.oracle.com/docs/cd/E11882_01/server.112/e16638/os.htm#PFGRF94412).

  2 database instance uses ASM with raw devices.

  Edited by: P. Forstmann on July 19. 2011 18:43
  It is not ASM with ASMLib but ASM with gross as devices explained ASMLib and Linux block devices

  Edited by: P. Forstmann on July 19. 2011 19:36

• Copies of unexpected CR in the buffer cache

  Hello
  
  While trying to understand the mechanisms of the Oracle buffer cache, I ran a little experiment and observed an unexpected result. I believe that my expectation was wrong, and I would be so grateful, if someone could explain to me what I misunderstood.
  From what I understand, a copy of coherent reading (CR) of a buffer in the cache is created, when the old content of a buffer to be read, for example to ignore changes made by a transaction not yet committed when you query a table. I also thought, that copies of CR in the buffer cache can be reused by subsequent queries requiring a roll back image of the corresponding block.
  
  Now, I ran the following experiment on a DB of 10.2 or slowed down.
  1. I create a BC_TEST table (in a non-SAMS tablespace)
  -> V$ BH shows an A buffer with XCUR status for this table - V$ BH. COURSE number is 4, which indicates a segment according to various sources on the internet header.
  2 session 1 inserts a row into the table (and not valid)
  -> Now V$ BH shows 8 pads with XCUR status attached to the BC_TEST table. I think it's the blocks of a certain extent be allocated to the table (I expected as a block of data to load into the cache in addition to the header that was already there in step 1). There are still buffers with CLASS A # = 4 of step 1, a buffer B with XCUR and CLASS status # = 1, which indicates a block of data, according to various sources on the internet, and other 6 blocks with FREE status and CLASS # = 14 (this value is decoded differently in different sources on the internet).
  3 session 2 emits a ' select * from bc_test ".
  -> V$ BH shows 2 extra buffers with CR and the same FILE status #/ BLOCK # as buffer B in step 2. I understand that it compatible read copy needs to be done to undo the uncommitted changes in step 2 - However, I do not understand why * 2 * these copies are created.
  Note: with a slight variation of the experience, if I don't "select * from bc_test" in Session 2 between step 1 and 2, and then then I only get CR 1 copy in step 3 (I expect).
  4 session 2 issues "select * from bc_test"new"
  -> V$ BH presents yet another extra stamp with CR and the same FILE status #/ BLOCK # as buffer B step 2 (i.e. 3 these buffers in total). Here I don't understand, why the request cannot reuse the CR copy already created in step 3 (which already shows B buffer without changes to the transaction not posted in step 2).
  5 session 2 questions repeatedly ' select * from bc_test "new"
  --> The number of buffers with CR and the same FILE status #/ BLOCK # as buffer B step 2 increases by one with each additional request up to a total of 5. After that, the number of these buffers remains constant after additional queries. However various session statistics 2 ("consistent gets", "Blocks created CR", "the consistent changes", "data blocks consistent reads - undo records applied," "no work - gets consistent reading") suggests, that session 2 continues to generate copies of current reading with each "select * of bc_test" (are the buffers in the buffer cache may simply be reused from there on?).
  
  
  
  To summarize, I have the following question:
  (I) why the insertion of a single line (in step 2) load 8 blocks in the buffer cache - and what does the CLASS # = 14 indicate?
  (II) why the first select statement on the table (step 3) creates 2 copies of CR (use single) data block of the table (instead of one as I expect)?
  (III)) why other issues create copies of CR of this block of data that is unique (instead of reusing the copy created by the first select statement CR)?
  (IV) which limits the number of CR created copies to 5 (is there some parameter checking this value, it is according to some sizing of the cache or is it simply hard-coded)?
  (V) what exactly triggers the creation of a copy of CR of a buffer in the buffer cache?
  
  Thank you very much for any answer
  Kind regards
  Martin
  
  P.S. Please find below the Protocol of my experience
  
  --------------------------------------------------
  Control session
  --------------------------------------------------
  SQL > drop table bc_test;
  
  Deleted table.
  
  SQL > create table bc_test (collar number (9)) tablespace local01;
  
  Table created.
  
  SQL > SELECT bh.file #, bh.block #, bh.class #, bh.status, bh.dirty, bh.temp, bh.ping, bh.stale, bh.direct, bh.new
  2 from V$ BH bh
  3, o dba_objects
  4. WHERE bh. OBJD = o.data_object_id
  5 and o.object_name = 'BC_TEST. '
  6 order of bh.block #;
  
  FOLDER # BLOCK # CLASS # STATUS D T P S D N
  5 209 4 xcur O N N N N N
  
  
  --------------------------------------------------
  Session 1
  --------------------------------------------------
  SQL > insert into bc_test values (1);
  
  1 line of creation.
  
  --------------------------------------------------
  Control session
  --------------------------------------------------
  
  SQL > /.
  
  FOLDER # BLOCK # CLASS # STATUS D T P S D N
  5 209 4 xcur O N N N N N
  5 210 1 xcur O N N N N N
  5 211 14 free N N N N N N
  5 212 14 free N N N N N N
  5 213 14 free N N N N N N
  5 214 14 free N N N N N N
  5 215 14 free N N N N N N
  5 216 14 free N N N N N N
  
  8 selected lines.
  
  --------------------------------------------------
  Session 2
  --------------------------------------------------
  
  SQL > select * from bc_test;
  
  no selected line
  
  
  Statistics
  ----------------------------------------------------------
  28 recursive calls
  0 db block Gets
  Gets 13 coherent
  0 physical reads
  size of roll forward 172
  272 bytes sent via SQL * Net to client
  374 bytes received via SQL * Net from client
  1 SQL * Net back and forth to and from the client
  0 sorts (memory)
  0 sorts (disk)
  0 rows processed
  
  --------------------------------------------------
  Control session
  --------------------------------------------------
  SQL > /.
  
  FOLDER # BLOCK # CLASS # STATUS D T P S D N
  5 209 4 xcur N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 xcur N N N N N N
  5 211 14 free N N N N N N
  5 212 14 free N N N N N N
  5 213 14 free N N N N N N
  5 214 14 free N N N N N N
  
  8 selected lines.
  
  --------------------------------------------------
  Session 2
  --------------------------------------------------
  SQL > /.
  
  no selected line
  
  
  Statistics
  ----------------------------------------------------------
  0 recursive calls
  0 db block Gets
  Gets 5 in accordance
  0 physical reads
  size of roll forward 108
  272 bytes sent via SQL * Net to client
  374 bytes received via SQL * Net from client
  1 SQL * Net back and forth to and from the client
  0 sorts (memory)
  0 sorts (disk)
  0 rows processed
  
  SQL >
  
  --------------------------------------------------
  Control session
  --------------------------------------------------
  SQL > /.
  
  FOLDER # BLOCK # CLASS # STATUS D T P S D N
  5 209 4 xcur N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 xcur O N N N N N
  5 211 14 free N N N N N N
  5 213 14 free N N N N N N
  5 214 14 free N N N N N N
  
  8 selected lines.
  
  SQL >
  
  
  --------------------------------------------------
  Session 2
  --------------------------------------------------
  SQL > select * from bc_test;
  
  no selected line
  
  
  Statistics
  ----------------------------------------------------------
  0 recursive calls
  0 db block Gets
  Gets 5 in accordance
  0 physical reads
  size of roll forward 108
  272 bytes sent via SQL * Net to client
  374 bytes received via SQL * Net from client
  1 SQL * Net back and forth to and from the client
  0 sorts (memory)
  0 sorts (disk)
  0 rows processed
  
  SQL >
  
  --------------------------------------------------
  Control session
  --------------------------------------------------
  SQL > /.
  
  FOLDER # BLOCK # CLASS # STATUS D T P S D N
  5 209 4 xcur N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 xcur O N N N N N
  5 211 14 free N N N N N N
  5 213 14 free N N N N N N
  
  8 selected lines.
  
  --------------------------------------------------
  Session 2
  --------------------------------------------------
  SQL > select * from bc_test;
  
  no selected line
  
  
  Statistics
  ----------------------------------------------------------
  0 recursive calls
  0 db block Gets
  Gets 5 in accordance
  0 physical reads
  size of roll forward 108
  272 bytes sent via SQL * Net to client
  374 bytes received via SQL * Net from client
  1 SQL * Net back and forth to and from the client
  0 sorts (memory)
  0 sorts (disk)
  0 rows processed
  
  --------------------------------------------------
  Control session
  --------------------------------------------------
  SQL > /.
  
  FOLDER # BLOCK # CLASS # STATUS D T P S D N
  5 209 4 xcur N N N N N N
  5 210 1 xcur O N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 211 14 free N N N N N N
  5 213 14 free N N N N N N
  
  9 selected lines.
  
  --------------------------------------------------
  Session 2
  --------------------------------------------------
  SQL > select * from bc_test;
  
  no selected line
  
  
  Statistics
  ----------------------------------------------------------
  0 recursive calls
  0 db block Gets
  Gets 5 in accordance
  0 physical reads
  size of roll forward 108
  272 bytes sent via SQL * Net to client
  374 bytes received via SQL * Net from client
  1 SQL * Net back and forth to and from the client
  0 sorts (memory)
  0 sorts (disk)
  0 rows processed
  
  SQL >
  
  --------------------------------------------------
  Control session
  --------------------------------------------------
  SQL > /.
  
  FOLDER # BLOCK # CLASS # STATUS D T P S D N
  5 209 4 xcur N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 xcur O N N N N N
  
  7 selected lines.
  
  --------------------------------------------------
  Session 2
  --------------------------------------------------
  SQL > /.
  
  no selected line
  
  
  Statistics
  ----------------------------------------------------------
  0 recursive calls
  0 db block Gets
  Gets 5 in accordance
  0 physical reads
  size of roll forward 108
  272 bytes sent via SQL * Net to client
  374 bytes received via SQL * Net from client
  1 SQL * Net back and forth to and from the client
  0 sorts (memory)
  0 sorts (disk)
  0 rows processed
  
  SQL >
  
  --------------------------------------------------
  Control session
  --------------------------------------------------
  SQL > /.
  
  FOLDER # BLOCK # CLASS # STATUS D T P S D N
  5 209 4 xcur N N N N N N
  5 210 1 xcur O N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  5 210 1 cr N N N N N N
  
  7 selected lines.

  What version of 10.2, on what platform, and enabled to RAC? What exactly was the tablespace definition?

  (I) why the insertion of a single line (in step 2) load 8 blocks in the buffer cache - and what does the CLASS # = 14 indicate?

  It sounds like you may have formatted all of the first measure - assuming that you use 8 KB blocks and allocated system extended. But it didn't happen when I checked 10.2.0.3 on a version of the single instance of the Oracle.

  Class 14 is interpreted as "unused" in all versions of Oracle that I saw. This would be consistent with the formatting, but it bringing is not below the high water mark. You could ' alter system dump datafile N block min X block max Y' for the segment header block, the block used and unused block in the discharge.

  (II) why the first select statement on the table (step 3) creates 2 copies of CR (use single) data block of the table (instead of one as I expect)?

  Maybe because the first copy clean uncommitted transactions and clones of the second copy of the result to return to a given SNA - but that's just a guess, I had not noticed this behavior before, so I have to do some experiments to find out why it's happening.

  (III)) why other issues create copies of CR of this block of data that is unique (instead of reusing the copy created by the first select statement CR)?

  The first block of CR you create includes a moment earlier that the beginning of the second query, so your session must start from the current. If you have set the isolation level to fix SNA session (for example, "set transaction read only") before the first application, in my view, you would see that the copies of CR will not increase after the initial creation.

  (IV) which limits the number of CR created copies to 5 (is there some parameter checking this value, what is according to some sizing of the cache or is simply badly coded)?

  Hidden parameter Dbblock_max_cr_dba which, by default, is 6. The code still does not seem to obey this limit, but generally you will see only 6 copies of a block in the buffer.

  (V) what exactly triggers the creation of a copy of CR of a buffer in the buffer cache?

  There are at least two options - (a) a session needs to see a copy of a block with recent changes removed, either because they are uncommitted transactions, the session needs to see the block he was when he started to run a particular query or transaction, (b) a session changed a block when he gets hold of the current version - and in certain circumstances (possibly when the update is through a analysis), it will make a copy of the block, mark the previous CR copy, mark the new copy as xcur, and change the copy.

  Incidentally, xcur is a RAC status - it is possible to have blocks in the buffer which are xcur, but not "obtained in current mode.

  Concerning
  Jonathan Lewis

• How to run a function in the oracle plsql object when the object dies

  I have an object plsql function member as exec_last.
  I want this procedure that is called when the plsql object is cleaned or when the accommodation session this object dies.
  
  In C, we have a system call as atexit(). Is there such a feature in Oracle 10 g or no workaround using embedded java.
  
  This feature is required to empty the contents stored in the plsql in the object to the database, when the program terminates.
  
  Thank you
  Best regards,
  Navin Srivastava

  navsriva wrote:

  Is there a better way to cache in memory.

  What is the Oracle buffer cache? It is exactly that - a cache for data blocks. The two new blocks (created by inserting new rows) and existing blocks (used by selects, updates and deletions and reused (freespace) inserts).

  The Oracle buffer cache is a cache of very mature and sophisticated. Trying to do "+ best +" to the db, buffer cache in another layer of software (such as PL/SQL) is mostly a waste of time and resources... and invariable introduced another layer of s/w which simply increases the number of moving parts. This in turn usually means increased complexity and slow performance.

  Why use the treatment in bulk from PL/SQL? The basic answer is to reduce switching between the PL and engine SQL context.

  During the execution of a code to insert data in SQL, the data must be passed to the SQL engine, PL PL engine must perform a context to the SQL engine switch so that it can process these data and execute the SQL statement.

  If there is a 1000 lines of inserts, this means that a 1000 context switches.

  In bulk treatment makes the "+ pipe communication / data + ' between the two biggest ones. Instead of passing data from one line to the SQL engine via a context switch, a collection of in bulk / picture of a 100 lines is passed. There are now only 10 changes of context necessary to push this 1000 lines of the PL engine to the SQL engine.

  You can do the same on any other client SQL... (remember, that the PL itself is also a SQL client). You can, using C/C++ for example, do exactly the same thing. When the row data to the SQL engine to insert, pass a collection of 100 rows instead of the data for a single line.

  The exact result of the same benefits as in PL/SQL. A pipe communication more, allowing more data to be transferred to and from the SQL, with engine for result less context switching.

  Of course, a context switch ito C/C++ is much more expensive than in PL/SQL - as the engine PL is located in the same physical process as the SQL engine. Using C/C++, this will usually be a separate process, to communicate with the SQL engine on the network process.

  The same applies to other languages, such as Java, c#, Delphi, Visual Basic, and so on.

  It not be wise to introduce another layer of s/w, the motor of PL/SQL and the customer "+ insert +" stored in his memory structures... and then use the PL engine to '+ flower' + for the SQL engine via a process control in bulk.

  It will be faster and more scalable, have the language of the client with treatment directly and dealing with the SQL engine directly in bulk.

  Simple example. What is SQL * Loader program (written in C), use? It uses no PL as a proxy to move data from a CSV file into a SQL table. He calls SQL directly. It uses a treatment in bulk. It is very fast to load data.

  There is an exception to this rule. What PL is used as a layer of processing and validation of business. Instead of the client code, implementation of this logic, it is done using LP. The customer then will not is more manually add an invoice to the table of the INVOICES for example. He called the procedure of PL/SQL AddNewInvoice instead - and this procedure does everything. It checks the valid client code. Ensures that there are stocks of the products ordered on the invoice. Etc.

  But in this scenario, PL is not used a flea market "buffer cache. It is used for what it was designed for - a correct application inside the database layer.

• Difference between 12 c in memory option and 11 g USER_TABLES KEEP

  Can someone enlighten me please in a brief comment on the difference between the new option in memory of Oracle 12 c and the existing functionality in Oracle 11 g, where you can store a table permanently in STORAGE buffers (USER_TABLES KEEP) cache as shown in the code example below?

  I searched on internet for an answer to this, but without success.

  CREATE TABLE t1)

  my_date DATE NOT NULL,

  My_Number NUMBER (12,10) NOT NULL,

  my_row NUMBER (12) NOT NULL)

  STORAGE (USER_TABLES) KEEP;

  Source: Oracle Buffer Pool Keep pool to recycle

  Presentation of Juan Loaiza is probably available on the Oracle now, but in broad terms: the component in the data memory (specified tables - perhaps with a restriction to a subset of columns) in the form of columns in a space dedicated to the SGA. Data are kept up-to-date in real time, but Oracle is not using undo or redo to keep this copy of the data because he never persisted on disk in this form, it has recreated in memory (by a background process) if the instance is restarted. The optimizer can then decide if it would be faster to use a columnar approach or on lines to process a request.

  The intention is to help systems that are mixed OLTP and DSS - which sometimes have many clues 'extra' to optimize the DSS queries that affect the performance of the OLTP updated. With the copy of column in memory you should be able to much "DSS that they ', which improves the OLTP response time - indeed things in memory is behavior a little as non-persistent bitmap indexing.

  Last updated 18 Oct:

  I was reminded that, in my view, that the presentation also included a few comments about how the tire code also left the "vector" (SIMD) instructions to the CPU level allow the code to evaluate predicates on several lines (extracted from the Bank of the column, not the location of the line) at the same time, and which contributes to the high rates of data scanning Oracle Corp. is claiming.

  Concerning

  Jonathan Lewis

• Charge direct insert internals

  Hello
  
  I usually publish discussions about the internals of oracle. Today, the subject is load direct inserts.
  
  This is the concept of network
  
  in direct load insert oracle by pass cache buffers and inserts in directly into the data file. By passing the oracle buffer cache avoid redo log generation and other top of the head. Oracle builds a memory block and inserts into the database above high tide.
  
  Here are the questions
  
  where the data block in memory of generations of oracle's server process PGA.
  Oracle is built several blocks of data
  increase the size of the PGA memory can has no effect on platelets of direct charge.
  If oracle by buffer pass than rollback segament cache is always generated. Which inserts its mechanism under direct load
  
  concerning
  Nick

  Have you seen this:
  http://download.Oracle.com/docs/CD/B28359_01/server.111/b28319/ldr_modes.htm#i1008815

  I think that most of the issues is addressed in this page.

  Kind regards
  Greg Rahn
  http://structureddata.org

• Create the Signature buffer in oracle apex 5.0

  Hello, I'm trying to create the signature buffer in oracle apex 5.0, did see some plugins for that as: https://www.enkitec.com/products/plugins/signaturepad/help can I implement the same functionality without using this plugin. What I see: 1) http://keith-wood.name/signature.html 2) https://github.com/brinley/jSignature ) 3 https://github.com/thomasjbradley/signature-pad/blob/gh-pages/documentation.md Point is to make this cushion where I sign! and also save as image in database. Don't know if I'm clear enough with my question or not. Thank you.

  Hi Pranav.shah,

  Pranav.Shah wrote:

  Hello, I'm trying to create the signature buffer in oracle apex 5.0, did see some plugins for that love: https://www.enkitec.com/products/plugins/signaturepad/help can I implement the same functionality without using this plugin. What I see: 1) http://keith-wood.name/signature.html 2) https://github.com/brinley/jSignature 3) https://github.com/thomasjbradley/signature-pad/blob/gh-pages/documentation.md Point is to make this cushion where I sign! and also save as image in database. Don't know if I'm clear enough with my question or not. Thank you.

  Use the pad of Signature plugin Enkitec. Why don't you use this plugin, but only its features.

  Also, the plug-in can save the signature to be registered as JSON CLOB or BLOB image in the database.

  Reference:

  • https://www.enkitec.com/Apex/f?p=15000:1047:3046757651351:P1045_PLUGIN_ID, P1047_PLUGIN_ID:101, 101
  • -Plugin - Enkitec SignaturePad point

  Kind regards

  Kiran

• The Oracle trace: number of physical reads of the signifier of disk buffer

  Hi all

  
  Since yesterday, I was under the impression that, in a trace file Oracle, the "number of physical buffer of disk reads" should be reflected in the wait events section.

  Yesterday we add this trace file (Oracle 11 g 2):

  call the query of disc elapsed to cpu count current lines

  ------- ------  -------- ---------- ---------- ---------- ----------  ----------

  Parse        1      0.00       0.00          0          0          0           0

  Run 1 0.04 0.02 0 87 0 0

  Get 9 1.96 7.81 65957 174756 0 873

  ------- ------  -------- ---------- ---------- ---------- ----------  ----------

  total 11 2.01 7.84 65957 174843 0 873

  Elapsed time are waiting on the following events:

  Event waited on times max wait for the Total WHEREAS

  ----------------------------------------   Waited  ----------  ------------

  SQL * Net message to client 9 0.00 0.00

  reliable message 1 0.00 0.00

  ENQ: KO - checkpoint fast object 1 0.00 0.00

  direct path read 5074 0.05 5,88

  SQL * Net more data to the customer 5 0.00 0.00

  SQL * Net client message 9 0.01 0.00

  ********************************************************************************

  We can see that the 65957 physical disk reads resulted only 5074 direct path read. Normally, the number of physical reads from disk is more directly reflected in the wait events section.

  Is this normal? Why is that? Maybe because these discs are on a San have a cache?

  Best regards.

  Carl

  direct path read is an operation of e/s diluvium, is not just to read 1 block

• Oracle 11g R2 buffer Cache

  Hello

  We have a production Oracle 11 g r2 standard database with the following general settings:

  Shared pool: 608 MB

  Buffer cache: 608 MB

  ...

  SGA 1417 MB total

  We have noticed that over time, shared pool takes memory from the buffer cache, even if automatic shared memory management is disabled.

  The only way we can redistribute the memory is returned to the original settings by restarting the database service. We tried to redistribution of memory by using the following commands unsuccessfully.

  alter system set shared_pool_size = 608M;

  change the value system DB_cache_size = 608M.

  The application provider insists that automatic memory management should not be enabled.

  Could someone provide guidance as to 1. Why the buffer cache loses the memory of the shared pool 2. How can we redistribute the memory without having to restart the database service.

  Thank you

  Heck

  Hemant asked that means "standard"?

  In the meantime, you can pass by http://www.ora600.be/_memory_imm_mode_without_autosga+-+no+really+! + n % 27T + resizing + my + CMS +! + I + medium + TI +!

  HTH

  Anand

• too small Oracle of the buffer character ora-19011 chain

  Hello.

  I have the following XML:

  rowset <>

  < row >

  < code > < code > 01

  < details > 123 < / details >

  < / row >

  < row >

  < code > < code > 03

  < details > 1233 < / details >

  < / row >

  < row >

  < code > < code > 07

  < details > 12333 < / details >

  < / row >

  < / lines >

  I have Norman to extract the data of 1 in the sql query in this format:

  CodesList

  --------------

  01,02,03

  I use following code e:

  Select RTRIM (XMLAGG (XMLELEMENT(E,t.process_xml ||) ',')). Extract (' Row/Rowset/Code / Text () '). GETStringVAL(), ',') from table1 t

  The XML is being clob "process_xml."

  But I got the error message: too small oracle of the buffer character ora-19011 chain

  Help, please.

  The result is:

  ORA-19280: XQuery dynamic type mismatch: expected has atomic value - get the node

  My bad, I didn't test it.

  It works on 10.2.0.5 (the closest version I have at my disposal):

  Select t.id

  dbms_xmlgen.convert (x.column_value.getstringval (), 1) as val

  Table 1 t

  xmltable ("string-join(/Rowset/Row/Code,",")"

  by the way of xmltype (t.myxml)

  ) x ;

  or equivalent:

  Select t.id

  dbms_xmlgen.convert)

  XMLQUERY ('string-join(/Rowset/Row/Code, ",")"

  by the way of xmltype (t.myxml)

  contents of return

  ). getStringVal()

  1

  ) as val

  Table 1 t;

  DBMS_XMLGEN. Call CONVERT is here to ensure that the entity is referred to in elements (if any) will be unescaped back to their readable forms.

  If you know for sure that there's no entity occurrence, you can remove that extra step.

• Oracle DML/Select how exactly? What process / buffer use?

  Dear,
  
  Really, I read several post on the internet, but not not clear and dose everything so I have a few Q:
  
  1. for DML: after writing the data directly in database dose files? What are the criteria and what process?
  2. If the server process to extract the block necessary and necessary updated, so when DBWR extract data from datafile?
  3 - the analysis of the information recorded on the dose library cache? the use of cache Dictionary DML, and SELECTION of dose?
  4-if I update data huge at the same time for example: 1 sheet of Melon, where it save on the journal or database buffer buffer? and if not enough dose it back up into a temporary table? or what the procedure for this?
  
  5 and this very confusion:! the dose commit happen after control point?
  
  explain to be below please... I do a lot of insertion and then validate and check the query below for a long time
  
  Select checkpoint_change # v$ database - 14026091 - control file
  Select double; - 14027831 dbms_flashback.get_system_change_number (just this change, but does not change in the control file and data file)
  SELECT name, checkpoint_change # from v$ datafile;--14026091
  Select name, checkpoint_change # from v$ datafile_header; -14026091
  
  While you see above point control of the dose will not change and reflected on order, data file... are there different types of control point in oracle! and when everyone arrives and why?
  
  6. what DBWR works exactly? What criteria?
  7 - how LGWR work exactly? What criteria?
  8. when validate you the data, and then select before the checkpoint or whatever it is, you just read the data? database buffer? or the log buffer? or online redo log file?
  
  Best regards
  Awad Awad

  Yes, the documentation, I've referenced discusses how Oracle treats DML. There is a section that explains how Oracle analyzes DML and implements the query plan. Then there's the chapter on how Oracle keeps track of the changed data, and there is a chapter on how work background processes.

  writers of the database uses lazy writes to write data to the disk. If the system crashes after the validation has been issued but before dbwr had time to writing computer change Oracle will always contain the changes after the restart as crash recovery will be rapply changes to the database data files. The basic mechanisms used are discussed in a form sufficiently detailed in the manaul of Concepts.

  There is no better place to start to read the manual of Concepts from start to finish if you are an Oracle DBA. However, a developer can probably start with the Application Developers Guide - Fundamentals.

  IMHO - Mark D Powell-

• buffer busy elapse cnanging lob storage for oracle SECUREFICHIERS

  Hello world
  
  I need help to solve a problem with buffer busy waits in a lob using SECUREFICHIERS for storage segment.
  
  While loading the application inserts a record into a table with the lob segment and update the record after the filling of the lob data. The size of the block on the table space holding the lob is 8 KB and the segment on the lob segment size is limited to 8 KB. The average size of the recording of the lob is 6 KB and the minimum size is 4.03 KB. The problem only occurs when the execution of a work with a large number of relatively small inserts (4.03 Kb) in the lob column. The definition of the table allow online storage and the ptcfree set to 10%. The same jobs runs smoothly when you use storage basicfiles for the lob column.
  
  According to [oracle whitepaper | http://www.oracle.com/technetwork/database/options/compression/overview/securefiles-131281.pdf] SECUREFICHIERS have a number of performance improvements. I was particularly interested test gather Write Cache our app do a lot of relatively small inserts in a lob segment.
  
  Here is a fragment of the AWR report. It looks like all busy expectations buffer belong to a class of free list. The lob segment is located in a tablespace SAMS and I can't raise to freelists.
  
  
  

  Connected to:
  Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - 64bit Production
  With the Partitioning option
  Host Name        Platform                         CPUs Cores Sockets Memory(GB)
  ---------------- -------------------------------- ---- ----- ------- ----------
  DB5              Microsoft Windows x86 64-bit        8     2              31.99
  
                Snap Id      Snap Time      Sessions Curs/Sess
              --------- ------------------- -------- ---------
  Begin Snap:      1259 01-Apr-11 14:40:45       135       5.5
    End Snap:      1260 01-Apr-11 15:08:59       155      12.0
     Elapsed:               28.25 (mins)
     DB Time:              281.55 (mins)
  
  Cache Sizes                       Begin        End
  ~~~~~~~~~~~                  ---------- ----------
                 Buffer Cache:     2,496M     2,832M  Std Block Size:         8K
             Shared Pool Size:     1,488M     1,488M      Log Buffer:    11,888K
  
  Load Profile              Per Second    Per Transaction   Per Exec   Per Call
  ~~~~~~~~~~~~         ---------------    --------------- ---------- ----------
        DB Time(s):               10.0                0.1       0.01       0.00
         DB CPU(s):                2.8                0.0       0.00       0.00
         Redo size:        1,429,862.3            9,390.5
     Logical reads:          472,459.0            3,102.8
     Block changes:            9,849.7               64.7
    Physical reads:               61.1                0.4
   Physical writes:               98.6                0.7
        User calls:            2,718.8               17.9
            Parses:              669.8                4.4
       Hard parses:                2.2                0.0
  W/A MB processed:                1.1                0.0
            Logons:                0.1                0.0
          Executes:            1,461.0                9.6
         Rollbacks:                0.0                0.0
      Transactions:              152.3
  
  Top 5 Timed Foreground Events
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                                             Avg
                                                            wait   % DB
  Event                                 Waits     Time(s)   (ms)   time Wait Class
  ------------------------------ ------------ ----------- ------ ------ ----------
  buffer busy waits                 1,002,549       8,951      9   53.0 Concurrenc
  DB CPU                                            4,724          28.0
  latch: cache buffers chains      11,927,297       1,396      0    8.3 Concurrenc
  direct path read                    121,767         863      7    5.1 User I/O
  enq: DW - contention                209,278         627      3    3.7 Other
  ?Host CPU (CPUs:    8 Cores:    2 Sockets: )
  ~~~~~~~~         Load Average
                 Begin       End     %User   %System      %WIO     %Idle
             --------- --------- --------- --------- --------- ---------
         38.7       3.5       57.9
  
  Instance CPU
  ~~~~~~~~~~~~
                % of total CPU for Instance:      40.1
                % of busy  CPU for Instance:      95.2
    %DB time waiting for CPU - Resource Mgr:       0.0
  
  Memory Statistics
  ~~~~~~~~~~~~~~~~~                       Begin          End
                    Host Mem (MB):     32,762.6     32,762.6
                     SGA use (MB):      4,656.0      4,992.0
                     PGA use (MB):        318.4        413.5
      % Host Mem used for SGA+PGA:        15.18        16.50
  
  .....................
                                                               Avg
                                          %Time Total Wait    wait    Waits   % DB
  Event                             Waits -outs   Time (s)    (ms)     /txn   time
  -------------------------- ------------ ----- ---------- ------- -------- ------
  buffer busy waits             1,002,549     0      8,951       9      3.9   53.0
  latch: cache buffers chain   11,927,297     0      1,396       0     46.2    8.3
  direct path read                121,767     0        863       7      0.5    5.1
  enq: DW - contention            209,278     0        627       3      0.8    3.7
  log file sync                   288,785     0        118       0      1.1     .7
  SQL*Net more data from cli    1,176,770     0        103       0      4.6     .6
  
  
  Buffer Wait Statistics                DB/Inst: ORA11G/ora11g  Snaps: 1259-1260
  -> ordered by wait time desc, waits desc
  
  Class                    Waits Total Wait Time (s)  Avg Time (ms)
  ------------------ ----------- ------------------- --------------
  free list              818,606               8,780             11
  undo header            512,358                 141              0
  2nd level bmb          105,816                  29              0
  .....
  
  -> Total Logical Reads:     800,688,490
  -> Captured Segments account for   19.8% of Total
  
             Tablespace                      Subobject  Obj.       Logical
  Owner         Name    Object Name            Name     Type         Reads  %Total
  ---------- ---------- -------------------- ---------- ----- ------------ -------
  EAG50NSJ   EAG50NSJ   SYS_LOB0000082335C00            LOB    127,182,208   15.88
  SYS        SYSTEM     TS$                             TABLE    7,641,808     .95
  ..
         -------------------------------------------------------------
  
  Segments by Physical Reads            DB/Inst: ORA11G/ora11g  Snaps: 1259-1260
  -> Total Physical Reads:         103,481
  -> Captured Segments account for  224.4% of Total
  
             Tablespace                      Subobject  Obj.      Physical
  Owner         Name    Object Name            Name     Type         Reads  %Total
  ---------- ---------- -------------------- ---------- ----- ------------ -------
  EAG50NSJ   EAG50NSJ   SYS_LOB0000082335C00            LOB        218,858  211.50
  ....

  Best regards
  Yuri Kogun

  A couple of quick notes to anyone who is interested.
  I was sent a few AWR reports and doing some tests on 11.2.0.2.
  Interesting things are:

  (a) SECUREFICHIERS have a free type of block called 'Clerks space', which is essentially space available of LOBs deleted; they are stored in v$ waitstat in the category 'free lists.

  (b) code OP inserts a null value / empty_lob(), it inserts the BLOB and then updates the BLOB - this is why the code generates a lot of BLOBs empty and eventually fill constantly, sweeping and empty blocks of the "free list".

  Possible solutions-
  (1) use the core files because they use very different mechanisms
  (2) do not insert and update the BLOB

  In a way the problem exists because type LOB data aren't really OLTP objects, but the application manages LOB in a kind of type OLTP.

• Can make the size of the log buffer be changed or is managed internally by oracle

  Can again change the log buffer size? or is managed internally by oracle in the SGA? We are on oracle 10.2.0.3.
  
  The reason why I asked the question was that our construction team do estimates for data/memory sizing properly... so we wanted to know if it can be changed or not?

  Hi S2k!

  The SGA Memorystructure is handled automatically by Oracle, if the SGA_TARGET initializationparameter is set. But nothing less you are able to configure the size of a memorystructure by yourself. Here is a good article on the optimization of the log buffer.

  [http://www.dba-oracle.com/t_log_buffer_optimal_size.htm]

  I hope this will help you along.

  Yours sincerely

  Florian W.

• [Space oracle] - selects all customers in a buffer of demi-mille of co

  Hi, people,.
  I'm having a problem with SQL statemnt to select all customers in a buffer of demi-mille of the competitor. In fact, I don't know how to build the SQL statement.
  
  If anyone can help, thanks in advance.

  There are several ways to achieve this. You can use SDO_NN, but in this case I'd stick probably just using a buffer.

  Assuming that you have two tables named CUSTOMER and COMPETITOR each with a GEOMETRY of type SDO_GEOMETRY that contains a representation of the column feature point...

  SELECT /*+ ORDERED */ cust.*
  FROM competitor comp, customer cust
  WHERE sdo_anyinteract(cust.geometry, sdo_geom.sdo_buffer(comp.geometry, , )) = 'TRUE'
  AND comp.id = 
  

  If you want to extend this to return customers by order of distance from the competitor, then you might be better off using SDO_NN & SDO_NN_DISTANCE. There are many examples in the documentation. Also other examples by searching this forum for those keywords.