Você só tem a ganhar utilizando a ferramenta HOTWords: enriqueça o conteúdo exibindo anúncios relevantes. Conheça os benefícios e vantagens.
O Google AdSense é um programa gratuito que permite que editores on-line gerem receita exibindo anúncios relevantes em uma ampla variedade de conteúdo.
# Concatenando campo string e number utilizando o operador "+"
# ------------------------------------------------------------
MagikSF> a << "1.234" # Atribuindo uma string a variável "a"
MagikSF> write ("o valor é: " + a)
$
o valor é: 123.4
# Concatenando utilizando a função "Concatenation"
# ------------------------------------------------
MagikSF> c << "10"
MagikSF> write ("".concatenation("O valor é: " + c))
$
O valor é: 10
# Outro exemplo
# -------------
MagikSF> a << "Para"
MagikSF> b << "lele"
MagikSF> c << "pípe"
MagikSF> d << "do"
MagikSF> write (a + b + c + d) # Utilizando operador "+"
$
Paralelepípedo
MagikSF> write ("".concatenation(a, b, c, d)) # Utilizando a função "Concatenation"
$
Paralelepípedo
# Concatenando e convertendo campo numérico em string
# ---------------------------------------------------
MagikSF> a << 1.234 # Atribuindo um valor a variável "a"
MagikSF> write ("o valor é: " + a.write_string)
$
o valor é: 1.234
Magik é uma linguagem de programação orientada a objetos que suporta herança múltipla, polimorfismo e tipos de dados dinâmicos. GE Energy o proporciona como parte da plataforma Smallworld e, a princípio, foi desenhado para implementar aplicações complexas para empresas como telecomunicações.
Magik foi criado originalmente em 1990, e através dos anos foi melhorado e atualizado.
Semelhanças com Smalltalk
Magik tem algumas semelhanças com Smalltalk em termos de características da linguagem e arquitetura: a linguagem Magik compila-se em bytecode que é interpretado pela Máquina virtual do Magik. A máquina virtual do Magik está disponível em várias plataformas, entre elas Microsoft Windows, várias versões de Unix e Linux.
Magik está baseado em console, e o código pode ser alterado em tempo de execução. O console pode ser utilizada tanto para executar código Magik como para ver os resultados.
O código compilado é salvo em um único arquivo chamado “arquivo imagem”. Cada “arquivo imagem” contém o bytecode completo e o estado da sessão (por exemplo valores de variáveis) do momento do último guardado da imagem.
Características da linguagem
Comentários
Magik usa o # para marcar seções de código como comentário:
# Isto é um comentário.
Atribuições
Magik usa o operador << para fazer atribuições:
a << 1.234
b << b + a
c << “foo” + “bar” # Concatenando strings
Esta anotação lê-se como "a recebe 1.234" ou "b recebe b+a". Isto serve para diferenciar corretamente atribuição de comparação.
Magik suporta também uma variação comprimida do operador que funciona de forma similar aos que podemos encontrar em C:
b +<< a # Equivalente a b << b + a Símbolos.
Bem como os tipos de dados convencionais como inteiros, números em ponto flutuante e strings, Magik também implementa símbolos. Os símbolos são um tipo de dado especial que são usados extensamente em Magik para identificar de forma única os objetos. Representa-se mediante dois pontos ":" seguidos de uma string de caracteres. Os símbolos podem se concatenarr mediante a barra vertical "|". Por exemplo:
a << :hello # Quando se encontra :hello referir-se-á à mesma instância
b << :|hello world|
Tipos dinâmicos
As variáveis de Magik não têm tipos fixados como em C# e podem referir diferentes objetos na execução. Qualquer coisa em Magik é um objeto (Não há distinção entre objetos e tipos de dados primitivos como os inteiros):
a << 1.2 # um número em ponto flutuante atribuído à variável 'a'
a << “1.2” # mais tarde atribui uma string à variável 'a'
Objetos
Os objetos são implementados em Magik usando instâncias. As instâncias são parecidas às classes de outras linguagens de programação como Java, mas com importantes diferenças. Magik suporta herança múltipla e misturas. As novas instâncias criam-se clonando uma já existente (que tipicamente é a instância, mas não tem o porquê de ser).
As novas instâncias criam-se com a sentença def_slotted_exemplar(), por exemplo:
def_slotted_exemplar(:my_object,
{
{:slot_a, 34},
{:slot_b, "hello"}
}, {:parent_object_a, :parent_object_b})
Este fragmento de código define uma instância chamada my_object que tem dois parâmeros (ou campos) chamados slot_a (pré-inicializado com o valor 34) e slot_b (pré-inicializado com o valor "hello") que herda de duas instâncias já existentes chamados parent_object_a e parent_object_b.
Comparação
Magik implementa todos os operadores binários tipicamente usados (=, <, <=, >, >=, =/<>) para a comparação, bem como alguns mais incomuns. Os operadores _is e _isnt usam-se para comparar instâncias específicas de objetos, ou referências de objetos em lugar de valores.
Por exemplo:
a << "hello"
b << "hello"
a = b retorna True (_true) porque os valores da e b são iguais
a _is b retorna False (_false) porque a e b não são a mesma instância
a << "hello"
b << a = b retorna True (_true) porque os valores da e b são iguais
a _is b retorna True (_true) porque b se atribui a uma instância específica do mesmo objeto que a, em lugar do mesmo valor que a.
Métodos
Os métodos definem-se nas instâncias usando as sentenças _method e _endmethod:
_method my_object.my_method(a, b)
_return a + b
_endmethod
Esta é uma forma de substituir os métodos new() (para criar novas instâncias) e init() (para inicializar uma instância).
# Método New
_method person.new(name, age)
_return _clone.init(name, age)
_endmethod
# Método Initialize
_private _method person.init(name, age)
# Chama a implementação do pai.
_super.init(name, age)
# Inicializa os campos.
.name << name
.age << age
_return _self
_endmethod
O _clone cria uma cópia física do objeto person. A sentença _super permite aos objetos invocar uma implementação de um método em uma instância pai. Os objetos podem referir-se a si mesmos usando a sentença _self.
Os métodos que não são parte da interface pública de um objeto podem ser marcados como privados usando a sentença _private. Os métodos privados só podem ser chamados por _self , _super e _clone.
Há argumentos opcionais que se podem declarar com a sentença _optional. Os argumentos opcionais que não são passados são atribuídos pelo Magik a um objeto especial _unset (o equivalente a NULL). A sentença _gather pode-se usar para declarar uma lista de argumentos opcionais.
_method my_object.my_method(_gather values)
_endmethod
Iteração
Em Magik as sentenças _for, _over, _loop e _endloop permitem iterar.
_method my_object.my_method(_gather values)
total << 0.0
_for a _over values.elements()
_loop
total +<< a
_endloop
_return total
_endmethod
m << my_object.new()
x << m.my_method(1.0, 2, 3.0, 4) # x = 10.0
Os novos métodos de iteração definem-se usando as sentenças _iter e _loopbody:
_iter _method my_object.even_elements()
_for a _over _self.elements()
_loop
_if a.even? _is _true
_then
_loopbody(a)
_endif
_endloop
_endmethod
Procedimentos
Magik também suporta funções chamadas procedimentos. Os procedimentos são também objetos, declarados com as sentenças _proc e _endproc. Os procedimentos são atribuídos a variáveis que podem ser invocadas:
my_procedure << _proc @my_procedure(a, b, c)
_return a + b + c
_endproc
x << my_procedure(1, 2, 3) # x = 6
Particularidades linguísticas
Já que Magik foi desenvolvido originalmente na Inglaterra, os métodos do núcleo e as livrarias de Smallworld estão esctitas em inglês britânico British English. Por exemplo:
Usa-se "initialise", em vez de "initialize".
Exemplo Hello World
O seguinte fragmento de código é o programa que emite a mensagem "hello world" escrito em Magik:
write ("Hello World!")
MagikSF> sql(gis_program_manager.cached_dataset(:gis))
$
SQL> SELECT name, address1 FROM hotel ORDER BY address1
$
Name Address 1
Acorn Guest House 154 Chesterton Road
Hamilton Lodge 156 Chesterton Road
De Freville House 166 Chesterton Road
Rosswill 17 Chesterton Road
Cam Guest House 17 Elizabeth Way
Kirkwood House 172 Chesterton Road
All Seasons 219 Chesterton Road
Lyngamore 35 Chesterton Road
Suffolk House 69 Milton Road
Southampton House 7 Elizabeth Way
Ashley Hotel 74 Chesterton Road
Arundel House Chesterton Road
Gonville Hotel Gonville Place
Garden House Granta Place
University Arms Regent Street
15 record(s) selected
SQL> SQL> select count(*) from min_road
$
COUNT(*)
833
1 record(s) selected
SQL> SQL>
It has been bothering me for years that Magik does not seem to support Regular Expressions. I tried to make do with the ro_charindex_mixin.matches?() method. But that method only uses wildcard characters %*, %? and %\.
So when l_santi asked a question in sw-gis about Magik support for Regular Expressions, it got me thinking: WWBD (What Would Bhimesh Do)? Bhimesh is the owner of the Magik Fun blog and many of his posts explore the interaction of Magik with various OLE objects. I began to wonder if there was an OLE object that could support regular expressions. It turns out that vbscript.regexp is exactly what I was looking for.
Here is an example of testing that a telephone number string matches the correct format for North America...
MagikSF> regexp << ole_client.createobject("vbscript.regexp")
$
MagikSF> regexp.pattern << "^[0-9]{3}-[0-9]{3}-[0-9]{4}$"
$
MagikSF> regexp.test("303-555")
$
False
MagikSF> regexp.test("303-555-5555")
$
True
... and another example testing if a string is in a valid e-mail format.
MagikSF> regexp.pattern << "\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}\b"
$
MagikSF> regexp.test("alfred@ifactorconsulting.com")
$
True
MagikSF> regexp.test("alfred!ifactorconsulting.com")
$
False
| | select 'select dbms_metadata.get_ddl(''TABLE'','''||object_name||''',''&&schema'')||chr(10)||''/'' from dual;' |
1. Introdução
Este artigo descreve a maneira pela qual podem ser realizadas operações aritméticas envolvendo campos DATE no SGBD Oracle.
2. O Tipo de Dado DATE
Conforme todo desenvolvedor Oracle sabe, os campos do tipo DATE costumam ser usados em tabelas para a representação de informação referente à data e hora de algum evento. Campos do tipo DATE ocupam apenas 7 bytes e são capazes armazenar datas com a precisão na casa dos segundos; Melhor detalhando, um campo DATE é capaz de manter as seguintes informações temporais associadas a um determinado evento: século, ano, mês, dia, hora, minuto e segundo de ocorrência do evento.
Para aplicações onde necessita-se manter informações de tempo com maior precisão, o Oracle disponibiliza outro tipo de dado, denominado TIMESTAMP. Este tipo representa uma extensão do tipo DATE que é capaz de gerenciar informações na ordem de fração de segundo (milissegundos, microssegundos, etc).
3. Aritmética de Datas
O que poucos desenvolvedores Oracle sabem é que este SGBD disponibiliza uma aritmética bastante simples para a manipulação do tipo de dado DATE. É possível somar (e subtrair) constantes numéricas a uma data de maneira rápida e fácil.
Em operações aritméticas envolvendo datas, o Oracle interpreta constantes numéricas como quantidade de dias. Desta forma, se você deseja obter a data do dia seguinte através de uma instrução SQL, basta fazer SYSDATE + 1:
| | SELECT SYSDATE + 1 as AMANHA FROM DUAL; |
De maneira análoga, se você quiser recuperar num mesmo SELECT a data corrente e também a data equivalente a data corrente mais 30 dias, basta executar a seguinte instrução:
SELECT SYSDATE, SYSDATE + 30 FROM DUAL; SYSDATE SYSDATE+30 -------------- ------------------- 25/06/07 25/07/07 |
Para obter a data da “semana passada” (data de 7 dias atrás), utilize a seguinte instrução:
SELECT SYSDATE, SYSDATE - 7 FROM DUAL; SYSDATE SYSDATE - 7 -------------- ------------------- 25/06/07 18/06/07 |
3.1 Lidando com Horas, Minutos e Segundos
Em muitas situações práticas poderemos estar interessados em adicionar ou subtrair não dias, mas horas, minutos ou segundos do valor de uma data. Isto também é possível no Oracle. No entanto, o SGBD solicitará com que seja especificada uma “fração de dia” adequada para a operação aritmética. Sabemos que um dia possui:
- 24 horas.
- 24 x 60 = 1440 minutos.
- 24 x 60 x 60 = 86.400 segundos.
Com isto, se desejamos somar 5 minutos a uma determinada data no Oracle, devemos somar a fração 5/1440 a esta data! Observe este cálculo no exemplo a seguir:
SELECT TO_CHAR(SYSDATE,‘DD/MM/YYYY HH24:MI:SS’) AS AGORA, TO_CHAR(SYSDATE + 5/1440, ‘DD/MM/YYYY HH24:MI:SS’) AGORA_MAIS_5_MIN FROM DUAL; AGORA AGORA_MAIS_5_MIN ------------------- ------------------- 25/06/2007 18:18:29 25/06/2007 18:23:29 |
Para, por exemplo, subtrair 30 segundos, pode-se utilizar o SELECT abaixo:
| | SELECT TO_CHAR(SYSDATE,‘DD/MM/YYYY HH24:MI:SS’) AS AGORA, TO_CHAR(SYSDATE - 30/86400, ‘DD/MM/YYYY HH24:MI:SS’) TRINTA_SEG_ATRAS FROM DUAL; AGORA TRINTA_SEG_ATRAS -------------------- ------------------ 25/06/2007 18:22:42 25/06/2007 18:22:12 |
