PC Toledo

Em homenagem a Paulo Cesar Toledo
https://pctoledo.org/

Filtragem por índices Arquivo CDX

https://pctoledo.org/viewtopic.php?t=14883

Página 1 de 1

Filtragem por índices Arquivo CDX

Enviado: 10 Mar 2014 00:43
por lugab
Amigos, além do ORDSCOPE (que eu já sei usar), quais os outros recursos de filtragem q o CDX oferece ?
Como funcionam ?

Uso harbour e xharbour em modo console

Grato

Filtragem por índices Arquivo CDX

Enviado: 10 Mar 2014 09:30
por Itamar M. Lins Jr.
Ola!
set filter
OrdWildSeek
Index .. for temporary
index memio: ... direto na memória RAM

Código: Selecionar todos

#require "hbmemio"

REQUEST HB_MEMIO

PROCEDURE Main()

   LOCAL tmp

   dbCreate( "mem:test", { { "F1", "N", 9, 0 } }, , .T., "memarea" )
   FOR tmp := 1 TO 1000
      dbAppend()
      FIELD->F1 := hb_Random() * 1000000
   NEXT
   INDEX ON FIELD->F1 TAG f1
   dbEval( {|| QOut( FIELD->F1 ) } )
   dbCloseArea()
   dbDrop( "mem:test" )  /* Free memory resource */

   RETURN
index, set filter, set relation, via letodb ou netio

Saudações,
Itamar M. Lins Jr.

Filtragem por índices Arquivo CDX

Enviado: 10 Mar 2014 13:36
por lugab
Putz, esse index memio deve ser um avião... Mas tb pode travar tudo se o arquivo em memória ficar grande, né ??

Muito Obrigado, Itamar....

Filtragem por índices Arquivo CDX

Enviado: 10 Mar 2014 15:39
por Itamar M. Lins Jr.
Não trava.
A memória é do OS, se tem 4Gib, e precisar de mais, o OS faz uso do cache em HD, isso é um problema do OS não do HB.
Por isso a importância de rodar em 64Bits coisa que o Harbour já faz há algum tempo e com ganhos efetivos de performance inclusive usando todos os processadores, coisa que o xHb não faz.

Código: Selecionar todos

Recently I've repeated above tests on the same Hardware but using 64-bit
Linux kernels and 64bit Harbour builds and here the difference is even
bigger. Here are results for ST mode:

   2009-10-27 13:24:41 Linux 2.6.31.3-1-desktop x86_64
   Harbour 2.0.0beta3 (Rev. 12776) GNU C 4.4 (64-bit) x86-64
   THREADS: 0
   N_LOOPS: 1000000
   [ T000: empty loop overhead ]...................................0.02
   ====================================================================
   [ T001: x := L_C ]..............................................0.03
   [ T002: x := L_N ]..............................................0.02
   [ T003: x := L_D ]..............................................0.02
   [ T004: x := S_C ]..............................................0.03
   [ T005: x := S_N ]..............................................0.03
   [ T006: x := S_D ]..............................................0.03
   [ T007: x := M->M_C ]...........................................0.03
   [ T008: x := M->M_N ]...........................................0.04
   [ T009: x := M->M_D ]...........................................0.03
   [ T010: x := M->P_C ]...........................................0.04
   [ T011: x := M->P_N ]...........................................0.03
   [ T012: x := M->P_D ]...........................................0.03
   [ T013: x := F_C ]..............................................0.10
   [ T014: x := F_N ]..............................................0.17
   [ T015: x := F_D ]..............................................0.08
   [ T016: x := o:Args ]...........................................0.11
   [ T017: x := o[2] ].............................................0.06
   [ T018: round( i / 1000, 2 ) ]..................................0.15
   [ T019: str( i / 1000 ) ].......................................0.32
   [ T020: val( s ) ]..............................................0.18
   [ T021: val( a [ i % 16 + 1 ] ) ]...............................0.28
   [ T022: dtos( d - i % 10000 ) ].................................0.28
   [ T023: eval( { || i % 16 } ) ].................................0.29
   [ T024: eval( bc := { || i % 16 } ) ]...........................0.18
   [ T025: eval( { |x| x % 16 }, i ) ].............................0.24
   [ T026: eval( bc := { |x| x % 16 }, i ) ].......................0.18
   [ T027: eval( { |x| f1( x ) }, i ) ]............................0.27
   [ T028: eval( bc := { |x| f1( x ) }, i ) ]......................0.22
   [ T029: eval( bc := &("{ |x| f1( x ) }"), i ) ].................0.22
   [ T030: x := &( "f1(" + str(i) + ")" ) ]........................2.05
   [ T031: bc := &( "{|x|f1(x)}" ), eval( bc, i ) ]................2.41
   [ T032: x := valtype( x ) +  valtype( i ) ].....................0.27
   [ T033: x := strzero( i % 100, 2 ) $ a[ i % 16 + 1 ] ]..........0.54
   [ T034: x := a[ i % 16 + 1 ] == s ].............................0.17
   [ T035: x := a[ i % 16 + 1 ] = s ]..............................0.19
   [ T036: x := a[ i % 16 + 1 ] >= s ].............................0.18
   [ T037: x := a[ i % 16 + 1 ] <= s ].............................0.19
   [ T038: x := a[ i % 16 + 1 ] < s ]..............................0.19
   [ T039: x := a[ i % 16 + 1 ] > s ]..............................0.18
   [ T040: ascan( a, i % 16 ) ]....................................0.22
   [ T041: ascan( a, { |x| x == i % 16 } ) ].......................2.01
   [ T042: iif( i%1000==0, a:={}, ) , aadd(a,{i,1,.T.,s,s2,a2 ]....0.53
   [ T043: x := a ]................................................0.02
   [ T044: x := {} ]...............................................0.08
   [ T045: f0() ]..................................................0.05
   [ T046: f1( i ) ]...............................................0.08
   [ T047: f2( c[1...8] ) ]........................................0.07
   [ T048: f2( c[1...40000] ) ]....................................0.07
   [ T049: f2( @c[1...40000] ) ]...................................0.08
   [ T050: f2( @c[1...40000] ), c2 := c ]..........................0.09
   [ T051: f3( a, a2, s, i, s2, bc, i, n, x ) ]....................0.21
   [ T052: f2( a ) ]...............................................0.08
   [ T053: x := f4() ].............................................0.34
   [ T054: x := f5() ].............................................0.16
   [ T055: x := space(16) ]........................................0.12
   [ T056: f_prv( c ) ]............................................0.21
   ====================================================================
   [ total application time: ]....................................15.60
   [ total real time: ]...........................................15.61

   2009-10-27 13:25:10 Linux 2.6.31.3-1-desktop x86_64
   xHarbour build 1.2.1 Intl. (SimpLex) (Rev. 6629) GNU C 4.4 (64 bit) ?
   THREADS: 0
   N_LOOPS: 1000000
   [ T000: empty loop overhead ]...................................0.06
   ====================================================================
   [ T001: x := L_C ]..............................................0.05
   [ T002: x := L_N ]..............................................0.03
   [ T003: x := L_D ]..............................................0.04
   [ T004: x := S_C ]..............................................0.05
   [ T005: x := S_N ]..............................................0.03
   [ T006: x := S_D ]..............................................0.05
   [ T007: x := M->M_C ]...........................................0.05
   [ T008: x := M->M_N ]...........................................0.04
   [ T009: x := M->M_D ]...........................................0.04
   [ T010: x := M->P_C ]...........................................0.06
   [ T011: x := M->P_N ]...........................................0.04
   [ T012: x := M->P_D ]...........................................0.04
   [ T013: x := F_C ]..............................................0.25
   [ T014: x := F_N ]..............................................0.17
   [ T015: x := F_D ]..............................................0.11
   [ T016: x := o:Args ]...........................................0.30
   [ T017: x := o[2] ].............................................0.07
   [ T018: round( i / 1000, 2 ) ]..................................0.32
   [ T019: str( i / 1000 ) ].......................................0.87
   [ T020: val( s ) ]..............................................0.32
   [ T021: val( a [ i % 16 + 1 ] ) ]...............................0.48
   [ T022: dtos( d - i % 10000 ) ].................................0.43
   [ T023: eval( { || i % 16 } ) ].................................0.62
   [ T024: eval( bc := { || i % 16 } ) ]...........................0.40
   [ T025: eval( { |x| x % 16 }, i ) ].............................0.47
   [ T026: eval( bc := { |x| x % 16 }, i ) ].......................0.37
   [ T027: eval( { |x| f1( x ) }, i ) ]............................0.66
   [ T028: eval( bc := { |x| f1( x ) }, i ) ]......................0.56
   [ T029: eval( bc := &("{ |x| f1( x ) }"), i ) ].................0.58
   [ T030: x := &( "f1(" + str(i) + ")" ) ]........................5.95
   [ T031: bc := &( "{|x|f1(x)}" ), eval( bc, i ) ]................6.57
   [ T032: x := valtype( x ) +  valtype( i ) ].....................0.76
   [ T033: x := strzero( i % 100, 2 ) $ a[ i % 16 + 1 ] ]..........0.90
   [ T034: x := a[ i % 16 + 1 ] == s ].............................0.25
   [ T035: x := a[ i % 16 + 1 ] = s ]..............................0.25
   [ T036: x := a[ i % 16 + 1 ] >= s ].............................0.24
   [ T037: x := a[ i % 16 + 1 ] <= s ].............................0.25
   [ T038: x := a[ i % 16 + 1 ] < s ]..............................0.25
   [ T039: x := a[ i % 16 + 1 ] > s ]..............................0.24
   [ T040: ascan( a, i % 16 ) ]....................................0.46
   [ T041: ascan( a, { |x| x == i % 16 } ) ].......................4.10
   [ T042: iif( i%1000==0, a:={}, ) , aadd(a,{i,1,.T.,s,s2,a2 ]....0.92
   [ T043: x := a ]................................................0.04
   [ T044: x := {} ]...............................................0.16
   [ T045: f0() ]..................................................0.21
   [ T046: f1( i ) ]...............................................0.23
   [ T047: f2( c[1...8] ) ]........................................0.25
   [ T048: f2( c[1...40000] ) ]....................................0.24
   [ T049: f2( @c[1...40000] ) ]...................................0.24
   [ T050: f2( @c[1...40000] ), c2 := c ]..........................0.28
   [ T051: f3( a, a2, s, i, s2, bc, i, n, x ) ]....................0.41
   [ T052: f2( a ) ]...............................................0.24
   [ T053: x := f4() ].............................................0.94
   [ T054: x := f5() ].............................................0.63
   [ T055: x := space(16) ]........................................0.41
   [ T056: f_prv( c ) ]............................................0.86
   ====================================================================
   [ total application time: ]....................................37.14
   [ total real time: ]...........................................37.16

As we can see in xHarbour we do not have any improvement executing MT
programs on MultiCPU machines while in Harbour the speed is noticeably
better. It means that Harbour is quite well scalable and users should
expect speed improvement executing MT parallel programs on multi CPU
machines. For some programs like MT servers it may be critical - programs
compiled by Harbour can be quite well improved by simple hardware
upgrade to 4, 8, 16 or more CPU machines.
Teste feitos em 2009 pelo Przemek.
Isso também parece não ser importante p/ os usuários do xHarbour.

Saudações,
Itamar M. Lins Jr.

Filtragem por índices Arquivo CDX

Enviado: 10 Mar 2014 17:07
por Itamar M. Lins Jr.
Uma opção interessante.
Créditos p/ Rafa Carmona.
ANGIE SARAH LOWE
SARAH CARMONA
JULIA SARAH SMITH
Eso se consigue , pasando el patrón "*"+Cadena+"?"

cNombre := "SARAH"

fast_filter( "*"+ alltrim( cNombre ) + "?", 4, 22, 28 )
Browse()

Código: Selecionar todos

/* 
 Sustituto de SET FILTER
 cExpr  
    Expresion a buscar que forme parte del indice, podemos 
    poner *Texto? , para buscar palabra que forme parte

 nOrder
    Sobre que indice activo vamos a recorrer la lista.
    Por defecto es el indice activo.

 nRow, nCol 
     Posicion fila,columna para mostrar progreso. Se ejecuta en 
     un hilo aparte

 Return: Indice anterior

*/
function fast_filter( cExpr, nOrder, nRow, nCol )
      local PantaAnt := savescreen(0,0,MaxRow(),MaxCol())
      Local p := hb_threadStart( @Pajaritos(), nRow, nCol )
      Local nIndice := OrdNumber()

      DEFAULT nOrder TO OrdNumber()

      set order to nOrder
      INDEX ON &(IndexKey()) TAG _TEMP_ TO tHarbourt ;
               CUSTOM ADDITIVE MEMORY
       
      set order to nOrder
      go top

      DO WHILE OrdWildSeek( cExpr, .T. )
         OrdKeyAdd( "_TEMP_" )
      ENDDO
      OrdSetFocus( "_TEMP_" )
       
      hb_threadTerminateAll()
      restscreen(0 ,0 ,MaxRow(), MaxCol(), PantaAnt)

return nIndice

PROCEDURE Pajaritos( nRow, nCol )
        Local pajarito := "|",n := 0
        
        DEFAULT nRow := MaxRow(), nCol := 1

        DO WHILE .T.

           do case
              case n = 1 
                   pajarito = "|" 
              case n = 2 
                   pajarito = "/" 
              case n = 3  
                   pajarito = "-" 
              case n = 4 
                   pajarito = "\" 
              Otherwise 
                   n := 0
           end case

           DispOutAt( nRow, nCol, "Generando Consulta....[ " +  pajarito +" ]" ) //, "GR+/N" )
           ThreadSleep( 500 )
           n++
       ENDDO
RETURN
Saudações,
Itamar M. Lins Jr.

Filtragem por índices Arquivo CDX

Enviado: 10 Mar 2014 18:28
por lugab
Muito bom, Itamar e fácil de entender, muito obrigado

Filtragem por índices Arquivo CDX

Enviado: 05 Mar 2015 19:30
por nasouza
teria como esta função fast_filter() funcionar no xharbour...

Filtragem por índices Arquivo CDX

Enviado: 05 Mar 2015 19:54
por Itamar M. Lins Jr.
E porque não funciona no xHarbour ?

Saudações,
Itamar M. Lins Jr.
Todos os horários são UTC-03:00
Página 1 de 1

Powered by phpBB® Forum Software © phpBB Limited

Traduzido por: Suporte phpBB