Oracle DB - tablespace (de)fragmentation tutorial

This article describes how the objects are "physically" stored in Oracle DB. In tutorial is used on VM with preinstalled Oracle DB 12c.

Introduction - datafile structure

Every tablespace is one or group of multiple datafiles. Datafile has 3 levels of configuration

• File sizing - file size on hard disk, increasing size and max size.
• Extent management - size of extents etc. (automatic / uniform size)
• Segment management - automatic (common) / manual (PCT_USED, FREELISTS, GROUPS ... settings is necessary)

Every extent contains blocks (usual 4KiB or 8KiB) which contain rows.

Datafile structure

Tutorial

For this tutorial, connect to db as system (sys as sysdba).

Step 1 - create tablespace with one datafile

Parameters

• Initial size 30MiB, next 20MiB if needed, maximum of size is 100MB
• Extent has uniform size 4MiB - it is good for tutorial. Usually use automatic extent management.
• ASSM - automatic segment space management

define ts = TBS_TEST_DATA

--

-- Create tablespace

--

CREATE TABLESPACE "&ts."

DATAFILE '/home/oracle/test_file01.dbf' SIZE 30M AUTOEXTEND ON NEXT 20M MAXSIZE 100M

EXTENT MANAGEMENT LOCAL UNIFORM SIZE 4M

SEGMENT SPACE MANAGEMENT AUTO; --  MANUAL (PCTUSED, FREELISTS, and FREELISTS GROUPS), do not use it

Step 2 - create view TABLESPACE_MAP_VIEW

This view will be used repeately - show you content of tablespace (i.e. datafile):

create view TABLESPACE_MAP_VIEW as

SELECT   'free space' owner, '      ' OBJECT, dfs.file_id, dfs.block_id, dfs.blocks, dfs.blocks*8192/1024/1024 size_In_MB, ddf.FILE_NAME

    FROM dba_free_space dfs, DBA_DATA_FILES ddf

   WHERE dfs.tablespace_name = UPPER ('&ts.') and ddf.file_id = dfs.file_id

UNION

SELECT   SUBSTR (dext.owner, 1, 20), SUBSTR (dext.segment_name, 1, 32), dext.file_id, dext.block_id, dext.blocks, dext.blocks*8192/1024/1024 size_In_MB, ddf.FILE_NAME

    FROM dba_extents dext, DBA_DATA_FILES ddf

   WHERE dext.tablespace_name = UPPER ('&ts.') and dext.file_id = ddf.file_id

ORDER BY 3, 4;

Step 3 - create table TEST_TABLE and check the datafile

First, check tablespace map: select * from TABLESPACE_MAP_VIEW;
Result: 28MB of freespace (3584 blocks):

Now, create table with only one row but allocate initial 16MiB space:

--
-- create tmp table
--
create table TEST_TABLE tablespace TBS_TEST_DATA
storage (initial 16M NEXT 10M
        PCTINCREASE 0
        MINEXTENTS 1
        MAXEXTENTS UNLIMITED)
as
  select rownum id, ao.* from ALL_OBJECTS ao where rownum<2 ; -- 0MB dat


Check the map: select * from TABLESPACE_MAP_VIEW;

You see, there will be allocated 16MB for test table (4 extents with uniform size 4MB). But table is almost empty! Contains only one row!

Step 4 - Insert some data

First, insert cca 13MB: 

--

-- insert 13mb

--

insert into TEST_TABLE

select rownum id, ao.* from ALL_OBJECTS ao; -- 13MB dat

commit;

Check it - nothing changed because of enough space was allocated before:

 And now, insert next 7MB:

--

-- insert 7mb

--

insert into TEST_TABLE

select rownum id, ao.* from ALL_OBJECTS ao where rownum<40000 ; -- 7MB dat

commit;

Check it - rest of freespace was used and next 4MB was allocated (why only 4MB and not 10MB? - db probably rounds sizes)

Step 5 - add second table (GREAT_TABLE)

Add some another table:

--

-- great

--

create table GREAT_TABLE

tablespace TBS_TEST_DATA

storage (initial 4M NEXT 4K

          PCTINCREASE 0

          MINEXTENTS 1

          MAXEXTENTS UNLIMITED)

as

select rownum id, ao.* from ALL_OBJECTS ao; -- cca 14MB data




Check the tablespace map:

• Datafile was extended to 48MiB (add  cca 20MiB)
• new table needs 16MiB space

Step 6 - Create "tablespace level" fragmentation for TEST_TABLE

Insert next 7 MB into table, delete second table:

--

-- insert 7mb

--

insert into TEST_TABLE

select rownum id, ao.* from ALL_OBJECTS ao where rownum<40000 ; -- 7MB dat

commit;

-- make a hole

drop table GREAT_TABLE;

See the map:

Again insert:

insert into TEST_TABLE

select rownum id, ao.* from ALL_OBJECTS ao where rownum<40000 ; -- 7MB dat

commit;

The hole will not be filled because of "segment level fragmentation"!!!. Instead new extend will be allocated:

After delete some space...
 

-- delete "random", no space will be free

delete from TEST_TABLE where id < 60000;

commit;

...no space will be free: 







Step 7 - Defragmentation of TEST_TABLE ("tablespace level" and also "segment level" fragmentation)

Check the table block usage:

set serveroutput on;

-- fragmentation in blocks

declare

   v_unformatted_blocks number;

   v_unformatted_bytes  number;

   v_fs1_blocks         number;

   v_fs1_bytes          number;

   v_fs2_blocks         number;

   v_fs2_bytes          number;

   v_fs3_blocks         number;

   v_fs3_bytes          number;

   v_fs4_blocks         number;

   v_fs4_bytes          number;

   v_full_blocks        number;

   v_full_bytes         number;

 begin

   dbms_space.space_usage('SYS',

                          'TEST_TABLE',

                          'table',

                          v_unformatted_blocks,

                          v_unformatted_bytes,

                          v_fs1_blocks,

                          v_fs1_bytes,

                          v_fs2_blocks,

                          v_fs2_bytes,

                          v_fs3_blocks,

                          v_fs3_bytes,

                          v_fs4_blocks,

                          v_fs4_bytes,

                          v_full_blocks,

                          v_full_bytes);

   

   dbms_output.put_line('Unformatted Blocks = ' || v_unformatted_blocks);

   dbms_output.put_line('Unformatted Bytes = ' || v_unformatted_bytes);

   dbms_output.put_line('FS1 Bytes (at least 0 to 25% free space) = ' || v_fs1_bytes);

   dbms_output.put_line('FS1 Blocks(at least 0 to 25% free space) = ' || v_fs1_blocks);

   dbms_output.put_line('FS2 Bytes (at least 25 to 50% free space)= ' || v_fs2_bytes);

   dbms_output.put_line('FS2 Blocks(at least 25 to 50% free space)= ' || v_fs2_blocks);

   dbms_output.put_line('FS3 Bytes (at least 50 to 75% free space) = ' || v_fs3_bytes);

   dbms_output.put_line('FS3 Blocks(at least 50 to 75% free space) = ' || v_fs3_blocks);

   dbms_output.put_line('FS4 Bytes (at least 75 to 100% free space) = ' || v_fs4_bytes);

   dbms_output.put_line('FS4 Blocks(at least 75 to 100% free space)= ' || v_fs4_blocks);

   dbms_output.put_line('Full Blocks in segment = ' || v_full_blocks);

   dbms_output.put_line('Full Bytes in segment  = ' || v_full_bytes);

 end;

Many blocks are fragmented:

• Low HWM and HWM is at the end => by adding new data will not be used free space and will be allocated a new extent (see Segment Space and the High Water Mark on page https://docs.oracle.com/cd/E11882_01/server.112/e40540/logical.htm)
• Wasting space - many blocks are filled 0-75%, only few are full.

Shrinking table makes some data free:

--

-- "release free space" - shrink

--

alter table TEST_TABLE enable row movement;

alter table TEST_TABLE shrink space;

Alter table TEST_TABLE shrink space cascade;

alter table TEST_TABLE disable row movement;

 -- deallocate unused extents

ALTER TABLE TEST_TABLE DEALLOCATE UNUSED;

Table is almost defragmented (one block is 50% to 75%)

See the map:

 

Defragmentation by move storage. Init 16MiB for new extents:

-- "free space" - move to new extents

--

alter table TEST_TABLE move

storage (initial 16M NEXT 10M

          PCTINCREASE 0

          MINEXTENTS 1

          MAXEXTENTS UNLIMITED);

Result of block usages:

 Move storage contains init size (in this case 16MB), therefore 4 extents are allocated. And also first 8MB are free because there was the table stored before move:

"Move storage" benefits:

• choose some parameters similar to table creation (init size etc...)
• better "block level" defragmentation
• should be fast 

"shrink" benefits:

• less capacity (does not create new extends)
• in some cases better "extent level" defragmentation

Step 8 - cleanup

--

-- DROP

--

drop table TEST_TABLE;

drop table GREAT_TABLE;

DROP TABLESPACE "&ts." INCLUDING CONTENTS AND DATAFILES;

Spring and OSGi

OSGi

We are using OSGi framework for ensuring dynamic modularity in our solution. OSGi is great tool for this purposes. Adding and replacing bundles (let's say plugins or jars) into running system works well. Also dependecy resolving for keep all stuff in consistent state makes us happy.

Simple OSGi runtime schema

OSGi is focused on "low-level" modularity (jars, classloaders, class dependecies and their versions, import/export classes, services...). For "high-level" modularity or, better to say "business-level" features like the Inversion of Control, you need add support from outside.

Spring 

Spring is great IoC container (and even more) for creating apps. It is well known, popular and extensible. Huge community ensures support, project is very active and still inovative. Therefore would like to add Spring as IoC to our OSGi based system.

Simple Spring IoC container runtime schema

IoC and OSGi

Spring developers tried to break through OSGi world with "Spring Dynamic Modules". Unfortunately this project is almost dead. As a replacement is recommended to use an OSGi extension called "Blueprint", which is specification of IoC for OSGi framework. There are two usable implementations:

• Eclipse Gemini Blueprint
• Apache Aries Bluperint

... but, they are not Spring:(

Only one think which was done (by Apache ServiceMix community) is Spring framework wrapped as bundles. It was a starting point for our integration.

Our simple solution for Spring-OSGi

Our solution works very simple way which is sufficient for almost usecases:

• Every OSGi-bundle has it's own isolated application context
• Application context is defined by java configuration only.
• Public and listen to service with cardinality 1..1.
• No service filtering.

Our solution Spring-OSGi

Annotations

We need to define annotations which define spring beans as public services and also external beans which are imported via services into context (from outside).

Annotation for public spring beans into OSGi world as a OSGi service:

  @Retention(RetentionPolicy.RUNTIME)
  public @interface ExposeAsService  {}

Annotation for obtain OSGi service into spring world:

  @Retention(RetentionPolicy.RUNTIME)
  public @interface ObtainAsService {}

Example of application context configuration via java class:

@Configuration 
public abstract class DatabaseServicesContextConfiguration {
  @Bean
  @ExposeAsService
  protected ISystemService systemService() {
    return new SystemService();
  }
  
  @Bean
  @ObtainAsService
  public abstract IAppPropertiesService appProperties();
}

New post-processor and application-context

We need "somehow" handle new declared annotations. Therefore bean-factory-post-processor and application context will be created.

OsgiServiceObtainerBeanFactoryPostProcessor
This bean-factory-post-processor uses simple "trick": find all bean-definitions in context annotated by @ObtainAsService. Those definitions are removed and replaced by singleton instance of class which was lookuped from OSGi as service.

public class OsgiServiceObtainerBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
     private final BundleContext bundleContext;

     public OsgiServiceObtainerBeanFactoryPostProcessor(BundleContext bundleContext) {
         this.bundleContext = bundleContext;
      }
         /** 
          * Find beanDefinitios with annotation ObtainAsService, 
          * lookup this service and register this service as

     * singletons into spring context. 
     */ 
      @Override    
      public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        
        DefaultListableBeanFactory beanFactoryEx = ((DefaultListableBeanFactory)beanFactory);

        // all beanDefinitions 
        String[] beanDefinitionNames = beanFactoryEx.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
           BeanDefinition beanDefinition = beanFactoryEx.getBeanDefinition(beanDefinitionName);
           if (beanDefinition.getSource() instanceof StandardMethodMetadata) {
              StandardMethodMetadata metadata = (StandardMethodMetadata)(beanDefinition.getSource()); 
              if (metadata.isAnnotated(ObtainAsService.class.getCanonicalName())) {            
               
               // 1. remove abstract definition 
               beanFactoryEx.removeBeanDefinition(beanDefinitionName); 
               
               // 2. get service from osgi
               String serviceClassName = metadata.getIntrospectedMethod().getReturnType().getCanonicalName();
               serviceInstance = getServiceTracker(serviceClassName).waitForService(0);
               ...   
               
               // 3. register service as singleton
               ...                
               beanFactoryEx.registerSingleton(metadata.getMethodName(), serviceInstance);
               ...
             }
         }
      }
   }
   ...
}

OsgiApplicationContext
This context is used in bundle activator and adds support for OSGi via "BundleContext" instance which is obrained in constructor. In constructor is also added "osgi bean-postprocessor" for service obtaining. Method "exposeService" ensures publicing annotated services into OSGi.

public class OsgiApplicationContext extends AnnotationConfigApplicationContext {

  private BundleContext bundleContext;

  // all exposed services.
  private List<ServiceRegistration> serviceRegistrations = new ArrayList<ServiceRegistration>();

  public OsgiApplicationContext(BundleContext bundleContext) {
    if (bundleContext!=null) {
      this.addBeanFactoryPostProcessor(new OsgiServiceObtainerBeanFactoryPostProcessor(bundleContext));
      this.bundleContext = bundleContext;
    } 
  }
  
  /**
   * Expose beans annotated as "ExposeAsService" to OSGi as services 
   */
  public void exposeServices() {
   // get beanDefinition of current bean
   for (String name : this.getBeanDefinitionNames()) {
      BeanDefinition beanDefinition = this.getBeanDefinition(name);
      if (beanDefinition.getSource() instanceof StandardMethodMetadata) {
         StandardMethodMetadata metadata = (StandardMethodMetadata)(beanDefinition.getSource()); 
         if (metadata.isAnnotated(ExposeAsService.class.getCanonicalName())) {
            String className = metadata.getIntrospectedMethod().getReturnType().getCanonicalName();
            // expose as service
            Object bean = this.getBean(name);
            LOGGER.info("Exposing bean "+name+" "+bean.toString() + " as a service "+className);
            ServiceRegistration serviceRegistration = this.bundleContext.registerService(className, bean, null);
            this.serviceRegistrations.add(serviceRegistration);
         }
      }
    }
  }
  @Override
  public void close() {
   for (ServiceRegistration registration : this.serviceRegistrations) {
      registration.unregister();
   }
   super.close();
  } 
} 

Bundle activator example

Usage of these classes is quite simple:

public class DatabaseServiceActivator implements BundleActivator {
  @Override
  public void start(final BundleContext bundleContext) throws Exception {

    springContext = new OsgiApplicationContext(bundleContext);
    springContext.setClassLoader(this.getClass().getClassLoader());

    springContext.register(DatabaseServicesContextConfiguration.class); 
    springContext.refresh();  

    springContext.exposeServices();
  } 

}

When bundle is activated, spring context will be created and obtains some beans as services from outside. After context activation (refresh call), some beans will be exposed as services. Important is to set classloader, because spring runs under it's own classloader and he cannot see your bean classes.

Future

Great news are comming from Apache Aries community! Blueprint will be implemented as "bridge" for Spring IoC. First release 0.1.0 is on download page at Apache Aries web.

When it will be more stable, we can replace our simple solution with more featured implementation.

http://aries.apache.org/modules/blueprint.html

Automobilový zázrak Magnufuel aneb podvod okem vývojáře

Jak ušetřit za palivo?

Přesně takto nazvaný sponzorovaný příspěvek na mě vykouknul na facebooku. Příspěvek byl navíc okořeněný slůvky jako "true story", "fuel-economy" a dovětkem "pokud utrácíte spousty peněz za palivo, přečtětě si tohle". V očekávání, že se dozvím něco o uspornějším způsobu řízení apod. jsem příspěvek rozkliknul.

Zde je pro zájemnce odkaz:
http://www.fuel-economy.info/CZ_Fuel-saving-blog_B8/index.php
 

Autentický blog šťastného řidiče

Odkaz me přesměroval na stránku vypadající jako blog, ve kterém se jeden taxikář chlubí, jak mu zázračné zařízení zvané "Magnufuel" ušetřilo přemnoho peněz. Článek se snaží působit věrohodně, v textu se důmyslně objevují odkazy na distributora tohoto zázraku. Na konci, jak už to bývá, je mnoho kladných odpovědí dalších řidičů.

Všimněte si použitých vět:

• "...Prodává se v mnoha obchodech, ale nejlevnější je na český distributor..."
• "A nakonec to nejdůležitější, tedy stránka kde si můžete koupit Magnufuel. Odkaz na stránku. Doporučuju, nebudete toho litovat. "

kde podtržená slova jsou odkazy. Ukázka z komentářů k blogu:

Při kliknutí na odkaz v článku se dostanete na stránky distributora http://www.magnufuel.com/CZ_official_T8/.

Stránky distributora

Stránky jsou interaktivní a celkem líbivé. Autor není na poli webdesignu úpný amatér. Stránka je přehledná, máme zde pěkné animace, které ukazují funkci nabízeného produktu, jsou zde dobře formulované texty, které příjemným způsobem popisují, jak vše pracuje. Tvurce použil několik technických výrazů, jako "uhlovodíkové molekuly" či "frekvence magnetické rezonance", aby čtenáři navodil dojem, že tomu hluboce rozumí. V zápětí však vše zabaluje do jednoduchých konstrukce "sraženiny", aby se dostal na úroveň laika - potenciálního zákazníka .

Celá stránka je lemována certifikacemi, čisly patentů, různých asociací a nadnárodních organizací jako General Motors. Stačí jen objednat a výsledek je zaručen:)

Necháme stranou odbornost textů a to, zda je či nění funkce výrobku fyzikálně možná, mrkněme rovnou na web jako takový z technického pohledu.

Podvodné signály

První zvláštnost, které si všimně i jen trochu zkušený uživatel, je, že počítadlo, které odpočítává 15 minut, ve kterých si máte možnost koupit si výrobek za sníženou cenu, se při každým refresh stránky restartuje. Model slev založený tímto způsobem je ekonomický nesmysl. O podikatelské levárně není pochyb.

Pár vteřin po návštěvě stránky se s pevnou pravidelností v pravém dolním rohu objevuje notifikační čtvereček s různými texty:

• V této chvíli si tuto stránku prohlíží 172 návštěvníků.
• Zbývá už jen 5 balíčků za akční cenu!
• Právě byla zadána objednávka z města Opava.

Především poslední text ve mě vyvolá zvědavost a otevírám zdrojový kód stránky.

Zdrojový kód

Html kód stránky vypadá úhledně, je zarovnaný a přehledný. Autoři webu respektují SEO apod.

Neplýtvám čas podrobnějším zkoumáním, rovnou otevírám javascriptový
popup.js.php soubor. Zde nacházím vysvětlení pro otázku, odkud se beru texty v popup okně.

Ve prostřed souboru je pak vidět užití tohoto pole.

Vše se děje pomocí random čísel:) Nezapomeňte si všimnout zajímavých programátorských technik. Velice mne pobavil fragment, ve kterém se nahrazuje číslo 15 číslem náhodným.

  var text = "Zbývá už jen 15 balíčků za akční cenu!";
  var count = genRandNum(4, 8);
  catchText3 = count;
  document.getElementById("popWindow").innerHTML = text.replace("15", "<b>"+count+"</b>");

Zde mé zkoumání skončilo. Zvědavci mohou jít dále a objevit další špeky.

Podvod jak vyšitý

Věřím, že člověk s průměrnou inteligencí bez znalostí programování je schopen podvod odhalit minimálně tím, že si produkt zkusí jednoduše vygooglit, a najít tak skutečné názory jiných.

Podvedeným přeji minimum finančních ztrát a maximum poučení a vývojářům veselé pobavení.