Para melhor visualização, recomendo resolução de no mínimo 1280 x 800 e navegador Mozilla Firefox


quinta-feira, 17 de setembro de 2020

MongoDB - Obtendo informações das collections de um banco de dados

Por Eduardo Legatti

Olá,

Neste artigo irei demonstrar através de um script como obter informações de cada collection de um banco de dados, tais como quantidade de documentos, tamanho total real em MB e o tamanho total em MB ocupado em disco.

mongoPrdSet:PRIMARY> use bd01
switched to db bd01
mongoPrdSet:PRIMARY> cols.forEach(function(col) {
...     {
...       vstat=db.getCollection(col).stats({ scale : 1024*1024 }) //Em MB
...       print(vstat.ns + " - count: " + vstat.count + " - size MB: " + vstat.size + " - storage_size MB: "+vstat.storageSize)
...     }
... });
bd01.col01 - count: 2507  - size MB: 139 - storage_size MB: 53
bd01.col02 - count: 44372 - size MB: 2852 - storage_size MB: 600
bd01.col03 - count: 118476 - size MB: 710 - storage_size MB: 155
bd01.col04 - count: 3936 - size MB: 49 - storage_size MB: 16
bd01.col05 - count: 1797 - size MB: 12 - storage_size MB: 3
bd01.col06 - count: 2728 - size MB: 24 - storage_size MB: 5
bd01.col07 - count: 9406 - size MB: 73 - storage_size MB: 14
bd01.col08 - count: 57 - size MB: 32 - storage_size MB: 3
bd01.col09 - count: 1760 - size MB: 62 - storage_size MB: 14
bd01.col10 - count: 1616 - size MB: 38 - storage_size MB: 11
bd01.col11 - count: 1501 - size MB: 64 - storage_size MB: 18
bd01.col12 - count: 42880 - size MB: 4783 - storage_size MB: 1045
bd01.col13 - count: 2652 - size MB: 98 - storage_size MB: 28
bd01.col14 - count: 211 - size MB: 5 - storage_size MB: 1
bd01.col15 - count: 8055 - size MB: 5 - storage_size MB: 1
bd01.col16 - count: 225 - size MB: 14 - storage_size MB: 18
bd01.col17 - count: 309 - size MB: 7 - storage_size MB: 2
bd01.col18 - count: 7579 - size MB: 37 - storage_size MB: 11
bd01.col19 - count: 27762 - size MB: 135 - storage_size MB: 28
bd01.col20 - count: 26807 - size MB: 72 - storage_size MB: 12

segunda-feira, 17 de agosto de 2020

GOLDENGATEBR - Entrevista 20/08 - Quinta 20H30

Por Eduardo Legatti

 

 
 
 
 
 

terça-feira, 11 de agosto de 2020

SQL Server - Realizando manutenção nos índices do banco de dados

Por Eduardo Legatti

Olá,

No SQL Server diferentemente do Oracle, temos que nos preocupar em verificar com o tempo a fragmentação dos índices das tabelas. Vale a penas salientar que no SQL Server temos dois tipo de índices que são os mais utilizados - (CLUSTERED INDEX e NONCLUSTERED INDEX). No mais, a fragmentação no SQL Server ocorre quando os índices têm páginas nas quais a ordenação lógica no índice com base no valor de chave do índice não corresponde à ordenação física das páginas de índice. O Mecanismo de Banco de Dados modifica os índices automaticamente sempre que são realizadas operações de entrada, atualização ou exclusão nos dados subjacentes. Por exemplo, a adição de linhas em uma tabela pode fazer com que as páginas existentes nos índices de rowstore sejam divididas para liberar espaço para a inserção de novos valores de chave. No decorrer do tempo, essas modificações podem fazer com que as informações do índice sejam dispersadas pelo banco de dados (fragmentadas). Índices intensamente fragmentados podem prejudicar o desempenho da consulta, porque uma E/S adicional é necessária para localizar dados para os quais o índice aponta. E/S adicionais fazem com que a resposta do aplicativo seja lenta, especialmente quando operações de verificação estão envolvidas. Depois que o grau de fragmentação for conhecido, use a seguinte tabela para determinar o melhor método para remover a fragmentação.

Avg_fragmentation_in_percent      Instrução corretiva
--------------------------------- --------------------------------------
> 5% e < = 30%                    ALTER INDEX REORGANIZE
> 30%                             ALTER INDEX REBUILD WITH (ONLINE = ON)
 
Seguindo essa recomendação da Microsoft, costumo utilizar o script abaixo para verificar o grau de fragmentação e realizar a manutenção apropriada (REBUILD ou REORGANIZE). No caso do REORGANIZE, o mesmo pode ser realizado de forma on-line sem prejudicar o desempenho do banco de dados. No caso do REBUILD, caso seja utilizado a versão Enterprise, é melhor adicionar a opção (ONLINE = ON) para não "lockar" a tabela durante a reconstrução do índice.

SELECT distinct (Index_Statement) FROM
(
            SELECT      CASE WHEN avg_fragmentation_in_percent BETWEEN 5 AND 30 THEN
                                   'ALTER INDEX [' + name + '] ON ' + (SELECT TOP 1 TABLE_SCHEMA FROM 
                                                                       INFORMATION_SCHEMA.TABLES
                                                                       WHERE 
                                                                       TABLE_NAME = OBJECT_NAME(b.[OBJECT_ID]) AND TABLE_TYPE = 'BASE TABLE')
                                   + '.[' + OBJECT_NAME(b.[OBJECT_ID]) + '] REORGANIZE;'
                                   WHEN avg_fragmentation_in_percent > 30 THEN
                                   'ALTER INDEX [' + name + '] ON ' + (SELECT TOP 1 TABLE_SCHEMA FROM 
                                                                       INFORMATION_SCHEMA.TABLES
                                                                       WHERE
                                                                       TABLE_NAME = OBJECT_NAME(b.[OBJECT_ID]) AND TABLE_TYPE = 'BASE TABLE')
                                   + '.[' + OBJECT_NAME(b.[OBJECT_ID]) + '] REBUILD;'
                                   END AS Index_Statement       
                        FROM sys.dm_db_index_physical_stats (DB_ID(), NULL, NULL, NULL, NULL) AS a
                             JOIN sys.indexes AS b ON a.object_id = b.object_id AND a.index_id = b.index_id
                        WHERE avg_fragmentation_in_percent > 5
                                   AND index_type_desc <> 'HEAP'
                                   AND page_count > 640) index_rebuild_reorganize
WHERE Index_Statement Is NOT NULL;


Index_Statement
----------------------------------------------------
ALTER INDEX [IDX_TBL_08] ON dbo.[TBL_08] REORGANIZE;
ALTER INDEX [IDX_TBL_07] ON dbo.[TBL_07] REBUILD;
ALTER INDEX [IDX_TBL_06] ON dbo.[TBL_06] REORGANIZE;
ALTER INDEX [IDX_TBL_05] ON dbo.[TBL_05] REBUILD;
ALTER INDEX [IDX_TBL_04] ON dbo.[TBL_04] REORGANIZE;
ALTER INDEX [IDX_TBL_03] ON dbo.[TBL_03] REBUILD;
ALTER INDEX [IDX_TBL_02] ON dbo.[TBL_02] REORGANIZE;
ALTER INDEX [IDX_TBL_01] ON dbo.[TBL_01] REORGANIZE;
ALTER INDEX [PKI_TBL_08] ON dbo.[TBL_08] REORGANIZE;
ALTER INDEX [PKI_TBL_09] ON dbo.[TBL_09] REORGANIZE;

(10 rows affected)


Completion time: 2020-08-07T16:24:33.6867313-03:00

segunda-feira, 13 de julho de 2020

MongoDB - Um pouco sobre o db.currentOp()

Por Eduardo Legatti

Olá,


O MongoDB possui função chamada db.currentOp() que retorna todas as conexões abertas da instância. No comando abaixo irei retornar todas as conexões que estão realizando operações que estão em execução a mais de 1 segundo. É possível verificar no exemplo abaixo que a conexão conn9145756 proveniente do servidor 192.168.1.10 está realizando uma query no banco bd01 e collection customer através do _id: ObjectId("0000001") com duração de 3 segundos. As demais operações estão ligadas ao namespace local.oplog.rs que são operações de replicação do MongoDB.

mongoSet:PRIMARY> db.currentOp({"secs_running": {$gte: 1}})
{
        "inprog" : [
                {
                        "desc" : "conn9145756",
                        "threadId" : "139937773053696",
                        "connectionId" : 9145756,
                        "client" : "192.168.1.10:34456",
                        "active" : true,
                        "opid" : 425355448,
                        "secs_running" : 3,
                        "microsecs_running" : NumberLong(7491051),
                        "op" : "query",
                        "ns" : "bd01.customer",
                        "query" : {
                                "find" : "customer",
                                "filter" : {
                                        "_id" : ObjectId("0000001")
                                },
                                "batchSize" : 300
                        },
                        "numYields" : 0,
                        "locks" : {
                                "Global" : "r",
                                "Database" : "r",
                                "Collection" : "r"
                        },
                        "waitingForLock" : false,
                        "lockStats" : {
                                "Global" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(2)
                                        }
                                },
                                "Database" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(1)
                                        }
                                },
                                "Collection" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(1)
                                        }
                                }
                        }
                },
                {
                        "desc" : "ReplBatcher",
                        "threadId" : "139937860310784",
                        "active" : true,
                        "opid" : 10,
                        "secs_running" : 1300926,
                        "microsecs_running" : NumberLong("22775762702217"),
                        "op" : "none",
                        "ns" : "local.oplog.rs",
                        "query" : {

                        },
                        "numYields" : 0,
                        "locks" : {

                        },
                        "waitingForLock" : false,
                        "lockStats" : {
                                "Global" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(2)
                                        }
                                },
                                "Database" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(1)
                                        }
                                },
                                "oplog" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(1)
                                        }
                                }
                        }
                },
                {
                        "desc" : "rsSync",
                        "threadId" : "139938179233536",
                        "active" : true,
                        "opid" : 9,
                        "secs_running" : 1300926,
                        "microsecs_running" : NumberLong("22775762702158"),
                        "op" : "none",
                        "ns" : "local.oplog.rs",
                        "query" : {

                        },
                        "numYields" : 0,
                        "locks" : {

                        },
                        "waitingForLock" : false,
                        "lockStats" : {
                                "Global" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(24704),
                                                "w" : NumberLong(18515),
                                                "R" : NumberLong(6172),
                                                "W" : NumberLong(6172)
                                        },
                                        "acquireWaitCount" : {
                                                "W" : NumberLong(974)
                                        },
                                        "timeAcquiringMicros" : {
                                                "W" : NumberLong(19504794)
                                        }
                                },
                                "Database" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(8),
                                                "w" : NumberLong(1),
                                                "W" : NumberLong(18514)
                                        }
                                },
                                "Collection" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(7)
                                        }
                                },
                                "Metadata" : {
                                        "acquireCount" : {
                                                "w" : NumberLong(1)
                                        }
                                },
                                "oplog" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(1),
                                                "w" : NumberLong(1)
                                        }
                                }
                        }
                },
                {
                        "desc" : "WT RecordStoreThread: local.oplog.rs",
                        "threadId" : "139938314262272",
                        "active" : true,
                        "opid" : 424925952,
                        "secs_running" : 920,
                        "microsecs_running" : NumberLong(920757610),
                        "op" : "none",
                        "ns" : "local.oplog.rs",
                        "query" : {

                        },
                        "numYields" : 0,
                        "locks" : {

                        },
                        "waitingForLock" : false,
                        "lockStats" : {
                                "Global" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(1),
                                                "w" : NumberLong(1)
                                        }
                                },
                                "Database" : {
                                        "acquireCount" : {
                                                "w" : NumberLong(1)
                                        }
                                },
                                "oplog" : {
                                        "acquireCount" : {
                                                "w" : NumberLong(1)
                                        }
                                }
                        }
                }
        ],
        "ok" : 1
}

Caso queiramos filtrar apenas as conexões ativas ignorando operações internas de replicação, bastará utilizar o exemplo abaixo.

mongoSet:PRIMARY> db.currentOp({"active" : true,"secs_running" : { "$gt" : 0 },"ns" : {$ne : "local.oplog.rs"}})
{
        "inprog" : [
                {
                        "desc" : "conn1371708",
                        "threadId" : "140655653025536",
                        "connectionId" : 1371708,
                        "client" : "172.31.80.121:51282",
                        "active" : true,
                        "opid" : 2036637847,
                        "secs_running" : 1,
                        "microsecs_running" : NumberLong(1082772),
                        "op" : "query",
                        "ns" : "bd01.product",
                        "query" : {
                                "$msg" : "query not recording (too large)"
                        },
                        "numYields" : 58,
                        "locks" : {
                                "Global" : "r",
                                "Database" : "r"
                        },
                        "waitingForLock" : true,
                        "lockStats" : {
                                "Global" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(118)
                                        }
                                },
                                "Database" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(59)
                                        },
                                        "acquireWaitCount" : {
                                                "r" : NumberLong(58)
                                        },
                                        "timeAcquiringMicros" : {
                                                "r" : NumberLong(935638)
                                        }
                                },
                                "Collection" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(58)
                                        }
                                }
                        }
                },
                {
                        "desc" : "conn980301",
                        "threadId" : "140655740397312",
                        "connectionId" : 980301,
                        "client" : "192.168.1.10:55542",
                        "active" : true,
                        "opid" : 2036637676,
                        "secs_running" : 1,
                        "microsecs_running" : NumberLong(1310312),
                        "op" : "query",
                        "ns" : "bd01.product",
                        "query" : {
                                "$msg" : "query not recording (too large)"
                        },
                        "numYields" : 74,
                        "locks" : {
                                "Global" : "r",
                                "Database" : "r",
                                "Collection" : "r"
                        },
                        "waitingForLock" : false,
                        "lockStats" : {
                                "Global" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(150)
                                        }
                                },
                                "Database" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(75)
                                        },
                                        "acquireWaitCount" : {
                                                "r" : NumberLong(71)
                                        },
                                        "timeAcquiringMicros" : {
                                                "r" : NumberLong(1140143)
                                        }
                                },
                                "Collection" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(75)
                                        }
                                }
                        }
                },
                {
                        "desc" : "conn980023",
                        "threadId" : "140655865579264",
                        "connectionId" : 980023,
                        "client" : "192.168.1.10:55132",
                        "active" : true,
                        "opid" : 2036637864,
                        "secs_running" : 1,
                        "microsecs_running" : NumberLong(1071661),
                        "op" : "query",
                        "ns" : "bd01.product",
                        "query" : {
                                "$msg" : "query not recording (too large)"
                        },
                        "numYields" : 63,
                        "locks" : {
                                "Global" : "r",
                                "Database" : "r"
                        },
                        "waitingForLock" : true,
                        "lockStats" : {
                                "Global" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(128)
                                        }
                                },
                                "Database" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(64)
                                        },
                                        "acquireWaitCount" : {
                                                "r" : NumberLong(60)
                                        },
                                        "timeAcquiringMicros" : {
                                                "r" : NumberLong(910226)
                                        }
                                },
                                "Collection" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(63)
                                        }
                                }
                        }
                },
                {
                        "desc" : "conn980300",
                        "threadId" : "140655781451520",
                        "connectionId" : 980300,
                        "client" : "192.168.1.10:44064",
                        "active" : true,
                        "opid" : 2036637740,
                        "secs_running" : 1,
                        "microsecs_running" : NumberLong(1200164),
                        "op" : "query",
                        "ns" : "bd01.product",
                        "query" : {
                                "$msg" : "query not recording (too large)"
                        },
                        "numYields" : 67,
                        "locks" : {
                                "Global" : "r",
                                "Database" : "r"
                        },
                        "waitingForLock" : true,
                        "lockStats" : {
                                "Global" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(136)
                                        }
                                },
                                "Database" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(68)
                                        },
                                        "acquireWaitCount" : {
                                                "r" : NumberLong(64)
                                        },
                                        "timeAcquiringMicros" : {
                                                "r" : NumberLong(1015696)
                                        }
                                },
                                "Collection" : {
                                        "acquireCount" : {
                                                "r" : NumberLong(67)
                                        }
                                }
                        }
                }
        ],
        "ok" : 1
}

quarta-feira, 10 de junho de 2020

SQL Server - Obtendo a porta de conexão através de uma instrução SQL

Por Eduardo Legatti

Olá,

Neste artigo rei demonstrar como podemos obter a porta que a instância do SQL Server está atendendo através de uma instrução SQL. Essa instrução é válida tanto para instalações Linux quanto para Windows.

[root@linux /]# sqlcmd -S localhost -U SA -Pminhasenha
1> DECLARE @test varchar(20), @key varchar(100)
2> if charindex('\',@@servername,0) <>0
3> begin
4> set @key = 'SOFTWARE\MICROSOFT\Microsoft SQL Server\'+@@servicename+'\MSSQLServer\Supersocketnetlib\TCP'
5> end
6> else
7> begin
8> set @key = 'SOFTWARE\MICROSOFT\MSSQLServer\MSSQLServer\Supersocketnetlib\TCP'
9> end
10> EXEC master..xp_regread @rootkey='HKEY_LOCAL_MACHINE',@key=@key,@value_name='Tcpport',@value=@test OUTPUT
11> SELECT 'Server Name: '+@@servername + ' Port Number:'+convert(varchar(10),@test) port;
12> GO

port
-----------------------------------
Server Name: linux Port Number:1433

(1 rows affected)

segunda-feira, 11 de maio de 2020

MongoDB - Um pouco sobre o db.setProfilingLevel()

Por Eduardo Legatti

Olá,


No MongoDB, por padrão, todas as operações executadas nos banco de dados da instância que gastam mais de 100 ms para serem executadas são armazenada no arquivo de log em um arquivo texto. Dependendo do ambiente, esse tempo pode ser aumentado ou diminuído. É possível alterar esse comportamento da instância executando o comando db.setProfilingLevel(). Ao conectar na instância do MongoDB podemos ver que a configuração atual do parâmetro slowms é 100 ms. O primeiro parâmetro mostrado na saída do comando db.getProfilingStatus() ("was" : 0) é nível de detalhes que são enviados para o log. O padrão é 0 e inclui informações mais simples. O valor máximo que pode ser setado para esse nível pode ir de 1 a 5 e pode ser utilizado para debug das operações executadas na instância do MongoDB com informações mais detalhadas.

[mongodb ~]$ mongo --host localhost --port 27017
MongoDB shell version v4.0.17
connecting to: mongodb://localhost:27017/?authSource=admin&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("41d40407-eb0e-4e45-b9b9-7882d4a30fcc") }
MongoDB server version: 4.0.17

> db.getProfilingStatus()
{ "was" : 0, "slowms" : 100 }

Agora irei aumentar o valor slowms para 500 ms.

> db.setProfilingLevel(0,500)
{ "was" : 0, "slowms" : 100, "ok" : 1 }

Para checar a alteração realizada, bastará executar novamente o comando db.getProfilingStatus() para ver o valor atual.

> db.getProfilingStatus()
{ "was" : 0, "slowms" : 500 }

segunda-feira, 13 de abril de 2020

MongoDB - Capped Collection

Por Eduardo Legatti

Olá,

No artigo de Março/2020 eu comentei sobre índices TTL no MongoDB que pode ser criado para automaticamente remover documentos da collection de acordo com o valor especificado na propriedade expireAfterSeconds do índice. Agora irei comentar sobre capped collections. Uma collection no MongoDB pode ser criada para que o seu tamanho não ultrapasse um tamanho definido em bytes. Se por acaso quisermos criar uma collection chamada "log_events" na qual seu tamanho não ultrapasse 5MB, poderemos utilizar a sintaxe abaixo para criá-la.

db.createCollection( "log_events", { capped: true, size: 5242880 } )

Nesse caso o MongoDB irá se encarregar de que os documentos mais antigos sejam excluídos de forma a dar espaço para os novos documentos inseridos e assim mantendo o tamanho máximo da collection em 5MB.

Caso queiramos limitar também o número de documentos dentro da collection, poderemos utilizar o parâmetro "max" como no exemplo abaixo na qual limito o tamanho da collection para 5MB até um total de 100 mil documentos.

db.createCollection("log_events", { capped : true, size : 5242880, max : 100000 } )

Vale a pena salientar que um documento dentro de uma capped collection não pode ter seu tamanho alterado após a inserção. Caso isso ocorra, o erro abaixo será emitido.

Command failed with error 10003: 'Cannot change the size of a document in a capped collection: 608 != 1601' on server.
The full response is {"ok": 0.0, "errmsg": "Cannot change the size of a document in a capped collection: 608 != 1601", "code": 10003}

Uma capped collection não pode ser revertida para uma collection normal, mas é possível alterar uma collection normal para uma capped collection conforme a seguir.

db.runCommand( { convertToCapped: "log_events", size: 5242880 } )

Postagens populares