úterý 2. února 2016

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


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

Step 1 - create tablespace with one datafile

  • 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
DATAFILE '/home/oracle/test_file01.dbf' SIZE 30M AUTOEXTEND ON NEXT 20M MAXSIZE 100M

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
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
        MINEXTENTS 1
  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

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

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
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
-- 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
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;
...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
   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;
   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);
Many blocks are fragmented:

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

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
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 table TEST_TABLE;
drop table GREAT_TABLE;

neděle 31. ledna 2016

Spring and 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 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


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:

  public @interface ExposeAsService  {}

Annotation for obtain OSGi service into spring world:

  public @interface ObtainAsService {}
Example of application context configuration via java class:

public abstract class DatabaseServicesContextConfiguration {
  protected ISystemService systemService() {
    return new SystemService();
  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.

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;

OsgiServiceObtainerBeanFactoryPostProcessor(BundleContext bundleContext) {
         this.bundleContext = bundleContext;

          * Find beanDefinitios with annotation ObtainAsService, 
          * lookup this service and register this service as

     * singletons into spring context. 
      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 
               // 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);

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);
  public void close() {
   for (ServiceRegistration registration : this.serviceRegistrations) {

Bundle activator example

Usage of these classes is quite simple:
public class DatabaseServiceActivator implements BundleActivator {
  public void start(final BundleContext bundleContext) throws Exception {
    springContext = new OsgiApplicationContext(bundleContext);

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.


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.


čtvrtek 21. ledna 2016

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:

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í.