Diário de Informática

Windows Mail: Erro ao abrir anexos de associação de programas

2012-04-17T09:54:00.003-07:00

PROBLEMA: Ao tentar abrir um anexo no Windows Mail como exemplo .doc, .pdf e outros mais você pode receber a mensagem de erro abaixo.

MENSAGEM: Este arquivo não tem um programa associado a ele para realizar esta ação. Crie uma associação no painel de controle Definir Associaçõ

SOLUÇÃO:
Método 1: Apagar a associação da extensão para o usuário. No seguinte caminho:
HKEY_CURRENT_USER/Software/Microsoft/Windows/Current/Version/Explorer/File/Exts, por exemplo abaixo desta chave temos .doc, .pdf e outras mais. Podemos excluir o .doc e associar novamente a extensão ao Microsoft Word, ou podemos excluir o .PDF e associar ao Adobe Reader.

Método 2: Apagar a associação da extensão para o Windows. No seguinte caminho:
HKEY_CLASSES_ROOT/.doc ou HKEY_CLASSES_ROOT/.pdf, por exemplo abaixo desta chave temos .doc, .pdf e outras mais. Podemos excluir o .doc e associar novamente a extensão ao Microsoft Word, ou podemos excluir o .PDF e associar ao Adobe Reader.
Método 3: Se ainda assim persistir renomear o arquivo windowsmail.msmessagestore para windowsmail.old para que possa refazer o indíce das mensagens do Windows Mail.
Localizar o arquivo a ser renomeado na pasta C:Users/<user profile>/App/DataLocal/Microsoft/Windows Mail

Fonte: http://www.windowsbrasil.com.br/?p=1303

Tomcat - Erro no deploy

2012-03-28T08:20:00.000-07:00

Mensagem de erro:

HTTP Status 500 -

type Exception report
message
description The server encountered an internal error () that prevented it from fulfilling this request.
exception

java.lang.IllegalStateException: org.apache.tomcat.util.http.fileupload.FileUploadBase$SizeLimitExceededException: the request was rejected because its size (54526273) exceeds the configured maximum (52428800)
 org.apache.catalina.connector.Request.parseParts(Request.java:2666)
 org.apache.catalina.connector.Request.parseParameters(Request.java:2875)
 org.apache.catalina.connector.Request.getParameter(Request.java:1131)
 org.apache.catalina.connector.RequestFacade.getParameter(RequestFacade.java:384)
 org.apache.catalina.filters.CsrfPreventionFilter.doFilter(CsrfPreventionFilter.java:163)

root cause

org.apache.tomcat.util.http.fileupload.FileUploadBase$SizeLimitExceededException: the request was rejected because its size (54526273) exceeds the configured maximum (52428800)
 org.apache.tomcat.util.http.fileupload.FileUploadBase$FileItemIteratorImpl.<init>(FileUploadBase.java:799)
 org.apache.tomcat.util.http.fileupload.FileUploadBase.getItemIterator(FileUploadBase.java:282)
 org.apache.tomcat.util.http.fileupload.FileUploadBase.parseRequest(FileUploadBase.java:302)
 org.apache.tomcat.util.http.fileupload.servlet.ServletFileUpload.parseRequest(ServletFileUpload.java:129)
 org.apache.catalina.connector.Request.parseParts(Request.java:2638)
 org.apache.catalina.connector.Request.parseParameters(Request.java:2875)
 org.apache.catalina.connector.Request.getParameter(Request.java:1131)
 org.apache.catalina.connector.RequestFacade.getParameter(RequestFacade.java:384)
 org.apache.catalina.filters.CsrfPreventionFilter.doFilter(CsrfPreventionFilter.java:163)

note The full stack trace of the root cause is available in the Apache Tomcat/7.0.16 logs.

Apache Tomcat/7.0.16

Solução:

Procure o arquivo "web.xml" do "manager application" (normalmente encontra-se em /tomcat7/webapps/manager/WEB-INF/web.xml)

Procure os parametros: "max-file-size" e "max-request-size"

<multipart-config>
<!– 50MB max –>
<max-file-size>52428800</max-file-size>
<max-request-size>52428800</max-request-size>
<file-size-threshold>0</file-size-threshold>
</multipart-config>

E aumente os valores do "max-file-size" e "max-request-size".

Comando Top 10 do SQL Server correspondente no Oracle

2012-03-27T12:35:00.002-07:00

Exemplo MS SQL SERVER:

select top 10 * from tabela;

Exemplo ORACLE:

select * from tabela
where ROWNUM <= 10;

Oracle - ASM

2012-03-10T11:48:00.001-08:00

--configurar o listner
netca (interface nova)
ou
netmgr (interface antiga)

obs.: mudar para instancia +ASM, antes para trabalhar com a base e voltar para ORCL para configurar a instancia

--------
Ferramentas:

. oraenv
determina qual base trabalhar, alternando entre elas

dba
cria e configurar um database

-------------------
sqlplus / as sysdba (entra com as credenciais do sistema operacional)
sqlplus sys/oracle as sysdba
sqlplus hr/senha
sqlplus /nolog (abre o sqlplus sem conectar-se)
sqlplus hr/senha@teste
sqlplus system/oracle@10.68.46.74:1521/orcl.localdomain
sqlplus hr (pedirá a senha para conectar-se)
sqlplus sys as sysdba (pedirá a senha para conectar)

---------

emctl start dbconsole
inicializa o enterprise manager

emctl stop dbconsole
para o enterprise manager

emctl status dbconsole
mostra o estado atual do enterprise manager

-------------------------
lsnrclt start (Inicia o listener)
lsnrclt stop (para o listener)
lsnrclt status (Verifica o status do listener)

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

--comandos para acessar o ASM, deve estar na base +ASM

asmcmd -p (utilizado para acessar os arquivos do ASM)

asmca (utilizado para configurar os discos do ASM)

Oracle - Ferramentas

2012-03-10T11:46:00.002-08:00

sqlplus - acessar a base de dados

asmcmd - acessar o conteudo dos discos do ASM

asmca - criar os grupos de discos do ASM

dbca - criar base de dados

netmgr - ferramenta para gerenciamento de rede

netca - ferramenta para gerenciamento de rede

lsnrctl - ferramenta para gerenciar o listener

emctl - ferramenta para iniciar/parar o enterprise manager

srvctl - oracle Restart, permite executar uma série de comandos em apenas uma linha de prompt

orapwd - criar arquivo de senha da base, onde ficam indicados quais usuário acessam a base via sysdba com a base fechada.

Oracle formato - hora minuto segundo

2012-03-07T09:30:00.001-08:00

Oracle date to hundredths of a second

Oracle Tips by Burleson Consulting

Question: In have incoming data that records hundredths of a second and I cannot find a DATE format (i.e. nls_date_format) to hold hundredths of a second.

Answer: It's tempting to try the SSSS date format, but you annot use the "SSSS" format for milliseconds because SSSS is the number of seconds after midnight.

Instead, you need to use the TIMESTAMP datatype instead of the DATE datatype. The TIMESTAMP datatype has fractional seconds, as noted by the FF notation:

'DD-Mon-YYYY HH24:MI:SS.FF'

For example, you can define a TIMESTAMP column and store data into it, something like this:

create table t1 (timecol TIMESTAMP);

insert into T1 (timecol) values
to_timestamp('200612251211000000','YYYYMMDDHHMISSFF')

this query will convert to fractional seconds:

select
   to_char(sysdate, 'DD-Mon-YYYY HH24:MI:SS'),
   localtimestamp(2),
   to_timestamp(
      to_char(
         sysdate, 'DD-Mon-YYYY HH24:MI:SS'
      )||'.55', 'DD-Mon-YYYY HH24:MI:SS.FF')
from
   dual;

Fonte: http://www.dba-oracle.com/t_date_format_hundredths_second.htm

Oracle - Diferenças em dias entre duas datas

2012-03-06T08:19:00.003-08:00

Oracle - Exemplo para calcular a diferenças em dias entre duas datas

SELECT TRUNC(sysdate) - TRUNC(t.hiredate) FROM myTable t;

fonte: http://stackoverflow.com/questions/3129707/count-the-number-of-days-between-today-the-hiredate-in-oracle-sql

Cinco sites para você estudar inglês de graça

2012-02-20T10:32:00.001-08:00

Com a copa do mundo e as olimpíadas batendo em nossa porta, estudar inglês nunca foi tão importante para os empreendedores brasileiros. Afinal, daqui a alguns anos, seu empreendimento estará lotado de turistas estrangeiros querendo comprar seus produtos e usufruir dos serviços prestados pela sua empresa. A comunicação será fundamental para a satisfação desses clientes. Mas, infelizmente, estudar um outro idioma no Brasil é muito difícil. As escolas de idiomas cobram uma fortuna mensalmente e o estudo do inglês na escola pública é uma piada. Pensando nisso, o Ambiente Externo selecionou cinco sites para você estudar inglês pela internet, e, o melhor, sem pagar nada.

1- Livemocha

O Livemocha é uma rede social para estudantes de línguas estrangeiras. Nesse site, você pode estudar diversos idiomas, realizar os exercícios propostos e a correção será realizada pelos usuários nativos dos países onde o idioma, ao qual você está estudando, é falado. É um ótimo lugar para conhecer pessoas de outros lugares. Se você quiser assessoria profissional, é possível contar com o apoio de professores formados adquirindo o pacotes Actives, por um preço muito abaixo do praticado pelas escolas de idiomas tradicionais.

http://www.livemocha.com

2- Engvid

Mantido por um grupo de professores canadenses, o EngVid fornece vídeos com a explicação da gramática, gírias e expressões em inglês. O bom desse site, é que você pode aprender a gramática e ao mesmo tempo treinar o seu “listening”. No final de cada vídeo, o site fornece um pequeno quiz para você testar sua compreensão sobre a lição.

http://www.engvid.com

3- Learn American English Online

Atualizado diariamente pelo professor Paul, o Learn American English Online (não se assuste com o tamanho do nome) fornece um curso de inglês completo, do básico ao avançado. Em cada lição, você terá uma explicação escrita e outra em vídeo. O layout do site é simples, mas acessando-o diariamente, é possível aprender muita coisa.

http://www.learnamericanenglishonline.com

4- PodEnglish

Criado pela escola a distância Englishtown, o PodEnglish fornece podcasts que permite você estudar inglês através de seu ipod, mp4 players ou derivados. No canal do Youtube, você encontra todos os episódios gravados, desde do iniciante até o avançado.

http://www.youtube.com/user/podEnglish

5- CNN Students News

Para os estudantes mais avançados, o CNN Students News pode ser uma boa opção. Trata-se de um podcast de um programa do canal CNN destinado a estudantes de ensino médio dos Estados Unidos. São notícias do mundo faladas em uma linguagem simples, para ser compreendida por estudantes americanos. Pode ser um boa idéia para você treinar seu listening e compreensão sobre o idioma.

http://edition.cnn.com/US/studentnews/quick.guide/archive/index.html

fonte: http://www.ambienteexterno.com/2012/01/01/cinco-sites-para-voce-estudar-ingles-de-graca/#.T0KRsfEgds0

Windows 7 - Desabilitar logon automático

2012-01-02T08:00:00.001-08:00

Você é o único usuário do computador, não possui senha para sua conta e está cansado do sistema de logon automático do Windows 7?
Basta clicar em Iniciar -> Executar e digitar “netplwiz” (sem aspas).
Abre-se a caixa Contas de Usuário.
Selecione seu usuário e desmarque o item “Os usuários devem digitar um nome de usuário e uma senha para usar este computador”. Clique em Ok e o sistema pedirá que você digite sua senha duas vezes. Confirme a operação. Na próxima vez em que você entrar no sistema, o logon automático estará desabilitado e vai entrar automaticamente.

Fonte: http://tecnoinformacao.wordpress.com/2011/05/17/windows-7-desabilitar-logon-automatico/

Word e Excel - Modo de Exibição Protegido

2011-12-14T04:20:00.000-08:00

Modo de Exibição Protegido

No MS Office 2010, ao abri um arquivo no formato Word ou Excel vindo anexado de um e-mail, internet ou rede, aparece a mensagem “Modo de Exibição Protegido”, como na imagem abaixo.

Para desabilitar essa mensagem no Word ou Excel, pasta ir ao menu Arquivo\Opções

Na tena de Opões, vá ao menu “Central de Confiabilidade”

Na tela da central de confiabilidade, vá ao menu “Modo de exibição protegido”

Basta desmarcarmo as caixas de seleção para desabilitar a exibição da mensagem.

Anderson

Mapeando Dados Oracle para SQL Server

2011-12-12T10:09:00.001-08:00

Mapeamento de tipo de dados para Publicadores Oracle

SQL Server 2008 R2

Tipos de dados de Oracle e tipos de dados de MicrosoftSQL Server nem sempre correspondem exatamente. Onde possível, o tipo de dados correspondente é selecionado automaticamente ao publicar uma tabela de Oracle. Em casos em que o mapeamento de um único tipo de dados não é claro, mapeamentos alternativos de tipo de dados são fornecidos. Para obter informações sobre como selecionar mapeamentos alternativos, consulte "Especificando Mapeamentos Alternativos de Tipos de Dados”, mais adiante neste tópico.
A tabela a seguir mostra como os tipos de dados são mapeados por padrão entre o Oracle e o SQL Server quando os dados são movidos de um Publicador Oracle para o Distribuidor do SQL Server. A coluna de Alternativas indica se mapeamentos alternativos estão disponíveis.

Tipo de dados de Oracle	Tipos de dados SQL Server	Alternativas
BFILE	VARBINARY(MAX)	Sim
BLOB	VARBINARY(MAX)	Sim
CHAR([1-2000])	CHAR([1-2000])	Sim
CLOB	VARCHAR(MAX)	Sim
DATE	DATETIME	Sim
FLOAT	FLOAT	Não
FLOAT ([1-53])	FLOAT ([1-53])	Não
FLOAT ([54-126])	FLOAT	Não
INT	NUMERIC(38)	Sim
INTERVAL	DATETIME	Sim
LONG	VARCHAR(MAX)	Sim
LONG RAW	IMAGE	Sim
NCHAR([1-1000])	NCHAR([1-1000])	Não
NCLOB	NVARCHAR(MAX)	Sim
NUMBER	FLOAT	Sim
NUMBER([1-38])	NUMERIC([1-38])	Não
NUMBER([0-38],[1-38])	NUMERIC([0-38],[1-38])	Sim
NVARCHAR2 ([1-2000])	NVARCHAR([1-2000])	Não
RAW ([1-2000])	VARBINARY([1-2000])	Não
REAL	FLOAT	Não
ROWID	CHAR([1-2000])	Não
TIMESTAMP	DATETIME	Sim
TIMESTAMP(0-7)	DATETIME	Sim
TIMESTAMP(8-9)	DATETIME	Sim
TIMESTAMP(0-7) WITH TIME ZONE	VARCHAR(37)	Sim
TIMESTAMP(8-9) WITH TIME ZONE	VARCHAR(37)	Não
TIMESTAMP(0-7) WITH LOCAL TIME ZONE	VARCHAR(37)	Sim
TIMESTAMP(8-9) WITH LOCAL TIME ZONE	VARCHAR(37)	Não
UROWID	CHAR(18)	Não
VARCHAR2([1-4000])	VARCHAR([1-4000])	Sim

Considerações para o mapeamento do tipo de dados

Pense nos seguintes problemas de tipo de dados ao replicar dados de um banco de dados de Oracle.

Tipos de dados sem suporte

Os seguintes tipos de dados não têm suporte; não podem ser replicadas as colunas que têm estes tipos:

Tipos de objeto
Tipos XML
Varrays
Tabelas aninhadas
Colunas que usam REF

O tipo de dados de DATE.

As datas no SQL Server vão de 1753 a.C. a 9999 d.C. enquanto as datas no Oracle vão de 4712 a.C. a 4712 d.C. Se uma coluna do tipo DATE contém valores que estão fora do intervalo do SQL Server, selecione um tipo de dados alternativo para a coluna, que é VARCHAR(19).

Tipos FLOAT e NUMBER

A escala e precisão especificadas durante o mapeamento de tipos de dados FLOAT e NUMBER dependem da escala e precisão especificadas para a coluna usando o tipo de dados no banco de dados do Oracle. A precisão é o número de dígitos em um número. A escala é o número de dígitos à direita da casa decimal em um número. Por exemplo, o número 123,45 tem uma precisão de 5 e uma escala de 2.
O Oracle permite números a serem definidos com a escala maior que a precisão, tal como NUMBER(4,5), mas o SQL Server requer que a precisão seja igual ou maior que a escala. Para garantir que não há truncamento de dados, se a escala for maior que a precisão no Publicador Oracle, a precisão é definida igual à escala quando o tipo de dados for mapeado: NUMBER (4,5) ele seria mapeado como NUMERIC (5,5).

Observação
Se você não especificar a escala e a precisão para NUMBER, o SQL Server usa o padrão máximo de escala (8) e precisão (38). É recomendável que você defina uma escala e precisão específicas no Oracle para melhor armazenamento e desempenho quando os dados forem replicados.

Tipos de objeto grande

O Oracle suporta até 4 gigabytes (GB), enquanto que o SQL Server suporta até 2 GB. Dados replicados acima de 2 GB são truncados.
Se uma tabela de Oracle incluir uma coluna de BFILE, os dados para a coluna serão armazenados no sistema de arquivos. A conta do usuário administrativo da replicação deve receber acesso ao diretório no qual os dados estão armazenados usando a seguinte sintaxe:
GRANT READ ON DIRECTORY <directory_name> TO <replication_administrative_user_schema>
Para obter mais informações sobre tipos de objetos grandes, consulte a seção "Considerações sobre objetos grandes" em Considerações de design e limitações para Editores Oracle.

Especificando mapeamentos alternativos de tipo de dados

Tipicamente, o padrão de mapeamento de tipo de dados é apropriado, porém para muitos tipos de dados do Oracle, você pode selecionar um mapeamento de tipo de dados a partir de um conjunto de mapeamentos alternativos, ao invés de usar o padrão. Há dois modos para especificar os mapeamentos alternativos:

Substitua o padrão em uma base por artigo usando procedimentos armazenados ou o Assistente para Nova Publicação .
Globalmente altere o padrão para todos os artigos futuros usando procedimentos armazenados (não são alterados os padrões para os artigos existentes).

Para especificar mapeamentos alternativos de tipo de dados

SQL Server Management Studio: Como especificar mapeamentos de tipo de dados para o Editor Oracle (SQL Server Management Studio)
Programação da replicação: Como especificar mapeamentos de tipo de dados para um Editor Oracle (Programação Transact-SQL de replicação)

Fonte: http://msdn.microsoft.com/pt-br/library/ms151817.aspx

Oracle - Trabalhando com datas

2011-12-12T10:05:00.001-08:00

SELECT SYSDATE DATA_ATUAL,
ADD_MONTHS(SYSDATE,-1) MENOS_UM_MES,
ADD_MONTHS(SYSDATE,1) MAIS_UM_MES,
LAST_DAY(SYSDATE) ULTIMO_DIA_MES,
TRUNC(SYSDATE,"MONTH") PRIMEIRO_DIA_MES,
MONTHS_BETWEEN(SYSDATE,"01-JAN-2001") QTD_MES,
FLOOR(MONTHS_BETWEEN(SYSDATE,"01-JAN-2001")) ARREDONDA_ABAIXO,
CEIL(MONTHS_BETWEEN(SYSDATE,"01-JAN-2001")) ARREDONDA_ACIMA,
ABS(MONTHS_BETWEEN(SYSDATE,"01-JAN-2001")) VALOR_ABSOLUTO,
ROUND((MONTHS_BETWEEN(SYSDATE,"01-JAN-2001")),2) ARREDONDA,
TRUNC(SYSDATE,"year") PRIMEIRO_DIA_ANO,
to_char(SYSDATE,"dd " DE " FMMONTH " DE " YYYY","nls_date_language=portuguese") DIAMES_EXTENSO,
to_char(SYSDATE,"FMMONTH " DE " YYYY","nls_date_language=portuguese") MES_EXTENSO,
TO_CHAR(SYSDATE,"HH24:MI") HORA_MINUTO,
to_char(sysdate,"FMMonth","nls_date_language=portuguese") mes_corrente,
to_date(lpad(to_char(1234),4,"0"),"hh24mi") dias_data,
Floor(floor(months_between(SYSDATE,SYSDATE)) / 12) IDADE,
decode(TO_NUMBER(TO_CHAR(SYSDATE,"D")),2,"segunda-feira",3,"terça-feira",4,"quarta-feira",
5,"quinta-feira",6,"sexta-feira",7,"sabado",1,"domingo") dia_da_semana
FROM DUAL

fonte: http://www.linhadecodigo.com.br/Dica.aspx?id=1292

SQL Server - Views Indexadas

2011-12-12T10:04:00.001-08:00

Melhorando desempenho de consultas utilizando Views Indexadas

O artigo tem o objetivo de ensinar a utilização e criação de Views Indexadas, mostrando a melhora de desempenho ao utilizá-la.

O artigo tem o objetivo de ensinar a utilização e criação de Views Indexadas, mostrando a melhora de desempenho ao utilizá-la. Para conseguir exemplificar com mais precisão, mostrarei os conceitos de utilização e criação de Views e Index independentemente um recurso do outro. Nos exemplos deste artigo, utilizaremos o banco AdventureWorks, que vem com o banco de exemplo do SQL Server 2005.

Aconselho fortemente que você pesquise no Books Online sobre a criação e uso de sintaxe de Views e Indexes. No artigo vou apresentar a melhora no desempenho e não sua sintaxe. No Books Online você irá encontrar um material rico e completo sobre estes recursos.

Entendendo o que é uma View

A criação de instruções de consulta é na maioria dos casos simples, mas quando repetidos diversas vezes os mesmos códigos, pode-se começar a ficar cansativa a sua criação. Para armazenar estas consultas em banco, utiliza-se um recurso já antigo de bancos de dados chamado View. Uma View é uma representação virtual de uma tabela, e pode conter colunas de uma ou varias tabelas físicas ou até mesmo de outras Views. Na maioria das vezes, as Views não armazenam os dados em banco, elas consultam os dados que foram selecionados em suas tabelas de origem. É possível utilizar uma View em qualquer lugar onde se possa utilizar uma tabela.

Vamos criar uma View de exemplo, consultando as tabelas Product e ProductModel do banco AdventureWorks.

CREATE VIEW vw_ProdutoDescricao WITH SCHEMABINDING AS

SELECT P.ProductID Codigo, P.Name Descricao, M.Name Produto

FROM Production.Product P INNER JOIN

Production.ProductModel M

ON P.ProductModelID = M.ProductModelID

Esta View irá retornar os dados relacionados entre as duas tabelas, e como não foi especificado nenhum Schema e neste caso estou conectado ao banco como usuário SA(System Administrator), a View irá assumir que o Schema é o do DBO.

Abaixo estão as sessões de Views do banco AdventureWorks, que exibe onde ficam armazenados todos objetos Views deste banco. Repare que na imagem da esquerda exibe o banco sem a View que criamos, e na imagem da direita, já apresenta a View criada.

Para ativar o retorno das estatísticas de IO (Input/Output), e solicitar que seja exibido na aba de Messages não somente a quantidade de linhas que foram retornadas, mas também quais tabelas foram acessadas e quantas leituras lógicas (Logical Reads) foram necessárias em cada tabela para conseguir atingir o resultado solicitado, devemos executar o código abaixo:

SET STATISTICS IO ON

Para executar a consulta que acabamos de criar, podemos chamar a View vw_ProdutoDescricao, fazendo um SELECT simples nela, como se fosse o de uma tabela.

SELECT * FROM vw_ProdutoDescricao

Repare que ao executar o SELECT na View, é apresentado o mesmo resultado da execução do SELECT nas tabelas que foram utilizadas em sua criação.

Pelo fato das estatísticas de IO estarem ativadas, o resultado é semelhante a este apresentado:

(295 row(s) affected)

Table "Worktable". Scan count 0, logical reads 0, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

Table "Product". Scan count 1, logical reads 15, physical reads 1, read-ahead reads 14, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

Table "ProductModel". Scan count 1, logical reads 2, physical reads 1, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

Neste exemplo são poucos dados que são armazenados na tabela de exemplo, mas já é possível visualizar que foram lidas 17 páginas de arquivos. Sendo 15 páginas da tabela Products e 2 páginas da tabela ProductModel.

O que é um Index?

O SQL Server é um banco de dados relacional, e em bancos de dados relacionais existe um recurso chamado Index (Indexação). O Index permite que o banco de dados acesse rapidamente linhas em uma tabela baseando-se nos valores de uma ou varias colunas. Para criar Index não se deve somente pensar em código T-SQL, Index é mais complicado do que isso. Criar um Index depende de estudo e análise das estruturas das tabelas para conseguir um resultado satisfatório. Caso você crie um Index em uma tabela que sofra muitas inserções de dados, o tempo para recalcular o Index pode ser mais demorado que se fosse executada uma consulta diretamente na tabela origem sem o Index.

Existem dois tips de Index, o Index Clustered e o Index Non-Clustered. O Index Clustered irá determinar a ordem física de armazenamento das linhas na tabela, diferente do Index Non-Clustered, que é um objeto dentro do banco de dados que aponta para uma linha dentro de uma tabela, mas não especifica como estas linhas devem estar armazenadas. Partindo do mesmo princípio da criação de Chaves Simples e Chaves Compostas em tabelas, os Index também podem ser simples ou composto. O Index simples é baseado em apenas uma coluna, enquanto o Index composto é baseado em duas ou mais colunas de uma tabela ou View.

A criação de um Index na View que criamos anteriormente será essencial para comprovar o que estou propondo no artigo. A melhora no desempenho.

CREATE UNIQUE CLUSTERED INDEX idx_ProdutoDescricao ON

vw_ProdutoDescricao(Codigo ASC)

Após a criação, o Index vai ficar armazenado na sessão de Index da View de exemplo. Para visualizar os Index criados em cada View, expanda as opções da View criada anteriormente e em seguida expanda as opções relacionadas aos indexes. Este procedimento pode ser realizado tanto para Views quanto para tabelas.

Repare que o Index com o nome que criamos está presente nesta sessão.

Como funcionam Views Indexadas.

A possibilidade de criação de Index em Views, foi desenvolvida para a versão 2000 do SQL Server e melhorada para a versão 2005. Ao indexar uma View, os dados são armazenados em uma tabela virtual e são atualizados sempre que os dados de suas tabelas originais são alterados. Em vários casos, este recurso pode melhorar o desempenho, visto que os dados não precisarão ser “recalculados” sempre que forem consultados. As Views indexadas são recomendadas, quando os dados das tabelas que são utilizadas nas Views não sofrerem muitas alterações. No caso de existirem muitas alterações nos dados das tabelas, o tempo de processamento para montar o Index da View pode ser maior que o tempo para fazer a consulta sem Index às tabelas.

Executando a mesma consulta que foi realizada à View no exemplo anterior, e mantendo as estatísticas de IO ativas, é possível comparar a quantidade de páginas que foram utilizadas para atingir o mesmo retorno. Repare que o SQL Server interpreta a View como sendo uma tabela do banco de dados, e faz leitura em 6 páginas para retornar os dados cadastrados.

(295 row(s) affected)

Table "vw_ProdutoDescricao". Scan count 1, logical reads 6, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

A velocidade de retorno de uma consulta é proporcional à quantidade de páginas que o SQL Server 2005 necessita ler para conseguir o resultado. Quanto mais páginas forem lidas para mostrar o resultado de uma consulta, mais tempo vai levar para esta consulta ser completada.

Toda vez que o SQL Server 2005 realiza uma consulta, ele gera um plano de execução. Este plano de execução é armazenado em memória por um determinado tempo, e se for realizada esta mesma consulta enquanto o plano ainda existir, o SQL Server 2005 vai realizar a consulta de forma mais rápida. Para provar o que estou escrevendo, execute a instrução SELECT que originou a View (não é a execução da View, é a execução do SELECT que está dentro dela), esta instrução fará consulta à tabela vw_ProdutoDescricao, e vai consultar somente 6 páginas.

SELECT P.ProductID Codigo, P.Name Descricao, M.Name Produto

FROM Production.Product P INNER JOIN

Production.ProductModel M

ON P.ProductModelID = M.ProductModelID

No resultado da consulta, na sessão de Messages é apresentada a prova disso.

(295 row(s) affected)

Table "vw_ProdutoDescricao". Scan count 1, logical reads 6, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

Neste artigo fico por aqui, apresentando a melhoria de performance ao utilizar Views indexadas. Espero que este artigo auxilie os desenvolvedores que necessitam melhorar o desempenho de consultas demoradas. Os dados apresentados são poucos, mas mesmo assim a melhora foi superior a 50%. Existem casos em que a melhora chega a ser de 90% ou mais.

fonte: http://www.linhadecodigo.com/ArtigoImpressao.aspx?id=1308

Oracle - Funções

2011-12-12T10:02:00.001-08:00

Funções de valores simples:

ABS(n)= Devolve o valor absoluto de (n).
CEIL(n)=Obtém o valor inteiro imediatamente superior ou igual a "n".
FLOOT(n) = Devolve o valor inteiro imediatamente inferior ou igual a "n".
MOD (m, n)= Devolve o resto resultante de dividir "m" entre "n".
NVL (valor, expressão)= Substitui um valor nulo por outro valor.
POWER (m, exponente)= Calcula a potência de um número.
ROUND (numero [, m])= Arredonda números com o número de dígitos de precisão indicados.
SIGN (valor)= Indica o signo do "valor".
SQRT(n)= Devolve a raiz quadrada de "n".
TRUNC (numero, [m])= Trunca números para que tenham uma certa quantidade de dígitos de precisão.
VAIRANCE (valor)= Devolve a média de um conjunto de valores.

Funções de grupos de valores:

AVG(n)= Calcula o valor médio de "n" ignorando os valores nulos.
COUNT (* | Expressão)= Conta o número de vezes que a expressão avalia algum dado com valor não nulo. A opção "*" conta todas as filas selecionadas.
MAX (expressão)= Calcula o máximo.
MIN (expressão)= Calcula o mínimo.
SUM (expressão)= Obtém a soma dos valores da expressão.
GREATEST (valor1, valor2…)= Obtém o maior valor da lista.
LEAST (valor1, valor2…)= Obtém o menor valor da lista.

Funções que devolvem valores de caracteres:

CHR(n) = Devolve o caractere cujo valor em binário é equivalente a "n".
CONCAT (cad1, cad2)= Devolve "cad1" concatenada com "cad2".
LOWER (cad)= Devolve a cadeia "cad" em minúsculas.
UPPER (cad)= Devolve a cadeia "cad" em maiúsculas.
INITCAP (cad)= Converte a cadeia "cad" a tipo título.
LPAD (cad1, n[,cad2])= Adiciona caracteres à esquerda da cadeia até que tenha uma certa longitude.
RPAD (cad1, n[,cad2])= Adiciona caracteres à direita até que tenha uma certa longitude.
LTRIM (cad [,set])= Suprime um conjunto de caracteres à esquerda da cadeia.
RTRIM (cad [,set])= Suprime um conjunto de caracteres à direita da cadeia.
REPLACE (cad, cadeia_busca [, cadeia_substitucao])= Substitui um caractere ou caracteres de uma cadeia com 0 ou mais caracteres.
SUBSTR (cad, m [,n])= Obtém parte de uma cadeia.
TRANSLATE (cad1, cad2, cad3)= Converte caracteres de uma cadeia em caracteres diferentes, segundo um plano de substituição marcado pelo usuário.

Funções que devolvem valores numéricos:

ASCII(cad)= Devolve o valor ASCII da primeira letra da cadeia "cad".
INSTR (cad1, cad2 [, comeco [,m]])= Permite uma busca de um conjunto de caracteres em uma cadeia, mas não suprime nenhum caractere depois.
LENGTH (cad)= Devolve o número de caracteres de cad.

Funções para o manejo de datas:

SYSDATE= Devolve a data do sistema.
ADD_MONTHS (data, n)= Devolve a data "data" incrementada em "n" meses.
LASTDAY (data)= Devolve a data do último dia do mês que contém "data".
MONTHS_BETWEEN (data1, data2)= Devolve a diferença em meses entre as datas "data1" e "data2".
NEXT_DAY (data, cad)= Devolve a data do primeiro dia da semana indicado por "cad" depois da data indicada por "data".

Funções de conversão:

TO_CHAR= Transforma um tipo DATE ou NUMBER em uma cadeia de caracteres.
TO_DATE= Transforma um tipo NUMBER ou CHAR em DATE.
TO_NUMBER= Transforma uma cadeia de caracteres em NUMBER.

fonte: http://www.criarweb.com/artigos/756.php

SQL Server - Trabalhando com data

2011-12-12T10:00:00.001-08:00

First Day of Month

select DATEADD(mm, DATEDIFF(mm,0,getdate()), 0)

First Day of Last Month

select DATEADD(mm, DATEDIFF(mm,0,DATEADD(mm,-1,getdate())), 0)

Monday of the Current Week

select DATEADD(wk, DATEDIFF(wk,0,getdate()), 0)

Sudday of the Current Week

set DATEFIRST 1

select DATEADD(dd, 1 - DATEPART(dw, getdate()), getdate())

First Day of the Year

select DATEADD(yy, DATEDIFF(yy,0,getdate()), 0)

First Day of the Quarter

select DATEADD(qq, DATEDIFF(qq,0,getdate()), 0)

Midnight for the Current Day

select DATEADD(dd, DATEDIFF(dd,0,getdate()), 0)

Last Day of Prior Month

select dateadd(ms,-3,DATEADD(mm, DATEDIFF(mm,0,getdate()  ), 0))

Last Day of Prior Year

select dateadd(ms,-3,DATEADD(yy, DATEDIFF(yy,0,getdate()  ), 0))

Last Day of Current Month

select dateadd(ms,-3,DATEADD(mm, DATEDIFF(m,0,getdate()  )+1, 0))

Last Day of Current Year

select dateadd(ms,-3,DATEADD(yy, DATEDIFF(yy,0,getdate()  )+1, 0))

First Monday of the Month

select DATEADD(wk, DATEDIFF(wk,0, dateadd(dd,6-datepart(day,getdate()),getdate()) ), 0)

DATEPART

Função
 usada para obter uma determinada parte de uma data como por exemplo o 
ano, mês, dia, hora, minuto, segundo, etc. Para utilizá-la pede-se dois 
parâmetros sendo o primeiro a parte da data e o segundo a data 
propriamente dita, repare que no exemplo abaixo usei no segundo 
parâmetro da função datepart a função getdate() usada para retornar a 
data atual do servidor.



DATEDIFF

Função
 usada para obter a diferença de anos, meses, dias, horas, minutos, 
segundos, dentre outros entre duas datas. Para utilizá-la pede-se três 
parâmetros sendo o primeiro a parte da data o segundo a data inicial e o
 terceiro a data final, repare que no exemplo abaixo usei no segundo 
parâmetro da função datepart a função getdate() usada para retornar a 
data atual do servidor.



DATEADD

Função
 usada para adicionar anos, meses, dias, horas, minutos, segundos, 
dentre outros a uma data. Para utilizá-la pede-se três parâmetros sendo o
 primeiro a parte da data o segundo o valor ao qual será adicionado e o 
terceiro a data propriamente dita, repare que no exemplo abaixo usei no 
segundo parâmetro da função datepart a função getdate() usada para 
retornar a data atual do servidor.



CONVERT

No
 contexto do artigo esta função é usada para converter um campo 
ou variável do tipo data para uma string baseado em uma norma ou padrão 
do SQL Server. Para utilizá-la pedem-se dois parâmetros sendo o primeiro
 o tipo ao qual o dado será convertido que no nosso caso é um varchar, o
 segundo parâmetro é a data na qual será convertida e o terceiro 
parâmetro é a norma ou padrão do SQL Server listado abaixo, repare que 
no exemplo abaixo usei no segundo parâmetro da função datepart a função 
getdate() usada para retornar a data atual do servidor.
Abaixo listei todas as normas/padrões do SQL Server a questão agora é usar a que se encaixa melhor para cada tipo de situação.

fontes:

http://shanecooper.net/cooldatefunctions.htm

http://www.devmedia.com.br/articles/viewcomp.asp?comp=14015

SQL Server - Data por Extenso – DateName

2011-12-12T09:59:00.001-08:00

Script para retornar uma data por extenso.

SET LANGUAGE Português

SELECT DATENAME(weekday, GetDate()) + ‘, ‘ +

DATENAME(day, GetDate()) + ‘ de ‘ +

DATENAME(month, GetDate()) + ‘ de ‘ +

DATENAME(year, GetDate())

Lembrar de utilizar o SET LANGUAGE para retornar a data no idioma desejado, para verificar o idioma padrão de sua sessão execute “DBCC UserOptions”

Para visualizar qual é o nome dos idiomas existentes no SQL verifique na coluna name da tabela sysLanguages.

select * from master.dbo.syslanguages

Obs.: Evite usar SET LANGUAGE dentro de procedures pois isso irá causar RECOMPILE.

fonte: http://blogfabiano.com/2008/04/24/data-por-extenso-datename/

Como resolver o erro ORA-01422

2011-12-12T09:57:00.000-08:00

O erro oracle, em código PL-SQL, ORA-01422: exact fetch returns more than request number of rows, é retornado quando em uma única váriavel é tentado retornar mais de um valor, para acertar isso há várias formas dependendo da sua necessidade, vamos a alguns casos: 1 – Query não deve retornar mais de um registro
Vamos a uma situação hipotética, temos uma tabela de pedidos e uma tabela de clientes e queremos pegar um número de pedido dele, para isso usamos a seguinte query:

select id_pedido

into vID_Pedido

from pedido p, cliente c

where c.nome = 'MEISON'

and c.id_cliente = p.id_cliente;

Se o cliente tiver feito somente um pedido, essa query retornará só uma linha, mas se ele já for um cliente que está pedindo pela segunda ou mais vez será retornado mais de uma linha o que retornará o erro em questão, pois tentará jogar para a variavel vID_Pedido mais de um valor, o que não é possível. Para corrigir se a regra permitir é só pegar uma linha, por exemplo o ultimo pedido, ficando dessa forma:

select id_pedido

into vID_Pedido

from pedido p, cliente c

where c.nome = 'MEISON'

and c.id_cliente = p.id_cliente

and rownum=1

order by id_pedido desc;

O rownum=1 restringe a só uma linha, mas lembrando que sem o order by, ele pega a primeira linha que trouxer do banco. O order by irá garantir que seja a ultima linha criada.
2 – Query pode retornar mais de um registro
Tendo como base o primeiro exemplo, porém precisando pegar todos os pedidos desse cliente, o que deve ser feito é tratar cada um deles individualmente, eu utilizaria o loop, ficando assim:

for vAux in (select id_pedido from pedido where id_cliente = 1)

loop

--Procedimento para tratar vAux.id_pedido

end loop;

Dessa forma não é dado o erro ORA-01422 e trata-se da maneira certa cada um dos pedidos.
3 – Query não deve retornar mais de uma linha, erro de cadastro
Isso é causado quando o sistema deveria inserir somente uma linha e por algum erro, inseriu mais de uma, provocando um erro conceitual. É claro que nesse caso deve-se corrigir a origem que é a inserção erronea de mais de uma linha, mas pode-se tratar também no destino, vamos utilizar a mesma query, ela deveria tratar os erros e ficaria dessa forma:

begin

select id_pedido

into vID_pedido

from pedido

where id_cliente = 1;

exception

when too_many_rows then

raise_application_error(-20000,'Erro na tabela pedido, mais linhas para o cliente do que permitido.');

end;

Dessa forma abordamos alguns cenários que podemos sanar esse problema. Caso você tenha algum outro problema, comente poderemos fazer outro artigo para solucionar seu problema.

fonte: http://www.meison.com.br/2010/02/19/como-resolver-o-erro-ora-01422/

COMANDOS DBCC DO SQL SERVER 2000

2011-12-12T09:49:00.000-08:00

O SQL SERVER 2000 possui um conjunto de comandos DBCC
(DATABASE CONSOLE COMMAND), usados na administração do
banco de dados.
De acordo com sua funcionalidades, são agrupados em 4 categorias:
MANUTENÇÃO - comandos que realizam tarefas de manutenção em:

databases
índices
grupos de arquivos

DBCC DBREINDEX
DBCC DBREPAIR --> MANTIDO POR COMPATIBILIDADE (DEVE-SE DROPAR E RECRIAR O DATABASE CORROMPIDO)
DBCC INDEXDEFRAG
DBCC SHRINKDATABASE
DBCC SHRINKFILE
DBCC UPDATEUSAGE
STATUS - comandos que checam o status de objetos do sistema:
DBCC INPUTBUFFER
DBCC OPENTRAN
DBCC OUTPUTBUFFER
DBCC PROCCACHE
DBCC SHOWCONTIG
DBCC SHOW_STATISTICS
DBCC SQLPERF
DBCC TRACESTATUS
DBCC USEROPTIONS
VALIDAÇÃO - comandos que validam a estrutura e/ou alocação de:

databases
tabelas
índices
catálogos
grupos de arquivos
tabelas de sistema
páginas do database

DBCC CHECKALLOC
DBCC CHECKCATALOG
DBCC CHECKCONSTRAINTS
DBCC CHECKDB
DBCC CHECKFILEGROUP
DBCC CHECKIDENT
DBCC CHECKTABLE
DBCC NEWALLOC
DIVERSOS - comandos que realizam tarefas não enquadrados nas categorias acima:
DBCC dllname (FREE)
DBCC HELP
DBCC PINTABLE
DBCC ROWLOCK
DBCC TRACEOFF
DBCC TRACEON
DBCC UNPINTABLE
******************************************************************
ABAIXO, APRESENTAREI OS COMANDOS, SEGUIDOS DE EXEMPLOS DE USO.
LEMBRO QUE NÃO ESTOU LHES MOSTRANDO A SINTAXE COMPLETA DO COMANDO, MAS AS SUAS FORMAS MAIS USADAS.
PARA MAIS DETALHES, CONSULTE OS BOOKS ON LINE DO SQL SERVER OU O SITE HTTP://MSDN.MICROSOFT.COM/SQL
******************************************************************
Listagem 01 - Exemplos dos comandos
USE PUBS
--TODOS OS EXEMPLOS ABAIXO SERÃO EXECUTADOS NESSE DATABASE

/*
DBCC DBREINDEX(NOME DA TABELA) WITH NO_INFOMSGS

RECRIA TODOS OS ÍNDICES DA TABELA PASSADA COMO PARÂMETRO
ONDE:
  NOME DA TABELA:
   É O NOME DA TABELA A REINDEXAR
  WITH NO_INFOMSGS:
   INDICA QUE NÃO DEVEM SER APRESENTADAS AS MENSAGENS
*/
DBCC DBREINDEX(AUTHORS)
--DBCC execution completed. If DBCC printed error messages, contact your system administrator.
DBCC DBREINDEX(AUTHORS) WITH NO_INFOMSGS
--The command(s) completed successfully.
EXEC SP_MSFOREACHTABLE
@COMMAND1 = PRINT REINDEXANDO A TABELA ?,
@COMMAND2 = DBCC DBREINDEX(?) WITH NO_INFOMSGS
/*
REINDEXANDO A TABELA [dbo].[titleauthor]
REINDEXANDO A TABELA [dbo].[stores]
REINDEXANDO A TABELA [dbo].[sales]
REINDEXANDO A TABELA [dbo].[roysched]
REINDEXANDO A TABELA [dbo].[discounts]
REINDEXANDO A TABELA [dbo].[jobs]
REINDEXANDO A TABELA [dbo].[pub_info]
REINDEXANDO A TABELA [dbo].[employee]
REINDEXANDO A TABELA [dbo].[authors]
REINDEXANDO A TABELA [dbo].[publishers]
REINDEXANDO A TABELA [dbo].[titles]
*/

/*
DBCC INDEXDEFRAG(DATABASE, TABELA, ÍNDICE) WITH NO_INFOMSGS
REORGANIZA O ÍNDICE DA TABELA PASSADA COMO PARÂMETRO
ONDE:
  DATABASE:
   É O NOME DO DATABASE QUE CONTÉM A TABELA
  TABELA:
   É O NOME DA TABELA QUE CONTÉM O ÍNDICE
  ÍNDICE:
   É O NÚMERO QUE INDICA A ORDEM DO ÍNDICE
  WITH NO_INFOMSGS:
   INDICA QUE NÃO DEVEM SER APRESENTADAS AS MENSAGENS
*/
DBCC INDEXDEFRAG(PUBS, EMPLOYEE, 1)
/*
Pages Scanned Pages Moved Pages Removed
------------- ----------- -------------
0             0           0
DBCC execution completed. If DBCC printed error messages, contact your system administrator.
*/
DBCC INDEXDEFRAG(PUBS, EMPLOYEE, 1) WITH NO_INFOMSGS
--The command(s) completed successfully.

/*
DBCC SHRINKDATABASE(DATABASE, ESPAÇO_LIVRE) WITH NO_INFOMSGS
DESALOCA ESPAÇOS NÃO OCUPADOS PELO DATABASE
ONDE:
  DATABASE:
   É O NOME DO DATABASE
  ESPAÇO_LIVRE:
   É O ESPAÇO LIVRE EM % QUE DEVERÁ ESTAR ALOCADO
   NO FIM DO PROCESSO
*/
DBCC SHRINKDATABASE(PUBS, 0)
/*
DbId   FileId CurrentSize MinimumSize UsedPages   EstimatedPages
------ ------ ----------- ----------- ----------- --------------
5      1      160         80          152         152
5      2      63          63          56          56
DBCC execution completed. If DBCC printed error messages, contact your system administrator.
*/
DBCC SHRINKDATABASE(PUBS, 0) WITH NO_INFOMSGS
--The command(s) completed successfully.
EXEC SP_MSFOREACHDB
@COMMAND1 = PRINT FAZENDO SHRINK DO DATABASE ?,
@COMMAND2 = DBCC SHRINKDATABASE(?, 0) WITH NO_INFOMSGS
/*
FAZENDO SHRINK DO DATABASE CAP_03
FAZENDO SHRINK DO DATABASE CAP_04
FAZENDO SHRINK DO DATABASE CAP_05
FAZENDO SHRINK DO DATABASE CAP_06
FAZENDO SHRINK DO DATABASE CAP_07
FAZENDO SHRINK DO DATABASE CAP_08_09
FAZENDO SHRINK DO DATABASE correio
FAZENDO SHRINK DO DATABASE DB_CDS
FAZENDO SHRINK DO DATABASE DVD
FAZENDO SHRINK DO DATABASE FILMES
FAZENDO SHRINK DO DATABASE IMPACTA
FAZENDO SHRINK DO DATABASE master
FAZENDO SHRINK DO DATABASE model
FAZENDO SHRINK DO DATABASE msdb
FAZENDO SHRINK DO DATABASE Northwind
FAZENDO SHRINK DO DATABASE pubs
FAZENDO SHRINK DO DATABASE tempdb
*/

/*
DBCC SHRINKFILE(NOME_LÓGICO, ESPAÇO_LIVRE) WITH NO_INFOMSGS
DESALOCA ESPAÇOS NÃO OCUPADOS POR UM ARQUIVO DE DADOS OU LOG
ONDE:
  NOME_LÓGICO:
   É O NOME LÓGICO DO ARQUIVO
  ESPAÇO_LIVRE:
   É O ESPAÇO LIVRE EM % QUE DEVERÁ ESTAR ALOCADO
   NO FIM DO PROCESSO
*/
EXEC SP_HELPDB PUBS
/*MÚLTIPLAS LINHAS COM INFORMAÇÕES SOBRE O DATABASE PUBS
*/
DBCC SHRINKFILE(PUBS, 0)
/*
DbId   FileId CurrentSize MinimumSize UsedPages   EstimatedPages
------ ------ ----------- ----------- ----------- --------------
5      1      160         80          152         152
DBCC execution completed. If DBCC printed error messages, contact your system administrator.
*/

/*
DBCC UPDATEUSAGE(DATABASE, TABELA, ÍNDICE) WITH COUNT_ROWS, NO_INFOMSGS
APRESENTA E CORRIGE OS VALORES ARMAZENADOS INCORRETAMENTE NA TABELA
SYSINDEXES, QUE FAZEM COM QUE A SAÍDA DA PROCEDURE SP_SPACEUSED SEJA FALSA
ONDE:
  DATABASE:
   É O NOME DO DATABASE QUE CONTÉM A TABELA - SE FOR
   DIGITADO O VALOR 0 (ZERO), O DATABASE USADO SERÁ O
   QUE ESTÁ EM USO
  TABELA:
   É O NOME DA TABELA QUE CONTÉM O ÍNDICE - OPCIONAL
  ÍNDICE:
   É O NÚMERO QUE INDICA A ORDEM DO ÍNDICE - OPCIONAL
  WITH NO_INFOMSGS:
   INDICA QUE NÃO DEVEM SER APRESENTADAS AS MENSAGENS
  WITH COUNT_ROWS:
   ATUALIZA A COLUNA "ROWS" DA TABELA SYSINDEXES COM A
   QUANTIDADE DE LINHAS DA TABELA QUE ESTÁ SENDO ANALISADA,
   PARA OS ÍNDICES DE ID 0 E 1
*/
EXEC SP_SPACEUSED EMPLOYEE
/*
name       rows reserved data   index_size unused
---------- ----- --------- ------ ----------- -------
employee   43    152 KB    64 KB 32 KB       56 KB
*/
DBCC UPDATEUSAGE (PUBS, EMPLOYEE) WITH COUNT_ROWS
/*
DBCC UPDATEUSAGE: sysindexes row updated for table employee (index ID 1):
        DATA pages: Changed from (8) to (1) pages.
        USED pages: Changed from (12) to (5) pages.
        RSVD pages: Changed from (19) to (5) pages.
DBCC execution completed. If DBCC printed error messages, contact your system administrator.
*/
EXEC SP_SPACEUSED EMPLOYEE
/*
name      rows reserved data index_size unused
--------- ----- --------- ----- ----------- -------
employee 43    40 KB     8 KB 32 KB       0 KB
*/

/*
DBCC INPUTBUFFER(PROCESSO)
RETORNA O ÚLTIMO COMANDO ENVIADO PELO CLIENTE AO SQL SERVER
ONDE:
  PROCESSO:
   ID DO PROCESSO
*/
SELECT @@SPID
--51
DBCC INPUTBUFFER(51)
/*
EventType      Parameters EventInfo
-------------- ---------- ----------------------
Language Event 0          DBCC INPUTBUFFER(51)
DBCC execution completed. If DBCC printed error messages, contact your system administrator.
*/
--AGORA, ABRA UMA NOVA JANELA (CTRL+N) E EXECUTE O COMANDO ABAIXO:
SELECT @@SPID
--52
SELECT * FROM SYSOBJECTS
--DIVERSAS LINHAS DE TABELA
--VOLTE A ESSA JANELA, SEM FECHAR A OUTRA (CTRL+TAB) E EXECUTE O COMANDO ABAIXO:
DBCC INPUTBUFFER(52)
/*
EventType      Parameters EventInfo
-------------- ---------- --------------------------
Language Event 0          SELECT * FROM SYSOBJECTS
DBCC execution completed. If DBCC printed error messages, contact your system administrator.
*/

/*
DBCC OPENTRAN(DATABASE) WITH TABLERESULTS
RETORNA DETALHES DAS TRANSAÇÕES ABERTAS
ONDE:
  DATABASE:
   É O NOME DO DATABASE - SE FOR DIGITADO O VALOR 0
   (ZERO), O DATABASE USADO SERÁ O QUE ESTÁ EM USO
  WITH TABLERESULTS:
   RETORNA EM FORMATO DE TABELA
*/
--ABRA UMA NOVA JANELA (CTRL+N) E EXECUTE OS COMANDOS ABAIXO:
BEGIN TRAN
SELECT *
FROM TITLES A,
TITLES B,
TITLES C,
TITLES D,
TITLES E,
TITLES F
--ESSE SELECT RETORNA 34,012,224 REGISTROS
--(A TABELA TITLES TEM 18 REGISTROS)
--AGORA, ANTES DE O COMANDO TERMINAR, (PAREI A EXECUÇÃO AOS 10 MINUTOS E AINDA TINHA GERADO APENAS 12,500,000 REGISTROS)VOLTE PARA ESSA JANELA (CTRL+TAB) E EXECUTE O COMANDO ABAIXO:
DBCC OPENTRAN(0)
/*
Transaction information for database pubs.
Oldest active transaction:
    SPID (server process ID) : 55
    UID (user ID) : 1
    Name          : user_transaction
    LSN           : (4:365:1)
    Start time    : Jul 30 2006 4:35:14:633PM
*/
DBCC OPENTRAN(0) WITH TABLERESULTS
/*
pubs              OPENTRAN
----------------- ---------------------------
OLDACT_SPID       55
OLDACT_UID        1
OLDACT_NAME       user_transaction
OLDACT_LSN        (4:365:1)
OLDACT_STARTTIME Jul 30 2006 4:35:14:633PM
*/
--FINALMENTE, CANCELE A EXECUÇÃO DO SELECT NA OUTRA JANELA

/*
DBCC OUTPUTBUFFER(PROCESSO)
RETORNA EM HEXA E ASCII A RESPOSTA DO SERVIDOR À SOLICITAÇÃO
DO CLIENTE
ONDE:
  PROCESSO:
   ID DO PROCESSO
*/
--ABRA UMA NOVA JANELA (CTRL+N) E EXECUTE OS COMANDOS ABAIXO:
SELECT @@SPID
--53
SELECT GETDATE()
--2006-07-30 17:01:36.800
--AGORA, VOLTE PARA ESSA JANELA (CTRL+TAB) E EXECUTE O COMANDO ABAIXO:
DBCC OUTPUTBUFFER(53)
/*
Output Buffer
---------------------------------------------------------
00000000   04 01 00 ... 00 00 00 00 a7   ...+.5.........§
00000010   07 00 09 ... 41 47 4e 41 4c   .. .Ð.4.Ñ..AGNAL
00000020   44 4f fd ... 00 fd 01 00 ba   DOý..Á......ý..º
... saída dos endereços -> 00000020 A 00000fc0
00000fd0   00 70 17 ... 1a 8a 01 00 00   .p..@...€s..Š...
00000fe0   ff ff ff ... 00 00 00 00 00   ÿÿÿÿ¹...........
00000ff0   00 00 00 ... 00 00 00 01 00   ................
*/

fonte: http://www.devmedia.com.br/articles/viewcomp.asp?comp=2481

Exemplo - Oracle - Coluna Acumulado

2011-12-12T09:46:00.000-08:00

SQL> SELECT 
  2    B.SAL
  3  , SUM(A.SAL) ACUMULADO
  4  FROM 
  5    EMP A
  6  , EMP B
  7  WHERE A.ROWID <= B.ROWID
  8  GROUP BY B.ROWID, B.SAL
  9  /

       SAL  ACUMULADO
---------- ----------
       800        800
      1600       2400
      1250       3650
      2975       6625
      1250       7875
      2850      10725
      2450      13175
      3000      16175
      5000      21175
      1500      22675
      1100      23775
       950      24725
      3000      27725
      1300      29025
                29025

15 rows selected.

SQL>

fonte: http://glufke.net/oracle/viewtopic.php?t=530

Removendo senhas de rede salvas

2011-12-12T09:08:00.001-08:00

Aplicação: Windows XP, Vista, Seven e 2003 Sever.
Quando você acessa um compartilhamento remoto (\\server\arquivos) e é salvo uma senha para esse acesso pode-se remover esse senhas e outras com o script abaixo.
Ir em Iniciar> Executar digite cmd para abrir o ms-dos.

Digitar no ms-dos rundll32.exe keymgr.dll, KRShowKeyMgr tudo de uma vez inclusive a vírgula.

Irá abrir essa janela onde você pode remover senhas salvar de compartilhamentos, msn, conexão remotas e outras.

Nota: Senhas salvas de sites não são removidas com esse procedimento, apenas senhas de rede e Windows Messenger.

Fonte: http://hrapytor.webnode.com.br/news/removendo-senhas-salvas-/

Excel – Protegendo planilhas de maneira eficiente

2011-12-07T10:16:00.001-08:00

Introdução

O Microsoft Excel permite diversas formas de proteção de dados, incluindo ocultar planilhas e fórmulas a fim de proteger a inteligência, a lógica, da sua planilha.
É importante proteger, conservar a inteligência/lógica de nossas fórmulas, seja por proteção da propriedade intelectual ou por qualquer outro motivo. Alguns recursos são bastante conhecidos. Citarei aqui todas as formas que conheço e que creio serem suficientes para proteger nossas planilhas.

Ocultando planilhas

O método mais básico de proteger planilhas é ocultando-as através do comando: Formatar -> Planilha -> Ocultar, conforme indicado na figura a seguir:

O Excel ocultará a planilha que estiver ativa naquele momento, conforme indicado na figura a seguir:

Esta é uma maneira simples de ocultar as planilhas. Para voltar a exibira as planilhas ocultas, basta usar o comando: Formatar -> Planilha -> Reexibir, conforme indicado na figura a seguir:

Ao executar o comando Formatar -> Planilha -> Reexibir , será aberta a janela Reexibir, na qual são listadas as planilhas ocultas, conforme indicado na figura a seguir. Na listagem estão todas as planilhas ocultas, as quais poderão ser reexibidas.

Por exemplo, para reexibir a planilha Plan1, basta clicar na planilha, para seleciona-la e clicar em OK. Com isso a planilha “Plan1” voltará a ser exibida.
Protegendo e ocultando células
Podemos contornar este problema protegendo a planilha pelo modo clássico. Acionando o comando: Ferramentas -> Proteger -> Proteger planilha, teremos acesso a diferente níveis de proteção à planilha conforme mostra as duas figuras a seguir:

Dentre as opções disponíveis, as mais interessantes são:
Selecionar células bloqueadas à Desmarcando esta opção, o usuário só poderá navegar nas células que tiverem nas suas propriedades, a opção Travada desmarcada (Veja esta opção em Formatar -> Células, guia Proteção).
Selecionar células desbloqueadas à Desmarcando esta opção, o usuário não conseguirá navegar pela planilha.
Todas as outras opções trabalham nesse mesmo padrão. Deixando a caixa de seleção desmarcada, a opção corrente não será liberada ao usuário. Dessa forma você pode conduzir o usuário na utilização da planilha. Outro recurso interessante, é que marcando a opção Oculta na caixa de formatação de células, seu conteúdo (fórmulas) não serão visíveis para o usuário, mesmo que este possa navegar pela célula, conforme ilustrado pela seqüência de figuras a seguir:

Protegendo a planilha conforme citado anteriormente, o conteúdo da fórmula não estará visível na barra de fórmulas:

Outra opção bastante utilizada, porém sem muita proteção é a de ocultar as guias de planilhas no menu Ferramentas -> Opções, guia Exibir, desmarcando a opção Guias de planilha, conforme destacado na figura a seguir:

Dessa forma, planilhas exibidas ou ocultas não estarão visíveis conforme segue:

Até aí tudo bem. Mas não precisamos ser muito veteranos no Excel a ponto de saber alguns atalhos básico como Ctrl+C para copiar, Ctrl+V para colar ou até mesmo Ctrl+1 para abrir a caixa de formatação de células. Por isso, sabemos que existe um atalho também para navegação de planilhas, que é o Ctrl+PageDown para ir para a planilha à direita da planilha atual e Ctrl+PageUp para a esquerda. Ocultar as guias de planilha não impede o usuário de navegar pelas planilhas. Faça o teste e comprove. Abra uma nova pasta, oculta as guias de planilha e tente navegar com os atalhos citados acima.
Algumas combinações desses recursos podem resultar em resultados mais eficientes, porém, existe uma maneira de fazê-lo de forma simples e segura (ou quase).
Ocultando definitivamente as planilhas
As planilhas tem 3 modos de exibição, dois muito conhecidos e 1 mais restrito a usuários avançados, mas que detalharei de forma que possa ser acessível a qualquer nível de usuário.

Visível
Oculta
Muito oculta <- é neste que devemos dar atenção.

Nota: A tradução do recurso (Muito oculta) é por minha conta e risco.
Para acessar este último nível de visibilidade da planilha, teremos que ir ao Editor do Visual Basic disponível no Excel.
Atenção! Dependendo do processo de instalação do Office, o Visual Basic pode não estar disponível em seu Microsoft Excel.
Para acessar o Editor do Visual Basic, vá em Ferramentas, Macro, Editor do Visual Basic, ou simplesmente no Excel, tecle Alt+F11. A janela a seguir será exibida:

Nota: Caso não consiga ver os painéis visíveis à esquerda da tela, acione-os no menu Exibir, Project Explorer (VBA Project) e Janela de propriedades. No Project Explorer, podemos ver todos os objetos de nossa pasta de trabalho hierarquizados. O primeiro é a própria pasta de trabalho, seguida de todas as planilhas identificadas pelo seu respectivo nome.
Selecionando uma das planilhas, suas propriedades serão exibidas na janela de propriedades conforme indicado na figura a seguir:
Obs : as janelas foram re-dispostas na tela para facilitar a visualização.
Detalhar todas as propriedades das planilhas é assunto para outro tutorial. Neste caso, nos atentaremos para a propriedade Visible:

Vou detalhar as opções disponíveis:

Visível	->	-1 – xlSheetVisible
Oculta	->	0 – xlSheetHidden
Muito oculta	->	2 – xlSheetVeryHidden

As duas primeiras já são conhecidas e podem ser acessadas pelo Excel como mostrado anteriormente. A propriedade Visible setada para “-1 – xlSheetVisible” é a planilha visível normalmente.
Setada para “0 – xlSheetHidden” , deixa planilha oculta, mas podendo ser exibida através do menu Formatar, planilha, Reexibir.
Já a última opção, coloca a planilha em modo oculto, de forma que nem mesmo através da opção Reexibir , poderá ser acessada! Faça o teste. Coloque a planilha Plan1 com a propriedade Visible setada para “2 – xlSheetVeryHidden”:

Retorne ao Excel, bastando fechar o Visual Basic ou clicando no botão Exibir Microsoft Excel:

Você verá que a planilha Plan1 está oculta como esperávamos. Agora tente ir ao menu Formatar -> Planilha, a opção Reexibir estará desabilitada (conforme indicado na próxima figura). Mesmo que você oculte manualmente a planilha Plan2 ou Plan3 e acionar o menu Reexibir, a planilha Plan1 não aparecerá! Porém, ela continua existindo e pode conter valores referenciados por fórmulas nas outras planilhas. Faça o teste e comprove.

Você pode estar se perguntando: Mas o que eu faço, alguém pode desfazer? A resposta é sim. Mas o nosso trabalho é dificultar ao máximo o trabalho de quem quer fazê-lo, já que não existe sistema 100% seguro, nem mesmo nos poderosos e sofisticados laboratórios na NASA.
A solução é proteger seu projeto VBA. Na mesma tela em que você alterou as configurações da planilha, vá até o Project Explorer e clique com o botão direito no título do Projeto e seleciona Propriedade do VBA Project:

Nesta tela, selecione a opção bloquear projeto para exibição e coloque uma senha para proteção do projeto. Salve e fecha a planilha. Abra-a novamente e vá ao Editor do Visual Basic (Alt+F11). Você verá que o Project Explorer será exibido da seguinte forma:

Se alguém tentar expandir o nó do projeto, verá a seguinte mensagem:

Pronto! Sua planilha está protegida! (desde que você não tenha definido uma senha que seja facilmente descoberta por programas de quebra de senhas. Uma boa senha deve ter letras, números e caracteres especiais. Se tiver somente letras e números, os programas de quebra de senha, como o Passware Kit, irão descobrir a senha em menos de um minuto).
É claro que esta não é uma proteção infalível, até mesmo porque nós mesmos temos o péssimo costume de não anotar senhas e acabamos virando nossa defesa contra nós mesmos. Programas para quebrar senhas como o Advanced Office 2000 Password Recovery podem recuperar a senha de projetos VBA ou sobreescrevê-las para que possam ser acessados.
Meu conselho para este tipo de ferramenta é você adotar uma metodologia segura de definição de senhas, por exemplo, não colocar informações pessoais, não colocar senhas do tipo “1234”. Sempre procure colocar senhas que não se relacionem em nada com você e que contenham letras e números intercalados e, o mais importante, sempre tenha senhas com mais de 6 ou 7 dígitos.
Creio que seguindo estas metodologias, é possível ter um nível de segurança razoável em nossos trabalhos com o Microsoft Excel.

Fonte: http://www.tomasvasquez.com.br/blog/microsoft-office/excel-protegendo-planilhas-de-maneira-eficiente

O usuário root

2011-12-05T07:50:00.001-08:00

Introdução
O Linux (na verdade, qualquer sistema operacional baseado em Unix) possui um tipo de usuário que tem acesso irrestrito aos arquivos e processos do sistema: trata-se do usuário root ou super usuário. Este artigo, voltado a iniciantes, mostrará qual a utilidade dessa conta e os cuidados que a cercam. Para isso, são abordados os seguintes assuntos: processos e arquivos, UID e GID, e comandos su e sudo.
Processos e arquivos
Para uma melhor compreensão sobre o usuário root, é necessário entender que cada arquivo e cada processo (programa em execução) do sistema tem um dono, ou seja, um proprietário que determina quem pode e como usar o arquivo/processo em questão. Obviamente, o proprietário tem acesso irrestrito aos seus "pertences", exceto quando ele mesmo bloqueia um arquivo/processo contra si (sim, isso é possível).
Se você é usuário de um sistema Linux, pode impedir os demais usuários de utilizar seus arquivos. Da mesma forma, há arquivos que podem ser bloqueados a você.
No caso de arquivos e processos ligados ao funcionamento do sistema, seu proprietário natural é o usuário root. Isso significa que só ele (e outros usuários que sejam definidos como "super usuários") é que pode alterá-los. O root também pode atuar sobre qualquer arquivo ou processo de outros usuários já que, no sistema, "ele é um deus".
Uma das formas de saber a quem pertence um determinado arquivo é digitando o seguinte comando em um terminal do sistema:
ls -l arquivo
Exemplo:
ls -l /iw/infowester.txt
Resultado: -rwx--- 1 wester eng 1880 Feb 3 12:01 /iw/infowester.txt
O resultado informa que o arquivo em questão pertence ao usuário wester e ao grupo eng.
Um arquivo ou um processo sempre tem um dono, mas é possível fazer com que um ou mais grupos de usuários tenha os mesmos privilégios sobre ele. Assim, no exemplo anterior, o usuário wester pode dar acesso irrestrito ao grupo eng para o arquivo infowester.txt.
UID e GID
O Linux gerencia os usuários e os grupos através de números conhecidos como UID (User ID) e GID (Group ID). Como é possível perceber, UID são números de usuários e GID são números de grupos. Os nomes dos usuários e dos grupos servem apenas para facilitar o uso humano do computador.
Um fato ainda não citado, é que cada usuário precisa pertencer a um ou mais grupos. Como cada arquivo ou processo pertence a um usuário, logo, esse arquivo/processo pertence ao grupo de seu proprietário. Assim sendo, cada arquivo/processo está associado a um UID e a um GID.
Os números UID e GID variam de 0 a 65536. Dependendo do sistema, o valor limite pode ser maior. No caso do usuário root, esses valores são sempre 0 (zero). Assim, para fazer com que um usuário tenha os mesmos privilégios que o root, é necessário que seu GID seja 0. Isso informa ao sistema que o usuário em questão é super usuário.
Observação: na verdade, existe um UID real e um UID efetivo. O mesmo ocorre com o GID. Os números reais geralmente são iguais aos efetivos. Os UIDs e GIDs reais são usados, basicamente, para fins de contabilidade, enquanto que os efetivos são os usados para execução.
O usuário root
Como não poderia deixar de ser, o Linux "vê" o usuário root como algo especial, já que ele (na verdade, qualquer usuário que tenha UID igual a 0) pode alterar a configuração do sistema, configurar interfaces de rede, manipular usuários e grupos, alterar a prioridades de processos, entre outros.
Por ser tão poderoso, o usuário root é perigoso. Por isso, ele só deve ser usado em situações que não podem ser trabalhadas por usuários que não possuem privilégios de super usuário. Imagine, por exemplo, que você está trabalhando com o usuário root. Ao atender uma solicitação de emergência, você saiu da frente do computador sem bloqueá-lo. Alguém mal-intencionado percebe isso e vai até seu computador, apaga diretórios importantes ao sistema e "sai de mansinho". Se você estivesse utilizando um usuário comum, isto é, um usuário sem permissões para mexer nesses diretórios, aquele sujeito não teria conseguido apagá-los. Ainda há a possibilidade de você cometer algum erro e pôr tudo a perder...
O usuário root é tão importante que até sua senha deve ser bem elaborada. É recomendável que ela tenha ao menos 8 caracteres e que misture letras e números. Além disso, é recomendável mudar essa senha a determinados intervalos de tempo (como a cada 3 meses) ou quando alguém que acessava a conta root não utilizará mais o computador (quando a pessoa sai da empresa, por exemplo).
Comando su
Você pode estar usando o sistema através de seu usuário, quando percebe que terá que fazer uma alteração de configuração permitida apenas ao root. Uma maneira rápida e segura de fazer isso é pelo comando su (substitute user).
Digite su no terminal e o sistema pedirá que você informe a senha root. Em seguida, você poderá fazer a modificação necessária. Ao concluir, basta digitar exit ou fechar o terminal e os privilégios de root estarão desabilitados novamente.
Observação: também é possível usar o comando su para acessar outra conta. Para isso, digite:
su usuário
Por exemplo:
su wester
Esse recurso é útil quando, por exemplo, é necessário testar uma configuração feita para um usuário ou para um grupo.
Ao fazer uso do su, seu usuário passa a ter poderes de usuário root naquele momento. No entanto, suas configurações de usuário são mantidas, ou seja, as configurações definidas para o usuário root não são carregadas. Para fazer que com o usuário atual adquira toda a configuração do usuário root, deve-se digitar o comando su seguido de -:
su -
Comando sudo
O comando sudo é um recurso mais poderoso que o su. Isso porque, nele, é possível definir quem pode utilizá-lo e quais comandos podem ser executados por esses usuários. Alem disso, o sudo pode ser configurado para exigir a senha novamente quando o usuário deixa de utilizar o sistema por um determinado tempo, por exemplo, por 10 minutos. A configuração do sudo geralmente é feita através do arquivo /etc/sudoers.
O uso do sudo é interessante porque o usuário não precisa saber a senha do root, apenas terá que ter permissão para usar determinados comandos pelo sudo. Além disso, o sudo permite registrar em um arquivo de log todas as atividades efetuadas, algo que é bem limitado no su.
Para mais informações sobre o sudo, visite o site www.courtesan.com.

Finalizando
O controle sobre o que os usuários podem ou não fazer é uma das características que tornam sistemas baseados em Unix mais seguros. Como foi possível notar, o usuário root (super usuário ou ainda, administrador) é o único que pode ter acesso ilimitado aos recursos do sistema. Como tal, seu uso deve ser feito apenas em situações que o exigem. Para tarefas cotidianas, deve-se utilizar um usuário comum. Para minimizar o uso do usuário root, pode-se utilizar os comandos su e sudo.

Fonte: http://www.infowester.com/linroot.php

EXCEL - Cont.Se com dois critérios

2011-11-29T10:58:00.001-08:00

Para quem precisa usar dois critérios dentro da formula CONT.SE , segue uma solução sem a utlização de Matricial:

=SOMARPRODUTO((A1:A10=Criterio1)*(B1:B10=Criterio2))

Criando e gerenciando usuários no GNU/Linux

2011-11-29T09:30:00.001-08:00

Introdução

Uma das coisas que torna seguro o sistema operacional GNU/Linux (na verdade, qualquer sistema baseado no Unix), é a sua exigência de que cada coisa tenha dono e permissões de uso. Assim, para que seja possível restringir ou permitir o acesso e o uso de determinados recursos a uma ou mais pessoas, é necessário que cada uma tenha um usuário devidamente criado no sistema operacional. Mas, como criar usuários no Linux? Como alterar as características desses usuários? Como bloquear ou mesmo eliminar um usuário do sistema? É isso que você verá nas próximas linhas.

Por que criar usuários no GNU/Linux?

Criar uma conta para cada usuário no sistema operacional não serve apenas para restringir ou permitir o acesso aos recursos oferecidos, mas também para respeitar o espaço que cada pessoa tem. Com uma conta, uma pessoa poderá ter os seus próprios diretórios, personalizar o seu desktop, ter atalhos e configurações para os seus programas preferidos, entre outros. Além disso, mesmo que o computador onde o GNU/Linux está instalado seja usado apenas por uma pessoa, é recomendável criar um usuário próprio para ela. Mas, por qual motivo, se o sistema já conta com um usuário nativo, o root? O usuário root é o que "manda" no sistema, pois ele tem poderes de administrador, o que significa que ele tem acesso a todos os recursos do sistema operacional. Usá-lo no dia-a-dia não é recomendável, pois se o computador for tomado por outra pessoa ou se o próprio usuário fizer alguma coisa errada, o sistema operacional poderá ser seriamente comprometido.
Respondendo a pergunta desse tópico com base nisso, a resposta é muito simples: deve-se criar usuários no GNU/Linux meramente para permitir a sua utilização por cada pessoa.

Entendendo o controle de usuários no GNU/Linux

Para criar, gerenciar ou eliminar contas de usuários no GNU/Linux, é necessário estar "logado" no sistema operacional com o usuário root (ou outro usuário que tenha privilégios de administrador). Os motivos para isso são óbvios: somente usuários autorizados é que podem manipular outras contas, do contrário, a segurança do sistema seria seriamente comprometida, pois qualquer usuário poderia criar, alterar ou apagar contas. Note que, dependendo das configurações do seu sistema, pode ser necessário executar cada instrução antecedida do comando 'sudo', como acontece por padrão com a distribuição Ubuntu.
Antes de criar e controlar contas no GNU/Linux, é conveniente entender como o sistema operacional lida com isso. Em geral, cada conta criada fica armazenada em um arquivo de nome passwd localizado dentro do diretório /etc/ (ou seja, seu caminho completo é /etc/passwd). Esse arquivo contém várias informações sobre cada usuário:
- o seu nome de login (ou seja, o nome que é necessário digitar para entrar no sistema);
- senha (neste caso, a informação da senha pode estar criptografada ou em outro arquivo);
- UID (User IDentification), ou seja, número de identificação do usuário;
- GID (Group IDentification), isto é, número de identificação do grupo do usuário;
- informações adicionais sobre o usuário (nome completo, dados de contato, etc);
- diretório "home", ou seja, o diretório principal de cada usuário;
- shell do usuário, uma espécie de programa que interpretará os comandos que o usuário digitar.
Para que você possa entender melhor cada um desses itens, vamos analisá-los usando como base a linha abaixo extraída de um arquivo /etc/passwd, que mostra a posição que cada uma das informações acima ocupa:
tintin:x:1001:500:TinTin,Belgica,846-846:/home/tintin:/bin/bash
Note que cada parâmetro do usuário é separado por : (dois pontos). Vamos estudar cada um:
tintin: é neste ponto que fica localizado o nome de login do usuário, neste caso, tintin. Esse nome não pode ser igual a outro já existente no sistema e, geralmente é limitado a 32 caracteres. Todavia, dependendo da configuração aplicada, o nome pode ser "case sensitive", ou seja, diferencia letras maiúsculas de minúsculas. Assim, 'wester' será diferente de 'wEster', por exemplo;
x: essa posição indica a senha do usuário. A letra x informa que a senha está armazenada e protegida dentro do arquivo /etc/shadow. Se houver um asterisco (*) no lugar, significa que a conta está desativada. Todavia, se não houver nada, significa que não há senha para esse usuário. Em alguns casos, embora isso não seja recomendável, a senha pode estar inserida diretamente ali, mas criptografada;
1001: esse campo indica o número UID (User IDentification) do usuário, mas você pode estar se perguntando o que é isso. Como o próprio nome informa, é número que serve para identificar o usuário. Em geral, o sistema pode suportar UIDs que vão de 0 a 4.294.967.296, embora alguns sistemas limitem esse número a valores inferiores. Normalmente, o UID 0 é atribuído pelo próprio GNU/Linux ao usuário root. O sistema também pode criar automaticamente usuários para a execução de determinadas rotinas e atribuir a eles UIDs baixos, como 1, 2, 3 e assim por diante. Note que, em nosso exemplo, o UID do usuário é 1001. Para usuários "humanos" do sistema, realmente é uma boa prática criar UIDs mais altas, para fins de organização;
500: esse é o campo que indica o GID (Group IDentification) do usuário, isto é, o número de identificação do grupo do qual ele faz parte. Assim como no UID, geralmente o usuário 0 é indicado para o grupo do usuário root. Note, no entanto, que um mesmo usuário pode fazer parte de mais de um grupo (geralmente, o GNU/Linux permite a participação do usuário em até 32 grupos). Mas qual a vantagem de se ter mais de um grupo? Simples: suponha, por exemplo, que você queira que somente os funcionários do departamento contábil de sua empresa acessem os arquivos disponíveis na pasta /contabilidade/. Para isso, você cria um grupo e uma definição que faz com que apenas os usuários desse grupo tenham direito ao acesso. Feito isso, basta adicionar ao grupo cada usuário do departamento contábil. Assim, somente eles acessarão o diretório. Via de regra, o sistema operacional cria um grupo para cada conta de usuário criada;
TinTin,Belgica,846-846: esse campo é muito interessante, pois permite a inclusão de informações adicionais sobre o usuário. Também chamado de GECOS (General Electric Comprehensive Operating System) em alusão a uma funcionalidade existente em um sistema operacional Unix que tinha esse nome, esse campo serve para, por exemplo, cadastrar o nome completo do usuário, seu endereço, seu telefone ou o seu ramal, etc. Cada informação é separada da outra por uma vírgula, por exemplo: Emerson Alecrim,Rua X,1234-4321. Na prática, você pode inserir as informações que achar melhor, não apenas os dados informados anteriormente;
/home/tintin: cada usuário criado no sistema tem direito a uma pasta "home", ou seja, uma pasta sua, para uso exclusivo. É neste campo que você indica onde estará essa pasta. Em geral, essas pastas ficam dentro do diretório /home/, mas você pode definir o diretório que quiser (ou mesmo não indicar nenhum);
/bin/bash: esse é o campo que informa qual o shell (interpretador de comandos) de login que o usuário utilizará. O GNU/Linux trabalha com vários, entre eles, o bash, o sh e o csh. Caso nenhum shell seja informado, o sistema utilizará o bash como padrão.

Criando usuários no GNU/Linux

Agora que você já conta com informações importantes sobre o gerenciamento de usuários no GNU/Linux, chegou a hora de criar contas. Para isso, você pode abrir um terminal e utilizar o comando adduser (dependendo do seu sistema, o comando pode ser somente/também useradd), que é aplicado da seguinte forma:
adduser opções usuário
Em opções, você pode colocar parâmetros específicos para a configuração da conta de usuário que será criada. Você pode usar vários parâmetros (veja uma lista completa digitando man adduser no terminal), entre eles:
adduser -disabled-login usuário: faz com que a conta do usuário seja criada sem a solicitação de uma senha (ou seja, não executa o comando passwd). No entanto, a conta não poderá ser usada até que o usuário defina sua senha de acesso;
adduser -force-badname usuário: em geral, os sistemas GNU/Linux checam se a conta criada pode ter em seu nome (ou mesmo na senha) algo que aumente os riscos ao sistema. Com esse comando, o sistema é instruído a não fazer esse tipo de verificação;

adduser -group grupo: com esse parâmetro, ao invés de uma conta de usuário, um grupo é criado. Para essa tarefa também pode-se utilizar o comando addgroup;
adduser -home diretório usuário: com essa opção, você define em qual diretório ficará o "home" do usuário. Se esse parâmetro não for usado, o sistema criará o "home" no diretório padrão (geralmente, em /home/nome_do_usuário). Se preferir que nenhum diretório desse tipo seja criado, você pode utilizar a opção -no-create-home (não recomendável);
adduser -uid número usuário: quando usuários são criados, o sistema geralmente adiciona a eles UIDs sequenciais, mas você pode especificar o UID que quiser usando o parâmetro uid seguido de um número, por exemplo, uid 31415. Note que, em muitas distribuições GNU/Linux, você pode utilizar apenas a letra u ao invés de uid. Note também que o GID do usuário será igual ao valor informado por você, a não ser que você especifique outro através da opção -gid, vista abaixo;
adduser -gid número usuário: semelhante ao parâmetro acima, mas especifica manualmente um grupo para o usuário ao invés de criar um parâmetro. Note que, em muitas distribuições GNU/Linux, você pode utilizar apenas a letra g ao invés de gid. O gid informado deve ser o de um grupo já existente;
adduser -ingroup grupo usuário: adiciona o usuário criado a um grupo já existente, ao invés de criar um novo grupo para ele;
adduser -shell shell usuário: através desse parâmetro, você pode especificar qual será o shell padrão do usuário. Em alguns sistemas é possível usar a letra s ao invés da palavra shell.
Para servir de exemplo, vamos criar um usuário de nome wester. Esse usuário deverá:
- ter um UID de número 27182;
- ser inserido no grupo infowester (já existente).
Veja como ficará o comando:
adduser -uid 27182 -ingroup infowester wester
Assim que esse comando for digitado, o sistema pedirá que você digite duas vezes uma senha para o usuário. Em seguida, perguntará as informações adicionais, como nome completo, telefone, etc. Note que você pode deixar essas informações em branco, se preferir. Você deve ter notado pelo comando acima de que é possível utilizar mais de uma opção ao mesmo tempo no comando adduser.

Eliminando usuários no GNU/Linux

Se você precisa apagar um usuário, saiba que o procedimento é fácil. Basta digitar o comando userdel seguido do nome do usuário. Por exemplo:
userdel voldmort
Se além de eliminar esse usuário do sistema você quiser que sua pasta "home" seja apagada (junto com todo o seu conteúdo), basta digitar o comando userdel seguido do parâmetro -r e do nome do usuário:
userdel -r voldemort
Ao fazer isso, certifique-se que o usuário tem cópia de todos os arquivos a serem apagados, quando cabível.

Alterando e controlando a senha do usuário

Por segurança, é recomendável alterar a senha de todos os usuários periodicamente. Para isso, usa-se o comando passwd. Se qualquer usuário quiser alterar a sua própria senha, basta digitar apenas passwd em um terminal. Quando isso ocorrer, o sistema pedirá que o usuário digite a sua senha atual e, em seguida, pedirá a nova seqüência, que deve ser informada duas vezes, para confirmação.
O usuário root (ou outro que tenha privilégios de administrador) pode mudar não só a sua própria senha como a senha de todos os outros usuários do sistema. Para isso, o comando passwd também é usado e pode ser acrescido de opções:
passwd usuário opções
Eis algumas das opções disponíveis (para conhecer as outras, pode-se digitar o comando man passwd em um terminal):
-e: faz com que a senha do usuário expire, forçando-o a fornecer uma nova combinação no próximo login;
-k: permite a alteração da senha somente se esta estiver expirada;
-x dias: faz com que a senha funcione apenas pela quantidade de dias informada. Depois disso, a senha expira e o usuário deve trocá-la;
-n dias: indica a quantidade mínima de dias que o usuário deve aguardar para trocar a senha;
-w dias: define a quantidade mínima de dias em que o usuário receberá o aviso de que sua senha precisa ser alterada;
-i: deixa a conta inativa, caso a senha tenha expirado;
-l: "tranca" a conta do usuário;
-u: desbloqueia uma conta que esteja "trancada";
-S: exibe o status da conta (note que a letra S deve estar em maiúscula).
Vamos a alguns exemplos para que você possa entender essas opções:
Suponha que você queira que a senha do usuário marvin expire após 30 dias. O comando é:
passwd marvin -x 30
Suponha, agora, que você queira que a senha do usuário bender expire após 14 dias e exiba uma mensagem de que é necessário trocar a senha três dias antes da data limite. O comando será o seguinte:
passwd bender -x 14 -w 3
Agora, vamos supor que você queira saber do status do usuário bender, para confirmar as alterações. Eis o comando:
passwd bender -S
O resultado exibido neste exemplo é:
bender P 12/11/2007 0 14 3 -1
A letra P acima informa que o usuário bender tem senha. Se não tivesse, no lugar de P estariam as letras NP. Se a conta do usuário estivesse bloqueada, apareceria a letra L. Por sua vez, a data que aparece na seqüência (no formato mês/dia/ano) informa a última alteração de senha que houve. As próximas quatro informações indicam, respectivamente, o período mínimo de utilização da senha, o período máximo (lembra que você definiu esse período com sendo de 14 dias?), o período de alerta (que você informou como sendo de 3 dias) e, por fim, o período de inatividade (quando não há inatividade, o resultado é -1).

Como já informado antes, o GNU/Linux usa o arquivo /etc/shadow para lidar com as senhas de usuários. As informações desse arquivo têm o seguinte padrão (usando como exemplo os dados do usuário toad):
toad:$1$O48MNVt9$08BBOTqV0cr2LtKtMXtAY1:13849:0:99999:7:::
Assim como acontece no arquivo /etc/passwd, as informações do arquivo /etc/shadow são separadas por : (dois pontos). No caso acima, aparece o nome do usuário (toad), a senha criptografada (é por que isso que há esse monte de caracteres sem sentido), a data da última mudança (13849), a quantidade mínima de dias que o usuário deve esperar para mudar a sua senha (0), a quantidade máxima de dias para a alteração de senha ser feita (99999) e a quantidade de dias restantes à data de expiração que o sistema operacional deve esperar para exibir alertas de mudança de senha (7). Os demais campos (que estão em branco) são destinados à informações de expiração de conta, mas dificilmente são usados.
Você pode ter se perguntado sobre o motivo das datas serem representadas por um único número, como o valor 13849, acima. Essa formato indica a quantidade de dias que já se passou desde 1 de janeiro de 1970.

Gerenciando grupos

Lidar com grupos no GNU/Linux é tarefa muito semelhante ao trabalho com usuários. Veja os principais comandos disponíveis:
addgroup grupo: funciona de maneira igual ao comando adduser (inclusive algumas opções são as mesmas), no entanto, obviamente, cria grupos ao invés de usuários;
groupdel grupo: serve para eliminar grupos do sistema;
newgrp - grupo: com este comando é possível mudar o grupo efetivo do usuário, isto é, o grupo pertencente a ele, por um outro grupo do qual ele faz parte. Essa operação somente é executada caso o grupo tenha senha;
groups usuário: mostra os grupos dos quais um usuário faz parte. Se quiser, por exemplo, saber os grupos do usuário gandalf, basta digitar em um terminal:
groups gandalf
As informações dos grupos são armazenadas no arquivo /etc/groups. Esse arquivo também indica quais usuários pertencem aos grupos existentes. Cada grupo contém uma linha com essas informações. Vamos analisar a seguinte linha de um arquivo /etc/groups para entender melhor como isso funciona:
infowester:x:1002:wester,toad,marvin
Assim como nos arquivos /etc/passwd e /etc/shadow, os campos da linha são separados por : (dois pontos). No exemplo acima, o primeiro campo indica o nome do grupo (infowester). O segundo campo informa a senha (sim, é possível definir senhas para grupos, embora raramente isso seja feito). Neste caso, usa-se x para indicar a ausência de senha. O terceiro campo informa o GID do grupo (1002) e, por fim, o quarto campo informa quais são os usuários pertencentes a esse grupo. Note que, neste exemplo, os usuários wester, toad e marvin fazem parte do grupo infowester. A lista de usuários deve ser separada por vírgulas, sem espaço entre os nomes.
No que se refere a este assunto, é possível que encontre grupos em seu sistema que você não lembra de ter criado. Suponha, por exemplo, que você digitou o comando groups lestat para saber quais os grupos dos quais participa o usuário lestat, e o resultado foi o seguinte:
lestat : lestat adm cdrom floppy audio video scanner lpadmin powerdev
Note que o usuário lestat participa de vários grupos, sendo um deles o seu grupo principal, que leva o seu nome. Mas, de onde surgiram os demais? O GNU/Linux possui alguns grupos considerados "padrão", isto é, grupos que servem para permitir que o usuário execute determinadas tarefas. A quantidade e as finalidades dos grupos podem variar de acordo com a distribuição GNU/Linux utilizada e a sua configuração. Eis alguns grupos bastante comuns:
cdrom: grupo para utilização de unidades de CD/DVD;
audio: grupo para acesso aos recursos de áudio do computador;
video: grupo para acesso aos recursos de vídeo do computador;
floppy: grupo para utilização da unidade de disquete;
adm: grupo para acesso de recursos administrativos.

Alterando informações dos usuários

Se você pode criar e apagar contas de usuários, pode também alterá-las. Isso é feito facilmente com o comando usermod, cujo funcionamento é semelhante ao comando adduser:
usermod opções usuário
Eis algumas de suas opções:
usermod -d diretório usuário: altera o diretório "home" do usuário. Adicione -m no final para mover o conteúdo da pasta anterior para a nova. Por exemplo:
usermod -d /financeiro -m peterpan
usermod -e data usuário: define a data de expiração da conta do usuário. Em geral, a data é fornecida no esquema ano/mês/dia (aaaa-mm-dd). Por exemplo:
usermod -e 2008-10-28 galadriel
usermod -l novo_nome usuário: altera o nome do login do usuário. No exemplo abaixo, o usuário peterparker teve seu nome alterado para spiderman:
usermod -l spiderman peterparker
usermod -g grupo número usuário: altera o GID do grupo principal do usuário. Por exemplo:
usermod -g 42 galadriel

usermod -s shell usuário: altera o shell do usuário;
usermod -u número usuário: altera o UID da conta do usuário.

Comandos adicionais

O GNU/Linux ainda conta com vários outros comandos que lhe ajudam a gerenciar e obter informações de usuários e grupos. Veja alguns:
logname: mostra o nome do seu usuário;
users: mostra os usuários que estão conectados ao sistema no momento;
id: mostra dados da identificação do usuário. Eis algumas opções:
id usuário: exibe os grupos (e seus respectivos GIDs) dos quais o usuário faz parte;
id -g usuário: mostra o GID do grupo do usuário;
id -G usuário: exibe o GID de todos os grupos do usuário (nome que a letra G fica em caixa alta);
id -u usuário: indica o UID do usuário.
finger usuário: mostra informações detalhadas do usuário. Se o comando for digitado isoladamente (ou seja, somente finger), o sistema exibe todos os usuários que estão conectados no sistema operacional no momento;

chfn usuário: comando para mudar as informações adicionais do usuário (nome completo, telefone, etc).
last: o comando last é bastante interessante e útil, pois mostra os últimos usuários que estiveram logados no sistema, os terminais usados por eles para se conectar, o hostname (quando a conexão é feita remotamente), as datas e os horários de utilização do computador, assim como o tempo de permanência no sistema. Esses dados geralmente são obtidos do arquivo de logs /var/log/wtmp. O last também possui opções. Veja algumas:
last -n número: mostra apenas as últimas linhas do log. Para definir a quantidade de linhas, substitua número pelo valor desejado. Por exemplo:
last -n 10
last -x: mostra os dados de desligamento do sistema, assim como informações do nível de execução;
last -R: faz com que o comando não exiba os hostnames (note que a letra R fica em caixa alta);
last -a: faz com que os hostnames sejam exibidos apenas na última coluna.

Fonte: http://www.infowester.com/usuarioslinux.php

Excel: Aprenda a criar tabelas dinâmicas

2011-11-28T08:12:00.001-08:00

O programa Microsoft Excel é bastante utilizado por diversos tipos de pessoas e para variadas finalidades. Com ele, é possível criar simples tabelas de horários escolares, por exemplo, até mesmo complexos bancos de dados.
Contudo, no caso dos bancos de dados, quanto maior for o seu tamanho e a quantidade de informações contidas, mais difícil será para gerenciá-lo e até mesmo para realizar buscas por dados.
Neste caso, você poderá criar tabelas dinâmicas para facilitar a comparação, elaboração de relatórios e acesso aos dados de suas planilhas. Além disso, com ela ficará mais fácil também a reordenação de linhas e colunas em suas tabelas. O Baixaki irá ensinar agora, através de um tutorial simples de seguir, como criar este tipo de planilhas. Então, mãos à obra!
Criando tabelas dinâmicas
O primeiro passo é abrir o arquivo com a tabela que você deseja transformar em tabela dinâmica.

Selecione o campo da tabela com o mouse.

Agora, clique na guia Inserir e depois em Tabela Dinâmica e então surgirá uma nova janela em sua tela. Nela, você poderá alterar os campos que farão parte de sua nova tabela e também definir o local aonde ela será criada (na mesma ou em uma nova planilha).

Além dos campos em sua própria planilha, é possível também selecionar fontes externas, para isso, clique em Usar uma fonte de dados externa e então escolha a partir de onde virão os dados de sua nova tabela dinâmica. Depois disso, clique em OK.

Sua tabela dinâmica está pronta. A partir de agora, para acessar os valores e dados, clique sobre a tabela e então selecione tudo o que deseja analisar.

Com este tipo de tabela, você poderá comparar dados facilmente, como no exemplo abaixo, quando foram selecionados os dados de somente três pessoas:

Ainda na barra do lado direito, você poderá mover os dados entre os campos Filtro de Relatórios, Rótulos de Coluna, Rótulos de Linha e Valores.

Acessando as opções da tabela dinâmica (Tabela Dinâmica > Opções > Opções), você poderá alterar algumas configurações de sua planilha, como impressão, definições de exibição, layout, filtros e dados.

Adicionando filtros
Para melhor analisar os dados, você pode adicionar filtros para poder reduzir a visualização de dados a algo mais específico. Para isso, clique sobre a guia Rótulos de Linha para que seja aberto o seu menu, depois vá em Filtro de Valores e escolha o tipo de filtro que deseja aplicar.

Veja um exemplo com o filtro É Maior do que aplicado com o valor 140.000:

Outro tipo de filtros são os Filtros de Rótulos, estes relativos aos rótulos da sua tabela. No nosso exemplo, os rótulos são os meses. Esta função também será bem útil no caso de tabelas com um grando número de dados e informações.
Você pode ainda utilizar seus próprios dados como filtros para comparação na tabela. Por exemplo, arraste qualquer um dos dados da aba direita para o campo Filtro de Relatório e então ele aparecerá em cima da sua tabela.

Clique para abrir sua guia e então selecione o valor que deseja utilizar como referência. Desta forma, você pode selecionar um ou vários itens (no caso de nosso exemplo, meses) para filtrar e comparar com os demais dados informados na tabela.

Considerações
Apesar de nosso exemplo ser uma tabela pequena, este recurso é bastante interessante para bancos de dados com muitas informações, onde a simples visualização é prejudicada pela grande quantidade de informações. De qualquer maneira, este recurso é indicado para qualquer um que queira gerar relatórios de maneira eficiente e precisa, sem que para isso tenha muito trabalho.

Fonte: http://www.tecmundo.com.br/1056-excel-aprenda-a-criar-tabelas-dinamicas.htm